canvas_sync 0.10.3 → 0.11.1

data/lib/canvas_sync/jobs/report_starter.rb

@@ -12,7 +12,7 @@ module CanvasSync
       # @return [nil]
       def perform(job_chain, report_name, report_params, processor, options, allow_redownloads: false)
         account_id = options[:account_id] || job_chain[:global_options][:account_id] || "self"
-
+	options[:sync_start_time] = DateTime.now.utc.iso8601
         report_id = if allow_redownloads
                       get_cached_report(job_chain, account_id, report_name, report_params)
                     else
@@ -28,6 +28,17 @@ module CanvasSync
         )
       end
 
+      protected
+
+      def merge_report_params(job_chain, options={}, params={}, term_scope: true)
+        term_scope = job_chain[:global_options][:canvas_term_id] if term_scope == true
+        if term_scope.present?
+          params[:enrollment_term_id] = term_scope
+        end
+        params.merge!(options[:report_params]) if options[:report_params].present?
+        { parameters: params }
+      end
+
       private
 
       def get_cached_report(job_chain, account_id, report_name, report_params)

data/lib/canvas_sync/jobs/sync_admins_job.rb

@@ -7,12 +7,16 @@ module CanvasSync
       # @param job_chain [Hash]
       # @param options [Hash]
       def perform(job_chain, _options)
-        updated_admins = []
-        CanvasSync.get_canvas_sync_client(job_chain[:global_options]).account_admins("self").all_pages!.each do |admin_params|
-          admin = Admin.create_or_update(admin_params)
-          updated_admins.push(admin.id)
+        updated_admin_ids = []
+        api_client = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+        CanvasSync.sync_scope(Account).find_each do |acc|
+          api_client.account_admins(acc.canvas_id).all_pages_each do |admin_params|
+            admin_params[:account_id] = acc.canvas_id
+            admin = update_or_create_model(Admin, admin_params)
+            updated_admin_ids.push(admin.id)
+          end
         end
-        Admin.where.not(id: updated_admins).delete_all
+        Admin.where.not(id: updated_admin_ids).update_all(workflow_state: 'inactive')
         CanvasSync.invoke_next(job_chain)
       end
     end

data/lib/canvas_sync/jobs/sync_assignment_groups_job.rb

@@ -8,17 +8,11 @@ module CanvasSync
       #
       # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
-        report_params = if job_chain[:global_options][:canvas_term_id].present?
-                          { "parameters[enrollment_term_id]" => job_chain[:global_options][:canvas_term_id] }
-                        else
-                          {}
-                        end
-
+      def perform(job_chain, options)
         super(
           job_chain,
           "proserv_assignment_group_export_csv",
-          report_params,
+          merge_report_params(job_chain, options),
           CanvasSync::Processors::AssignmentGroupsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_assignments_job.rb

@@ -8,17 +8,11 @@ module CanvasSync
       #
       # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
-        report_params = if job_chain[:global_options][:canvas_term_id].present?
-                          { "parameters[enrollment_term_id]" => job_chain[:global_options][:canvas_term_id] }
-                        else
-                          {}
-                        end
-
+      def perform(job_chain, options)
         super(
           job_chain,
           "proserv_assignment_export_csv",
-          report_params,
+          merge_report_params(job_chain, options),
           CanvasSync::Processors::AssignmentsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_context_module_items_job.rb

@@ -8,17 +8,11 @@ module CanvasSync
       #
       # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
-        report_params = if job_chain[:global_options][:canvas_term_id].present?
-                          { "parameters[enrollment_term_id]" => job_chain[:global_options][:canvas_term_id] }
-                        else
-                          {}
-                        end
-
+      def perform(job_chain, options)
         super(
           job_chain,
           "proserv_context_module_items_csv",
-          report_params,
+          merge_report_params(job_chain, options),
           CanvasSync::Processors::ContextModuleItemsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_context_modules_job.rb

@@ -8,17 +8,11 @@ module CanvasSync
       #
       # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
-        report_params = if job_chain[:global_options][:canvas_term_id].present?
-                          { "parameters[enrollment_term_id]" => job_chain[:global_options][:canvas_term_id] }
-                        else
-                          {}
-                        end
-
+      def perform(job_chain, options)
         super(
           job_chain,
           "proserv_context_modules_csv",
-          report_params,
+          merge_report_params(job_chain, options),
           CanvasSync::Processors::ContextModulesProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_provisioning_report_job.rb

@@ -8,13 +8,23 @@ module CanvasSync
       #   models to sync.
       def perform(job_chain, options)
         if options[:term_scope]
-          Term.send(options[:term_scope]).find_each do |term|
-            # Deep copy the job_chain so each report gets the correct term id passed into
-            # its options with no side effects
-            term_id = get_term_id(term)
-            duped_job_chain = Marshal.load(Marshal.dump(job_chain))
-            duped_job_chain[:global_options][:canvas_term_id] = term_id
-            start_report(report_params(options, term_id), duped_job_chain, options)
+          sub_reports = CanvasSync.fork(@job_log, job_chain, keys: [:canvas_term_id]) do |job_chain|
+            Term.send(options[:term_scope]).find_each.map do |term|
+              # Deep copy the job_chain so each report gets the correct term id passed into
+              # its options with no side effects
+              term_id = get_term_id(term)
+              duped_job_chain = Marshal.load(Marshal.dump(job_chain))
+              duped_job_chain[:global_options][:canvas_term_id] = term_id
+              {
+                job_chain: duped_job_chain,
+                params: report_params(options, term_id),
+                options: options,
+              }
+            end
+          end
+
+          sub_reports.each do |r|
+            start_report(r[:params], r[:job_chain], r[:options])
           end
         else
           start_report(report_params(options), job_chain, options)
@@ -35,16 +45,18 @@ module CanvasSync
 
       def report_params(options, canvas_term_id=nil)
         params = {
-          "parameters[include_deleted]" => true
+          include_deleted: true,
         }
 
         options[:models].each do |model|
-          params["parameters[#{model}]"] = true
+          params[model] = true
         end
 
-        params["parameters[enrollment_term_id]"] = canvas_term_id if canvas_term_id
+        params[:enrollment_term_id] = canvas_term_id if canvas_term_id
+
+        params.merge!(options[:report_parameters]) if options[:report_parameters].present?
 
-        params
+        { parameters: params }
       end
 
       def get_term_id(term)

data/lib/canvas_sync/jobs/sync_roles_job.rb

@@ -7,12 +7,15 @@ module CanvasSync
       # @param job_chain [Hash]
       # @param options [Hash]
       def perform(job_chain, _options)
-        updated_roles = []
-        CanvasSync.get_canvas_sync_client(job_chain[:global_options]).list_roles("self").all_pages!.each do |role_params|
-          role = Role.create_or_update(role_params)
-          updated_roles.push(role.id)
+        updated_role_ids = []
+        api_client = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+        CanvasSync.sync_scope(Account).find_each do |acc|
+          api_client.list_roles(acc.canvas_id, state: %w[active inactive]).all_pages_each do |role_params|
+            role = update_or_create_model(Role, role_params)
+            updated_role_ids.push(role.id)
+          end
         end
-        Role.where.not(id: updated_roles).delete_all
+        Role.where.not(id: updated_role_ids).update_all(workflow_state: 'inactive')
         CanvasSync.invoke_next(job_chain)
       end
     end

data/lib/canvas_sync/jobs/sync_simple_table_job.rb

@@ -9,13 +9,23 @@ module CanvasSync
       # @param options [Hash]
       def perform(job_chain, options)
         if options[:term_scope]
-          Term.send(options[:term_scope]).find_each do |term|
-            # Deep copy the job_chain so each report gets the correct term id passed into
-            # its options with no side effects
-            term_id = get_term_id(term)
-            duped_job_chain = Marshal.load(Marshal.dump(job_chain))
-            duped_job_chain[:global_options][:canvas_term_id] = term_id
-            start_report(report_params(options, term_id), duped_job_chain, options)
+          sub_reports = CanvasSync.fork(@job_log, job_chain, keys: [:canvas_term_id]) do |job_chain|
+            Term.send(options[:term_scope]).find_each.map do |term|
+              # Deep copy the job_chain so each report gets the correct term id passed into
+              # its options with no side effects
+              term_id = get_term_id(term)
+              duped_job_chain = Marshal.load(Marshal.dump(job_chain))
+              duped_job_chain[:global_options][:canvas_term_id] = term_id
+              {
+                job_chain: duped_job_chain,
+                params: report_params(options, term_id),
+                options: options,
+              }
+            end
+          end
+
+          sub_reports.each do |r|
+            start_report(r[:params], r[:job_chain], r[:options])
           end
         else
           start_report(report_params(options), job_chain, options)

data/lib/canvas_sync/jobs/sync_submissions_job.rb

@@ -9,14 +9,10 @@ module CanvasSync
       # @param job_chain [Hash]
       # @param options [Hash]
       def perform(job_chain, options)
-        report_params = {}
-        report_params["parameters[enrollment_term_id]"] = job_chain[:global_options][:canvas_term_id] if job_chain[:global_options][:canvas_term_id].present?
-        report_params["parameters[include_all]"] = true if options[:include_all]
-
         super(
           job_chain,
           "proserv_student_submissions_csv",
-          report_params,
+          merge_report_params(job_chain, options, { include_all: options[:include_all] }, {}),
           CanvasSync::Processors::SubmissionsProcessor.to_s,
           {},
         )

data/lib/canvas_sync/jobs/sync_terms_job.rb

@@ -10,9 +10,15 @@ module CanvasSync
       def perform(job_chain, _options)
         CanvasSync.get_canvas_sync_client(job_chain[:global_options]).terms("self").all_pages!.each do |term_params|
           if job_chain[:global_options][:account_id]
-            Term.create_or_update(term_params, job_chain[:global_options][:account_id])
+            # These branches are primarily to support Legacy apps
+            if Term.respond_to?(:create_or_update) && Term.method(:create_or_update).arity.abs == 2
+              Term.create_or_update(term_params, job_chain[:global_options][:account_id])
+            else
+              term_params[:account_id] |= job_chain[:global_options][:account_id]
+              update_or_create_model(Term, term_params)
+            end
           else
-            Term.create_or_update(term_params)
+            update_or_create_model(Term, term_params)
           end
         end
 

data/lib/canvas_sync/jobs/sync_users_job.rb

@@ -1,11 +1,6 @@
 module CanvasSync
   module Jobs
     class SyncUsersJob < ReportStarter
-      REPORT_PARAMS = {
-        "parameters[users]" => true,
-        "parameters[include_deleted]" => true
-      }.freeze
-
       # Starts a provisioning report for just users.
       #
       # Provisioning reports do not scope users by term, so when we are
@@ -14,11 +9,14 @@ module CanvasSync
       #
       # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, _options)
+      def perform(job_chain, options)
         super(
           job_chain,
           "proservices_provisioning_csv",
-          REPORT_PARAMS,
+          merge_report_params(job_chain, options, {
+            users: true,
+            include_deleted: true,
+          }, term_scope: false),
           CanvasSync::Processors::ProvisioningReportProcessor.to_s,
           { models: ["users"] },
         )

data/lib/canvas_sync/processors/assignment_groups_processor.rb

@@ -8,15 +8,16 @@ module CanvasSync
     # @param options [Hash]
     class AssignmentGroupsProcessor < ReportProcessor
       def self.process(report_file_path, _options, report_id)
-        new(report_file_path)
+        new(report_file_path, _options)
       end
 
-      def initialize(report_file_path)
+      def initialize(report_file_path, options)
         CanvasSync::Importers::BulkImporter.import(
           report_file_path,
           mapping[:assignment_groups][:report_columns],
           AssignmentGroup,
           mapping[:assignment_groups][:conflict_target].to_sym,
+          import_args: options
         )
       end
     end

data/lib/canvas_sync/processors/assignments_processor.rb

@@ -8,15 +8,16 @@ module CanvasSync
     # @param options [Hash]
     class AssignmentsProcessor < ReportProcessor
       def self.process(report_file_path, _options, report_id)
-        new(report_file_path)
+        new(report_file_path, _options)
       end
 
-      def initialize(report_file_path)
+      def initialize(report_file_path, options)
         CanvasSync::Importers::BulkImporter.import(
           report_file_path,
           mapping[:assignments][:report_columns],
           Assignment,
           mapping[:assignments][:conflict_target].to_sym,
+          import_args: options
         )
       end
     end

data/lib/canvas_sync/processors/context_module_items_processor.rb

@@ -8,15 +8,16 @@ module CanvasSync
     # @param options [Hash]
     class ContextModuleItemsProcessor < ReportProcessor
       def self.process(report_file_path, _options, report_id)
-        new(report_file_path)
+        new(report_file_path, _options)
       end
 
-      def initialize(report_file_path)
+      def initialize(report_file_path, options)
         CanvasSync::Importers::BulkImporter.import(
           report_file_path,
           mapping[:context_module_items][:report_columns],
           ContextModuleItem,
           mapping[:context_module_items][:conflict_target].to_sym,
+          import_args: options
         )
       end
     end

data/lib/canvas_sync/processors/context_modules_processor.rb

@@ -8,15 +8,16 @@ module CanvasSync
     # @param options [Hash]
     class ContextModulesProcessor < ReportProcessor
       def self.process(report_file_path, _options, report_id)
-        new(report_file_path)
+        new(report_file_path, _options)
       end
 
-      def initialize(report_file_path)
+      def initialize(report_file_path, options)
         CanvasSync::Importers::BulkImporter.import(
           report_file_path,
           mapping[:context_modules][:report_columns],
           ContextModule,
           mapping[:context_modules][:conflict_target].to_sym,
+          import_args: options
         )
       end
     end

data/lib/canvas_sync/processors/normal_processor.rb

@@ -18,7 +18,8 @@ module CanvasSync
           report_file_path,
           mapping[options[:mapping].to_sym][:report_columns],
           options[:klass].constantize,
-          conflict_target ? conflict_target.to_sym : conflict_target
+          conflict_target ? conflict_target.to_sym : conflict_target,
+          import_args: options
         )
       end
     end

data/lib/canvas_sync/processors/provisioning_report_processor.rb

@@ -21,7 +21,6 @@ module CanvasSync
 
       def initialize(report_file_path, options) # rubocop:disable Metrics/AbcSize
         @options = options
-
         if options[:models].length == 1
           run_import(options[:models][0], report_file_path)
         else
@@ -75,6 +74,7 @@ module CanvasSync
           mapping[:users][:report_columns],
           User,
           mapping[:users][:conflict_target].to_sym,
+          import_args: @options
         )
       end
 
@@ -83,7 +83,8 @@ module CanvasSync
           report_file_path,
           mapping[:accounts][:report_columns],
           Account,
-          mapping[:accounts][:conflict_target].to_sym
+          mapping[:accounts][:conflict_target].to_sym,
+          import_args: @options
         )
       end
 
@@ -93,6 +94,7 @@ module CanvasSync
           mapping[:courses][:report_columns],
           Course,
           mapping[:courses][:conflict_target].to_sym,
+          import_args: @options
         )
       end
 
@@ -102,6 +104,7 @@ module CanvasSync
           mapping[:enrollments][:report_columns],
           Enrollment,
           mapping[:enrollments][:conflict_target].to_sym,
+          import_args: @options
         )
       end
 
@@ -111,6 +114,7 @@ module CanvasSync
           mapping[:sections][:report_columns],
           Section,
           mapping[:sections][:conflict_target].to_sym,
+          import_args: @options
         )
       end
 
@@ -120,6 +124,7 @@ module CanvasSync
           mapping[:xlist][:report_columns],
           Section,
           mapping[:xlist][:conflict_target].to_sym,
+          import_args: @options
         )
       end
     end