canvas_sync 0.24.0 → 0.25.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3391d91c2c45a7bbd04099137bfc94d896b703407c71b8b04c71b0e586bd4219
-  data.tar.gz: 581742ed82c4b5cdfcbd8d2c0c7ef2d97ab6c86833aebceeb4cd1bdab881aea1
+  metadata.gz: 796a4b260f5d15302e824852208d22bfceedcb1a7695f8246a4263af91df368f
+  data.tar.gz: 1cce9fdc47ad3b93df2523943dd9a7366ae6123d62338f05cf21df02444a14f6
 SHA512:
-  metadata.gz: 8dd6fb7e8585626f31564edd76f67227e306bc4d29449f154c197d3ef289ca69d2c7371659b4a479854e9a57f0f9c3a61e68a275370a965da0f192bb97c747e8
-  data.tar.gz: a31a167d26a44df1837038db87d9584c5f7f0e2964f142c34f08efc353a2cb2f713cf8002df681d79237ece0540f97eb35d2ab9eef931033bc1e264d847c9e15
+  metadata.gz: 179dcc7dc1f1456f7614788e5af8bd79adaaa7b9623af11293da320125024f8783b8453fd136d6d9385043e4a6e84067e26902e94b09c4356f79023253c889e2
+  data.tar.gz: 38b5630b0a9da79c707bb73a736bf90ae195dff08655aa2c62c76336b5f6eea2a86ac9dc5994e8d302ec2664e9006c6993ad6d92ce5cdeb25aa71fefb8caea6d

data/lib/canvas_sync/concerns/ability_helper.rb

@@ -73,8 +73,12 @@ module CanvasSync::Concerns
     end
 
     def canvas_super_user?
-      panda_pal_session.cache(:canvas_super_user?) do
-        panda_pal_session.canvas_site_admin? || (panda_pal_session.canvas_account_role_labels(:root) & ["AccountAdmin", "Account Admin"]).present?
+      canvas_account_admin?(:root)
+    end
+
+    def canvas_account_admin?(account = launch_account)
+      panda_pal_session.cache([:canvas_account_admin?, account]) do
+        panda_pal_session.canvas_site_admin? || (panda_pal_session.canvas_account_role_labels(account) & ["AccountAdmin", "Account Admin"]).present?
       end
     end
 

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

@@ -0,0 +1,47 @@
+module CanvasSync::Concerns
+  module User
+    module ThroughPseudonyms
+      extend ActiveSupport::Concern
+      include CanvasSync::Record
+
+      CanvasSync::Record.define_feature self, default: true
+
+      class_methods do
+        def has_many_via_pseudonyms(rel_name, *args, using_sis_id: false, **kwargs)
+          kwargs[:class_name] ||= rel_name.to_s.classify
+          kwargs[:primary_key] ||= using_sis_id ? :sis_id : :canvas_id
+
+          # TODO Try and guess the foreign key?
+          # kwargs[:foreign_key] ||= using_sis_id ? :"#{rel_name}_sis_id" : :"#{rel_name}_pseudonym_canvas_id"
+
+          through_rel = using_sis_id ? :active_pseudonyms : :all_pseudonyms
+
+          pseudo_rel = :"_user_#{rel_name}_via_pseudonym"
+          Pseudonym.has_many(pseudo_rel, *args, **kwargs)
+
+          class_eval <<~RUBY
+            has_many(:#{rel_name}, through: :#{through_rel}, source: :#{pseudo_rel}, inverse_of: :student) do
+              def scope_for_create(...)
+                # @association.reflection.inverse_of
+                super.tap do |scope|
+                  user = @association.owner
+                  scope[:#{kwargs[:foreign_key]}] = user.load_pseudonym_for_relation!(any: #{!using_sis_id}).canvas_id
+                end
+              end
+            end
+          RUBY
+        end
+      end
+
+      def load_pseudonym_for_relation!(any: false)
+        return @pseudonym_for_relation if defined?(@pseudonym_for_relation)
+
+        @pseudonym_for_relation = self.active_pseudonyms[0] || Pseudonym.find_by(user: self)
+        raise ActiveRecord::RecordNotFound, "No Pseudonym for User #{self.canvas_id}" unless @pseudonym_for_relation.present?
+        raise ActiveRecord::RecordNotFound, "No Active Pseudonym for User #{self.canvas_id}" unless @pseudonym_for_relation.workflow_state != "deleted" || any
+
+        @pseudonym_for_relation
+      end
+    end
+  end
+end

data/lib/canvas_sync/concerns/user_via_pseudonym.rb

@@ -0,0 +1,141 @@
+module CanvasSync::Concerns
+  module UserViaPseudonym
+    extend ActiveSupport::Concern
+
+    module RelationHook
+      extend ActiveSupport::Concern
+
+      def where!(*args)
+        return super unless self.respond_to?(:users_via_pseudonym)
+
+        super.tap do |q|
+          args.select { |a| a.is_a?(Hash) }.each do |hash|
+            hash.each do |key, value|
+              next unless users_via_pseudonym.key?(key)
+              q.joins!(key).references!(Arel::Nodes::SqlLiteral.new(key.to_s))
+            end
+          end
+        end
+      end
+    end
+
+    ActiveRecord::Relation.include(RelationHook)
+
+    class RefreshUserCachesJob < CanvasSync::Job
+      def perform
+        ActiveRecord::Base.subclasses.each do |model|
+          next unless model.respond_to?(:update_cached_user_ids!)
+          model.update_cached_user_ids!
+        end
+      end
+    end
+
+    included do
+      class_hash :users_via_pseudonym
+    end
+
+    class_methods do
+      def class_hash(key)
+        class_eval <<~RUBY
+          def self.#{key}
+            @#{key} ||= superclass.try(:#{key})&.dup || {}
+          end
+        RUBY
+      end
+
+      def belongs_to_user(rel_name = :user, using_sis_id: false)
+        rel_name = rel_name.to_sym
+
+        pseudonym_rel_name = :"#{rel_name}_pseudonym"
+        if using_sis_id
+          belongs_to pseudonym_rel_name, -> { active }, primary_key: :sis_id, foreign_key: :"#{rel_name}_sis_id", class_name: "Pseudonym"
+        else
+          belongs_to pseudonym_rel_name, primary_key: :canvas_id, foreign_key: :"#{rel_name}_pseudonym_canvas_id", class_name: "Pseudonym"
+        end
+
+        config = users_via_pseudonym[rel_name] = {
+          user_relation: rel_name,
+          pseudonym_relation: pseudonym_rel_name,
+          by_sis_id: using_sis_id,
+        }
+
+        cache_column = :"#{rel_name}_cached_user_canvas_id"
+        if column_names.include?(cache_column.to_s)
+          belongs_to(rel_name, primary_key: :canvas_id, foreign_key: cache_column, class_name: "User")
+          config[:user_cache_column] = cache_column
+        else
+          has_one(rel_name, through: pseudonym_rel_name, source: :user)
+        end
+
+        class_eval <<~RUBY
+          def #{rel_name}=(user)
+            return if self.#{rel_name} == user
+            association(:#{pseudonym_rel_name}).writer(user&.load_pseudonym_for_relation!(any: #{!using_sis_id}))
+            association(:#{rel_name}).writer(user) if association(:#{rel_name}).class <= ActiveRecord::Associations::BelongsToAssociation
+          end
+
+          def #{pseudonym_rel_name}=(pseudonym)
+            return if self.#{pseudonym_rel_name} == pseudonym
+            association(:#{pseudonym_rel_name}).writer(pseudonym)
+            association(:#{rel_name}).writer(pseudonym&.user) if association(:#{rel_name}).class <= ActiveRecord::Associations::BelongsToAssociation
+          end
+        RUBY
+      end
+
+      def update_cached_user_ids!
+        cached_configs = users_via_pseudonym.values.select { |c| c[:user_cache_column].present? }
+        return if cached_configs.empty?
+
+        query = all
+
+        # Add JOINs
+        query = cached_configs.reduce(query) do |clause, config|
+          clause.joins(config[:pseudonym_relation]).references([ config[:pseudonym_relation], config[:user_relation] ].map { |x| Arel.sql(x.to_s) })
+        end
+
+        # Add OR clauses for filtering to only records with stale caches
+        query = cached_configs.reduce(query.where("1=0")) do |clause, config|
+          where_clause = query
+          if (updated_after = CanvasSync::JobBatches::Batch.current_context[:updated_after]).present?
+            where_clause = where_clause.where("#{config[:pseudonym_relation]}.updated_at >= ?", updated_after)
+          end
+          where_clause = where_clause.where("#{table_name}.#{config[:user_cache_column]} IS DISTINCT FROM #{config[:pseudonym_relation]}.canvas_user_id")
+          clause.or(where_clause)
+        end
+
+        query.in_batches do |batch|
+          batch = batch.to_a
+
+          cacheable_pseudonym_ids = cached_configs.map { |config| :"#{config[:pseudonym_relation]}_canvas_id" }.map { |col| batch.map(&col) }.flatten
+          user_id_map = Pseudonym.where(canvas_id: cacheable_pseudonym_ids).pluck(:canvas_id, :canvas_user_id).to_h
+
+          transaction do
+            where(id: batch.map(&:id)).delete_all
+
+            cached_configs.each do |config|
+              batch.each do |record|
+                record[config[:user_cache_column]] = user_id_map[record[:"#{config[:pseudonym_relation]}_canvas_id"]]
+              end
+            end
+
+            import_results = import(
+              batch,
+              validate: false,
+              timestamps: false,
+              on_duplicate_key_ignore: true,
+            )
+
+            failures = import_results.failed_instances
+            if failures.present?
+              handle_duplicated_cache_failures(failures)
+            end
+          end
+        end
+      end
+
+      def handle_user_cache_refresh_failures(records)
+
+      end
+    end
+  end
+end

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

@@ -8,4 +8,6 @@ class Pseudonym < ApplicationRecord
 
   validates :canvas_id, uniqueness: true, presence: true
   belongs_to :user, primary_key: :canvas_id, foreign_key: :canvas_user_id
+
+  scope :active, -> { where(workflow_state: "active") }
 end

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

@@ -17,6 +17,8 @@ class User < ApplicationRecord
 
   validates :canvas_id, uniqueness: true, presence: true
   has_many :pseudonyms, primary_key: :canvas_id, foreign_key: :canvas_user_id
+  has_many :active_pseudonyms, ->() { active }, primary_key: :canvas_id, foreign_key: :canvas_user_id, class_name: "Pseudonym"
+  has_many :all_pseudonyms, primary_key: :canvas_id, foreign_key: :canvas_user_id, class_name: "Pseudonym"
   has_many :enrollments, primary_key: :canvas_id, foreign_key: :canvas_user_id
   has_many :admins, primary_key: :canvas_id, foreign_key: :canvas_user_id
   has_many :admin_roles, through: :admins, source: :role

data/lib/canvas_sync/version.rb

@@ -1,3 +1,3 @@
 module CanvasSync
-  VERSION = "0.24.0".freeze
+  VERSION = "0.25.1".freeze
 end

data/lib/canvas_sync.rb

@@ -177,6 +177,8 @@ module CanvasSync
       term_scope = term_scope.to_s if term_scope
       options = options.deep_symbolize_keys!
 
+      given_models = models.dup
+
       model_job_map = {
         terms: CanvasSync::Jobs::SyncTermsJob,
         accounts: CanvasSync::Jobs::SyncAccountsJob,
@@ -255,6 +257,10 @@ module CanvasSync
       # Wrap it all up
       ###############################
 
+      if given_models.include?('pseudonyms')
+        root_chain << Concerns::UserViaPseudonym::RefreshUserCachesJob
+      end
+
       root_chain
     end
 

data/spec/canvas_sync/processors/provisioning_report_processor_spec.rb

@@ -113,7 +113,6 @@ RSpec.describe CanvasSync::Processors::ProvisioningReportProcessor do
         subject.process('spec/support/fixtures/reports/grading_periods.csv', { models: ['grading_periods'] }, 1)
       }.to change { GradingPeriod.count }.by(2)
       obj = GradingPeriod.find_by(canvas_id: 1)
-      puts obj.inspect
       expect(obj.title).to eq 'Period 1'
       expect(obj.weight).to eq 0.2
       expect(obj.workflow_state).to eq 'active'
@@ -124,7 +123,6 @@ RSpec.describe CanvasSync::Processors::ProvisioningReportProcessor do
         subject.process('spec/support/fixtures/reports/grading_period_groups.csv', { models: ['grading_period_groups'] }, 1)
       }.to change { GradingPeriodGroup.count }.by(1)
       obj = GradingPeriodGroup.find_by(canvas_id: 1)
-      puts obj.inspect
       expect(obj.title).to eq 'Test Group'
       expect(obj.workflow_state).to eq 'active'
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canvas_sync
 version: !ruby/object:Gem::Version
-  version: 0.24.0
+  version: 0.25.1
 platform: ruby
 authors:
 - Instructure CustomDev
@@ -453,6 +453,8 @@ files:
 - lib/canvas_sync/concerns/live_event_sync.rb
 - lib/canvas_sync/concerns/role/base.rb
 - lib/canvas_sync/concerns/sync_mapping.rb
+- lib/canvas_sync/concerns/user/through_pseudonyms.rb
+- lib/canvas_sync/concerns/user_via_pseudonym.rb
 - lib/canvas_sync/config.rb
 - lib/canvas_sync/engine.rb
 - lib/canvas_sync/generators/install_generator.rb