canvas_sync 0.10.2 → 0.10.3

data/spec/dummy/app/services/live_events/course_section_event.rb

@@ -4,51 +4,25 @@
 # You can customize it as needed, but make sure you test
 # any changes you make to the auto generated methods.
 #
+# LiveEvent message formats can be found at https://canvas.instructure.com/doc/api/file.live_events.html
+# In the general case, LiveEvent message content should not be trusted - it is highly possible that events may
+# arrive out of order. Most of the CanvasSync LiveEvent templates solve this by always fetching the object from the API.
+#
 
 
 module LiveEvents
   class CourseSectionEvent < LiveEvents::BaseEvent
-    # The following is provided in the live events call:
-    # {
-    #   course_section_id: section.id,
-    #   sis_id: section.sis_id,
-    #   sis_batch_id: section.sis_batch_id,
-    #   course_id: section.course_id,
-    #   root_account_id: section.root_account_id,
-    #   enrollment_term_id: section.enrollment_term_id,
-    #   name: section.name,
-    #   default_section: section.default_section,
-    #   accepting_enrollments: section.accepting_enrollments,
-    #   can_manually_enroll: section.can_manually_enroll,
-    #   start_at: section.start_at,
-    #   end_at: section.end_at,
-    #   workflow_state: section.workflow_state,
-    #   restrict_enrollments_to_section_dates: section.restrict_enrollments_to_section_dates,
-    #   nonxlist_course_id: section.nonxlist_course_id,
-    #   stuck_sis_fields: section.stuck_sis_fields,
-    #   integration_id: section.integration_id
-    # }
 
-    def perform(_event_payload)
-      super
-      attrs = {
-        canvas_section_id: local_canvas_id(payload[:course_section_id]),
-        canvas_course_id: local_canvas_id(payload[:course_id]),
-        name: payload[:name],
-        workflow_state: payload[:workflow_state],
-        start_at: payload[:start_at],
-        end_at: payload[:end_at],
-        canvas_nonxlist_course_id: payload[:nonxlist_course_id],
-      }
-      create_or_update(attrs)
+    def process
+      section = Section.where(canvas_id: local_canvas_id(payload[:course_section_id])).first_or_initialize
+      section.sync_from_api
+      # A section change could constitute a crosslisting change, which means
+      # we need to make sure all our enrollments are pointing to the correct course
+      section.enrollments.update_all(canvas_course_id: section.canvas_course_id)
     end
 
-    private
-
-    def create_or_update(attrs)
-      section = Section.where(canvas_section_id: attrs[:canvas_section_id]).first_or_initialize
-      section.assign_attributes(attrs)
-      section.save!
-    end
   end
+
+  class CourseSectionCreatedEvent < LiveEvents::CourseSectionEvent; end
+  class CourseSectionUpdatedEvent < LiveEvents::CourseSectionEvent; end
 end

data/spec/dummy/app/services/live_events/enrollment_event.rb

@@ -4,58 +4,27 @@
 # You can customize it as needed, but make sure you test
 # any changes you make to the auto generated methods.
 #
+# LiveEvent message formats can be found at https://canvas.instructure.com/doc/api/file.live_events.html
+# In the general case, LiveEvent message content should not be trusted - it is highly possible that events may
+# arrive out of order. Most of the CanvasSync LiveEvent templates solve this by always fetching the object from the API.
+#
 
 
 module LiveEvents
   class 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(payload)
-      super
-      return if course.nil? || section.nil? || user.nil?
-      attrs = {
-        canvas_enrollment_id: local_canvas_id(payload[:enrollment_id]),
-        canvas_course_id: course.try(:id),
-        canvas_user_id: user.try(:id),
-        role: payload[:type],
-        canvas_section_id: section.try(:id),
-        status: payload[:workflow_state],
-      }
-      create_or_update(attrs)
-    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]))
+    attr_accessor :enrollment
+
+    def process()
+      @enrollment = Enrollment.where(canvas_id: local_canvas_id(payload[:enrollment_id])).first_or_initialize
+      enrollment.canvas_course_id = local_canvas_id(payload[:course_id])
+      enrollment.sync_from_api
+      if enrollment.user.nil?
+        u = User.new(canvas_id: enrollment.canvas_user_id)
+        u.sync_from_api
+      end
     end
   end
+
+  class EnrollmentCreatedEvent < LiveEvents::EnrollmentEvent; end
+  class EnrollmentUpdatedEvent < LiveEvents::EnrollmentEvent; end
 end

data/spec/dummy/app/services/live_events/grade_event.rb

@@ -4,48 +4,21 @@
 # You can customize it as needed, but make sure you test
 # any changes you make to the auto generated methods.
 #
+# LiveEvent message formats can be found at https://canvas.instructure.com/doc/api/file.live_events.html
+# In the general case, LiveEvent message content should not be trusted - it is highly possible that events may
+# arrive out of order. Most of the CanvasSync LiveEvent templates solve this by always fetching the object from the API.
+#
 
 
 module LiveEvents
   class GradeEvent < LiveEvents::BaseEvent
-    # The following is provided in the live events call:
-    # {
-    #   submission_id: submission.global_id,
-    #   assignment_id: submission.global_assignment_id,
-    #   grade: submission.grade,
-    #   old_grade: old_submission.try(:grade),
-    #   score: submission.score,
-    #   old_score: old_submission.try(:score),
-    #   points_possible: submission.assignment.points_possible,
-    #   old_points_possible: old_assignment.points_possible,
-    #   grader_id: grader_id,
-    #   student_id: submission.global_user_id,
-    #   user_id: submission.global_user_id,
-    #   grading_complete: submission.graded?,
-    #   muted: submission.muted_assignment?
-    # }
-
-    def perform(event_payload)
-      super
-      attrs = {
-        submission_id: submission.try(:id),
-        assignment_id: assignment.try(:id),
-        score: payload[:score],
-        points_possible: payload[:points_possible],
-        grader_id: payload[:grader_id],
-        user_id: user.try(:id),
-        grading_complete: payload[:grading_complete],
-        muted: payload[:muted],
-      }
-      create_or_update(attrs)
+
+    def process
+      raise "process must be implemented in your subclass"
     end
 
     private
 
-    def create_or_update(attrs)
-      # TODO: add your code here
-    end
-
     def submission
       Submission.find_by(canvas_submission_id: local_canvas_id(payload[:submission_id]))
     end
@@ -58,4 +31,6 @@ module LiveEvents
       User.find_by(canvas_user_id: local_canvas_id(payload[:user_id]))
     end
   end
+
+  class GradeChangedEvent < LiveEvents::GradeEvent; end
 end

data/spec/dummy/app/services/live_events/module_event.rb

@@ -4,42 +4,23 @@
 # You can customize it as needed, but make sure you test
 # any changes you make to the auto generated methods.
 #
+# LiveEvent message formats can be found at https://canvas.instructure.com/doc/api/file.live_events.html
+# In the general case, LiveEvent message content should not be trusted - it is highly possible that events may
+# arrive out of order. Most of the CanvasSync LiveEvent templates solve this by always fetching the object from the API.
+#
 
 
 module LiveEvents
   class ModuleEvent < LiveEvents::BaseEvent
-    # The following is provided in the live events call:
-    # {
-    #   module_id,
-    #   context_id,
-    #   context_type,
-    #   name,
-    #   position,
-    #   workflow_state,
-    # }
-
-    def perform(_event_payload)
-      super
-      create_or_update_from_api(payload)
-    end
-
-    private
 
-    def create_or_update_from_api(payload)
+    def process
       return unless payload["context_type"] == "Course"
       context_module = ContextModule.find_or_initialize_by(canvas_id: payload["module_id"])
-      api_params = canvas_sync_client.course_module(payload["context_id"], payload["module_id"])
-
-      context_module.assign_attributes(
-        canvas_context_id: payload["context_id"],
-        canvas_context_type: payload["context_type"],
-        position: api_params["position"],
-        name: api_params["name"],
-        workflow_state: payload["workflow_state"],
-        unlock_at: api_params["unlock_at"],
-      )
-
-      context_module.save! if context_module.changed?
+      context_module.sync_from_api
     end
+
   end
+
+  class ModuleCreatedEvent < LiveEvents::ModuleEvent; end
+  class ModuleUpdatedEvent < LiveEvents::ModuleEvent; end
 end

data/spec/dummy/app/services/live_events/module_item_event.rb

@@ -4,40 +4,22 @@
 # You can customize it as needed, but make sure you test
 # any changes you make to the auto generated methods.
 #
+# LiveEvent message formats can be found at https://canvas.instructure.com/doc/api/file.live_events.html
+# In the general case, LiveEvent message content should not be trusted - it is highly possible that events may
+# arrive out of order. Most of the CanvasSync LiveEvent templates solve this by always fetching the object from the API.
+#
 
 
 module LiveEvents
   class ModuleItemEvent < LiveEvents::BaseEvent
-    # The following is provided in the live events call:
-    # {
-    #   module_item_id,
-    #   module_id,
-    #   context_id,
-    #   context_type,
-    #   position,
-    #   workflow_state,
-    # }
-
-    def perform(_event_payload)
-      super
-      create_or_update_from_api(payload)
-    end
-
-    private
 
-    def create_or_update_from_api(payload)
+    def process
       context_module_item = ContextModuleItem.find_or_initialize_by(canvas_id: payload["module_item_id"])
-      api_params = canvas_sync_client.module_item(payload["context_id"], payload["module_id"], payload["module_item_id"])
-
-      context_module_item.assign_attributes(
-        canvas_context_module_id: payload["module_id"],
-        position: payload["position"],
-        workflow_state: payload["workflow_state"],
-        canvas_content_id: api_params["content_id"],
-        canvas_content_type: api_params["type"],
-      )
-
-      context_module_item.save! if context_module_item.changed?
+      context_module_item.sync_from_api
     end
+
   end
+
+  class ModuleItemCreatedEvent < LiveEvents::ModuleItemEvent; end
+  class ModuleItemUpdatedEvent < LiveEvents::ModuleItemEvent; end
 end

data/spec/dummy/app/services/live_events/submission_event.rb

@@ -4,55 +4,25 @@
 # You can customize it as needed, but make sure you test
 # any changes you make to the auto generated methods.
 #
+# LiveEvent message formats can be found at https://canvas.instructure.com/doc/api/file.live_events.html
+# In the general case, LiveEvent message content should not be trusted - it is highly possible that events may
+# arrive out of order. Most of the CanvasSync LiveEvent templates solve this by always fetching the object from the API.
+#
 
 
 module LiveEvents
   class SubmissionEvent < LiveEvents::BaseEvent
-    # The following is provided in the live events call:
-    # {
-    #     submission_id: submission.global_id,
-    #     assignment_id: submission.global_assignment_id,
-    #     user_id: submission.global_user_id,
-    #     submitted_at: submission.submitted_at,
-    #     graded_at: submission.graded_at,
-    #     updated_at: submission.updated_at,
-    #     score: submission.score,
-    #     grade: submission.grade,
-    #     submission_type: submission.submission_type,
-    #     body: LiveEvents.truncate(submission.body),
-    #     url: submission.url,
-    #     attempt: submission.attempt
-    # }
 
-    def perform(event_payload)
-      super
-      return if assignment.nil? || user.nil?
-      attrs = {
-        canvas_submission_id: local_canvas_id(payload[:submission_id]),
-        canvas_assignment_id: assignment.try(:id),
-        canvas_user_id: user.try(:id),
-        submitted_at: payload[:submitted_at],
-        graded_at: payload[:graded_at],
-        score: payload[:score],
-      }
-      create_or_update(attrs)
+    def process
+      submission = Submission.where(canvas_id: local_canvas_id(payload["submission_id"])).first_or_initialize
+      submission.canvas_assignment_id = local_canvas_id(payload["assignment_id"])
+      submission.canvas_user_id = local_canvas_id(payload["user_id"])
+      submission.canvas_course_id = submission.assignment.context.canvas_id
+      submission.sync_from_api
     end
-  end
-
-  private
 
-  def create_or_update(attrs)
-    submission = Submission.where(canvas_submission_id: attrs[:canvas_submission_id]).first_or_initialize
-    submission.assign_attributes(attrs)
-    submission.save!
-    submission
   end
 
-  def assignment
-    @assignment ||= Assignment.find_by(canvas_assignment_id: local_canvas_id(payload[:assignment_id]))
-  end
-
-  def user
-    @user ||= User.find_by(canvas_user_id: local_canvas_id(payload[:user_id]))
-  end
+  class SubmissionCreatedEvent < LiveEvents::SubmissionEvent; end
+  class SubmissionUpdatedEvent < LiveEvents::SubmissionEvent; end
 end

data/spec/dummy/app/services/live_events/syllabus_event.rb

@@ -4,37 +4,28 @@
 # You can customize it as needed, but make sure you test
 # any changes you make to the auto generated methods.
 #
+# LiveEvent message formats can be found at https://canvas.instructure.com/doc/api/file.live_events.html
+# In the general case, LiveEvent message content should not be trusted - it is highly possible that events may
+# arrive out of order. Most of the CanvasSync LiveEvent templates solve this by always fetching the object from the API.
+#
 
 
 module LiveEvents
   class SyllabusEvent < LiveEvents::BaseEvent
-    # The following is provided in the live events call:
-    # {
-    #   course_id: course.global_id,
-    #   syllabus_body: LiveEvents.truncate(course.syllabus_body),
-    #   old_syllabus_body: LiveEvents.truncate(old_syllabus_body)
-    # }
-    #
 
-    def perform(event_payload)
-      super
-      attrs = {
-        course_id: course.try(:id),
-        syllabus_body: payload[:syllabus_body],
-      }
-      create_or_update(attrs)
+    def process
+      # syllabus = Syllabus.where(course_id: attrs[:course_id]).first_or_initialize
+      # syllabus.body = attrs[:syllabus_body] # Syllabus Body can get truncated by live events
+      # syllabus.save!
+      raise "process must be implemented in your subclass"
     end
 
     private
 
-    def create_or_update(attrs)
-      syllabus = Syllabus.where(course_id: attrs[:course_id]).first_or_initialize
-      syllabus.body = attrs[:syllabus_body] # Syllabus Body can get truncated by live events
-      syllabus.save!
-    end
-
     def course
       Course.find_by(canvas_course_id: local_canvas_id(payload[:course_id]))
     end
   end
+
+  class SyllabusUpdatedEvent < LiveEvents::SyllabusEvent; end
 end

data/spec/dummy/app/services/live_events/user_event.rb

@@ -4,37 +4,26 @@
 # You can customize it as needed, but make sure you test
 # any changes you make to the auto generated methods.
 #
+# LiveEvent message formats can be found at https://canvas.instructure.com/doc/api/file.live_events.html
+# In the general case, LiveEvent message content should not be trusted - it is highly possible that events may
+# arrive out of order. Most of the CanvasSync LiveEvent templates solve this by always fetching the object from the API.
+#
 
 
 module LiveEvents
   class UserEvent < LiveEvents::BaseEvent
-    # The following is provided in the live events call:
-    # {
-    #   user_id: user.global_id,
-    #   uuid: user.uuid,
-    #   name: user.name,
-    #   short_name: user.short_name,
-    #   workflow_state: user.workflow_state,
-    #   created_at: user.created_at,
-    #   updated_at: user.updated_at
-    # }
 
-    def perform(event_payload)
-      super
-      attrs = {
-        canvas_user_id: local_canvas_id(payload[:user_id]),
-        name: payload[:name],
-        status: payload[:workflow_state],
-      }
-      create_or_update(attrs)
+    def process
+      canvas_user_id = local_canvas_id(payload[:user_id])
+      user = User.where(canvas_id: canvas_user_id).first_or_initialize
+      user.sync_from_api
+    rescue Footrest::HttpError::Unauthorized => e
+      # This can happen when a new user is created, but hasn't setup a login on Canvas yet.
+      Rails.logger.info("Failed to fetch user #{canvas_user_id}: #{e.backtrace}")
     end
 
-    private
-
-    def create_or_update(attrs)
-      user = User.where(canvas_user_id: attrs[:canvas_user_id]).first_or_initialize
-      user.assign_attributes(attrs)
-      user.save!
-    end
   end
+
+  class UserCreatedEvent < LiveEvents::UserEvent; end
+  class UserUpdatedEvent < LiveEvents::UserEvent; end
 end