bright 0.2.0 → 1.2

data/lib/bright/sis_apis/base.rb

@@ -1,17 +1,17 @@
 module Bright
   module SisApi
     class Base
-      
+
       def filter_students_by_params(students, params)
         total = params[:limit]
         count = 0
         found = []
-  
+
         keys = (Student.attribute_names & params.keys.collect(&:to_sym))
         puts "filtering on #{keys.join(",")}"
         students.each do |student|
           break if total and count >= total
-    
+
           should = (keys).all? do |m|
             student.send(m) =~ Regexp.new(Regexp.escape(params[m]), Regexp::IGNORECASE)
           end
@@ -20,7 +20,33 @@ module Bright
         end
         found
       end
-  
+
+      def connection_retry_wrapper(&block)
+        retry_attempts = connection_options[:retry_attempts] || 2
+        retries = 0
+        begin
+          yield
+        rescue Bright::ResponseError => e
+          retries += 1
+          if e.server_error? && retries <= retry_attempts.to_i
+            puts "retrying #{retries}: #{e.class.to_s} - #{e.to_s}"
+            sleep(retries * 3)
+            retry
+          else
+            raise
+          end
+        rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Net::ReadTimeout, Net::OpenTimeout, SocketError, EOFError => e
+          retries += 1
+          if retries <= retry_attempts.to_i
+            puts "retrying #{retries}: #{e.class.to_s} - #{e.to_s}"
+            sleep(retries * 3)
+            retry
+          else
+            raise
+          end
+        end
+      end
+
     end
   end
-end
+end

data/lib/bright/sis_apis/bright_sis.rb

@@ -55,7 +55,8 @@ module Bright
             :seed_page => students,
             :total => total_results,
             :per_page => params[:limit],
-            :load_more_call => load_more_call
+            :load_more_call => load_more_call,
+            :no_threads => options[:no_threads]
           })
         else
           students
@@ -92,7 +93,8 @@ module Bright
             :seed_page => schools,
             :total => total_results,
             :per_page => params[:limit],
-            :load_more_call => load_more_call
+            :load_more_call => load_more_call,
+            :no_threads => options[:no_threads]
           })
         else
           schools
@@ -108,11 +110,12 @@ module Bright
         else
           body = JSON.dump(params)
         end
-        puts uri.inspect
-        headers = self.headers_for_auth(uri)
 
-        connection = Bright::Connection.new(uri)
-        response = connection.request(method, body, headers)
+        response = connection_retry_wrapper {
+          connection = Bright::Connection.new(uri)
+          headers = self.headers_for_auth
+          connection.request(method, body, headers)
+        }
 
         if !response.error?
           response_hash = JSON.parse(response.body)
@@ -149,7 +152,6 @@ module Bright
 
       def convert_to_student_data(student_params)
         return {} if student_params.nil?
-
         student_data_hsh = {
           :api_id => student_params["uuid"],
           :first_name => student_params["first_name"],
@@ -165,7 +167,7 @@ module Bright
           :image => student_params["picture"],
           :hispanic_ethnicity => student_params["hispanic_latino"],
           :last_modified => student_params["updated_at"]
-        }
+        }.reject{|k,v| v.blank?}
         unless student_params["birthdate"].blank?
           student_data_hsh[:birth_date] = Date.parse(student_params["birthdate"]).to_s
         end
@@ -177,19 +179,21 @@ module Bright
           end
         end
 
-        unless student_params["student_street"].blank?
-          student_data_hsh[:addresses] = [{
-            :street => student_params["student_street"],
-            :apt => student_params["student_street_line_2"],
-            :city => student_params["student_city"],
-            :state => student_params["student_state"],
-            :postal_code => student_params["student_zip"]
-          }]
+        unless student_params["addresses"].blank?
+          student_data_hsh[:addresses] = student_params["addresses"].collect do |address_params|
+            convert_to_address_data(address_params)
+          end
+        end
+
+        unless student_params["phone_numbers"].blank?
+          student_data_hsh[:phone_numbers] = student_params["phone_numbers"].collect do |phone_params|
+            convert_to_phone_number_data(phone_params)
+          end
         end
 
-        unless student_params["student_email"].blank?
+        unless student_params["email_addresses"].blank?
           student_data_hsh[:email_address] = {
-            :email_address => student_params["student_email"]
+            :email_address => student_params["email_addresses"].first["email_address"]
           }
         end
 
@@ -197,6 +201,36 @@ module Bright
           student_data_hsh[:school] = convert_to_school_data(student_params["school"])
         end
 
+        unless student_params["contacts"].blank?
+          student_data_hsh[:contacts] = student_params["contacts"].collect do |contact_params|
+            contact_data_hsh = {
+              :api_id => contact_params["uuid"],
+              :first_name => contact_params["first_name"],
+              :middle_name => contact_params["middle_name"],
+              :last_name => contact_params["last_name"],
+              :relationship_type => contact_params["relationship"],
+              :sis_student_id => contact_params["sis_id"],
+              :last_modified => contact_params["updated_at"]
+            }
+            unless contact_params["addresses"].blank?
+              contact_data_hsh[:addresses] = contact_params["addresses"].collect do |address_params|
+                convert_to_address_data(address_params)
+              end
+            end
+            unless contact_params["phone_numbers"].blank?
+              contact_data_hsh[:phone_numbers] = contact_params["phone_numbers"].collect do |phone_params|
+                convert_to_phone_number_data(phone_params)
+              end
+            end
+            unless contact_params["email_addresses"].blank?
+              contact_data_hsh[:email_address] = {
+                :email_address => contact_params["email_addresses"].first["email_address"]
+              }
+            end
+            contact_data_hsh.reject{|k,v| v.blank?}
+          end
+        end
+
         return student_data_hsh
       end
 
@@ -213,6 +247,28 @@ module Bright
         return filter_params
       end
 
+      def convert_to_phone_number_data(phone_number_params)
+        return {} if phone_number_params.nil?
+        {
+          :phone_number => phone_number_params["phone_number"],
+          :type => phone_number_params["phone_type"]
+        }.reject{|k,v| v.blank?}
+      end
+
+      def convert_to_address_data(address_params)
+        return {} if address_params.nil?
+        {
+          :street => address_params["street"],
+          :apt => address_params["street_line_2"],
+          :city => address_params["city"],
+          :state => address_params["state"],
+          :postal_code => address_params["zip"],
+          :lattitude => address_params["latitude"],
+          :longitude => address_params["longitude"],
+          :type => address_params["address_type"]
+        }.reject{|k,v| v.blank?}
+      end
+
       def convert_to_school_data(school_params)
         return {} if school_params.nil?
 

data/lib/bright/sis_apis/focus.rb

@@ -0,0 +1,377 @@
+require 'oauth'
+
+module Bright
+  module SisApi
+    class Focus < Base
+
+      @@description = "Connects to the Focus OneRoster API for accessing student information"
+      @@doc_url = ""
+      @@api_version = "1.1"
+
+      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"
+      }
+
+      def initialize(options = {})
+        self.connection_options = options[:connection] || {}
+        # {
+        #   :client_id => "",
+        #   :client_secret => "",
+        #   :api_version => "", (defaults to @@api_version)
+        #   :uri => "",
+        #   :token_uri => ""  (api_version 1.2 required)
+        # }
+      end
+
+      def api_version
+        Gem::Version.new(self.connection_options.dig(:api_version) || @@api_version)
+      end
+
+      def get_student_by_api_id(api_id, params = {})
+        st_hsh = self.request(:get, "students/#{api_id}", params)
+        Student.new(convert_to_user_data(st_hsh["user"])) if st_hsh and st_hsh["user"]
+      end
+
+      def get_student(params = {}, options = {})
+        self.get_students(params, options.merge(:limit => 1, :wrap_in_collection => false)).first
+      end
+
+      def get_students(params = {}, options = {})
+        params[:limit] = params[:limit] || options[:limit] || 100
+        students_response_hash = self.request(:get, 'students', self.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"]
+          students_hash = [students_response_hash["users"]].flatten
+
+          students = students_hash.compact.collect {|st_hsh|
+            Student.new(convert_to_user_data(st_hsh))
+          }
+        end
+        if options[:wrap_in_collection] != false
+          api = self
+          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})
+          }
+          ResponseCollection.new({
+            :seed_page => students,
+            :total => total_results,
+            :per_page => params[:limit],
+            :load_more_call => load_more_call,
+            :no_threads => options[:no_threads]
+          })
+        else
+          students
+        end
+      end
+
+      def create_student(student)
+        raise NotImplementedError
+      end
+
+      def update_student(student)
+        raise NotImplementedError
+      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"]
+      end
+
+      def get_school(params = {}, options = {})
+        self.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))
+        total_results = schools_response_hash[:response_headers]["x-total-count"].to_i
+        if schools_response_hash and schools_response_hash["orgs"]
+          schools_hash = [schools_response_hash["orgs"]].flatten
+
+          schools = schools_hash.compact.collect {|sc_hsh|
+            School.new(convert_to_school_data(sc_hsh))
+          }
+        end
+        if options[:wrap_in_collection] != false
+          api = self
+          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})
+          }
+          ResponseCollection.new({
+            :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"]
+      end
+
+      def request(method, path, params = {})
+        uri  = "#{self.connection_options[:uri]}/#{path}"
+        body = nil
+        if method == :get
+          query = URI.encode_www_form(params)
+          uri += "?#{query}" unless query.strip == ""
+        else
+          body = JSON.dump(params)
+        end
+
+        response = connection_retry_wrapper {
+          connection = Bright::Connection.new(uri)
+          headers = self.headers_for_auth(uri)
+          connection.request(method, body, headers)
+        }
+
+        if !response.error?
+          response_hash = JSON.parse(response.body)
+          response_hash[:response_headers] = response.headers
+        else
+          puts "#{response.inspect}"
+          puts "#{response.body}"
+        end
+        response_hash
+      end
+
+      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
+          end
+          {
+            "Authorization" => "Bearer #{self.connection_options[:access_token]}",
+            "Accept" => "application/json;charset=UTF-8",
+            "Content-Type" =>"application/json;charset=UTF-8"
+          }
+        end
+      end
+
+      def retrieve_access_token
+        connection = Bright::Connection.new(self.connection_options[:token_uri])
+        response = connection.request(:post,
+          {
+            "grant_type" => "client_credentials",
+            "username" => self.connection_options[:client_id],
+            "password" => self.connection_options[:client_secret]
+          },
+          self.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"]
+        end
+        response_hash
+      end
+
+      def headers_for_access_token
+        {
+          "Authorization" => "Basic #{Base64.strict_encode64("#{self.connection_options[:client_id]}:#{self.connection_options[:client_secret]}")}",
+          "Content-Type" => "application/x-www-form-urlencoded;charset=UTF-8"
+        }
+      end
+
+      def map_search_params(params)
+        params = params.dup
+        default_params = {}
+
+        filter = []
+        params.each do |k,v|
+          case k.to_s
+          when "first_name"
+            filter << "givenName='#{v}'"
+          when "last_name"
+            filter << "familyName='#{v}'"
+          when "email"
+            filter << "email='#{v}'"
+          when "student_id"
+            filter << "identifier='#{v}'"
+          when "last_modified"
+            filter << "dateLastModified>='#{v.to_time.utc.xmlschema}'"
+          when "role"
+            filter << "role='#{v}'"
+          else
+            default_params[k] = v
+          end
+        end
+        unless filter.empty?
+          params = {"filter" => filter.join(" AND ")}
+        end
+        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|
+          case k.to_s
+          when "number"
+            filter << "identifier='#{v}'"
+          when "last_modified"
+            filter << "dateLastModified>='#{v.to_time.utc.xmlschema}'"
+          else
+            default_params[k] = v
+          end
+        end
+        unless filter.empty?
+          params = {"filter" => filter.join(" AND ")}
+        end
+        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"]
+        }
+        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?}
+        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.dig("metadata", "stateId").blank?
+          user_data_hsh[:state_student_id] = user_params.dig("metadata", "stateId")
+        end
+        unless user_params["email"].blank?
+          user_data_hsh[:email_address] = {
+            :email_address => user_params["email"]
+          }
+        end
+        unless user_params["orgs"].blank?
+          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"])
+              self.schools_cache[attending_school.api_id] = attending_school
+            end
+          end
+          if attending_school
+            user_data_hsh[:school] = attending_school
+          end
+        end
+        unless user_params["phone"].blank?
+          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"]}
+        end
+
+        #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?
+          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
+            end
+          end.compact
+          user_data_hsh[:grade] = (user_params["grades"] || []).first
+          if !user_data_hsh[:grade].blank?
+            user_data_hsh[:grade_school_year] = get_grade_school_year
+          end
+        end
+
+        return user_data_hsh
+      end
+
+      def get_demographic_information(api_id)
+        demographic_hsh = {}
+
+        begin
+          demographics_params = request(:get, "demographics/#{api_id}")["demographics"]
+        rescue Bright::ResponseError => e
+          if e.message.to_s.include?('404')
+            return demographic_hsh
+          else
+            raise e
+          end
+        end
+
+        unless (bday = demographics_params["birthdate"] || demographics_params["birthDate"]).blank?
+          demographic_hsh[:birth_date] = Date.parse(bday).to_s
+        end
+        unless demographics_params["sex"].to_s[0].blank?
+          demographic_hsh[:gender] = demographics_params["sex"].to_s[0].upcase
+        end
+        DEMOGRAPHICS_CONVERSION.each do |demographics_key, demographics_value|
+          if demographics_params[demographics_key].to_bool
+            if demographics_value == "Hispanic Or Latino"
+              demographic_hsh[:hispanic_ethnicity] = true
+            else
+              demographic_hsh[:race] ||= []
+              demographic_hsh[:race] << demographics_value
+            end
+          end
+        end
+        return demographic_hsh
+      end
+
+      def get_grade_school_year(date = Date.today)
+        # 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
+          if school_years.size == 1
+            self.school_years_cache[date] = school_years.first
+          end
+        end
+        return self.school_years_cache[date]
+      end
+
+    end
+  end
+end