canvas_sync 0.3.3 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4cb4e4d83e146469a152b7582f9dff23adbf57e5
-  data.tar.gz: 7ac7ec7146259a6099093c63134a070af1656a07
+SHA256:
+  metadata.gz: 5deb79781b2837c369b7dc299b0ced0082af7612027280eacdc63f4473dd9396
+  data.tar.gz: 9c1e5af6281752f7a467c6238c08e0810a108083c1e6b170f0fa81364e4d63ae
 SHA512:
-  metadata.gz: 1b98e4574ce7bce06cfba710c003fe8e8b4bf48b3f84326307d099bc9ab80136384c367ef4913e85a80331e4f0a855e41c40ea89e5cb4f30dec7af9e81c7585e
-  data.tar.gz: d572b58ae50eab9287e04972f79a72f0619cb25623a8615d4c2e55f93f58d54c9232e5371ffce4d844405380fb8c7e4e4d5706909f88f730d75878ddab10280a
+  metadata.gz: 26045a4eb9f2f7c9f6cfb7bf7b978314322781d30945fe5ed4a60f138da3deea8fb407e31d19102003c55bb412ce1f10836ee076ddc6e2b8fef7a00db62e2eee
+  data.tar.gz: 57d54b949ad57b42fdd948886693af3a4c04361be9fbff6919ca6bd0fa4ce5cee50a7431f251ffbbd19e5b166b011ccd0ea150b272a0e665fa62276cd52907a9

data/app/controllers/api/v1/health_check_controller.rb

@@ -0,0 +1,7 @@
+class Api::V1::HealthCheckController < ActionController::Base
+
+  def ping
+    head :ok
+  end
+
+end

data/app/controllers/api/v1/live_events_controller.rb

@@ -0,0 +1,16 @@
+class Api::V1::LiveEventsController < ActionController::Base
+
+  def process_event
+    payload = SymmetricEncryption.decrypt(params[:payload])
+    payload = JSON.parse(payload)
+    Rails.logger.debug("Processing event type: #{payload['attributes']['event_name']}")
+    Rails.logger.debug("Payload: #{payload}")
+    event = "LiveEvents::#{payload['attributes']['event_name'].camelcase}Event".constantize
+    event.perform_later(payload)
+    head :ok
+  rescue => e
+    Rails.logger.error("Live Events Error: #{e.message} - #{e.backtrace}")
+    render json: {error: "Live Events Error: #{e.message}"}, status: 422
+  end
+
+end

data/lib/canvas_sync.rb

@@ -9,18 +9,20 @@ require "canvas_sync/jobs/report_processor_job"
 require "canvas_sync/jobs/sync_provisioning_report_job"
 require "canvas_sync/jobs/sync_terms_job"
 require "canvas_sync/jobs/sync_users_job"
+require "canvas_sync/jobs/sync_roles_job"
 
 Dir[File.dirname(__FILE__) +  "/canvas_sync/processors/*.rb"].each {|file| require file }
 Dir[File.dirname(__FILE__) +  "/canvas_sync/importers/*.rb"].each {|file| require file }
 Dir[File.dirname(__FILE__) +  "/canvas_sync/generators/*.rb"].each {|file| require file }
 
 module CanvasSync
-  SUPPORTED_MODELS = %w(users courses terms enrollments sections)
+  SUPPORTED_MODELS = %w(users courses terms enrollments sections roles)
+  SUPPORTED_LIVE_EVENTS = %w(course enrollment submission assignment user syllabus grade)
 
   # Runs a standard provisioning sync job with no extra report types.
-  # Terms will be synced first using the API. If you are syncing users
-  # and have also specified a Term scope, Users will by synced first, before
-  # every other model (as Users are never scoped to Term).
+  # Terms will be synced first using the API. If you are syncing users/roles
+  # and have also specified a Term scope, Users/Roles will by synced first, before
+  # every other model (as Users/Roles are never scoped to Term).
   #
   # @param models [Array<String>] A list of models to sync. e.g., ['users', 'courses'].
   #   must be one of SUPPORTED_MODELS
@@ -63,7 +65,7 @@ module CanvasSync
     next_job_class.perform_later(duped_job_chain, next_job[:options])
   end
 
-  # Syncs terms, users if necessary, then the rest of the specified models.
+  # Syncs terms, users/roles if necessary, then the rest of the specified models.
   #
   # @param models [Array<String>]
   # @param term_scope [String]
@@ -86,6 +88,12 @@ module CanvasSync
       models = models - ['users']
     end
 
+    if models.include?('roles')
+      # Sync all roles first when scoping by term, because roles cannot be scoped to term
+      jobs.push({ job: CanvasSync::Jobs::SyncRolesJob.to_s, options: {} })
+      models = models - ['roles']
+    end
+
     jobs.push({ job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: term_scope, models: models } })
 
     global_options = { legacy_support: legacy_support }
@@ -114,4 +122,11 @@ module CanvasSync
       raise "Invalid model(s) specified: #{invalid.join(', ')}. Only #{SUPPORTED_MODELS.join(', ')} are supported."
     end
   end
+
+  def self.validate_live_events!(events)
+    invalid = events - SUPPORTED_LIVE_EVENTS
+    if invalid.length > 0
+      raise "Invalid live event(s) specified: #{invalid.join(', ')}. Only #{SUPPORTED_LIVE_EVENTS.join(', ')} are supported."
+    end
+  end
 end

data/lib/canvas_sync/generators/install_generator.rb

@@ -4,7 +4,7 @@ require "rails/generators/migration"
 module CanvasSync
   class InstallGenerator < Rails::Generators::Base
     include Rails::Generators::Migration
-    source_root File.expand_path('../templates', __FILE__)
+    source_root File.expand_path('../templates/models', __FILE__)
     class_option :models, type: :string, required: true
 
     def self.next_migration_number(path)

data/lib/canvas_sync/generators/install_live_events_generator.rb

@@ -0,0 +1,38 @@
+require "rails/generators"
+
+module CanvasSync
+  class InstallLiveEventsGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates/services/live_events', __FILE__)
+    class_option :events, type: :string, required: true
+
+    def autogenerated_event_warning
+      <<-HERE.strip_heredoc
+        #
+        # AUTO GENERATED LIVE EVENT
+        # This was auto generated by the CanvasSync Gem.
+        # You can customize it as needed, but make sure you test
+        # any changes you make to the auto generated methods.
+        #
+      HERE
+    end
+
+    # Generates the specified live events. Invoke with:
+    #
+    # bin/rails generate canvas_sync:install_live_events --events users,courses
+    #
+    # Install all live events with:
+    #
+    # bin/rails generate canvas_sync:install_live_events --events all
+    def generate_live_events
+      events = options['events'] == 'all' ? CanvasSync::SUPPORTED_LIVE_EVENTS : options['events'].split(',')
+      CanvasSync.validate_live_events!(events)
+
+      events.each do |event|
+        Dir.glob("#{File.dirname(__FILE__)}/templates/services/live_events/#{event}/*.rb") do |rb_file|
+          template "#{rb_file}", "app/services/live_events/#{File.basename(rb_file)}"
+        end
+      end
+      template 'base_event.rb', 'app/services/live_events/base_event.rb'
+    end
+  end
+end

data/lib/canvas_sync/generators/templates/models/create_roles.rb

@@ -0,0 +1,17 @@
+<%= autogenerated_migration_warning %>
+
+class CreateRoles < ActiveRecord::Migration[5.1]
+  def change
+    create_table :roles do |t|
+      t.integer :canvas_role_id, null: false
+      t.string :label, null: false
+      t.string :base_role_type, null: false
+      t.json :account
+      t.string :workflow_state, null: false
+      t.json :permissions
+
+      t.timestamps
+    end
+    add_index :roles, :canvas_role_id, unique: true
+  end
+end

data/lib/canvas_sync/generators/templates/models/role.rb

@@ -0,0 +1,18 @@
+<%= autogenerated_model_warning %>
+
+class Role < ApplicationRecord
+  validates :canvas_role_id, uniqueness: true, presence: true
+
+  def self.create_or_update(role_params)
+    role = Role.find_or_initialize_by(canvas_role_id: role_params['id'])
+
+    role.assign_attributes(label: role_params['label'],
+                           base_role_type: role_params['base_role_type'],
+                           account: role_params['account'],
+                           permissions: role_params['permissions'],
+                           workflow_state: role_params['workflow_state'])
+
+    role.save! if role.changed?
+    role
+  end
+end

data/lib/canvas_sync/generators/templates/services/live_events/assignment/assignment_created_event.rb

@@ -0,0 +1,5 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::AssignmentCreatedEvent < LiveEvents::AssignmentEvent
+
+end

data/lib/canvas_sync/generators/templates/services/live_events/assignment/assignment_event.rb

@@ -0,0 +1,63 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::AssignmentEvent < LiveEvents::BaseEvent
+  # The following is provided in the live events call:
+  # {
+  #     assignment_id: assignment.global_id,
+  #     context_id: assignment.global_context_id,
+  #     context_type: assignment.context_type,
+  #     workflow_state: assignment.workflow_state,
+  #     title: LiveEvents.truncate(assignment.title),
+  #     description: LiveEvents.truncate(assignment.description),
+  #     due_at: assignment.due_at,
+  #     unlock_at: assignment.unlock_at,
+  #     lock_at: assignment.lock_at,
+  #     updated_at: assignment.updated_at,
+  #     points_possible: assignment.points_possible
+  # }
+
+  def perform(event_payload)
+    super
+    attrs = {
+        canvas_assignment_id: local_canvas_id(payload[:assignment_id]),
+        course_id: course.try(:id),
+        name: payload[:title],
+        workflow_state: payload[:workflow_state],
+        description: payload[:description],
+        due_at: payload[:due_at],
+        unlock_at: payload[:unlock_at],
+        lock_at: payload[:lock_at],
+        points_possible: payload[:points_possible],
+        canvas_updated_at: payload[:updated_at]
+    }
+    create_or_update(attrs)
+  rescue => e
+    log_error e
+  ensure
+    true
+  end
+
+  private
+  def create_or_update(attrs)
+    assignment = Assignment.where(canvas_assignment_id: attrs[:canvas_assignment_id]).first_or_initialize
+    assignment.assign_attributes(attrs)
+    assignment.save!
+    assignment
+  end
+
+  # This could be nil if the context type for this assignment is not 'Course' of if a local course was not found
+  def canvas_course_id
+    payload[:context_type] == 'Course' ? local_canvas_id(payload[:context_id]) : nil
+  end
+
+  # This could be nil if the context type for this assignment is not 'Course' of if a local course was not found
+  def course
+    unless @course
+      if canvas_course_id.present?
+        @course = Course.find_by(canvas_course_id: canvas_course_id)
+      end
+    end
+    @course
+  end
+
+end

data/lib/canvas_sync/generators/templates/services/live_events/assignment/assignment_updated_event.rb

@@ -0,0 +1,4 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::AssignmentUpdatedEvent < LiveEvents::AssignmentEvent
+end

data/lib/canvas_sync/generators/templates/services/live_events/base_event.rb

@@ -0,0 +1,23 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::BaseEvent
+
+  attr_accessor :payload
+
+  def perform(event_payload)
+    @payload = HashWithIndifferentAccess.new(event_payload['body'])
+  end
+
+  # Live events will use a canvas global ID (cross shard) for any ID's provided. This method will return the local ID.
+  def local_canvas_id(id)
+    id.to_i % 10_000_000_000_000
+  end
+
+  def log_error(e)
+    Rails.logger.error "Error processing Live Event: #{self.class.name}"
+    Rails.logger.error "#{payload}"
+    Rails.logger.error e.message
+    Rails.logger.error e.backtrace.join("\n")
+  end
+
+end

data/lib/canvas_sync/generators/templates/services/live_events/course/course_created_event.rb

@@ -0,0 +1,4 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::CourseCreatedEvent < LiveEvents::CourseEvent
+end

data/lib/canvas_sync/generators/templates/services/live_events/course/course_event.rb

@@ -0,0 +1,42 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::CourseEvent < LiveEvents::BaseEvent
+
+  # The following is provided in the live events call:
+  # {
+  #     course_id: course.global_id,
+  #     uuid: course.uuid,
+  #     account_id: course.global_account_id,
+  #     name: course.name,
+  #     created_at: course.created_at,
+  #     updated_at: course.updated_at,
+  #     workflow_state: course.workflow_state
+  # }
+
+
+  def perform(event_payload)
+    super
+    attrs = {
+        canvas_course_id: local_canvas_id(payload[:course_id]),
+        canvas_account_id: local_canvas_id(payload[:account_id]),
+        name: payload[:name],
+        workflow_state: payload[:workflow_state]
+    }
+    create_or_update(attrs)
+  rescue => e
+    log_error e
+  ensure
+    true
+  end
+
+  private
+
+  def create_or_update(attrs)
+    course = Course.where(canva_course_id: attrs[:canva_course_id]).first_or_initialize
+    course.assign_attributes(attrs)
+    course.save!
+    course
+  end
+
+end
+

data/lib/canvas_sync/generators/templates/services/live_events/course/course_updated_event.rb

@@ -0,0 +1,4 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::CourseUpdatedEvent < LiveEvents::CourseEvent
+end

data/lib/canvas_sync/generators/templates/services/live_events/enrollment/enrollment_created_event.rb

@@ -0,0 +1,4 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::EnrollmentCreatedEvent < LiveEvents::EnrollmentEvent
+end

data/lib/canvas_sync/generators/templates/services/live_events/enrollment/enrollment_event.rb

@@ -0,0 +1,58 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::EnrollmentEvent < LiveEvents::BaseEvent
+
+  # The following is provided in the live events call:
+  # {
+  #
+  #     enrollment_id: enrollment.global_id,
+  #     course_id: enrollment.global_course_id,
+  #     user_id: enrollment.global_user_id,
+  #     user_name: enrollment.user_name,
+  #     type: enrollment.type,
+  #     created_at: enrollment.created_at,
+  #     updated_at: enrollment.updated_at,
+  #     limit_privileges_to_course_section: enrollment.limit_privileges_to_course_section,
+  #     course_section_id: enrollment.global_course_section_id,
+  #     workflow_state: enrollment.workflow_state
+  # }
+
+  def perform(paload)
+    super
+    return if course.nil? || section.nil? || user.nil?
+    attrs = {
+
+        canvas_enrollment_id: local_canvas_id(payload[:enrollment_id]),
+        course_id: course.try(:id),
+        user_id: user.try(:id),
+        type: payload[:type],
+        section_id: section.try(:id),
+        workflow_state: payload[:workflow_state]
+    }
+    create_or_update(attrs)
+  rescue => e
+    log_error e
+  ensure
+    true
+  end
+
+  private
+  def create_or_update(attrs)
+    enrollment = Enrollment.where(canvas_enrollment_id: attrs[:canvas_enrollment_id]).first_or_initialize
+    enrollment.assign_attributes(attrs)
+    enrollment.save!
+    enrollment
+  end
+
+  def course
+    @course ||= Course.find_by(canvas_course_id: local_canvas_id(payload[:course_id]))
+  end
+
+  def section
+    @section ||= Section.find_by(canvas_section_id: local_canvas_id(payload[:section_id]))
+  end
+
+  def user
+    @user ||= User.find_by(canvas_user_id: local_canvas_id(payload[:user_id]))
+  end
+end

data/lib/canvas_sync/generators/templates/services/live_events/enrollment/enrollment_updated_event.rb

@@ -0,0 +1,4 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::EnrollmentUpdatedEvent < LiveEvents::EnrollmentEvent
+end

data/lib/canvas_sync/generators/templates/services/live_events/grade/grade_changed_event.rb

@@ -0,0 +1,4 @@
+<%= autogenerated_event_warning %>
+
+class LiveEvents::GradeChangedEvent < LiveEvents::GradeEvent
+end