canvas_sync 0.22.9 → 0.22.12.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0537b456eab7c4816125ddf995d80bb0afbd49a5d2f197fba4367e9753a85de7
-  data.tar.gz: e8789634293ef5517faba77d4c654036d45fc42f5aad69b836736dea2cd5f1dd
+  metadata.gz: 76f6f3637d9ecdc189ecc30fdac1016655a43d0bd86af95e4662c000a96a8210
+  data.tar.gz: 573116e847a84823a69a293266f29a47c9979a9ad3207177702657a796ed5310
 SHA512:
-  metadata.gz: 83fc5373c5bb541d163e4c5bcfee7adf43c2f5c70a6957a879d657b03a48a7ef5b96adde4b28fefadf913533942a538d7b014a0409ed41b6fed694191ec9d2ac
-  data.tar.gz: 5b212e20447e8a743e276407e7251ede63bdf1df2650d1378c60a40fedff6ef29efe716d25f1ec6a6c0ca1e7f6938c2b3b012d677189c5b158c876209ae5f48f
+  metadata.gz: 44ae47c098f47555afee2d9bdcbba35b8ac7afbf5dadbece224c133ffefccd4efb32023d0b38a698f48e9cb24427e07ce7cc6ed34cbcc0181c80ec7bc38a430c
+  data.tar.gz: 05347f7d9b3f0950c05ae6af133d7ea6d0e9237b8fa4f7872faa4fc93233e5ed4aa9050955f90515744fb15fd8d8f52112a813c08151e848c918c4135741d8b3

data/lib/canvas_sync/concerns/auto_relations.rb

@@ -0,0 +1,11 @@
+module CanvasSync::Concerns
+  module AutoRelations
+    extend ActiveSupport::Concern
+
+    # CanvasSync::Record.define_feature self, default: true
+
+    included do
+
+    end
+  end
+end

data/lib/canvas_sync/concerns/live_event_sync.rb

@@ -3,27 +3,95 @@ module CanvasSync::Concerns
   module LiveEventSync
     extend ActiveSupport::Concern
 
+    mattr_accessor :registered_models
+    self.registered_models = []
+
+    def self.register_model(model)
+      self.registered_models << model
+    end
+
+    def self.lookup_event_model(event_model)
+      self.registered_models.each do |model|
+        event_prefix = model.live_events_config[:event_prefix].presence || model.name.underscore
+        return model if event_model == event_prefix
+      end
+      nil
+    end
+
+    def self.split_event_name(event_name)
+      model, _, subtype = event_name.rpartition('_')
+      [model, subtype.to_sym]
+    end
+
     included do
       define_model_callbacks :process_live_event
+      CanvasSync::Concerns::LiveEventSync.register_model(self)
     end
 
+    VALID_CONFIG_KEYS = %i[event_prefix key].freeze
+
     class_methods do
+      def live_events_config(**kwargs)
+        @live_events_config ||= {}
+        if kwargs.present?
+          raise ArgumentError, "Invalid keys: #{kwargs.keys - VALID_CONFIG_KEYS}" if (kwargs.keys - VALID_CONFIG_KEYS).present?
+          @live_events_config.merge!(kwargs)
+        end
+        @live_events_config
+      end
+
       def cs_internal_process_live_event(event)
         meta = event[:metadata]
         payload = event[:payload] || event[:body]
 
-        canvas_id = payload[:id] || payload[:"#{name.underscore}_id"]
-        inst = self.find_or_initialize_by(canvas_id: canvas_id)
-        model, _, subtype = meta[:event_name].rpartition('_')
+        model, subtype = CanvasSync::Concerns::LiveEventSync.split_event_name(meta[:event_name])
+        cfg = self.live_events_config
+
+        Thread.current[:cs_current_live_event] = {
+          event: meta[:event_name],
+          type: model,
+          action: subtype,
+          meta: meta,
+          payload: payload,
+        }
+
+        pkey = cfg[:key]
+        if pkey.present?
+          if pkey.is_a?(Symbol)
+            lookup = payload[pkey]
+          elsif pkey.is_a?(Proc)
+            lookup = pkey.call(payload, meta)
+          end
+        else
+          lookup = payload[:id]
+          lookup ||= payload[:"#{cfg[:event_prefix]}_id"] if cfg[:event_prefix].present?
+          lookup ||= payload[:"#{model}_id"]
+          lookup ||= payload[:"#{name.underscore}_id"]
+        end
+
+        if lookup.is_a?(String) || lookup.is_a?(Numeric)
+          lookup = { canvas_id: lookup }
+        end
+
+        if lookup.is_a?(Hash)
+          inst = self.find_or_initialize_by(**lookup)
+        elsif lookup.is_a?(ActiveRecord::Base)
+          inst = lookup
+        end
 
         result = inst.run_callbacks(:process_live_event) do
-          inst.process_live_event(subtype.to_sym, payload, meta)
+          inst.process_live_event(subtype, payload, meta)
         end
 
         inst.save! if result != false && inst.changed?
+        Thread.current[:cs_current_live_event] = nil
       end
     end
 
+    def current_live_event
+      Thread.current[:cs_current_live_event]
+    end
+
     def process_live_event(event_type, payload, metadata)
       if self.has_attribute?(:workflow_state) && payload['workflow_state'].present? && payload['workflow_state'] == 'deleted'
         # API will respond with 404, so just update the workflow_state
@@ -41,8 +109,8 @@ module CanvasSync::Concerns
 
     event_type = meta[:event_name]
 
-    model, _, subtype = event_type.rpartition('_')
-    mcls = model.classify.constantize rescue nil
+    model, subtype = split_event_name(event_type)
+    mcls = lookup_event_model(model)
 
     if mcls.present? && mcls < LiveEventSync
       mcls.cs_internal_process_live_event(event)

data/lib/canvas_sync/concerns/user/sharded.rb

@@ -0,0 +1,18 @@
+module CanvasSync::Concerns
+  module User
+    module CanvasSharded
+      extend ActiveSupport::Concern
+
+      CanvasSync::Record.define_feature self, default: false
+
+      included do
+
+      end
+
+      class_methods do
+
+      end
+
+    end
+  end
+end

data/lib/canvas_sync/job_batches/compat/sidekiq/web/batches_assets/js/batch_tree.js

@@ -1,5 +1,5 @@
-import { h, Component, render } from 'https://unpkg.com/preact?module';
-import htm from 'https://unpkg.com/htm?module';
+import { h, Component, render } from 'https://esm.sh/preact';
+import htm from 'https://esm.sh/htm';
 import { root_url } from './util.js';
 
 // Initialize htm with Preact

data/lib/canvas_sync/job_batches/jobs/concurrent_batch_job.rb

@@ -5,9 +5,9 @@ module CanvasSync::JobBatches
     def self.make_batch(sub_jobs, **kwargs, &blk)
       ManagedBatchJob.make_batch(
         sub_jobs,
+        concurrency: true,
         **kwargs,
         ordered: false,
-        concurrency: true,
         desc_prefix: 'ConcurrentBatchJob: ',
         &blk
       )

data/lib/canvas_sync/jobs/term_batches_job.rb

@@ -19,14 +19,14 @@ module CanvasSync
                 end
               end
 
-              JobBatches::ManagedBatchJob.make_batch(jobs, ordered: false, concurrency: true) do |b|
+              JobBatches::ManagedBatchJob.make_batch(jobs, ordered: false, concurrency: 8) do |b|
                 b.description = "TermBatchJob(#{term_id}) Root"
                 b.context = local_context
                 b.on(:success, "#{self.class.to_s}.batch_finished") unless options[:mark_synced] == false
               end
             end
           else
-            JobBatches::ConcurrentBatchJob.make_batch(jobs, context: context)
+            JobBatches::ConcurrentBatchJob.make_batch(jobs, context: context, concurrency: 8)
           end
         end
       end