canvas_sync 0.12.0 → 0.16.1

data/lib/canvas_sync/concerns/api_syncable.rb

@@ -0,0 +1,189 @@
+module CanvasSync::Concerns
+  module ApiSyncable
+    extend ActiveSupport::Concern
+    NON_EXISTANT_ERRORS = [Faraday::Error::ResourceNotFound, Footrest::HttpError::NotFound]
+
+    class_methods do
+      def find_or_fetch(canvas_id, save: false, retries: 1, **kwargs)
+        inst = find_or_initialize_by(canvas_id: canvas_id)
+        return inst if inst.persisted?
+
+        api_response = inst.request_from_api(retries: retries, **kwargs)
+        api_sync_race_create!(inst, save: save) do |inst2|
+          inst2.assign_from_api_params(api_response, **kwargs)
+        end
+      rescue *NON_EXISTANT_ERRORS
+        nil
+      end
+
+      def find_or_fetch!(*args)
+        inst = find_or_fetch(*args)
+        raise ActiveRecord::RecordNotFound unless inst.present?
+        inst
+      end
+
+      def create_or_update_from_api_params(api_params)
+        api_params = api_params.with_indifferent_access
+        api_sync_race_create!(api_params[:id]) do |inst|
+          inst.assign_from_api_params(api_params)
+        end
+      end
+
+      def api_sync_options=(opts)
+        @api_sync_options = opts
+      end
+
+      def api_sync_options
+        @api_sync_options || superclass.try(:api_sync_options)
+      end
+
+      # Define the model as being syncable via the Canvas API and configure sync options/parameters
+      # @param [Hash] map A hash of local_field => (:api_response_key | ->(api_response){ value })
+      # @param [->(bearcat?){ api_response }] fetch <description>
+      # @param [Hash] options <description>
+      # @option options [] :mark_deleted Hash to be merged | Symbol to invoke | ->(){ }
+      # @yield [api_response, [mapped_data]] Callback to merge data into a Model instance
+      def api_syncable(map, fetch, options={}, &blk)
+        default_options = {
+          mark_deleted: -> {
+            %i[workflow_state= status=].each do |sym|
+              next unless self.respond_to?(sym)
+              self.send(sym, 'deleted')
+              return
+            end
+          },
+          field_map: map,
+          fetch_from_api: fetch,
+          process_response: blk,
+        }
+        default_options.merge!(options)
+        self.api_sync_options = default_options.merge!(options)
+      end
+
+      private
+
+      def api_sync_race_create!(inst, save: true)
+        inst = find_or_initialize_by(canvas_id: inst) unless inst.is_a?(self)
+        yield inst
+        inst.save! if save && inst.changed?
+        inst
+      rescue ActiveRecord::RecordNotUnique
+        inst = find_by(canvas_id: inst.canvas_id)
+        yield inst
+        inst.save! if save && inst.changed?
+        inst
+      end
+    end
+
+    # Call the API and Syncs this model.
+    # Calls the mark_deleted workflow if a 404 is received.
+    # @param [Number] retries Number of retries
+    # @return [Hash]  Response Hash from API
+    def sync_from_api(retries: 3, **kwargs)
+      api_response = request_from_api(retries: retries, **kwargs)
+      update_from_api_params!(api_response, **kwargs)
+      api_response
+    rescue *NON_EXISTANT_ERRORS
+      api_mark_deleted
+      save! if changed?
+      nil
+    end
+
+    # Fetch this model from the API and return the response
+    # @param [Number] retries Number of retries
+    # @return [Hash] Response Hash from API
+    def request_from_api(retries: 3, **kwargs)
+      api_call_with_retry(retries || 3) {
+        blk = api_sync_options[:fetch_from_api]
+        case blk.arity
+        when 1
+          self.instance_exec(canvas_sync_client, &blk)
+        else
+          self.instance_exec(&blk)
+        end
+      }
+    end
+
+    # Apply a response Hash from the API to this model's attributes, but do not save
+    # @param [Hash] api_params API-format Hash
+    # @return [self] self
+    def assign_from_api_params(api_params, **kwargs)
+      options = self.api_sync_options
+      api_params = api_params.with_indifferent_access
+
+      map = options[:field_map]
+      mapped_params = {}
+      if map.present?
+        map.each do |local_name, remote_name|
+          if remote_name.respond_to?(:call)
+            mapped_params[local_name] = self.instance_exec(api_params, &remote_name)
+          elsif api_params.include?(remote_name)
+            mapped_params[local_name] = api_params[remote_name]
+            if remote_name == :id
+              current_value = send("#{local_name}")
+              raise "Mismatched Canvas ID" if current_value.present? && current_value != api_params[remote_name]
+            end
+          end
+        end
+      end
+
+      apply_block = options[:process_response]
+      if apply_block.present?
+        case apply_block.arity
+        when 1
+          self.instance_exec(api_params, &apply_block)
+        when 2
+          self.instance_exec(api_params, mapped_params, &apply_block)
+        end
+      else
+        mapped_params.each do |local_name, val|
+          send("#{local_name}=", val)
+        end
+      end
+      self
+    end
+
+    # Apply a response Hash from the API to this model's attributes and save if changed?
+    # @param [Hash] api_params API-format Hash
+    # @return [self] self
+    def update_from_api_params(*args)
+      assign_from_api_params(*args)
+      save if changed?
+    end
+
+    # Apply a response Hash from the API to this model's attributes, and save! if changed?
+    # @param [Hash] api_params API-format Hash
+    # @return [self] self
+    def update_from_api_params!(*args)
+      assign_from_api_params(*args)
+      save! if changed?
+    end
+
+    def api_sync_options
+      self.class.api_sync_options
+    end
+
+    private
+
+    def api_call_with_retry(retries=3)
+      tries ||= retries
+      yield
+    rescue Faraday::ConnectionFailed => e
+      raise e if (tries -= 1).zero?
+      sleep 5
+      retry
+    end
+
+    def api_mark_deleted
+      action = api_sync_options[:mark_deleted]
+      case action
+      when Hash
+        assign_attributes(action)
+      when Symbol
+        send(action)
+      when Proc
+        self.instance_exec(&action)
+      end
+    end
+  end
+end

data/lib/canvas_sync/concerns/legacy_columns.rb

@@ -0,0 +1,34 @@
+# Concern that can be used when dealing with Legacy code.
+#
+# It automatically aliases `canvas_id` -> `canvas_<model>_id` or vice-versa.
+module CanvasSync::Concerns
+  module LegacyColumns
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def inherited(subclass)
+        super.tap do
+          legacy_column_apply(subclass)
+        end
+      end
+
+      private
+
+      def legacy_column_apply(cls)
+        cid_column = "canvas_#{subclass.name.downcase}_id"
+        column_names = subclass.columns.map(&:name)
+        return if column_names.include?('canvas_id') && column_names.include?(cid_column)
+        if column_names.include?('canvas_id')
+          subclass.alias_attribute(cid_column.to_sym, :canvas_id)
+        elsif column_names.include?(cid_column)
+          subclass.alias_attribute(:canvas_id, cid_column.to_sym)
+        end
+      rescue ActiveRecord::StatementInvalid
+      end
+    end
+
+    included do
+      legacy_column_apply(self)
+    end
+  end
+end

data/lib/canvas_sync/generators/templates/migrations/create_group_memberships.rb

@@ -0,0 +1,18 @@
+# <%= autogenerated_migration_warning %>
+
+class CreateGroupMemberships < ActiveRecord::Migration[5.1]
+  def change
+    create_table :group_memberships do |t|
+      t.bigint :canvas_id, null: false
+      t.bigint :canvas_user_id, null: false
+      t.bigint :canvas_group_id, null: false
+      t.string :group_sis_id
+      t.string :user_sis_id
+      t.string :workflow_state
+
+      t.timestamps
+    end
+
+    add_index :group_memberships, :canvas_id, unique: true
+  end
+end

data/lib/canvas_sync/generators/templates/migrations/create_groups.rb

@@ -0,0 +1,23 @@
+# <%= autogenerated_migration_warning %>
+
+class CreateGroups < ActiveRecord::Migration[5.1]
+  def change
+    create_table :groups do |t|
+      t.bigint :canvas_id, null: false
+      t.string :sis_id
+      t.bigint :canvas_group_category_id
+      t.string :group_category_sis_id
+      t.bigint :canvas_account_id
+      t.bigint :canvas_course_id
+      t.string :name
+      t.string :workflow_state
+      t.bigint :context_id
+      t.string :context_type
+      t.integer :max_membership
+
+      t.timestamps
+    end
+
+    add_index :groups, :canvas_id, unique: true
+  end
+end

data/lib/canvas_sync/generators/templates/migrations/create_pseudonyms.rb

@@ -0,0 +1,18 @@
+# <%= autogenerated_migration_warning %>
+
+class CreatePseudonyms < ActiveRecord::Migration[5.1]
+  def change
+    create_table :pseudonyms do |t|
+      t.bigint :canvas_id, null: false
+      t.bigint :canvas_user_id
+      t.string :sis_id
+      t.string :unique_id
+      t.string :workflow_state
+
+      t.timestamps
+    end
+
+    add_index :pseudonyms, :canvas_id, unique: true
+    add_index :pseudonyms, :canvas_user_id
+  end
+end

data/lib/canvas_sync/generators/templates/migrations/create_submissions.rb

@@ -8,6 +8,7 @@ class CreateSubmissions < ActiveRecord::Migration[5.1]
       t.bigint :canvas_assignment_id
       t.bigint :canvas_user_id
       t.datetime :submitted_at
+      t.datetime :due_at
       t.datetime :graded_at
       t.float :score
       t.float :points_possible

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

@@ -1,11 +1,21 @@
 # <%= autogenerated_model_warning %>
 
 class Account < ApplicationRecord
-  include CanvasSync::ApiSyncable
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
+  # include CanvasSync::Concerns::Account::Ancestry # Add support for the ancestry Gem
 
   validates :canvas_id, uniqueness: true, presence: true
 
   has_many :admins, primary_key: :canvas_id, foreign_key: :canvas_account_id
+  belongs_to :canvas_parent, class_name: 'Account', optional: true,
+                             primary_key: :canvas_id, foreign_key: :canvas_parent_account_id
+  has_many :sub_accounts, class_name: 'Account',
+                          primary_key: :canvas_id, foreign_key: :canvas_parent_account_id
+  has_many :groups, primary_key: :canvas_id, foreign_key: :canvas_account_id
+
+  scope :active, -> { where.not(workflow_state: 'deleted') }
+  # scope :should_canvas_sync, -> { active } # Optional - uses .active if not given
 
   api_syncable({
     name: :name,

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

@@ -1,7 +1,8 @@
 # <%= autogenerated_model_warning %>
 
 class Admin < ApplicationRecord
-  include CanvasSync::ApiSyncable
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
 
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :account, primary_key: :canvas_id, foreign_key: :canvas_account_id, optional: true

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

@@ -1,7 +1,8 @@
 # <%= autogenerated_model_warning %>
 
 class Assignment < ApplicationRecord
-  include CanvasSync::ApiSyncable
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
 
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :context, polymorphic: true, optional: true, primary_key: :canvas_id, foreign_key: :canvas_context_id, foreign_type: :canvas_context_type

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

@@ -1,7 +1,8 @@
 # <%= autogenerated_model_warning %>
 
 class AssignmentGroup < ApplicationRecord
-  include CanvasSync::ApiSyncable
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
 
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :course, primary_key: :canvas_id, foreign_key: :canvas_course_id, optional: true

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

@@ -4,7 +4,8 @@
 #   1 - Module is a reserved word in Rails and you can't call a model a Module
 #   2 - Canvas calls them ContextModules
 class ContextModule < ApplicationRecord
-  include CanvasSync::ApiSyncable
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
 
   belongs_to :context, polymorphic: true, optional: true, primary_key: :canvas_id, foreign_key: :canvas_context_id, foreign_type: :canvas_context_type
   has_many :context_module_items, primary_key: :canvas_id, foreign_key: :canvas_context_module_id

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

@@ -1,7 +1,8 @@
 # # <%= autogenerated_migration_warning %>
 
 class ContextModuleItem < ApplicationRecord
-  include CanvasSync::ApiSyncable
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
 
   belongs_to :context_module, primary_key: :canvas_id, foreign_key: :canvas_context_module_id, optional: true
   belongs_to :content, polymorphic: true, optional: true, primary_key: :canvas_id, foreign_key: :canvas_content_id, foreign_type: :canvas_content_type

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

@@ -1,7 +1,8 @@
 # <%= autogenerated_model_warning %>
 
 class Course < ApplicationRecord
-  include CanvasSync::ApiSyncable
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
 
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :term, foreign_key: :canvas_term_id, primary_key: :canvas_id, optional: true
@@ -10,7 +11,8 @@ class Course < ApplicationRecord
   has_many :assignments, as: :context, primary_key: :canvas_id, foreign_key: :canvas_context_id, foreign_type: :canvas_context_type
   has_many :submissions, primary_key: :canvas_id, foreign_key: :canvas_course_id
   has_many :assignment_groups, primary_key: :canvas_id, foreign_key: :canvas_course_id
-  
+  has_many :groups, primary_key: :canvas_id, foreign_key: :canvas_course_id
+
   api_syncable({
     sis_id: :sis_course_id,
     course_code: :course_code,

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

@@ -1,7 +1,8 @@
 # <%= autogenerated_model_warning %>
 
 class Enrollment < ApplicationRecord
-  include CanvasSync::ApiSyncable
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
 
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :user, primary_key: :canvas_id, foreign_key: :canvas_user_id, optional: true

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

@@ -0,0 +1,19 @@
+# <%= autogenerated_model_warning %>
+
+class Group < ApplicationRecord
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
+
+  validates :canvas_id, uniqueness: true, presence: true
+  belongs_to :course, primary_key: :canvas_id, foreign_key: :canvas_course_id, optional: true
+  belongs_to :account, primary_key: :canvas_id, foreign_key: :canvas_account_id, optional: true
+  has_many :group_memberships, primary_key: :canvas_id, foreign_key: :canvas_group_id
+
+  api_syncable({
+    canvas_id: :id,
+    name: :name,
+    canvas_course_id: :course_id,
+    sis_id: :sis_group_id,
+    workflow_state: ->(r){ 'available' },
+  }, -> (api) { api.group(canvas_id) })
+end

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

@@ -0,0 +1,17 @@
+# <%= autogenerated_model_warning %>
+
+class GroupMembership < ApplicationRecord
+  include CanvasSync::Record
+  include CanvasSync::Concerns::ApiSyncable
+
+  validates :canvas_id, uniqueness: true, presence: true
+  belongs_to :group, primary_key: :canvas_id, foreign_key: :canvas_group_id
+  belongs_to :user, primary_key: :canvas_id, foreign_key: :canvas_user_id
+
+  api_syncable({
+    canvas_id: :id,
+    canvas_group_id: :group_id,
+    canvas_user_id: :user_id,
+    workflow_state: :workflow_state,
+  }, -> (api) { api.group_membership(canvas_group_id, canvas_id) })
+end

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

@@ -0,0 +1,8 @@
+# <%= autogenerated_model_warning %>
+
+class Pseudonym < ApplicationRecord
+  include CanvasSync::Record
+
+  validates :canvas_id, uniqueness: true, presence: true
+  belongs_to :user, primary_key: :canvas_id, foreign_key: :canvas_user_id
+end