coalescing_panda 4.0.4 → 4.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb5da44106384c3b615090a856967e4900211f4f
-  data.tar.gz: 6ef8ab6716ecec434679ef70b4a494d48320545b
+  metadata.gz: 426f1e67e2f5b5e67c512ddf08d4218e69195c58
+  data.tar.gz: 1fa762f16649d117921743c0f6d1ad08897a2a71
 SHA512:
-  metadata.gz: 8a15c122d6b85d8829766dac6b8aa6626cb38b4af08902b1ebf22057a56085cdd226014898089e768bf703d2a7f993b6d19f390316c02b03281d2c36d1878df0
-  data.tar.gz: ffbaafd12ead0f87670030f4ae4e9d527caf6ca58332bd8414dbe517f6b2c72910575365976c369d9859f592f39cd7d7ebdf4993208556c85d1627f6fd6c466e
+  metadata.gz: 008f2c9346cf73643171662a546e5f9749beb2b0215b297b253e3e130ef64b1014b69bd39d1222f711222e68ef712a0a9454d30437b7d7fbe7635f7e38c8f1a0
+  data.tar.gz: b9cf5e7c0907f2e0aff5dca5ead001ab65144977ddd06ab232dee32a5c12441d8f37f06b3767a5c1bd765177b8bc0f6969727282ef77bf2e8a7dc5d767b1d0f7

data/app/assets/javascripts/coalescing_panda/canvas_batch.js.coffee

@@ -7,7 +7,7 @@ window.CoalescingPanda.CanvasBatchProgress = class CanvasBatchProgress
     batch = $('#batch-progress').data('batch')
     url = $('#batch-progress').data('url')
     window.clearPath = $('#batch-progress').data('clear-path')
-    if batch && batch.status != "Completed" || batch.status != "Error"
+    if batch && (batch.status != "Completed" || batch.status != "Error")
       window.batchInterval = setInterval(getBatchStatus, 3000, batch.id, url, successCallback, errorCallback)
 
   getBatchStatus = (id, url, successCallback, errorCallback) ->
@@ -17,12 +17,14 @@ window.CoalescingPanda.CanvasBatchProgress = class CanvasBatchProgress
         $('#batch-progress').html(data)
         setFlashMessages()
         batch = $('#batch-info').data('batch')
-        if batch.status == "Completed"
+        if batch && batch.status == "Completed"
           clearIntervalAndBatch(data, batch)
           successCallback() if successCallback != undefined
-        else if batch.status == 'Error'
+        else if batch && batch.status == 'Error'
           clearIntervalAndBatch(data, batch)
           errorCallback() if errorCallback != undefined
+        else if batch && batch.status == "Canceled"
+          clearIntervalAndBatch(data, batch)
 
       error: (message) ->
         $('#batch-progress').html('Batch status request failed')
@@ -45,7 +47,3 @@ window.CoalescingPanda.CanvasBatchProgress = class CanvasBatchProgress
     if window.messages != undefined
       for key of window.messages
         $(".batch-message-#{key}").text("#{window.messages[key]}")
-
-$ ->
-  $("#batch-container").unbind().bind "batchStarted", (event, data) ->
-    new CanvasBatchProgress()

data/app/assets/stylesheets/coalescing_panda/progress.css.scss

@@ -0,0 +1,97 @@
+.progress {
+  overflow: hidden;
+  height: 20px;
+  margin-bottom: 20px;
+  background-color: #f5f5f5;
+  border-radius: 4px;
+  -webkit-box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+  box-shadow: inset 0 1px 2px rgba(0, 0, 0, 0.1);
+}
+.progress-bar {
+  float: left;
+  width: 0%;
+  height: 100%;
+  font-size: 12px;
+  line-height: 20px;
+  color: #ffffff;
+  text-align: center;
+  background-color: #337ab7;
+  -webkit-box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.15);
+  -webkit-transition: width 0.6s ease;
+  -o-transition: width 0.6s ease;
+  transition: width 0.6s ease;
+}
+
+.alert {
+  padding: 8px 35px 8px 14px;
+  margin-bottom: 20px;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
+  background-color: #fcf8e3;
+  border: 1px solid #fbeed5;
+  -webkit-border-radius: 4px;
+     -moz-border-radius: 4px;
+          border-radius: 4px;
+}
+
+.alert,
+.alert h4 {
+  color: #c09853;
+}
+
+.alert h4 {
+  margin: 0;
+}
+
+.alert .close {
+  position: relative;
+  top: -2px;
+  right: -21px;
+  line-height: 20px;
+}
+
+.alert-success {
+  color: #468847;
+  background-color: #dff0d8;
+  border-color: #d6e9c6;
+}
+
+.alert-success h4 {
+  color: #468847;
+}
+
+.alert-danger,
+.alert-error {
+  color: #b94a48;
+  background-color: #f2dede;
+  border-color: #eed3d7;
+}
+
+.alert-danger h4,
+.alert-error h4 {
+  color: #b94a48;
+}
+
+.alert-info {
+  color: #3a87ad;
+  background-color: #d9edf7;
+  border-color: #bce8f1;
+}
+
+.alert-info h4 {
+  color: #3a87ad;
+}
+
+.alert-block {
+  padding-top: 14px;
+  padding-bottom: 14px;
+}
+
+.alert-block > p,
+.alert-block > ul {
+  margin-bottom: 0;
+}
+
+.alert-block p + p {
+  margin-top: 5px;
+}

data/app/controllers/coalescing_panda/canvas_batches_controller.rb

@@ -7,6 +7,16 @@ module CoalescingPanda
       render @batch
     end
 
+    def retrigger
+      @batch = CanvasBatch.find(params[:id])
+      @batch.status = 'Queued'
+      @batch.save
+      worker = CoalescingPanda::Workers::CourseMiner.new(@batch.context, @batch.options)
+      session[:canvas_batch_id] = worker.batch.id
+      worker.start(true)
+      redirect_to :back
+    end
+
     def clear_batch_session
       session[:canvas_batch_id] = nil
       render nothing: true

data/app/controllers/coalescing_panda/lti_controller.rb

@@ -51,12 +51,12 @@ module CoalescingPanda
       if %w(course account user).include?(name)
         tail = '_navigation' unless name.include? '_navigation'
       end
-      (name+tail).to_sym
+      ([name, tail].join).to_sym
     end
 
     def ext_params(options)
       url = options.delete(:url)
-      options[:url] = main_app.send(url+'_url')
+      options[:url] = main_app.send([url,'_url'].join)
       options
     end
 

data/app/controllers/coalescing_panda/oauth2_controller.rb

@@ -13,7 +13,9 @@ module CoalescingPanda
         client_key = lti_account.oauth2_client_key
         user_id = params[:user_id]
         api_domain = params[:api_domain]
-        client = Bearcat::Client.new(prefix: oauth2_protocol+'://'+api_domain)
+        prefix = [oauth2_protocol, '://', api_domain].join
+        Rails.logger.info "Creating Bearcat client for auth token retrieval pointed to: #{prefix}"
+        client = Bearcat::Client.new(prefix: prefix)
         token = client.retrieve_token(client_id, coalescing_panda.oauth2_redirect_url, client_key, params['code'])
         CanvasApiAuth.where('user_id = ? and api_domain = ?', user_id, api_domain).first_or_create do |auth|
           auth.api_token = token

data/app/models/coalescing_panda/assignment.rb

@@ -1,6 +1,8 @@
 module CoalescingPanda
   class Assignment < ActiveRecord::Base
     belongs_to :course, foreign_key: :coalescing_panda_course_id, class_name: 'CoalescingPanda::Course'
+    belongs_to :assignment_group, foreign_key: :coalescing_panda_assignment_group_id, class_name: 'CoalescingPanda::AssignmentGroup'
+    belongs_to :group_category, foreign_key: :coalescing_panda_group_category_id, class_name: 'CoalescingPanda::GroupCategory'
     has_many :submissions, foreign_key: :coalescing_panda_assignment_id, class_name: 'CoalescingPanda::Submission', dependent: :destroy
 
     delegate :account, to: :course

data/app/models/coalescing_panda/assignment_group.rb

@@ -0,0 +1,11 @@
+module CoalescingPanda
+  class AssignmentGroup < ActiveRecord::Base
+    belongs_to :course, foreign_key: :coalescing_panda_course_id, class_name: 'CoalescingPanda::Course'
+    has_many :assignments, foreign_key: :coalescing_panda_assignment_group_id, class_name: 'CoalescingPanda::Assignment', dependent: :destroy
+
+    delegate :account, to: :course
+
+    validates :coalescing_panda_course_id, presence: true
+    validates :canvas_assignment_group_id, presence: true
+  end
+end

data/app/models/coalescing_panda/canvas_batch.rb

@@ -1,6 +1,10 @@
 module CoalescingPanda
   class CanvasBatch < ActiveRecord::Base
+    serialize :options
+
+    belongs_to :account, foreign_key: :coalescing_panda_lti_account_id, class_name: 'CoalescingPanda::LtiAccount'
     belongs_to :context, polymorphic: true
+
     default_scope { order('created_at DESC') }
   end
 end

data/app/models/coalescing_panda/course.rb

@@ -8,8 +8,10 @@ module CoalescingPanda
     has_many :submissions, through: :assignments, dependent: :destroy
     has_many :users, through: :sections, source: :users, class_name: 'CoalescingPanda::User'
     has_many :groups, :as => :context, class_name: 'CoalescingPanda::Group', dependent: :destroy
+    has_many :group_categories, :as => :context, class_name: 'CoalescingPanda::GroupCategory', dependent: :destroy
     has_many :group_memberships, through: :groups, source: :group_memberships, class_name: 'CoalescingPanda::GroupMembership', dependent: :destroy
     has_many :canvas_batches, as: :context, dependent: :destroy
+    has_many :assignment_groups, foreign_key: :coalescing_panda_course_id, class_name: 'CoalescingPanda::AssignmentGroup', dependent: :destroy
 
     validates :coalescing_panda_lti_account_id, presence: true
     validates :canvas_course_id, presence: true

data/app/models/coalescing_panda/group.rb

@@ -3,9 +3,10 @@ module CoalescingPanda
     belongs_to :context, :polymorphic => true
     include SingleTablePolymorphic
 
-    has_many :group_memberships, dependent: :destroy, foreign_key: :coalescing_panda_group_id, class_name: 'CoalescingPanda::GroupMembership', dependent: :destroy
+    belongs_to :leader, foreign_key: :leader_id, class_name: 'CoalescingPanda::User'
+    belongs_to :group_category, foreign_key: :coalescing_panda_group_category_id, class_name: 'CoalescingPanda::GroupCategory'
+    has_many :group_memberships, foreign_key: :coalescing_panda_group_id, class_name: 'CoalescingPanda::GroupMembership', dependent: :destroy
     validates :group_category_id, presence: true
     validates :canvas_group_id, presence: true
-    validates :coalescing_panda_user_id, presence: true
   end
 end

data/app/models/coalescing_panda/group_category.rb

@@ -0,0 +1,11 @@
+module CoalescingPanda
+  class GroupCategory < ActiveRecord::Base
+    belongs_to :context, :polymorphic => true
+    include SingleTablePolymorphic
+
+    belongs_to :leader, foreign_key: :leader_id, class_name: 'CoalescingPanda::User'
+    has_many :groups, foreign_key: :coalescing_panda_group_category_id, class_name: 'CoalescingPanda::Group'
+    has_many :assignments, foreign_key: :coalescing_panda_group_category_id, class_name: 'CoalescingPanda::Assignment'
+    validates :canvas_group_category_id, presence: true
+  end
+end

data/app/models/coalescing_panda/lti_account.rb

@@ -6,6 +6,7 @@ module CoalescingPanda
     has_many :terms, foreign_key: :coalescing_panda_lti_account_id, class_name: 'CoalescingPanda::Term'
     has_many :courses, foreign_key: :coalescing_panda_lti_account_id, class_name: 'CoalescingPanda::Course'
     has_many :users, foreign_key: :coalescing_panda_lti_account_id, class_name: 'CoalescingPanda::User'
+    has_many :canvas_batches, foreign_key: :coalescing_panda_lti_account_id, class_name: 'CoalescingPanda::CanvasBatch'
     has_many :sections, through: :courses
     has_many :enrollments, through: :sections
     has_many :assignments, through: :courses

data/app/models/coalescing_panda/user.rb

@@ -3,6 +3,7 @@ module CoalescingPanda
     belongs_to :account, foreign_key: :coalescing_panda_lti_account_id, class_name: 'CoalescingPanda::LtiAccount'
     has_many :enrollments, foreign_key: :coalescing_panda_user_id, class_name: 'CoalescingPanda::Enrollment', dependent: :destroy
     has_many :submissions, foreign_key: :coalescing_panda_user_id, class_name: 'CoalescingPanda::Submission', dependent: :destroy
+    has_many :leader_groups, foreign_key: :leader_id, class_name: 'CoalescingPanda::Group'
     has_many :sections, through: :enrollments
     has_many :courses, through: :sections
 

data/app/models/coalescing_panda/workers/course_miner.rb

@@ -1,32 +1,53 @@
 class CoalescingPanda::Workers::CourseMiner
-  SUPPORTED_MODELS = [:sections, :users, :enrollments, :assignments, :submissions, :groups, :group_memberships] #ORDER MATTERS!!
+  SUPPORTED_MODELS = [:sections, :users, :enrollments, :assignment_groups, :group_categories, :assignments, :submissions, :groups, :group_memberships] #ORDER MATTERS!!
+  COMPLETED_STATUSES = ['Completed', 'Error']
+  RUNNING_STATUSES = ['Queued', 'Started']
 
-  attr_accessor :options, :account, :course, :batch, :course_section_ids, :enrollment_ids, :assignment_ids, :group_ids, :user_ids
+  attr_accessor :options, :account, :course, :batch, :course_section_ids, :enrollment_ids, :assignment_ids, :assignment_group_ids, :group_ids, :user_ids
 
   def initialize(course, options = [])
     @course = course
     @account = course.account
     @options = options
-    @batch = CoalescingPanda::CanvasBatch.create(context: course, status: "Queued")
+    @batch = setup_batch
     @course_section_ids = []
     @enrollment_ids = []
     @assignment_ids = []
+    @assignment_group_ids = []
     @group_ids = []
     @user_ids = []
   end
 
+  def setup_batch
+    batch = account.canvas_batches.where(context: course).first
+    if batch.present? and RUNNING_STATUSES.include?(batch.status)
+      batch
+    else
+      batch = account.canvas_batches.create(context: course, status: "Queued")
+    end
+    batch.update_attributes(options: options)
+    batch
+  end
+
   def api_client
     @api_client ||= Bearcat::Client.new(prefix: account.settings[:base_url], token: account.settings[:account_admin_api_token])
   end
 
-  def start
+  def start(forced = false)
+    unless forced
+      return unless batch.status == 'Queued' # don't start if there is already a running job
+      return unless should_download?
+    end
+
     begin
       batch.update_attributes(status: "Started", percent_complete: 0)
-      SUPPORTED_MODELS.each_with_index do |model_key, index|
-        index += 1
-        process_api_data(model_key.to_sym) if options.include?(model_key)
+      index = 1
+      SUPPORTED_MODELS.each do |model_key|
+        next unless options.include?(model_key)
+        process_api_data(model_key.to_sym)
         percent_complete = (index/(options.count.nonzero? || 1).to_f * 100).round(1)
         batch.update_attributes(percent_complete: percent_complete)
+        index += 1
       end
       batch.update_attributes(status: "Completed", percent_complete: 100)
     rescue => e
@@ -35,8 +56,19 @@ class CoalescingPanda::Workers::CourseMiner
   end
   handle_asynchronously :start
 
+  def should_download?
+    return true unless account.settings[:canvas_download_interval].present?
+    return true unless last_completed_batch = account.canvas_batches.where(context: course, status: 'Completed').order('updated_at ASC').first
+    should_download = last_completed_batch.updated_at < Time.zone.now - account.settings[:canvas_download_interval].minutes
+    batch.update_attributes(status: 'Canceled') unless should_download
+    should_download
+  end
+
   def process_api_data(key)
     case key
+    when :assignment_groups
+      collection = api_client.list_assignment_groups(course.canvas_course_id).all_pages!
+      sync_assignment_groups(collection)
     when :sections
       collection = api_client.course_sections(course.canvas_course_id).all_pages!
       sync_sections(collection)
@@ -60,6 +92,9 @@ class CoalescingPanda::Workers::CourseMiner
     when :groups
       collection = api_client.course_groups(course.canvas_course_id).all_pages!
       sync_groups(collection)
+    when :group_categories
+      collection = api_client.list_group_categories('courses', course.canvas_course_id).all_pages!
+      sync_group_categories(collection)
     when :group_memberships
       collection = []
       course.groups.each do |group|
@@ -73,25 +108,40 @@ class CoalescingPanda::Workers::CourseMiner
     end
   end
 
+  def sync_assignment_groups(collection)
+    collection.each do |values|
+      begin
+        values['canvas_assignment_group_id'] = values['id'].to_s
+        assignment_group = course.assignment_groups.where(canvas_assignment_group_id: values['canvas_assignment_group_id']).first_or_initialize
+        assignment_group.assign_attributes(standard_attributes(assignment_group, values))
+        assignment_group.save(validate: false)
+        assignment_group_ids << assignment_group.id
+      rescue => e
+        Rails.logger.error "Error syncing assignment group: #{values} Error: #{e}"
+      end
+    end
+    course.assignment_groups.where.not(id: assignment_group_ids).destroy_all
+  end
+
   def sync_sections(collection)
-    begin
-      collection.each do |values|
+    collection.each do |values|
+      begin
         values['course_section_id'] = values['id'].to_s
         section = course.sections.where(canvas_section_id: values['course_section_id']).first_or_initialize
         section.assign_attributes(standard_attributes(section, values))
         section.sis_id = values['sis_section_id']
         section.save(validate: false)
         course_section_ids << section.id
+      rescue => e
+        Rails.logger.error "Error syncing section: #{values} Error: #{e}"
       end
-      course.sections.where.not(id: course_section_ids).destroy_all
-    rescue => e
-      Rails.logger.error "Error syncing sections: #{e}"
     end
+    course.sections.where.not(id: course_section_ids).destroy_all
   end
 
   def sync_users(collection)
-    begin
-      collection.each do |values|
+    collection.each do |values|
+      begin
         values['canvas_user_id'] = values["id"].to_s
         user = account.users.where(canvas_user_id: values['canvas_user_id']).first_or_initialize
         user.coalescing_panda_lti_account_id = account.id
@@ -99,103 +149,129 @@ class CoalescingPanda::Workers::CourseMiner
         user.sis_id = values['sis_user_id'].to_s
         user_ids << user.id
         user.save(validate: false)
+      rescue => e
+        Rails.logger.error "Error syncing user: #{values} Error: #{e}"
       end
-      removed_users = course.users.where.not(id: user_ids)
-      removed_users.each do |user|
-        user.enrollments.each do |enrollment|
-          course.submissions.where(coalescing_panda_user_id: enrollment.user.id).destroy_all
-          enrollment.destroy
-        end
+    end
+    removed_users = course.users.where.not(id: user_ids)
+    removed_users.each do |user|
+      user.enrollments.each do |enrollment|
+        course.submissions.where(coalescing_panda_user_id: enrollment.user.id).destroy_all
+        enrollment.destroy
       end
-      removed_users.destroy_all
-    rescue => e
-      Rails.logger.error "Error syncing users: #{e}"
     end
+    removed_users.destroy_all
   end
 
   def sync_enrollments(collection)
-    begin
-      collection.each do |values|
+    collection.each do |values|
+      begin
         values['canvas_enrollment_id'] = values['id'].to_s
-        enrollment = course.enrollments.where(canvas_enrollment_id: values['canvas_enrollment_id']).first_or_initialize
+        section = course.sections.find_by(canvas_section_id: values['course_section_id'].to_s)
+        enrollment = section.enrollments.where(canvas_enrollment_id: values['canvas_enrollment_id']).first_or_initialize
         enrollment.section = course.sections.find_by(canvas_section_id: values['course_section_id'].to_s)
         enrollment.user = account.users.find_by(canvas_user_id: values['user_id'].to_s)
         values['workflow_state'] = values["enrollment_state"]
         values['enrollment_type'] = values['type']
         enrollment.assign_attributes(standard_attributes(enrollment, values))
-        enrollment.save(validate: false)
+        enrollment.save!(validate: false)
         enrollment_ids << enrollment.id
+      rescue => e
+        Rails.logger.error "Error syncing enrollment: #{values} Error: #{e}"
       end
-      removed_enrollments = course.enrollments.where.not(id: enrollment_ids)
-      removed_enrollments.each do |enrollment|
-        course.submissions.where(coalescing_panda_user_id: enrollment.user.id).destroy_all
-      end
-      removed_enrollments.destroy_all
-    rescue => e
-      Rails.logger.error "Error syncing enrollments: #{e}"
     end
+    removed_enrollments = course.enrollments.where.not(id: enrollment_ids)
+    removed_enrollments.each do |enrollment|
+      course.submissions.where(coalescing_panda_user_id: enrollment.user.id).destroy_all
+    end
+    removed_enrollments.destroy_all
   end
 
   def sync_assignments(collection)
-    begin
-      collection.each do |values|
+    collection.each do |values|
+      begin
         values['canvas_assignment_id'] = values['id'].to_s
         assignment = course.assignments.where(canvas_assignment_id: values['canvas_assignment_id']).first_or_initialize
+        assignment_group = course.assignment_groups.find_by(canvas_assignment_group_id: values['assignment_group_id'].to_s)
+        group_category = course.group_categories.find_by(canvas_group_category_id: values['group_category_id'])
+        assignment.coalescing_panda_assignment_group_id = assignment_group.id if assignment_group
+        assignment.coalescing_panda_group_category_id = group_category.id if group_category
         assignment.assign_attributes(standard_attributes(assignment, values))
         assignment.save(validate: false)
         assignment_ids << assignment.id
+      rescue => e
+        Rails.logger.error "Error syncing assignment: #{values} Error: #{e}"
       end
-      course.assignments.where.not(id: assignment_ids).each do |assignment|
-        assignment.submissions.destroy_all
-        assignment.destroy!
-      end
-    rescue => e
-      Rails.logger.error "Error syncing assignments: #{e}"
+    end
+    course.assignments.where.not(id: assignment_ids).each do |assignment|
+      assignment.submissions.destroy_all
+      assignment.destroy!
     end
   end
 
   def sync_submissions(collection)
-    begin
-      collection.each do |values|
+    collection.each do |values|
+      begin
         values['canvas_submission_id'] = values['id'].to_s
         submission = course.submissions.where(canvas_submission_id: values['canvas_submission_id']).first_or_initialize
         submission.user = course.users.find_by(canvas_user_id: values['user_id'].to_s)
         submission.assignment = course.assignments.find_by(canvas_assignment_id: values['assignment_id'].to_s)
         submission.assign_attributes(standard_attributes(submission, values))
         submission.save(validate: false)
+      rescue => e
+        Rails.logger.error "Error syncing submission: #{values} Error: #{e}"
+      end
+    end
+  end
+
+  def sync_group_categories(collection)
+    collection.each do |values|
+      begin
+        values['canvas_group_category_id'] = values['id'].to_s
+        values.delete('context_type')    #assume only course for now
+        category = course.group_categories.where(canvas_group_category_id: values['canvas_group_category_id']).first_or_initialize
+        category.assign_attributes(standard_attributes(category, values))
+        category.save(validate: false)
+      rescue => e
+        Rails.logger.error "Error syncing group categories: #{values} Error: #{e.message} -  #{e.backtrace}"
       end
-    rescue => e
-      Rails.logger.error "Error syncing submissions: #{e}"
     end
   end
 
   def sync_groups(collection)
-    begin
-      collection.each do |values|
+    collection.each do |values|
+      begin
         values['canvas_group_id'] = values['id'].to_s
         group = course.groups.where(canvas_group_id: values['canvas_group_id']).first_or_initialize
+        group_category = course.group_categories.find_by(canvas_group_category_id: values['group_category_id'])
+        if values['leader']
+          group.leader = course.users.find_by(canvas_user_id: values['leader']['id'].to_s)
+        else
+          group.leader = nil
+        end
+        group.coalescing_panda_group_category_id = group_category.id if group_category
         group.assign_attributes(standard_attributes(group, values))
         group.save(validate: false)
         group_ids << group.id
+      rescue => e
+        Rails.logger.error "Error syncing group: #{values} Error: #{e}"
       end
-      course.groups.where.not(id: group_ids).destroy_all
-    rescue => e
-      Rails.logger.error "Error syncing groups: #{e}"
     end
+    course.groups.where.not(id: group_ids).destroy_all
   end
 
   def sync_group_memberships(collection)
-    begin
-      collection.each do |values|
+    collection.each do |values|
+      begin
         values['canvas_group_membership_id'] = values['id'].to_s
         group_membership = course.group_memberships.where(canvas_group_membership_id: values['canvas_group_membership_id']).first_or_initialize
         group_membership.group = course.groups.find_by(canvas_group_id: values['group_id'].to_s)
         group_membership.user = course.users.find_by(canvas_user_id: values['user_id'].to_s)
         group_membership.assign_attributes(standard_attributes(group_membership, values))
         group_membership.save(validate: false)
+      rescue => e
+        Rails.logger.error "Error syncing group memebership: #{values} Error: #{e}"
       end
-    rescue => e
-      Rails.logger.error "Error syncing group memberships: #{e}"
     end
   end
 
@@ -204,4 +280,4 @@ class CoalescingPanda::Workers::CourseMiner
     new_attributes.delete('id')
     new_attributes.delete_if { |key, value| !record.attributes.include?(key) }
   end
-end
+end

data/app/models/concerns/single_table_polymorphic.rb

@@ -8,4 +8,4 @@ module SingleTablePolymorphic
       end
     end
   end
-end
+end

data/app/views/coalescing_panda/canvas_batches/_canvas_batch.html.haml

@@ -1,20 +1,32 @@
 #batch-info{data: {batch: @batch.to_json}}
--if @batch.status == "Queued"
-  %h6.batch-message-queued Data is queued for download from Canvas.
+- if @batch.status == "Queued"
+  %span.batch-message-queued Data is queued for download from Canvas.
 
--if @batch.status == "Completed"
+- if @batch.status == "Completed"
   .alert.alert-success
     %button.close{"data-dismiss" => "alert", :type => "button"} ×
     %span.batch-message-completed
       Data successfully downloaded from Canvas.
 
--if @batch.status == "Started"
-  %h6.batch-message-started Downloading data from Canvas
-  .progress.progress-striped.active
-    .bar{:style => "width: #{@batch.percent_complete}%;"}
+- if @batch.status == "Started"
+  %h6.batch-message-started
+    Downloading data from Canvas
+    .progress.progress-striped.active
+      .bar{:style => "width: #{@batch.percent_complete}%;"}
 
--if @batch.status == "Error"
+
+- if @batch.status == "Error"
   .alert.alert-block.alert-error
     %button.close{"data-dismiss" => "alert", :type => "button"} ×
-    %h6.batch-message-error Data failed to download from Canvas
-    = @batch.message
+    %span.batch-message-error Data failed to download from Canvas
+    = @batch.message
+
+- if @batch.status == "Canceled"
+  .alert.alert-block.alert-info
+    %button.close{"data-dismiss" => "alert", :type => "button"} ×
+    %span.batch-message-retrigger
+      Canvas data last downloaded
+      = @batch.updated_at
+      .pull-right
+        = link_to "Retrigger", retrigger_canvas_batch_path(@batch), method: :post,  class: "btn btn-default"
+      .clearfix

data/app/views/coalescing_panda/canvas_batches/_canvas_batch_flash.html.haml

@@ -1,4 +1,4 @@
 - if current_batch.present?
   - path = CoalescingPanda::Engine.routes.url_helpers.canvas_batch_path(current_batch)
-  -clear_path = CoalescingPanda::Engine.routes.url_helpers.clear_batch_session_path
+  - clear_path = CoalescingPanda::Engine.routes.url_helpers.clear_batch_session_path
   #batch-progress{data: {batch: current_batch.try(:to_json), url: path, clear_path: clear_path} }

data/config/routes.rb

@@ -1,5 +1,7 @@
 CoalescingPanda::Engine.routes.draw do
-  resources :canvas_batches, only: [:show]
+  resources :canvas_batches, only: [:show, :update] do
+    post :retrigger, on: :member
+  end
   post '/canvas_batches/clear_batch_session', as: :clear_batch_session
 
   get '/oauth2/redirect' => 'oauth2#redirect'