coalescing_panda 4.0.11 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f20aad0bed2643617b47a4f4463343ac04a6ceb
-  data.tar.gz: 04b60e3b78c5922fea7c5b9271a3d3c9da98ab7a
+  metadata.gz: 049b4be87e2a94883db4321af5513b3de1292d95
+  data.tar.gz: 18cb2a2a9965e4d80e96e8bb5c2d342c4a1e7911
 SHA512:
-  metadata.gz: c0fab58d0a71779b9f32c8f9ae6b7e91a5d46e765353ca3692ffe8be162a4fcee5221a6538a022d6a03a27dbe8cfc0c69a3edfbfe8d516418b41043583f1927f
-  data.tar.gz: 0811856f48b94fa5777506f82385b6b1c6036f9d1514a0c29ae0aaae838917721dd073775b430275538f66153968b85614c6997a438c691791a1f60c9e36a2a2
+  metadata.gz: a71dcd02c993571e306894b3ba2a19ece4877ef108fb7475811a113d7c1442d38f2dfea109c94fb17dd43f5a63e18300dcfd805fc5411cc302fc3118858ade05
+  data.tar.gz: 38e4fc6d47585987d5611fa1544ca6792d357de01c9c8b18d169cd9fca210635434c4f161410de7c04ef367454d3642e77f16667927550805e4c383e108c3f06

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,14 +17,12 @@ window.CoalescingPanda.CanvasBatchProgress = class CanvasBatchProgress
         $('#batch-progress').html(data)
         setFlashMessages()
         batch = $('#batch-info').data('batch')
-        if batch && batch.status == "Completed"
+        if batch.status == "Completed"
           clearIntervalAndBatch(data, batch)
           successCallback() if successCallback != undefined
-        else if batch && batch.status == 'Error'
+        else if 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')
@@ -47,3 +45,7 @@ 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/application.css.scss

@@ -0,0 +1 @@
+@import "launch";

data/app/controllers/coalescing_panda/canvas_batches_controller.rb

@@ -7,16 +7,6 @@ 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].join).to_sym
+      (name+tail).to_sym
     end
 
     def ext_params(options)
       url = options.delete(:url)
-      options[:url] = main_app.send([url,'_url'].join)
+      options[:url] = main_app.send(url+'_url')
       options
     end
 

data/app/controllers/coalescing_panda/oauth2_controller.rb

@@ -13,9 +13,7 @@ module CoalescingPanda
         client_key = lti_account.oauth2_client_key
         user_id = params[:user_id]
         api_domain = params[: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)
+        client = Bearcat::Client.new(prefix: oauth2_protocol+'://'+api_domain)
         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,8 +1,6 @@
 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/canvas_batch.rb

@@ -1,10 +1,6 @@
 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,10 +8,8 @@ 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,10 +3,9 @@ module CoalescingPanda
     belongs_to :context, :polymorphic => true
     include SingleTablePolymorphic
 
-    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
+    has_many :group_memberships, dependent: :destroy, 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/lti_account.rb

@@ -6,7 +6,6 @@ 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,7 +3,6 @@ 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,54 +1,32 @@
 class CoalescingPanda::Workers::CourseMiner
-  SUPPORTED_MODELS = [:sections, :users, :enrollments, :assignment_groups, :group_categories, :assignments, :submissions, :groups, :group_memberships] #ORDER MATTERS!!
-  COMPLETED_STATUSES = ['Completed', 'Error']
-  RUNNING_STATUSES = ['Queued', 'Started']
+  SUPPORTED_MODELS = [:sections, :users, :enrollments, :assignments, :submissions, :groups, :group_memberships] #ORDER MATTERS!!
 
-  attr_accessor :options, :account, :course, :batch, :course_section_ids, :enrollment_ids, :assignment_ids, :assignment_group_ids, :group_ids, :group_membership_ids, :user_ids
+  attr_accessor :options, :account, :course, :batch, :course_section_ids, :enrollment_ids, :assignment_ids, :group_ids, :user_ids
 
   def initialize(course, options = [])
     @course = course
     @account = course.account
     @options = options
-    @batch = setup_batch
+    @batch = CoalescingPanda::CanvasBatch.create(context: course, status: "Queued")
     @course_section_ids = []
     @enrollment_ids = []
     @assignment_ids = []
-    @assignment_group_ids = []
     @group_ids = []
-    @group_membership_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(forced = false)
-    unless forced
-      return unless batch.status == 'Queued' # don't start if there is already a running job
-      return unless should_download?
-    end
-
+  def start
     begin
       batch.update_attributes(status: "Started", percent_complete: 0)
-      index = 1
-      SUPPORTED_MODELS.each do |model_key|
-        next unless options.include?(model_key)
-        process_api_data(model_key.to_sym)
+      SUPPORTED_MODELS.each_with_index do |model_key, index|
+        index += 1
+        process_api_data(model_key.to_sym) if options.include?(model_key)
         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
@@ -57,19 +35,8 @@ 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)
@@ -85,21 +52,14 @@ class CoalescingPanda::Workers::CourseMiner
     when :submissions
       collection = []
       course.assignments.each do |assignment|
-        begin
-          api_client.get_course_submissions(course.canvas_course_id, assignment.canvas_assignment_id).all_pages!.each do |submissions|
-            collection << submissions
-          end
-        rescue StandardError => e
-          Rails.logger.info("Failed to retrieve submissions for course #{course.id} and assignment #{assignment.id}: #{e}")
+        api_client.get_course_submissions(course.canvas_course_id, assignment.canvas_assignment_id).all_pages!.each do |submissions|
+          collection << submissions
         end
       end
       sync_submissions(collection)
     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|
@@ -113,40 +73,25 @@ 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)
-    collection.each do |values|
-      begin
+    begin
+      collection.each do |values|
         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)
-    collection.each do |values|
-      begin
+    begin
+      collection.each do |values|
         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
@@ -154,132 +99,104 @@ 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
-    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
+      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.destroy_all
+    rescue => e
+      Rails.logger.error "Error syncing users: #{e}"
     end
-    removed_users.destroy_all
   end
 
   def sync_enrollments(collection)
-    collection.each do |values|
-      begin
+    begin
+      collection.each do |values|
         values['canvas_enrollment_id'] = values['id'].to_s
-        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 = course.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)
-    collection.each do |values|
-      begin
+    begin
+      collection.each do |values|
         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
-    end
-    course.assignments.includes(:submissions).where.not(id: assignment_ids).each do |assignment|
-      assignment.submissions.each { |s| s.destroy }
-      assignment.destroy
+      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
   end
 
   def sync_submissions(collection)
-    collection.each do |values|
-      begin
+    begin
+      collection.each do |values|
         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)
-    collection.each do |values|
-      begin
+    begin
+      collection.each do |values|
         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)
-    collection.each do |values|
-      begin
+    begin
+      collection.each do |values|
         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)
-        group_membership_ids << group_membership.id
-      rescue => e
-        Rails.logger.error "Error syncing group memebership: #{values} Error: #{e}"
       end
+    rescue => e
+      Rails.logger.error "Error syncing group memberships: #{e}"
     end
-    course.group_memberships.where.not(id: group_membership_ids).destroy_all
   end
 
   def standard_attributes(record, attributes)
@@ -287,4 +204,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,32 +1,20 @@
 #batch-info{data: {batch: @batch.to_json}}
-- if @batch.status == "Queued"
-  %span.batch-message-queued Data is queued for download from Canvas.
+-if @batch.status == "Queued"
+  %h6.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"} ×
-    %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
+    %h6.batch-message-error Data failed to download from Canvas
+    = @batch.message

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

data/lib/coalescing_panda/controller_helpers.rb

@@ -7,21 +7,27 @@ module CoalescingPanda
       if lti_authorize!(*roles)
         user_id = params['user_id']
         launch_presentation_return_url = @lti_account.settings[:launch_presentation_return_url] || params['launch_presentation_return_url']
-        launch_presentation_return_url = [BearcatUri.new(request.env["HTTP_REFERER"]).prefix, launch_presentation_return_url].join unless launch_presentation_return_url.include?('http')
-        uri = BearcatUri.new(launch_presentation_return_url)
-        set_session(launch_presentation_return_url)
+        uri = URI.parse(launch_presentation_return_url)
+        api_domain = uri.host
+        api_domain = "#{api_domain}:#{uri.port.to_s}" if uri.port
+        scheme = uri.scheme + '://'
+        @lti_params = params.to_hash
+        session['user_id'] = user_id
+        session['uri'] = launch_presentation_return_url
+        session['lis_person_sourcedid'] = params['lis_person_sourcedid']
+        session['oauth_consumer_key'] = params['oauth_consumer_key']
+        session['custom_canvas_account_id'] = params['custom_canvas_account_id']
 
-        if token = CanvasApiAuth.where('user_id = ? and api_domain = ?', user_id, uri.api_domain).pluck(:api_token).first
-          @client = Bearcat::Client.new(token: token, prefix: uri.prefix)
+        if token = CanvasApiAuth.where('user_id = ? and api_domain = ?', user_id, api_domain).pluck(:api_token).first
+          @client = Bearcat::Client.new(token: token, prefix: scheme+api_domain)
         elsif @lti_account = params['oauth_consumer_key'] && LtiAccount.find_by_key(params['oauth_consumer_key'])
           client_id = @lti_account.oauth2_client_id
-          client = Bearcat::Client.new(prefix: uri.prefix)
+          client = Bearcat::Client.new(prefix: scheme+api_domain)
           session['state'] = SecureRandom.hex(32)
-          redirect_url = [coalescing_panda_url, coalescing_panda.oauth2_redirect_path({key: params['oauth_consumer_key'], user_id: user_id, api_domain: uri.api_domain, state: session['state']})].join
-          @canvas_url = client.auth_redirect_url(client_id, redirect_url)
-
+          @canvas_url = client.auth_redirect_url(client_id,
+                                                 coalescing_panda.oauth2_redirect_url({key: params['oauth_consumer_key'],
+                                                                                       user_id: user_id, api_domain: api_domain, state: session['state']}))
           #delete the added params so the original oauth sig still works
-          @lti_params = params.to_hash
           @lti_params.delete('action')
           @lti_params.delete('controller')
           render 'coalescing_panda/oauth2/oauth2', layout: 'coalescing_panda/application'
@@ -29,14 +35,6 @@ module CoalescingPanda
       end
     end
 
-    def set_session(launch_presentation_return_url)
-      session['user_id'] = params['user_id']
-      session['uri'] = launch_presentation_return_url
-      session['lis_person_sourcedid'] = params['lis_person_sourcedid']
-      session['oauth_consumer_key'] = params['oauth_consumer_key']
-      session['custom_canvas_account_id'] = params['custom_canvas_account_id']
-    end
-
     def have_session?
       if params['tool_consumer_instance_guid'] && session['user_id'] != params['user_id']
         reset_session
@@ -45,9 +43,12 @@ module CoalescingPanda
       end
 
       if (session['user_id'] && session['uri'])
-        uri = BearcatUri.new(session['uri'])
-        token = CanvasApiAuth.where('user_id = ? and api_domain = ?', session['user_id'], uri.api_domain).pluck(:api_token).first
-        @client = Bearcat::Client.new(token: token, prefix: uri.prefix) if token
+        uri = URI.parse(session['uri'])
+        api_domain = uri.host
+        api_domain = "#{api_domain}:#{uri.port.to_s}" if uri.port
+        scheme = uri.scheme + '://'
+        token = CanvasApiAuth.where('user_id = ? and api_domain = ?', session['user_id'], api_domain).pluck(:api_token).first
+        @client = Bearcat::Client.new(token: token, prefix: scheme+api_domain) if token
       end
 
       @lti_account = LtiAccount.find_by_key(session['oauth_consumer_key']) if session['oauth_consumer_key']
@@ -66,7 +67,9 @@ module CoalescingPanda
       logger.info 'not authorized on roles' if !authorized
       authorized = authorized && @lti_account.validate_nonce(params['oauth_nonce'], DateTime.strptime(params['oauth_timestamp'], '%s'))
       logger.info 'not authorized on nonce' if !authorized
-      render :text => 'Invalid Credentials, please contact your Administrator.', :status => :unauthorized unless authorized
+      if !authorized
+        render :text => 'Invalid Credentials, please contact your Administrator.', :status => :unauthorized
+      end
       authorized
     end
 

data/lib/coalescing_panda/version.rb

@@ -1,3 +1,3 @@
 module CoalescingPanda
-  VERSION = '4.0.11'
+  VERSION = '4.1.0'
 end