canvas_sync 0.3.12 → 0.3.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c6eec06420fbb476e980bf7c1aae7d9f8679eb6b98558de1cb7765f5df13a12
-  data.tar.gz: 60963185f828d72df3e2a24d3bb3d1d4cf4dde73c0e2a9ce38f0c2147c178d70
+  metadata.gz: 0e20004cc4e924da4afb400f82f223abcf3b384afda17db07e66923528586f35
+  data.tar.gz: d0b270232aa379fc899a19b20c659f71b6bbf211e2c0dea70f010f3b02a59678
 SHA512:
-  metadata.gz: 45c726b97e96b370c84fa2393d4d4378a22f145bf3b7f4544c4f78f1aff2a0a0b40b76e3b9d5c5e920e3ff423f6da0e5b8893f6744f05de69dcbfdabe5ea42d4
-  data.tar.gz: 02d4f57c81e21724da088b3bf877b88a507895da1fd595335a0f42581d82e3875646084ce229f0d58d6c5ad72b4e13e68712e1befab589bea2673193b3e7c9de
+  metadata.gz: cbe225d20cc4f43382d70c3594798f4cf69013ca3b9094a6180e0be0f71db98c97d924792bb9711fd4868f6b0afbf9a17ebed8e2c569c23fcf94a2d88a3caf7b
+  data.tar.gz: f3d814550bbeac5deb732ca77f49942f703a6cd3ddca1351d53b794181c33527f6604007fed4dd3619c9af851cc0590f50a42d0c32f9872360c44868c686e72a

data/README.md

@@ -26,7 +26,7 @@ bundle exec rake db:migrate
 
 For a list of currently supported models, see `CanvasSync::SUPPORTED_MODELS`.
 
-Additionally, your Canvas instance must have the "Proserv Provisioning Report" enabled.
+Additionally, your Canvas instance must have the "Proserv Provisioning Report" enabled. If you are syncing assignments the "Assignment Report" report must be enabled.
 
 ## Prerequisites
 

data/app/controllers/api/v1/health_check_controller.rb

@@ -1,7 +1,9 @@
-class Api::V1::HealthCheckController < ActionController::Base
-
-  def ping
-    head :ok
+module Api
+  module V1
+    class HealthCheckController < ActionController::Base
+      def ping
+        head :ok
+      end
+    end
   end
-
-end
+end

data/app/controllers/api/v1/live_events_controller.rb

@@ -1,16 +1,18 @@
-class Api::V1::LiveEventsController < ActionController::Base
-
-  def process_event
-    payload = SymmetricEncryption.decrypt(params[:payload])
-    payload = JSON.parse(payload)
-    Rails.logger.debug("Processing event type: #{payload['attributes']['event_name']}")
-    Rails.logger.debug("Payload: #{payload}")
-    event = "LiveEvents::#{payload['attributes']['event_name'].camelcase}Event".constantize
-    event.perform_later(payload)
-    head :ok
-  rescue => e
-    Rails.logger.error("Live Events Error: #{e.message} - #{e.backtrace}")
-    render json: {error: "Live Events Error: #{e.message}"}, status: 422
+module Api
+  module V1
+    class LiveEventsController < ActionController::Base
+      def process_event # rubocop:disable Metrics/AbcSize
+        payload = SymmetricEncryption.decrypt(params[:payload])
+        payload = JSON.parse(payload)
+        Rails.logger.debug("Processing event type: #{payload['attributes']['event_name']}")
+        Rails.logger.debug("Payload: #{payload}")
+        event = "LiveEvents::#{payload['attributes']['event_name'].camelcase}Event".constantize
+        event.perform_later(payload)
+        head :ok
+      rescue => e # rubocop:disable Style/RescueStandardError
+        Rails.logger.error("Live Events Error: #{e.message} - #{e.backtrace}")
+        render json: { error: "Live Events Error: #{e.message}" }, status: 422
+      end
+    end
   end
-
 end

data/app/models/canvas_sync/job_log.rb

@@ -5,7 +5,7 @@ module CanvasSync
   class JobLog < ApplicationRecord
     serialize :job_arguments, Array
 
-    ERROR_STATUS = 'error'
-    SUCCESS_STATUS = 'success'
+    ERROR_STATUS = "error".freeze
+    SUCCESS_STATUS = "success".freeze
   end
 end

data/lib/canvas_sync.rb

@@ -1,7 +1,6 @@
 require "bearcat"
 require "canvas_sync/version"
 require "canvas_sync/engine"
-
 require "canvas_sync/job"
 require "canvas_sync/jobs/report_starter"
 require "canvas_sync/jobs/report_checker"
@@ -12,7 +11,6 @@ require "canvas_sync/jobs/sync_terms_job"
 require "canvas_sync/jobs/sync_users_job"
 require "canvas_sync/jobs/sync_roles_job"
 require "canvas_sync/jobs/sync_admins_job"
-
 Dir[File.dirname(__FILE__) +  "/canvas_sync/processors/*.rb"].each { |file| require file }
 Dir[File.dirname(__FILE__) +  "/canvas_sync/importers/*.rb"].each { |file| require file }
 Dir[File.dirname(__FILE__) +  "/canvas_sync/generators/*.rb"].each { |file| require file }
@@ -77,36 +75,34 @@ module CanvasSync
   # @param account_id [Integer, nil] This optional parameter can be used if your Term creation and
   #   canvas_sync_client methods require an account ID.
   # @return [Hash]
-  def self.default_provisioning_report_chain(models, term_scope=nil, legacy_support=false, account_id=nil)
+  def self.default_provisioning_report_chain(models, term_scope=nil, legacy_support=false, account_id=nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
     term_scope = term_scope.to_s if term_scope
 
-
     # Always sync Terms first
     jobs = [{ job: CanvasSync::Jobs::SyncTermsJob.to_s, options: {} }]
 
-    if models.include?('users') && term_scope.present?
-      # Sync all users first when scoping by term, because users cannot be scoped to term
-      jobs.push({ job: CanvasSync::Jobs::SyncUsersJob.to_s, options: {} })
-      models = models - ['users']
+    # Users, roles, and admins are synced before provisioning because they cannot be scoped to term
+    if models.include?("users") && term_scope.present?
+      jobs.push(job: CanvasSync::Jobs::SyncUsersJob.to_s, options: {})
+      models -= ["users"]
     end
 
-    if models.include?('roles')
-      # Sync all roles first when scoping by term, because roles cannot be scoped to term
-      jobs.push({ job: CanvasSync::Jobs::SyncRolesJob.to_s, options: {} })
-      models = models - ['roles']
+    if models.include?("roles")
+      jobs.push(job: CanvasSync::Jobs::SyncRolesJob.to_s, options: {})
+      models -= ["roles"]
     end
 
-    if models.include?('admins')
-      # Sync all admins first when scoping by term, because admins cannot be scoped to term
-      jobs.push({ job: CanvasSync::Jobs::SyncAdminsJob.to_s, options: {} })
-      models = models - ['admins']
+    if models.include?("admins")
+      jobs.push(job: CanvasSync::Jobs::SyncAdminsJob.to_s, options: {})
+      models -= ["admins"]
     end
 
-    jobs.push(job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s, options: { term_scope: term_scope, models: models })
+    jobs.push(
+      job: CanvasSync::Jobs::SyncProvisioningReportJob.to_s,
+      options: { term_scope: term_scope, models: models },
+    )
 
-    if models.include?("assignments")
-      jobs.push(job: CanvasSync::Jobs::SyncAssignmentsJob.to_s, options: {})
-    end
+    jobs.push(job: CanvasSync::Jobs::SyncAssignmentsJob.to_s, options: {}) if models.include?("assignments")
 
     global_options = { legacy_support: legacy_support }
     global_options[:account_id] = account_id if account_id.present?
@@ -126,19 +122,15 @@ module CanvasSync
     end
   end
 
-  private
-
   def self.validate_models!(models)
     invalid = models - SUPPORTED_MODELS
-    if invalid.length > 0
-      raise "Invalid model(s) specified: #{invalid.join(', ')}. Only #{SUPPORTED_MODELS.join(', ')} are supported."
-    end
+    return if invalid.empty?
+    raise "Invalid model(s) specified: #{invalid.join(', ')}. Only #{SUPPORTED_MODELS.join(', ')} are supported."
   end
 
   def self.validate_live_events!(events)
     invalid = events - SUPPORTED_LIVE_EVENTS
-    if invalid.length > 0
-      raise "Invalid live event(s) specified: #{invalid.join(', ')}. Only #{SUPPORTED_LIVE_EVENTS.join(', ')} are supported."
-    end
+    return if invalid.empty?
+    raise "Invalid live event(s) specified: #{invalid.join(', ')}. Only #{SUPPORTED_LIVE_EVENTS.join(', ')} are supported."
   end
 end

data/lib/canvas_sync/engine.rb

@@ -1,4 +1,4 @@
-require 'rails'
+require "rails"
 
 module CanvasSync
   class Engine < ::Rails::Engine
@@ -9,7 +9,7 @@ module CanvasSync
         app.config.paths["db/migrate"] << expanded_path
       end
       # Apartment will modify this, but it doesn't fully support engine migrations, so we'll reset it here
-      ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
+      ActiveRecord::Migrator.migrations_paths = Rails.application.paths["db/migrate"].to_a
     end
   end
 end

data/lib/canvas_sync/generators/install_generator.rb

@@ -4,7 +4,7 @@ require "rails/generators/migration"
 module CanvasSync
   class InstallGenerator < Rails::Generators::Base
     include Rails::Generators::Migration
-    source_root File.expand_path('../templates/models', __FILE__)
+    source_root File.expand_path("../templates/models", __FILE__)
     class_option :models, type: :string, required: true
 
     def self.next_migration_number(path)
@@ -42,7 +42,7 @@ module CanvasSync
     #
     # bin/rails generate canvas_sync:install --models all
     def generate_migrations_and_models
-      models = options['models'] == 'all' ? CanvasSync::SUPPORTED_MODELS : options['models'].split(',')
+      models = options["models"] == "all" ? CanvasSync::SUPPORTED_MODELS : options["models"].split(",")
       CanvasSync.validate_models!(models)
 
       models.each do |model|

data/lib/canvas_sync/generators/install_live_events_generator.rb

@@ -2,7 +2,7 @@ require "rails/generators"
 
 module CanvasSync
   class InstallLiveEventsGenerator < Rails::Generators::Base
-    source_root File.expand_path('../templates/services/live_events', __FILE__)
+    source_root File.expand_path("../templates/services/live_events", __FILE__)
     class_option :events, type: :string, required: true
 
     def autogenerated_event_warning
@@ -24,15 +24,15 @@ module CanvasSync
     #
     # bin/rails generate canvas_sync:install_live_events --events all
     def generate_live_events
-      events = options['events'] == 'all' ? CanvasSync::SUPPORTED_LIVE_EVENTS : options['events'].split(',')
+      events = options["events"] == "all" ? CanvasSync::SUPPORTED_LIVE_EVENTS : options["events"].split(",")
       CanvasSync.validate_live_events!(events)
 
       events.each do |event|
         Dir.glob("#{File.dirname(__FILE__)}/templates/services/live_events/#{event}/*.rb") do |rb_file|
-          template "#{rb_file}", "app/services/live_events/#{File.basename(rb_file)}"
+          template rb_file.to_s, "app/services/live_events/#{File.basename(rb_file)}"
         end
       end
-      template 'base_event.rb', 'app/services/live_events/base_event.rb'
+      template "base_event.rb", "app/services/live_events/base_event.rb"
     end
   end
 end

data/lib/canvas_sync/generators/templates/services/live_events/syllabus/syllabus_updated_event.rb

@@ -1,2 +1,4 @@
+<%= autogenerated_event_warning %>
+
 class LiveEvents::SyllabusUpdatedEvent < LiveEvents::SyllabusEvent
-end
+end

data/lib/canvas_sync/importers/bulk_importer.rb

@@ -17,9 +17,9 @@ module CanvasSync
       #        Note: passing the key [:on_duplicate_key_ignore] will override the default behavior of [:on_duplicate_key_update]
       # @yieldparam [Array] row if a block is passed in it will yield the current row from the CSV.
       #   This can be used if you need to filter or massage the data in any way.
-      def self.import(report_file_path, mapping, klass, conflict_target, import_args: {})
+      def self.import(report_file_path, mapping, klass, conflict_target, import_args: {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
         csv_column_names = mapping.keys
-        database_column_names = mapping.values.map {|value| value[:database_column_name]}
+        database_column_names = mapping.values.map { |value| value[:database_column_name] }
         rows = []
         row_ids = {}
 
@@ -32,9 +32,9 @@ module CanvasSync
 
           rows << csv_column_names.map do |column|
             if mapping[column][:type].to_sym == :datetime
-              # todo - add some timezone config to the mapping.
+              # TODO: add some timezone config to the mapping.
               # In cases where the timestamp or date doesn't include a timezone, you should be able to specify one
-              DateTime.parse(row[column]).utc rescue nil
+              DateTime.parse(row[column]).utc rescue nil # rubocop:disable Style/RescueModifier
             else
               row[column]
             end
@@ -50,17 +50,17 @@ module CanvasSync
         perform_import(klass, database_column_names, rows, mapping[conflict_target][:database_column_name], import_args)
       end
 
-      private
-
       def self.perform_import(klass, columns, rows, conflict_target, import_args={})
-        return if rows.length == 0
+        return if rows.length.zero?
         columns = columns.dup
-        options = {validate: false, on_duplicate_key_update: {
-            conflict_target: conflict_target,
-            condition: condition_sql(klass, columns),
-            columns: columns
-        }}.merge(import_args)
-        options.delete(:on_duplicate_key_update) if options.has_key?(:on_duplicate_key_ignore)
+
+        options = { validate: false, on_duplicate_key_update: {
+          conflict_target: conflict_target,
+          condition: condition_sql(klass, columns),
+          columns: columns
+        } }.merge(import_args)
+
+        options.delete(:on_duplicate_key_update) if options.key?(:on_duplicate_key_ignore)
         klass.import(columns, rows, options)
       end
 
@@ -75,13 +75,13 @@ module CanvasSync
       # run_the_users_sync!
       # changed = User.where("updated_at >= ?", started_at)
       def self.condition_sql(klass, columns)
-        columns_str = columns.map {|c| "#{klass.quoted_table_name}.#{c}"}.join(", ")
-        excluded_str = columns.map {|c| "EXCLUDED.#{c}"}.join(", ")
+        columns_str = columns.map { |c| "#{klass.quoted_table_name}.#{c}" }.join(", ")
+        excluded_str = columns.map { |c| "EXCLUDED.#{c}" }.join(", ")
         "(#{columns_str}) IS DISTINCT FROM (#{excluded_str})"
       end
 
       def self.batch_size
-        batch_size = ENV['BULK_IMPORTER_BATCH_SIZE'].to_i
+        batch_size = ENV["BULK_IMPORTER_BATCH_SIZE"].to_i
         batch_size > 0 ? batch_size : DEFAULT_BATCH_SIZE
       end
     end

data/lib/canvas_sync/job.rb

@@ -5,20 +5,20 @@ module CanvasSync
   class Job < ActiveJob::Base
     around_perform do |job, block|
       @job_log = CanvasSync::JobLog.create(
-          started_at: Time.now,
-          job_class: self.class.name,
-          job_arguments: job.arguments
+        started_at: Time.now,
+        job_class: self.class.name,
+        job_arguments: job.arguments,
       )
 
       begin
         block.call
-      rescue => e
+      rescue => e # rubocop:disable Style/RescueStandardError
         @job_log.exception = "#{e.class}: #{e.message}"
         @job_log.backtrace = e.backtrace
         @job_log.status = JobLog::ERROR_STATUS
         raise e
       ensure
-        if @job_log.job_class == 'CanvasSync::Jobs::ReportChecker' && @job_log.status != JobLog::ERROR_STATUS
+        if @job_log.job_class == "CanvasSync::Jobs::ReportChecker" && @job_log.status != JobLog::ERROR_STATUS
           @job_log.destroy
         else
           @job_log.completed_at = Time.now

data/lib/canvas_sync/jobs/report_checker.rb

@@ -10,32 +10,34 @@ module CanvasSync
       # @param processor [String] a stringified report processor class name
       # @param options [Hash] hash of options that will be passed to the job processor
       # @return [nil]
-      def perform(job_chain, report_name, report_id, processor, options)
-        account_id = options[:account_id] || job_chain[:global_options][:account_id] || 'self'
-        report_status = CanvasSync.get_canvas_sync_client(job_chain[:global_options]).report_status(account_id, report_name, report_id)
+      def perform(job_chain, report_name, report_id, processor, options) # rubocop:disable Metrics/AbcSize
+        account_id = options[:account_id] || job_chain[:global_options][:account_id] || "self"
+        report_status = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+                                  .report_status(account_id, report_name, report_id)
 
-        case report_status['status'].downcase
-        when 'complete'
+        case report_status["status"].downcase
+        when "complete"
           CanvasSync::Jobs::ReportProcessorJob.perform_later(
-              job_chain,
-              report_name,
-              report_status['attachment']['url'],
-              processor,
-              options
+            job_chain,
+            report_name,
+            report_status["attachment"]["url"],
+            processor,
+            options,
           )
-        when 'error', 'deleted'
-          message = "Report failed to process; status was #{report_status} for report_name: #{report_name}, report_id: #{report_id}"
+        when "error", "deleted"
+          message = "Report failed to process; status was #{report_status} for report_name: #{report_name}, report_id: #{report_id}" # rubocop:disable Metrics/LineLength
           Rails.logger.error(message)
           raise message
         else
-          CanvasSync::Jobs::ReportChecker.set(wait: report_checker_wait_time)
-              .perform_later(
-                  job_chain,
-                  report_name,
-                  report_id,
-                  processor,
-                  options
-              )
+          CanvasSync::Jobs::ReportChecker
+            .set(wait: report_checker_wait_time)
+            .perform_later(
+              job_chain,
+              report_name,
+              report_id,
+              processor,
+              options,
+            )
         end
       end
     end

data/lib/canvas_sync/jobs/report_processor_job.rb

@@ -1,4 +1,4 @@
-require 'open-uri'
+require "open-uri"
 
 module CanvasSync
   module Jobs

data/lib/canvas_sync/jobs/report_starter.rb

@@ -11,7 +11,7 @@ module CanvasSync
       #   so that any later jobs in the chain will use the same generated report
       # @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'
+        account_id = options[:account_id] || job_chain[:global_options][:account_id] || "self"
 
         report_id = if allow_redownloads
                       get_cached_report(job_chain, account_id, report_name, report_params)
@@ -20,11 +20,11 @@ module CanvasSync
                     end
 
         CanvasSync::Jobs::ReportChecker.set(wait: report_checker_wait_time).perform_later(
-            job_chain,
-            report_name,
-            report_id,
-            processor,
-            options
+          job_chain,
+          report_name,
+          report_id,
+          processor,
+          options,
         )
       end
 
@@ -41,8 +41,9 @@ module CanvasSync
       end
 
       def start_report(job_chain, account_id, report_name, report_params)
-        report = CanvasSync.get_canvas_sync_client(job_chain[:global_options]).start_report(account_id, report_name, report_params)
-        report['id']
+        report = CanvasSync.get_canvas_sync_client(job_chain[:global_options])
+                           .start_report(account_id, report_name, report_params)
+        report["id"]
       end
     end
   end

data/lib/canvas_sync/jobs/sync_admins_job.rb

@@ -6,9 +6,9 @@ module CanvasSync
       #
       # @param job_chain [Hash]
       # @param options [Hash]
-      def perform(job_chain, options)
+      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|
+        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)
         end