qalam_oauth_engine 3.0.5 → 3.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1993e64ae7d887fb6d5ca81b7d41b841a41f16f6713dfa5750c16131b64b7b04
-  data.tar.gz: f8be0a0e38579e6a171cef590863fcca4ce7b7f06ed891c1824d12fdc07f3b61
+  metadata.gz: c39bb4366b4792b9a2b0746a9073f28d410f181d82147c266939ae96489d5d5f
+  data.tar.gz: 97dd0420a00015b587b5a2ece17cad01fbfe0a78d95a1e8941980d4b8d076a4d
 SHA512:
-  metadata.gz: 11c52e55a0c2f63ac009f6ef29d53601078e343959cc56ecfdc8506684aee1f70b18c65e9f3bc34328af8ddde91ba6facd2ca3277d2d5b2c525cf1ca4a92490b
-  data.tar.gz: bc76c81bedb0aac378b675cd6d7b6f56dc1053f5af6f70ab9518e4a34928ffba4fb6559921444c730df2b89877b645e581bac91b841765a68eac27b29e72e6df
+  metadata.gz: 4346ca322ffd60dbb3e78e0106832255d8950e0850f1297669737c3a3ac9867e2bd95c15f4c88543dcf39625df63971341fe2524d40ddc5378d807e7551a491d
+  data.tar.gz: 4b7e0be12099a9312f1e125de7e6eae8d676bde404929979bbb7cc4e274cfb008d8e7e3d3d893cf5d668b75af1d7c6ffed170269343efcc2b7691fabffff8c67

data/app/controllers/canvas_oauth/canvas_controller.rb

@@ -7,7 +7,7 @@ module CanvasOauth
         if token = canvas.get_access_token(params[:code])
           set_root_account
           refresh_token = canvas.refresh_token
-          if CanvasOauth::Authorization.cache_token(token, refresh_token, user_id, @root_account_id, tool_consumer_instance_guid)
+          if CanvasOauth::Authorization.cache_token(token, refresh_token, user_id, @root_account_id, tool_consumer_instance_guid, canvas_url)
             redirect_to main_app.root_path
           else
             render plain: "Error: unable to save token"
@@ -23,13 +23,6 @@ module CanvasOauth
     def verify_oauth2_state(callback_state)
       callback_state.present? && callback_state == session.delete(:oauth2_state)
     end
-  end
 
-  def set_root_account
-    if current_account_id
-      @root_account_id = canvas.root_account_id(current_account_id)
-    elsif current_course_id
-      @root_account_id = canvas.course_root_account_id(current_course_id)
-    end
   end
 end

data/app/models/canvas_oauth/authorization.rb

@@ -2,17 +2,35 @@ module CanvasOauth
   class Authorization < ActiveRecord::Base
     validates :canvas_user_id, :token, :refresh_token, :last_used_at, presence: true
 
-    def self.cache_token(token, refresh_token, user_id, account_id, tool_consumer_instance_guid)
+    def self.cache_token(token, refresh_token, user_id, account_id, tool_consumer_instance_guid, canvas_url)
       create do |t|
         t.token = token
         t.refresh_token = refresh_token
         t.canvas_user_id = user_id
-        t.canvas_root_account_id = account_id
+        t.canvas_root_account_id = account_id  if CanvasOauth::Authorization.column_names.include?('canvas_root_account_id')
+        t.canvas_url = canvas_url if canvas_url && CanvasOauth::Authorization.column_names.include?('canvas_url')
         t.tool_consumer_instance_guid = tool_consumer_instance_guid
         t.last_used_at = Time.now
       end
     end
 
+    def self.fetch_canvas_auth(user_id, tool_consumer_instance_guid, canvas_url)
+      user_canvas_auths = where(canvas_user_id: user_id, tool_consumer_instance_guid: tool_consumer_instance_guid).order("created_at DESC")
+      user_canvas_auths = user_canvas_auths.where('lower(canvas_url) LIKE :q', q: "%#{canvas_url.downcase}%") if canvas_url && CanvasOauth::Authorization.column_names.include?('canvas_url')
+      if canvas_auth = user_canvas_auths.first
+        canvas_auth.update_attribute(:last_used_at, Time.now)
+        return canvas_auth
+      end
+    end
+
+    def self.fetch_id(user_id, tool_consumer_instance_guid)
+      user_accounts = where(canvas_user_id: user_id, tool_consumer_instance_guid: tool_consumer_instance_guid).order("created_at DESC")
+      if canvas_auth = user_accounts.first
+        canvas_auth.update_attribute(:last_used_at, Time.now)
+        return canvas_auth.id
+      end
+    end
+
     def self.fetch_account(user_id, tool_consumer_instance_guid)
       user_accounts = where(canvas_user_id: user_id, tool_consumer_instance_guid: tool_consumer_instance_guid).order("created_at DESC")
       if canvas_auth = user_accounts.first

data/db/migrate/20121121005358_create_canvas_oauth_authorizations.rb

@@ -6,6 +6,7 @@ class CreateCanvasOauthAuthorizations < ActiveRecord::Migration[4.2]
       t.string   "tool_consumer_instance_guid", :null => false
       t.string   "token"
       t.string   "refresh_token"
+      t.string   "canvas_url"
       t.datetime "last_used_at"
       t.datetime "created_at",                  :null => false
       t.datetime "updated_at",                  :null => false

data/lib/canvas_oauth/canvas_api.rb

@@ -4,13 +4,14 @@ module CanvasOauth
     PER_PAGE = 50
 
     attr_accessor :token, :refresh_token, :key, :secret
-    attr_reader :canvas_url, :canvas_user_id
+    attr_reader :id, :canvas_url, :canvas_user_id, :canvas_root_account_id
 
-    def initialize(canvas_url, canvas_user_id, canvas_root_account_id, token, refresh_token, key, secret)
+    def initialize(id, canvas_url, canvas_user_id, canvas_root_account_id, token, refresh_token, key, secret)
       unless [key, secret].all?(&:present?)
         raise "Invalid Qalam oAuth configuration"
       end
-      
+
+      self.id = id
       self.refresh_token = refresh_token
       self.canvas_url = canvas_url
       self.canvas_user_id = canvas_user_id
@@ -104,18 +105,23 @@ module CanvasOauth
       authenticated_request(:put, *params)
     end
 
-    def paginated_get(url, params = {})
+    def paginated_get(url, params={})
       params[:query] ||= {}
-      params[:query][:per_page] = PER_PAGE
-
+      params[:query][:per_page] ||= PER_PAGE
+      params[:query][:page] ||= 1
       all_pages = []
 
-      while url && current_page = authenticated_get(url, params) do
+      if params[:current_page]
+        current_page = authenticated_get(url, params)
         all_pages.concat(current_page) if valid_page?(current_page)
+      else
+        while url && current_page = authenticated_get(url, params) do
+          all_pages.concat(current_page) if valid_page?(current_page)
 
-        links = LinkHeader.parse(current_page.headers['link'])
-        url = links.find_link(["rel", "next"]).try(:href)
-        params[:query] = nil if params[:query]
+          links = LinkHeader.parse(current_page.headers['link'])
+          url = links.find_link(["rel", "next"]).try(:href)
+          params[:query] = nil if params[:query]
+        end
       end
 
       all_pages
@@ -135,6 +141,10 @@ module CanvasOauth
     def canvas_root_account_id=(value)
       @canvas_root_account_id = value
     end
+
+    def id=(value)
+      @id = value
+    end
     
     def hex_sis_id(name, value)
       hex = value.unpack("H*")[0]
@@ -195,7 +205,7 @@ module CanvasOauth
       # root_account_id
       # course_root_account_id
     
-    def get_report(account_id, report_type, params)
+    def get_report(account_id, report_type, params={})
       report = authenticated_post("/api/v1/accounts/#{account_id}/reports/#{report_type}", { body: params })
       report = authenticated_get "/api/v1/accounts/#{account_id}/reports/#{report_type}/#{report['id']}"
       while (report['status'] == 'created' || report['status'] == 'running')
@@ -212,108 +222,108 @@ module CanvasOauth
       end
     end
 
-    def get_file(file_id)
+    def get_file(file_id, params={})
       authenticated_get "/api/v1/files/#{file_id}"
     end
 
-    def get_accounts_provisioning_report(account_id)
+    def get_accounts_provisioning_report(account_id, params={})
       get_report(account_id, :provisioning_csv, 'parameters[accounts]' => true)
     end
 
-    def get_courses
+    def get_courses(params={})
       paginated_get "/api/v1/courses"
     end
 
-    def get_account(account_id)
+    def get_account(account_id, params={})
       authenticated_get "/api/v1/accounts/#{account_id}"
     end
 
-    def get_account_sub_accounts(account_id)
+    def get_account_sub_accounts(account_id, params={})
       paginated_get "/api/v1/accounts/#{account_id}/sub_accounts", { query: { :recursive => true } }
     end
 
-    def get_account_courses(account_id)
+    def get_account_courses(account_id, params={})
       paginated_get "/api/v1/accounts/#{account_id}/courses"
     end
 
-    def get_account_users(account_id)
+    def get_account_users(account_id, params={})
       paginated_get "/api/v1/accounts/#{account_id}/users"
     end
 
-    def get_course(course_id)
+    def get_course(course_id, params={})
       authenticated_get "/api/v1/courses/#{course_id}"
     end
 
-    def get_section_enrollments(section_id)
+    def get_section_enrollments(section_id, params={})
       paginated_get "/api/v1/sections/#{section_id}/enrollments"
     end
 
-    def get_user_enrollments(user_id)
+    def get_user_enrollments(user_id, params={})
       paginated_get "/api/v1/users/#{user_id}/enrollments"
     end
 
-    def get_course_users(course_id)
+    def get_course_users(course_id, params={})
       paginated_get "/api/v1/courses/#{course_id}/users"
     end
 
-    def get_all_course_users(course_id)
+    def get_all_course_users(course_id, params={})
       paginated_get "/api/v1/courses/#{course_id}/users", { query: {enrollment_state: ["active","invited","rejected","completed","inactive"] } }
     end
 
-    def get_course_teachers_and_tas(course_id)
+    def get_course_teachers_and_tas(course_id, params={})
       paginated_get "/api/v1/courses/#{course_id}/users", { query: { enrollment_type: ['teacher', 'ta'] } }
     end
 
-    def get_course_students(course_id)
+    def get_course_students(course_id, params={})
       paginated_get "/api/v1/courses/#{course_id}/students"
     end
 
-    def get_course_active_students(course_id)
+    def get_course_active_students(course_id, params={})
       paginated_get "/api/v1/courses/#{course_id}/active_users"
     end
 
-    def get_section(section_id)
+    def get_section(section_id, params={})
       authenticated_get "/api/v1/sections/#{section_id}"
     end
 
-    def get_sections(course_id)
+    def get_sections(course_id, params={})
       paginated_get "/api/v1/courses/#{course_id}/sections", { query: { :include => ['students', 'avatar_url', 'enrollments'] } }
     end
 
-    def get_assignments(course_id)
+    def get_assignments(course_id, params={})
       paginated_get "/api/v1/courses/#{course_id}/assignments"
     end
 
-    def get_assignment(course_id, assignment_id)
+    def get_assignment(course_id, assignment_id, params={})
       authenticated_get "/api/v1/courses/#{course_id}/assignments/#{assignment_id}"
     end
 
-    def get_user_profile(user_id)
+    def get_user_profile(user_id, params={})
       authenticated_get "/api/v1/users/#{user_id}/profile"
     end
 
-    def create_assignment(course_id, params)
+    def create_assignment(course_id, params={})
       authenticated_post "/api/v1/courses/#{course_id}/assignments", { body: { assignment: params } }
     end
 
-    def update_assignment(course_id, assignment_id, params)
+    def update_assignment(course_id, assignment_id, params={})
       authenticated_put "/api/v1/courses/#{course_id}/assignments/#{assignment_id}", { body: { assignment: params } }
     end
 
-    def grade_assignment(course_id, assignment_id, user_id, params)
+    def grade_assignment(course_id, assignment_id, user_id, params={})
       authenticated_put "/api/v1/courses/#{course_id}/assignments/#{assignment_id}/submissions/#{user_id}", { body: params }
     end
 
-    def get_submission(course_id, assignment_id, user_id)
+    def get_submission(course_id, assignment_id, user_id, params={})
       authenticated_get "/api/v1/courses/#{course_id}/assignments/#{assignment_id}/submissions/#{user_id}"
     end
 
-    def course_account_id(course_id)
+    def course_account_id(course_id, params={})
       course = get_course(course_id)
       course['account_id'] if course
     end
 
-    def root_account_id(account_id)
+    def root_account_id(account_id, params={})
       if account_id && account = get_account(account_id)
         root_id = account['root_account_id']
       end
@@ -321,7 +331,7 @@ module CanvasOauth
       root_id || account_id
     end
 
-    def course_root_account_id(course_id)
+    def course_root_account_id(course_id, params={})
       root_account_id(course_account_id(course_id))
     end
     ### END CANVAS API ###
@@ -329,44 +339,84 @@ module CanvasOauth
     ### QALAM API ENDPOINTS ###
       # get_canvas_user_profile
       # get_course_active_pages
-      # course_external_tool_update
-      # account_external_tool_update
+      # update_external_tool_nav
       # get_school_details
-      # get_grade_students
-      # get_classroom_students
-
-    def get_canvas_user_profile
+      # get_school_grades
+      # get_school_grade
+      # get_school_class_rooms
+      # get_school_class_room
+      # get_school_subjects
+      # get_school_subject
+      # get_students_by_grade
+      # get_students_by_class_room
+
+    def get_canvas_user_profile(params={})
       authenticated_get "/api/v1/users/#{canvas_user_id}/profile"
     end
 
-    def get_course_active_pages(course_id, publish=nil)
+    def get_course_active_pages(course_id, publish=nil, params={})
       unless publish.nil?
-        paginated_get "/api/v1/courses/#{course_id}/pages?published=#{publish}&sort=created_at&order=desc"
+        paginated_get "/api/v1/courses/#{course_id}/pages?published=#{publish}&sort=created_at&order=desc", params
       else
-        paginated_get "/api/v1/courses/#{course_id}/pages?sort=created_at&order=desc"
+        paginated_get "/api/v1/courses/#{course_id}/pages?sort=created_at&order=desc", params
       end
     end
 
-    def course_external_tool_update(external_tool_url, tool_id, account_id, publish)
-      authenticated_put "/api/v1/accounts/#{account_id}/external_tools_url", { body: {"course_navigation"=>{"enabled"=>"#{publish}"},
-       "tool_id"=>tool_id, "external_tool_url"=>external_tool_url} }
+    def update_external_tool_nav(external_tool_url, tool_id, publish, type, account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      if type == 'account'
+        body = {"account_navigation"=>{"enabled"=>"#{publish}"},
+        "tool_id"=>tool_id, "external_tool_url"=>external_tool_url}
+      elsif type == 'course'
+        body = {"course_navigation"=>{"enabled"=>"#{publish}"},
+        "tool_id"=>tool_id, "external_tool_url"=>external_tool_url}
+      end
+      authenticated_put "/api/v1/accounts/#{account_id}/external_tools_url", { body: body } if body
     end
 
-    def account_external_tool_update(external_tool_url, tool_id, account_id, publish)
-      authenticated_put "/api/v1/accounts/#{account_id}/external_tools_url", { body: {"account_navigation"=>{"enabled"=>"#{publish}"},
-       "tool_id"=>tool_id, "external_tool_url"=>external_tool_url} }
+    def get_school_details(account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      authenticated_get "/api/v1/accounts/#{account_id}/school_details"
     end
 
-    def get_school_details(account_id)
-      authenticated_get "/api/v1/accounts/#{account_id}/school_details"
+    def get_school_grades(account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      paginated_get "/api/v1/accounts/#{account_id}/school_grades", params
+    end
+
+    def get_school_grade(grade_id, account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      authenticated_get "/api/v1/accounts/#{account_id}/school_grades/#{grade_id}", params
+    end
+
+    def get_school_subjects(account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      paginated_get "/api/v1/accounts/#{account_id}/school_subjects", params
+    end
+
+    def get_school_subject(subject_id, account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      authenticated_get "/api/v1/accounts/#{account_id}/school_subjects/#{subject_id}", params
+    end
+
+    def get_school_class_rooms(account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      paginated_get "/api/v1/accounts/#{account_id}/school_class_rooms", params
+    end
+
+    def get_school_class_room(class_room_id, account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      authenticated_get "/api/v1/accounts/#{account_id}/school_class_rooms/#{class_room_id}", params
     end
 
-    def get_grade_students(account_id, grade_id)
-      paginated_get "/api/v1/accounts/#{account_id}/grade_students/#{grade_id}"
+    def get_students_by_grade(grade_id, account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      paginated_get "/api/v1/accounts/#{account_id}/grade_students/#{grade_id}", params
     end
 
-    def get_classroom_students(account_id, class_id)
-      paginated_get "/api/v1/accounts/#{account_id}/classroom_students/#{class_id}"
+    def get_students_by_class_room(class_room_id, account_id=@canvas_root_account_id, params={})
+      account_id ||= @canvas_root_account_id
+      paginated_get "/api/v1/accounts/#{account_id}/class_room_students/#{class_room_id}", params
     end
     ### END QALAM API ###
   end

data/lib/canvas_oauth/canvas_api_extensions.rb

@@ -1,12 +1,22 @@
 module CanvasOauth
   class CanvasApiExtensions
-    def self.build(canvas_url, user_id, tool_consumer_instance_guid)
-      account_id = CanvasOauth::Authorization.fetch_account(user_id, tool_consumer_instance_guid)
-      token = CanvasOauth::Authorization.fetch_token(user_id, tool_consumer_instance_guid)
-      refresh_token = CanvasOauth::Authorization.fetch_refresh_token(user_id, tool_consumer_instance_guid)
-      canvas_key = ((CanvasLtiKey.table_exists? && CanvasLtiKey.find_by(canvas_url: canvas_url)&.key) or CanvasConfig.key)
-      canvas_secret = ((CanvasLtiKey.table_exists? && CanvasLtiKey.find_by(key: canvas_key, canvas_url: canvas_url)&.secret) or CanvasConfig.secret)
-      CanvasApi.new(canvas_url, user_id, account_id, token, refresh_token, canvas_key, canvas_secret)
+    def self.build(user_id, tool_consumer_instance_guid, canvas_url)
+      canvas_auth = CanvasOauth::Authorization.fetch_canvas_auth(user_id, tool_consumer_instance_guid, canvas_url)
+
+      id = canvas_auth&.id
+      account_id = canvas_auth&.canvas_root_account_id
+      token = canvas_auth&.token
+      refresh_token = canvas_auth&.refresh_token
+
+      if canvas_url && CanvasLtiKey.table_exists?
+        canvas_lti_key = CanvasLtiKey.where('lower(canvas_url) LIKE :q', q: "%#{canvas_url.downcase}%").first
+        canvas_key = canvas_lti_key&.key or CanvasConfig.key      
+        canvas_secret = canvas_lti_key&.secret or CanvasConfig.secret
+      else
+        canvas_key = CanvasConfig.key
+        canvas_secret = CanvasConfig.secret
+      end
+      CanvasApi.new(id, canvas_url, user_id, account_id, token, refresh_token, canvas_key, canvas_secret)
     end
   end
 end

data/lib/canvas_oauth/canvas_application.rb

@@ -16,7 +16,7 @@ module CanvasOauth
 
     protected
     def initialize_canvas
-      @canvas = ::CanvasOauth::CanvasApiExtensions.build(canvas_url, user_id, tool_consumer_instance_guid)
+      @canvas = ::CanvasOauth::CanvasApiExtensions.build(user_id, tool_consumer_instance_guid, canvas_url)
     end
 
     def canvas
@@ -58,6 +58,14 @@ module CanvasOauth
     # be overridden or the session data needs to be set up by the time the
     # oauth filter runs (like with the lti_provider_engine)
 
+    def set_root_account
+      if session[:account_id]
+        @root_account_id = canvas.root_account_id(session[:account_id])
+      elsif session[:course_id]
+        @root_account_id = canvas.course_root_account_id(session[:course_id])
+      end
+    end
+    
     def canvas_url
       session[:canvas_url]
     end

data/lib/canvas_oauth/canvas_config.rb

@@ -13,12 +13,12 @@ module CanvasOauth
 
     def self.setup!
       if File.exists?(config_file)
-        Rails.logger.info "Initializing Qalam using configuration in #{config_file}"
+        Rails.logger.info "Initializing Qalam using configuration in #{config_file}".green
         config = load_config
         self.key = config['key']
         self.secret = config['secret']
       elsif ENV['CANVAS_KEY'].present? && ENV['CANVAS_SECRET'].present?
-        Rails.logger.info "Initializing Qalam using environment vars CANVAS_KEY and CANVAS_SECRET"
+        Rails.logger.info "Initializing Qalam using environment vars CANVAS_KEY and CANVAS_SECRET".green
         self.key = ENV['CANVAS_KEY']
         self.secret = ENV['CANVAS_SECRET']
       else

data/lib/canvas_oauth/version.rb

@@ -1,3 +1,3 @@
 module CanvasOauth
-  VERSION = "3.0.5"
+  VERSION = "3.0.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qalam_oauth_engine
 version: !ruby/object:Gem::Version
-  version: 3.0.5
+  version: 3.0.9
 platform: ruby
 authors:
 - Dave Donahue
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-23 00:00:00.000000000 Z
+date: 2021-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -61,6 +61,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement