bright 1.3 → 2.1

data/lib/bright/sis_apis/{infinite_campus.rb → one_roster.rb}

@@ -1,22 +1,21 @@
-require 'oauth'
+require "oauth"
 
 module Bright
   module SisApi
-    class InfiniteCampus < Base
-
-      @@description = "Connects to the Infinite Campus OneRoster API for accessing student information"
-      @@doc_url = "https://content.infinitecampus.com/sis/latest/documentation/oneroster-api"
-      @@api_version = "1.1"
+    class OneRoster < Base
+      @@description = "Connects to the OneRoster API for accessing student information"
+      @@doc_url = "https://www.imsglobal.org/sites/default/files/spec/oneroster/v1p2/rostering-informationmodel/OneRosterv1p2RosteringService_InfoModelv1p0.html"
+      @@api_version = "1.2"
 
       attr_accessor :connection_options, :schools_cache, :school_years_cache
 
       DEMOGRAPHICS_CONVERSION = {
-        "americanIndianOrAlaskaNative"=>"American Indian Or Alaska Native",
-        "asian"=>"Asian",
-        "blackOrAfricanAmerican"=>"Black Or African American",
-        "nativeHawaiianOrOtherPacificIslander"=>"Native Hawaiian Or Other Pacific Islander",
-        "white"=>"White",
-        "hispanicOrLatinoEthnicity"=>"Hispanic Or Latino"
+        "americanIndianOrAlaskaNative" => "American Indian Or Alaska Native",
+        "asian" => "Asian",
+        "blackOrAfricanAmerican" => "Black Or African American",
+        "nativeHawaiianOrOtherPacificIslander" => "Native Hawaiian Or Other Pacific Islander",
+        "white" => "White",
+        "hispanicOrLatinoEthnicity" => "Hispanic Or Latino"
       }
 
       def initialize(options = {})
@@ -31,36 +30,36 @@ module Bright
       end
 
       def api_version
-        Gem::Version.new(self.connection_options.dig(:api_version) || @@api_version)
+        Gem::Version.new(connection_options.dig(:api_version) || @@api_version)
       end
 
       def get_student_by_api_id(api_id, params = {})
-        if api_version <= Gem::Version.new("1.1")
-          params = {:role => "student"}.merge(params)
+        params = if api_version <= Gem::Version.new("1.1")
+          {role: "student"}.merge(params)
         else
-          params = {:roles => "student"}.merge(params)
+          {roles: "student"}.merge(params)
         end
-        st_hsh = self.request(:get, "users/#{api_id}", params)
-        Student.new(convert_to_user_data(st_hsh["user"])) if st_hsh and st_hsh["user"]
+        st_hsh = request(:get, "users/#{api_id}", params)
+        Student.new(convert_to_user_data(st_hsh["user"])) if st_hsh && st_hsh["user"]
       end
 
       def get_student(params = {}, options = {})
-        self.get_students(params, options.merge(:limit => 1, :wrap_in_collection => false)).first
+        get_students(params, options.merge(limit: 1, wrap_in_collection: false)).first
       end
 
       def get_students(params = {}, options = {})
-        if api_version <= Gem::Version.new("1.1")
-          params = {:role => "student"}.merge(params)
+        params = if api_version <= Gem::Version.new("1.1")
+          {role: "student"}.merge(params)
         else
-          params = {:roles => "student"}.merge(params)
+          {roles: "student"}.merge(params)
         end
         params[:limit] = params[:limit] || options[:limit] || 100
-        students_response_hash = self.request(:get, 'users', self.map_search_params(params))
+        students_response_hash = request(:get, "users", map_search_params(params))
         total_results = students_response_hash[:response_headers]["x-total-count"].to_i
-        if students_response_hash and students_response_hash["users"]
+        if students_response_hash && students_response_hash["users"]
           students_hash = [students_response_hash["users"]].flatten
 
-          students = students_hash.compact.collect {|st_hsh|
+          students = students_hash.compact.collect { |st_hsh|
             Student.new(convert_to_user_data(st_hsh))
           }
         end
@@ -69,14 +68,14 @@ module Bright
           load_more_call = proc { |page|
             # pages start at one, so add a page here
             params[:offset] = (params[:limit].to_i * page)
-            api.get_students(params, {:wrap_in_collection => false})
+            api.get_students(params, {wrap_in_collection: false})
           }
           ResponseCollection.new({
-            :seed_page => students,
-            :total => total_results,
-            :per_page => params[:limit],
-            :load_more_call => load_more_call,
-            :no_threads => options[:no_threads]
+            seed_page: students,
+            total: total_results,
+            per_page: params[:limit],
+            load_more_call: load_more_call,
+            no_threads: options[:no_threads]
           })
         else
           students
@@ -92,22 +91,22 @@ module Bright
       end
 
       def get_school_by_api_id(api_id, params = {})
-        sc_hsh = self.request(:get, "schools/#{api_id}", params)
-        School.new(convert_to_school_data(sc_hsh["org"])) if sc_hsh and sc_hsh["org"]
+        sc_hsh = request(:get, "schools/#{api_id}", params)
+        School.new(convert_to_school_data(sc_hsh["org"])) if sc_hsh && sc_hsh["org"]
       end
 
       def get_school(params = {}, options = {})
-        self.get_schools(params, options.merge(:limit => 1, :wrap_in_collection => false)).first
+        get_schools(params, options.merge(limit: 1, wrap_in_collection: false)).first
       end
 
       def get_schools(params = {}, options = {})
         params[:limit] = params[:limit] || options[:limit] || 100
-        schools_response_hash = self.request(:get, 'schools', self.map_school_search_params(params))
+        schools_response_hash = request(:get, "schools", map_school_search_params(params))
         total_results = schools_response_hash[:response_headers]["x-total-count"].to_i
-        if schools_response_hash and schools_response_hash["orgs"]
+        if schools_response_hash && schools_response_hash["orgs"]
           schools_hash = [schools_response_hash["orgs"]].flatten
 
-          schools = schools_hash.compact.collect {|sc_hsh|
+          schools = schools_hash.compact.collect { |sc_hsh|
             School.new(convert_to_school_data(sc_hsh))
           }
         end
@@ -116,27 +115,27 @@ module Bright
           load_more_call = proc { |page|
             # pages start at one, so add a page here
             params[:offset] = (params[:limit].to_i * page)
-            api.get_schools(params, {:wrap_in_collection => false})
+            api.get_schools(params, {wrap_in_collection: false})
           }
           ResponseCollection.new({
-            :seed_page => schools,
-            :total => total_results,
-            :per_page => params[:limit],
-            :load_more_call => load_more_call,
-            :no_threads => options[:no_threads]
+            seed_page: schools,
+            total: total_results,
+            per_page: params[:limit],
+            load_more_call: load_more_call,
+            no_threads: options[:no_threads]
           })
         else
           schools
         end
       end
 
-      def get_contact_by_api_id(api_id, params ={})
-        contact_hsh = self.request(:get, "users/#{api_id}", params)
-        Contact.new(convert_to_user_data(contact_hsh["user"], bright_type: "Contact")) if contact_hsh and contact_hsh["user"]
+      def get_contact_by_api_id(api_id, params = {})
+        contact_hsh = request(:get, "users/#{api_id}", params)
+        Contact.new(convert_to_user_data(contact_hsh["user"], bright_type: "Contact")) if contact_hsh && contact_hsh["user"]
       end
 
       def request(method, path, params = {})
-        uri  = "#{self.connection_options[:uri]}/#{path}"
+        uri = "#{connection_options[:uri]}/#{path}"
         body = nil
         if method == :get
           query = URI.encode_www_form(params)
@@ -147,7 +146,7 @@ module Bright
 
         response = connection_retry_wrapper {
           connection = Bright::Connection.new(uri)
-          headers = self.headers_for_auth(uri)
+          headers = headers_for_auth(uri)
           connection.request(method, body, headers)
         }
 
@@ -155,8 +154,8 @@ module Bright
           response_hash = JSON.parse(response.body)
           response_hash[:response_headers] = response.headers
         else
-          puts "#{response.inspect}"
-          puts "#{response.body}"
+          puts response.inspect
+          puts response.body
         end
         response_hash
       end
@@ -164,48 +163,46 @@ module Bright
       protected
 
       def headers_for_auth(uri)
-        case api_version
-        when Gem::Version.new("1.1")
-          site = URI.parse(self.connection_options[:uri])
-          site = "#{site.scheme}://#{site.host}"
-          consumer = OAuth::Consumer.new(self.connection_options[:client_id], self.connection_options[:client_secret], { :site => site, :scheme => :header })
-          options = {:timestamp => Time.now.to_i, :nonce => SecureRandom.uuid}
-          {"Authorization" => consumer.create_signed_request(:get, uri, nil, options)["Authorization"]}
-        when Gem::Version.new("1.2")
-          if self.connection_options[:access_token].nil? or self.connection_options[:access_token_expires] < Time.now
-            self.retrieve_access_token
+        if api_version >= Gem::Version.new("1.2") || connection_options[:token_uri].present?
+          if connection_options[:access_token].nil? || (connection_options[:access_token_expires] < Time.now)
+            retrieve_access_token
           end
           {
-            "Authorization" => "Bearer #{self.connection_options[:access_token]}",
-            "Accept" => "application/json;charset=UTF-8",
-            "Content-Type" =>"application/json;charset=UTF-8"
+            "Authorization" => "Bearer #{connection_options[:access_token]}",
+            "Accept" => "application/json",
+            "Content-Type" => "application/json"
           }
+        else
+          site = URI.parse(connection_options[:uri])
+          site = "#{site.scheme}://#{site.host}"
+          consumer = OAuth::Consumer.new(connection_options[:client_id], connection_options[:client_secret], {site: site, scheme: :header})
+          options = {timestamp: Time.now.to_i, nonce: SecureRandom.uuid}
+          {"Authorization" => consumer.create_signed_request(:get, uri, nil, options)["Authorization"]}
         end
       end
 
       def retrieve_access_token
-        connection = Bright::Connection.new(self.connection_options[:token_uri])
+        connection = Bright::Connection.new(connection_options[:token_uri])
         response = connection.request(:post,
           {
             "grant_type" => "client_credentials",
-            "username" => self.connection_options[:client_id],
-            "password" => self.connection_options[:client_secret]
+            "username" => connection_options[:client_id],
+            "password" => connection_options[:client_secret]
           },
-          self.headers_for_access_token
-        )
+          headers_for_access_token)
         if !response.error?
           response_hash = JSON.parse(response.body)
         end
         if response_hash["access_token"]
-          self.connection_options[:access_token] = response_hash["access_token"]
-          self.connection_options[:access_token_expires] = (Time.now - 10) + response_hash["expires_in"]
+          connection_options[:access_token] = response_hash["access_token"]
+          connection_options[:access_token_expires] = (Time.now - 10) + response_hash["expires_in"]
         end
         response_hash
       end
 
       def headers_for_access_token
         {
-          "Authorization" => "Basic #{Base64.strict_encode64("#{self.connection_options[:client_id]}:#{self.connection_options[:client_secret]}")}",
+          "Authorization" => "Basic #{Base64.strict_encode64("#{connection_options[:client_id]}:#{connection_options[:client_secret]}")}",
           "Content-Type" => "application/x-www-form-urlencoded;charset=UTF-8"
         }
       end
@@ -215,7 +212,7 @@ module Bright
         default_params = {}
 
         filter = []
-        params.each do |k,v|
+        params.each do |k, v|
           case k.to_s
           when "first_name"
             filter << "givenName='#{v}'"
@@ -236,14 +233,14 @@ module Bright
         unless filter.empty?
           params = {"filter" => filter.join(" AND ")}
         end
-        default_params.merge(params).reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
+        default_params.merge(params).reject { |k, v| v.respond_to?(:empty?) ? v.empty? : v.nil? }
       end
 
       def map_school_search_params(params)
         params = params.dup
         default_params = {}
         filter = []
-        params.each do |k,v|
+        params.each do |k, v|
           case k.to_s
           when "number"
             filter << "identifier='#{v}'"
@@ -256,50 +253,46 @@ module Bright
         unless filter.empty?
           params = {"filter" => filter.join(" AND ")}
         end
-        default_params.merge(params).reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
+        default_params.merge(params).reject { |k, v| v.respond_to?(:empty?) ? v.empty? : v.nil? }
       end
 
       def convert_to_school_data(school_params)
         return {} if school_params.blank?
-        school_data_hsh = {
-          :api_id => school_params["sourcedId"],
-          :name => school_params["name"],
-          :number => school_params["identifier"],
-          :last_modified => school_params["dateLastModified"]
+        {
+          api_id: school_params["sourcedId"],
+          name: school_params["name"],
+          number: school_params["identifier"],
+          last_modified: school_params["dateLastModified"]
         }
-        return school_data_hsh
       end
 
       def convert_to_user_data(user_params, bright_type: "Student")
         return {} if user_params.blank?
         user_data_hsh = {
-          :api_id => user_params["sourcedId"],
-          :first_name => user_params["givenName"],
-          :middle_name => user_params["middleName"],
-          :last_name => user_params["familyName"],
-          :last_modified => user_params["dateLastModified"]
-        }.reject{|k,v| v.blank?}
+          api_id: user_params["sourcedId"],
+          first_name: user_params["givenName"],
+          middle_name: user_params["middleName"],
+          last_name: user_params["familyName"],
+          last_modified: user_params["dateLastModified"]
+        }.reject { |k, v| v.blank? }
         unless user_params["identifier"].blank?
           user_data_hsh[:sis_student_id] = user_params["identifier"]
         end
-        unless user_params["userMasterIdentifier"].blank?
-          user_data_hsh[:state_student_id] = user_params["userMasterIdentifier"]
-        end
         unless user_params["userIds"].blank?
-          if (state_id_hsh = user_params["userIds"].detect{|user_id_hsh| user_id_hsh["type"] == "stateID"})
+          if (state_id_hsh = user_params["userIds"].detect { |user_id_hsh| user_id_hsh["type"] == "stateID" })
             user_data_hsh[:state_student_id] = state_id_hsh["identifier"]
           end
         end
         unless user_params["email"].blank?
           user_data_hsh[:email_address] = {
-            :email_address => user_params["email"]
+            email_address: user_params["email"]
           }
         end
         unless user_params["orgs"].blank?
-          if (s = user_params["orgs"].detect{|org| org["href"] =~ /\/schools\//})
+          if (s = user_params["orgs"].detect { |org| org["href"] =~ /\/schools\// })
             self.schools_cache ||= {}
             if (attending_school = self.schools_cache[s["sourcedId"]]).nil?
-              attending_school = self.get_school_by_api_id(s["sourcedId"])
+              attending_school = get_school_by_api_id(s["sourcedId"])
               self.schools_cache[attending_school.api_id] = attending_school
             end
           end
@@ -308,26 +301,24 @@ module Bright
           end
         end
         unless user_params["phone"].blank?
-          user_data_hsh[:phone_numbers] = [{:phone_number => user_params["phone"]}]
+          user_data_hsh[:phone_numbers] = [{phone_number: user_params["phone"]}]
         end
         unless user_params["sms"].blank?
           user_data_hsh[:phone_numbers] ||= []
-          user_data_hsh[:phone_numbers] << {:phone_number => user_params["sms"]}
+          user_data_hsh[:phone_numbers] << {phone_number: user_params["sms"]}
         end
 
-        #add the demographic information
+        # add the demographic information
         demographics_hash = get_demographic_information(user_data_hsh[:api_id])
         user_data_hsh.merge!(demographics_hash) unless demographics_hash.blank?
 
-        #if you're a student, build the contacts too
-        if bright_type == "Student" and !user_params["agents"].blank?
+        # if you're a student, build the contacts too
+        if (bright_type == "Student") && !user_params["agents"].blank?
           user_data_hsh[:contacts] = user_params["agents"].collect do |agent_hsh|
-            begin
-              self.get_contact_by_api_id(agent_hsh["sourcedId"])
-            rescue Bright::ResponseError => e
-              if !e.message.to_s.include?("404")
-                raise e
-              end
+            get_contact_by_api_id(agent_hsh["sourcedId"])
+          rescue Bright::ResponseError => e
+            if !e.message.to_s.include?("404")
+              raise e
             end
           end.compact
           user_data_hsh[:grade] = (user_params["grades"] || []).first
@@ -336,7 +327,7 @@ module Bright
           end
         end
 
-        return user_data_hsh
+        user_data_hsh
       end
 
       def get_demographic_information(api_id)
@@ -345,7 +336,7 @@ module Bright
         begin
           demographics_params = request(:get, "demographics/#{api_id}")["demographics"]
         rescue Bright::ResponseError => e
-          if e.message.to_s.include?('404')
+          if e.message.to_s.include?("404")
             return demographic_hsh
           else
             raise e
@@ -368,22 +359,21 @@ module Bright
             end
           end
         end
-        return demographic_hsh
+        demographic_hsh
       end
 
       def get_grade_school_year(date = Date.today)
-        #return the school year of a specific date
+        # return the school year of a specific date
         self.school_years_cache ||= {}
         if self.school_years_cache[date].nil?
-          academic_periods_params = self.request(:get, "academicSessions", {"filter" => "startDate<='#{date.to_s}' AND endDate>='#{date.to_s}' AND status='active'"})["academicSessions"]
-          school_years = academic_periods_params.map{|ap| ap["schoolYear"]}.uniq
+          academic_periods_params = request(:get, "academicSessions", {"filter" => "startDate<='#{date}' AND endDate>='#{date}' AND status='active'"})["academicSessions"]
+          school_years = academic_periods_params.map { |ap| ap["schoolYear"] }.uniq
           if school_years.size == 1
             self.school_years_cache[date] = school_years.first
           end
         end
-        return self.school_years_cache[date]
+        self.school_years_cache[date]
       end
-
     end
   end
 end