Add SIS integration helpers for institutional data management

## Description
Implement Student Information System (SIS) integration helpers to enable seamless data synchronization between institutional SIS systems and Canvas, following Canvas SIS import/export patterns and SDK architectural standards.

## Background
Educational institutions require robust SIS integration capabilities to synchronize student data, course information, enrollments, and grades between their Student Information Systems and Canvas LMS. Canvas provides comprehensive SIS import/export APIs that require specialized handling and institutional-specific data mapping.

## Canvas SIS Integration Overview

### Canvas SIS Import Types
1. **Users Import** - Student, faculty, and staff data
2. **Courses Import** - Course catalog and course instance data
3. **Sections Import** - Course section organization
4. **Enrollments Import** - User-course-section relationships
5. **Terms Import** - Academic calendar and term definitions
6. **Cross-listings Import** - Course cross-listing relationships

### Canvas SIS Export Capabilities
1. **Users Export** - Current user data with SIS IDs
2. **Courses Export** - Course data with institutional identifiers
3. **Enrollments Export** - Current enrollment state
4. **Grades Export** - Grade passback to SIS systems

## Implementation Strategy

### Phase 1: SIS Data Mapping and Validation

#### SIS Data Mapper
```php
// New file: src/SIS/SISDataMapper.php
namespace CanvasLMS\SIS;

class SISDataMapper
{
    // Institutional data mapping
    public static function mapUserFromSIS(array $sisUserData): array
    public static function mapCourseFromSIS(array $sisCourseData): array
    public static function mapEnrollmentFromSIS(array $sisEnrollmentData): array
    public static function mapSectionFromSIS(array $sisSectionData): array
    
    // Canvas data mapping for export
    public static function mapUserForSIS(User $user): array
    public static function mapCourseForSIS(Course $course): array
    public static function mapEnrollmentForSIS(Enrollment $enrollment): array
    
    // Data validation
    public static function validateSISUserData(array $data): array
    public static function validateSISCourseData(array $data): array
}
```

#### SIS Data Validator  
```php
// New file: src/SIS/SISValidator.php
namespace CanvasLMS\SIS;

class SISValidator
{
    // SIS ID validation
    public static function validateSISUserId(string $sisUserId): bool
    public static function validateSISCourseId(string $sisCourseId): bool
    public static function validateSISSectionId(string $sisSectionId): bool
    public static function validateSISTermId(string $sisTermId): bool
    
    // Institutional data validation
    public static function validateEmailFormat(string $email): bool
    public static function validateUserRole(string $role): bool
    public static function validateEnrollmentStatus(string $status): bool
    
    // Batch validation for large datasets
    public static function validateSISBatch(array $data, string $type): array
}
```

### Phase 2: SIS Import Management

#### SIS Import Manager
```php
// New file: src/SIS/SISImportManager.php
namespace CanvasLMS\SIS;

class SISImportManager extends AbstractBaseApi
{
    // CSV import operations
    public static function importUsersFromCSV(string $csvContent, array $options = []): SISImportResult
    public static function importCoursesFromCSV(string $csvContent, array $options = []): SISImportResult
    public static function importSectionsFromCSV(string $csvContent, array $options = []): SISImportResult
    public static function importEnrollmentsFromCSV(string $csvContent, array $options = []): SISImportResult
    
    // Array-based import operations  
    public static function importUsersFromArray(array $userData, array $options = []): SISImportResult
    public static function importCoursesFromArray(array $courseData, array $options = []): SISImportResult
    
    // Import status and monitoring
    public static function getImportStatus(int $importId): array
    public static function getImportErrors(int $importId): array
    public static function cancelImport(int $importId): bool
    
    // Batch import with progress tracking
    public static function importWithProgress(
        string $type, 
        array $data, 
        callable $progressCallback = null
    ): SISImportResult
}
```

#### SIS Import Result Handler
```php
// New file: src/SIS/SISImportResult.php
namespace CanvasLMS\SIS;

class SISImportResult
{
    public int $importId;
    public string $importType;
    public int $totalRecords;
    public int $processedRecords;
    public int $createdRecords;
    public int $updatedRecords;
    public int $errorRecords;
    public array $errors;
    public string $status; // 'created', 'importing', 'completed', 'failed'
    public ?\DateTime $completedAt;
    
    // Status checking
    public function isCompleted(): bool
    public function isSuccessful(): bool  
    public function hasErrors(): bool
    public function getProgressPercentage(): float
    
    // Error analysis
    public function getErrorSummary(): array
    public function getErrorsByType(): array
}
```

### Phase 3: SIS Export Management

#### SIS Export Manager
```php
// New file: src/SIS/SISExportManager.php
namespace CanvasLMS\SIS;

class SISExportManager extends AbstractBaseApi
{
    // CSV export operations
    public static function exportUsersToCSV(array $filters = []): string
    public static function exportCoursesToCSV(array $filters = []): string
    public static function exportEnrollmentsToCSV(array $filters = []): string
    public static function exportGradesToCSV(array $courseIds = []): string
    
    // Structured data export
    public static function exportUsersToArray(array $filters = []): array
    public static function exportCoursesToArray(array $filters = []): array
    
    // Grade passback for SIS systems
    public static function exportFinalGrades(array $courseIds, string $format = 'csv'): string
    public static function exportGradebookEntries(int $courseId): array
    
    // Incremental export (only changes since date)
    public static function exportChangesSince(\DateTime $since, array $types = []): array
}
```

### Phase 4: SIS Synchronization Workflows

#### SIS Sync Manager
```php
// New file: src/SIS/SISSyncManager.php
namespace CanvasLMS\SIS;

class SISSyncManager  
{
    // Full synchronization workflows
    public static function fullUserSync(array $sisUsers): SISSyncResult
    public static function fullCourseSync(array $sisCourses): SISSyncResult
    public static function fullEnrollmentSync(array $sisEnrollments): SISSyncResult
    
    // Incremental synchronization
    public static function incrementalSync(\DateTime $lastSyncDate): SISSyncResult
    public static function syncUserChanges(array $userChanges): SISSyncResult
    public static function syncEnrollmentChanges(array $enrollmentChanges): SISSyncResult
    
    // Conflict resolution
    public static function resolveDataConflicts(array $conflicts, string $strategy = 'sis_wins'): array
    
    // Sync validation and rollback
    public static function validateSyncData(array $data): array
    public static function rollbackSync(string $syncId): bool
}
```

#### SIS Sync Result
```php
// New file: src/SIS/SISSyncResult.php
namespace CanvasLMS\SIS;

class SISSyncResult
{
    public string $syncId;
    public \DateTime $startTime;
    public ?\DateTime $endTime;
    public array $syncedTypes;
    public array $statistics;
    public array $conflicts;
    public array $errors;
    
    // Statistics tracking
    public function getTotalProcessed(): int
    public function getTotalCreated(): int
    public function getTotalUpdated(): int
    public function getTotalErrors(): int
    
    // Conflict analysis
    public function hasConflicts(): bool
    public function getConflictsByType(): array
    public function getResolvedConflicts(): array
}
```

### Phase 5: Institutional Configuration

#### SIS Configuration Manager
```php
// Enhance existing Config.php
class Config
{
    // SIS-specific configuration
    public static function setSISSourceSystem(string $system, ?string $context = null): void
    public static function setSISUserMapping(array $mapping, ?string $context = null): void
    public static function setSISCourseMapping(array $mapping, ?string $context = null): void
    public static function setSISSyncStrategy(string $strategy, ?string $context = null): void
    
    // SIS validation rules
    public static function setSISValidationRules(array $rules, ?string $context = null): void
    public static function getSISValidationRules(?string $context = null): array
    
    // Default SIS mappings for common systems
    public static function loadPowerschoolMapping(): void
    public static function loadBannerMapping(): void  
    public static function loadColleagueMapping(): void
}
```

## Required Features

### Core SIS Integration
- [ ] SIS data mapping and validation utilities
- [ ] CSV import/export functionality following Canvas format specifications  
- [ ] SIS import progress monitoring and error handling
- [ ] Grade passback capabilities for SIS systems

### Canvas SIS API Integration
- [ ] Complete Canvas SIS import API integration
- [ ] Canvas SIS export API utilization
- [ ] Canvas term and section hierarchy support
- [ ] Cross-listing and course relationship management

### Institutional Data Management
- [ ] Multi-institutional configuration support
- [ ] Common SIS system mapping presets (PowerSchool, Banner, Colleague)
- [ ] Data validation rules and institutional policy enforcement
- [ ] Audit trails and data change tracking

### Synchronization Workflows
- [ ] Full and incremental data synchronization
- [ ] Conflict resolution strategies
- [ ] Data rollback and recovery mechanisms  
- [ ] Automated sync scheduling capabilities

## Usage Examples

### SIS User Import
```php
// Import users from CSV file
$csvContent = file_get_contents('sis_users.csv');
$result = SISImportManager::importUsersFromCSV($csvContent, [
    'override_sis_stickiness' => true,
    'batch_mode' => true
]);

// Monitor progress
while (\!$result->isCompleted()) {
    sleep(5);
    echo "Progress: {$result->getProgressPercentage()}%\n";
}

if ($result->hasErrors()) {
    foreach ($result->getErrorsByType() as $type => $errors) {
        echo "{$type} errors: " . count($errors) . "\n";
    }
}
```

### SIS Synchronization Workflow
```php
// Configure SIS mapping
Config::setSISSourceSystem('PowerSchool');
Config::loadPowerschoolMapping();

// Perform full sync
$sisData = [
    'users' => $userArray,
    'courses' => $courseArray,  
    'enrollments' => $enrollmentArray
];

$syncResult = SISSyncManager::fullUserSync($sisData['users']);
$syncResult = SISSyncManager::fullCourseSync($sisData['courses']);
$syncResult = SISSyncManager::fullEnrollmentSync($sisData['enrollments']);

// Handle conflicts
if ($syncResult->hasConflicts()) {
    $resolved = SISSyncManager::resolveDataConflicts(
        $syncResult->conflicts, 
        'sis_wins'
    );
}
```

### Grade Passback
```php  
// Export grades for SIS system
$gradeCSV = SISExportManager::exportFinalGrades([123, 124, 125]);
file_put_contents('final_grades.csv', $gradeCSV);

// Export only changes since last sync
$lastSync = new \DateTime('2024-01-01');
$changes = SISExportManager::exportChangesSince($lastSync, ['grades']);
```

## Testing Strategy

### SIS Data Testing
- [ ] Unit tests for SIS data mapping and validation
- [ ] Mock Canvas SIS import/export API responses
- [ ] Test with sample institutional data sets
- [ ] Large dataset performance testing

### Integration Testing  
- [ ] Integration with existing User, Course, Enrollment APIs
- [ ] Multi-institutional configuration testing
- [ ] SIS synchronization workflow testing
- [ ] Grade passback integration testing

## Implementation Phases

### Phase 1 (4-5 weeks): Core SIS Infrastructure
1. Create SIS data mapping and validation utilities
2. Implement SIS import/export managers
3. Add Canvas SIS API integration

### Phase 2 (3-4 weeks): Sync Workflows
1. Implement SIS synchronization workflows
2. Add conflict resolution mechanisms
3. Create institutional configuration presets

### Phase 3 (2-3 weeks): Integration and Testing
1. Integration with existing API classes
2. Comprehensive testing with institutional data
3. Documentation and usage examples

## Priority
**Medium** - Important for institutional Canvas deployments and SIS integration requirements.

## Canvas Domain Benefits
- Enable seamless SIS-Canvas data synchronization
- Support for institutional data management workflows  
- Canvas SIS import/export API utilization
- Grade passback capabilities for institutional requirements

## Related Issues
- Foundation for bulk operations (#43)
- Enhances User, Course, Enrollment APIs  
- Required for institutional Canvas deployments
- Supports multi-tenant institutional configurations

This implementation provides enterprise-grade SIS integration capabilities while maintaining SDK architectural consistency and Canvas API compliance.

Uh oh!

Add SIS integration helpers for institutional data management #45

Description

Description

Background

Canvas SIS Integration Overview

Canvas SIS Import Types

Canvas SIS Export Capabilities

Implementation Strategy

Phase 1: SIS Data Mapping and Validation

SIS Data Mapper

SIS Data Validator

Phase 2: SIS Import Management

SIS Import Manager

SIS Import Result Handler

Phase 3: SIS Export Management

SIS Export Manager

Phase 4: SIS Synchronization Workflows

SIS Sync Manager

SIS Sync Result

Phase 5: Institutional Configuration

SIS Configuration Manager

Required Features

Core SIS Integration

Canvas SIS API Integration

Institutional Data Management

Synchronization Workflows

Usage Examples

SIS User Import

SIS Synchronization Workflow

Grade Passback

Testing Strategy

SIS Data Testing

Integration Testing

Implementation Phases

Phase 1 (4-5 weeks): Core SIS Infrastructure

Phase 2 (3-4 weeks): Sync Workflows

Phase 3 (2-3 weeks): Integration and Testing

Priority

Canvas Domain Benefits

Related Issues

Metadata

Metadata

Assignees

Labels

Type

Fields

Projects

Milestone

Relationships

Development

Issue actions