PHP code example of jjuanrivvera / canvas-lms-kit-laravel

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

jjuanrivvera / canvas-lms-kit-laravel example snippets

use CanvasLMS\Api\Courses\Course;
use CanvasLMS\Api\Users\User;

// That's it! The package auto-configures everything
$courses = Course::get();
$user = User::find(123);

// 😫 Before - Manual configuration everywhere
class CourseController 
{
    public function __construct() 
    {
        Config::setApiKey(env('CANVAS_API_KEY'));
        Config::setBaseUrl(env('CANVAS_BASE_URL'));
        Config::setAccountId(env('CANVAS_ACCOUNT_ID'));
        // ... more configuration
    }
}

// 😊 After - Just works!
class CourseController 
{
    public function index() 
    {
        return Course::get(); // Already configured!
    }
}

use CanvasLMS\Api\Courses\Course;
use CanvasLMS\Api\Enrollments\Enrollment;
use CanvasLMS\Api\Assignments\Assignment;

// Get all courses
$courses = Course::get();

// Get a specific course
$course = Course::find(123);

// Create a course
$course = Course::create([
    'name' => 'Introduction to Laravel',
    'course_code' => 'LAR101',
]);

// Update a course
$course->name = 'Advanced Laravel';
$course->save();

use CanvasLMS\Laravel\Facades\Canvas;

// Switch to a different Canvas instance
Canvas::connection('school_b');
$courses = Course::get(); // From school_b

// Temporarily use a different connection
Canvas::usingConnection('school_c', function () {
    $course = Course::find(456); // From school_c
});

// Back to default connection
Canvas::connection('main');

'connections' => [
    'main' => [
        'api_key' => env('CANVAS_API_KEY'),
        'base_url' => env('CANVAS_BASE_URL'),
    ],
    
    'school_b' => [
        'api_key' => env('SCHOOL_B_API_KEY'),
        'base_url' => env('SCHOOL_B_BASE_URL'),
    ],
],

use CanvasLMS\Laravel\Testing\CanvasFake;
use CanvasLMS\Api\Courses\Course;

test('creates a course in canvas', function () {
    // Arrange
    $fake = new CanvasFake();
    $fake->fake([
        'courses' => [
            ['id' => 123, 'name' => 'Test Course'],
        ],
    ]);
    
    // Act
    $courses = Course::get();
    
    // Assert
    expect($courses)->toHaveCount(1);
    expect($courses[0]->name)->toBe('Test Course');
    $fake->assertApiCallMade('GET', '/courses');
});

use CanvasLMS\Laravel\Facades\Canvas;

// These are equivalent:
Course::get();                    // Direct SDK usage
Canvas::courses()::get();         // Via facade

// The facade is most useful for connection management:
Canvas::connection('tenant_2')->courses()::get();

return [
    // Default connection to use
    'default' => env('CANVAS_CONNECTION', 'main'),
    
    // Multiple Canvas connections
    'connections' => [
        'main' => [
            // Authentication mode: 'api_key' or 'oauth'
            'auth_mode' => env('CANVAS_AUTH_MODE', 'api_key'),
            
            // API Key authentication (when auth_mode = 'api_key')
            'api_key' => env('CANVAS_API_KEY'),
            'base_url' => env('CANVAS_BASE_URL'),
            'account_id' => env('CANVAS_ACCOUNT_ID', 1),
            'timeout' => env('CANVAS_TIMEOUT', 30),
            'log_channel' => env('CANVAS_LOG_CHANNEL'),
            
            // OAuth 2.0 authentication (when auth_mode = 'oauth')
            'oauth_client_id' => env('CANVAS_OAUTH_CLIENT_ID'),
            'oauth_client_secret' => env('CANVAS_OAUTH_CLIENT_SECRET'),
            'oauth_redirect_uri' => env('CANVAS_OAUTH_REDIRECT_URI'),
            'oauth_token' => env('CANVAS_OAUTH_TOKEN'),
            'oauth_refresh_token' => env('CANVAS_OAUTH_REFRESH_TOKEN'),
            
            // Optional middleware configuration
            'middleware' => [
                'retry' => [
                    'max_attempts' => 3,
                    'delay' => 1000,
                ],
                'rate_limit' => [
                    'wait_on_limit' => true,
                ],
            ],
        ],
    ],
    
    // Testing configuration
    'testing' => [
        'fake' => env('CANVAS_FAKE', false),
    ],
];

use CanvasLMS\Config;

// Masquerade as a specific user for all subsequent calls
Config::asUser(12345);

// Make API calls as that user
$courses = Course::get(); // Returns courses visible to user 12345

// Stop masquerading
Config::stopMasquerading();

// Now calls are made as the authenticated user again
$courses = Course::get();

use CanvasLMS\Laravel\Testing\CanvasFake;

beforeEach(function () {
    $this->canvas = new CanvasFake();
});

test('enrolls user in course', function () {
    // Arrange
    $this->canvas->fake([
        'enrollments' => [
            'id' => 999,
            'user_id' => 123,
            'course_id' => 456,
            'type' => 'StudentEnrollment',
        ],
    ]);
    
    // Act
    $enrollment = Enrollment::create([
        'enrollment' => [
            'user_id' => 123,
            'course_id' => 456,
            'type' => 'StudentEnrollment',
        ],
    ]);
    
    // Assert
    expect($enrollment->user_id)->toBe(123);
    $this->canvas->assertEnrollmentCreated(123, 456, 'StudentEnrollment');
});

$canvas = new CanvasFake();

// Assert specific API calls
$canvas->assertCourseCreated(['name' => 'Laravel 101']);
$canvas->assertEnrollmentCreated($userId, $courseId);
$canvas->assertApiCallMade('GET', '/courses/*');
$canvas->assertApiCallCount(3);
$canvas->assertNoApiCallsMade();

use App\Models\User;
use CanvasLMS\Api\Users\User as CanvasUser;

class SyncUsersToCanvas
{
    public function handle()
    {
        User::chunk(100, function ($users) {
            foreach ($users as $user) {
                CanvasUser::create([
                    'user' => [
                        'name' => $user->name,
                        'email' => $user->email,
                        'sis_user_id' => $user->id,
                    ],
                ]);
            }
        });
    }
}

use CanvasLMS\Laravel\Facades\Canvas;

class TenantCourseService
{
    public function getCoursesByTenant(string $tenant): array
    {
        return Canvas::connection($tenant)
            ->courses()
            ::get(['per_page' => 100]);
    }
    
    public function syncCourseAcrossTenants(int $courseId, array $tenants): void
    {
        $sourceCourse = Course::find($courseId);
        
        foreach ($tenants as $tenant) {
            Canvas::usingConnection($tenant, function () use ($sourceCourse) {
                Course::create([
                    'name' => $sourceCourse->name,
                    'course_code' => $sourceCourse->course_code,
                ]);
            });
        }
    }
}

bash
php artisan vendor:publish --tag=canvas-config

bash
php artisan canvas:test