bright 0.2.0 → 1.2

data/lib/bright/sis_apis/power_school.rb

@@ -3,34 +3,34 @@ module Bright
     class PowerSchool < Base
       DATE_FORMAT = '%Y-%m-%d'
       INVALID_SEARCH_CHAR_RE = /[\,\;]/
-      
+
       @@description = "Connects to the PowerSchool API for accessing student information"
       @@doc_url = "http://psimages.sunnysideschools.org/api-developer-guide-1.6.0/"
       @@api_version = "1.6.0"
-      
+
       attr_accessor :connection_options, :expansion_options
-      
+
       def initialize(options = {})
         self.connection_options = options[:connection] || {}
         self.expansion_options = options[:expansion] || {}
         # {
-        #   :client_id => "", 
+        #   :client_id => "",
         #   :client_secret => "",
         #   :uri => ""
         #   :access_token => "", #optional
         # }
       end
-      
+
       def get_student_by_api_id(api_id, params = {})
         params = self.apply_expansions(params)
         st_hsh = self.request(:get, "ws/v1/student/#{api_id}", params)
         Student.new(convert_to_student_data(st_hsh["student"])) if st_hsh and st_hsh["student"]
       end
-      
+
       def get_student(params = {}, options = {})
         self.get_students(params, options.merge(:per_page => 1, :wrap_in_collection => false)).first
       end
-      
+
       def get_students(params = {}, options = {})
         params = self.apply_expansions(params)
         params = self.apply_options(params, options)
@@ -44,23 +44,25 @@ module Bright
         students_response_hash = self.request(:get, 'ws/v1/district/student', self.map_student_search_params(params))
         if students_response_hash and students_response_hash["students"] && students_response_hash["students"]["student"]
           students_hash = [students_response_hash["students"]["student"]].flatten
-        
+
           students = students_hash.compact.collect {|st_hsh|
             Student.new(convert_to_student_data(st_hsh))
           }
-        
+
           if options[:wrap_in_collection] != false
             api = self
             load_more_call = proc { |page|
               # pages start at one, so add a page here
-              api.get_students(params, {:wrap_in_collection => false, :page => (page + 1)})
+              params[:page] = (page + 1)
+              api.get_students(params, {:wrap_in_collection => false})
             }
 
             ResponseCollection.new({
-              :seed_page => students, 
+              :seed_page => students,
               :total => total_results,
-              :per_page => params[:pagesize], 
-              :load_more_call => load_more_call
+              :per_page => params[:pagesize],
+              :load_more_call => load_more_call,
+              :no_threads => options[:no_threads]
             })
           else
             students
@@ -69,7 +71,7 @@ module Bright
           []
         end
       end
-      
+
       def create_student(student, additional_params = {})
         response = self.request(:post, 'ws/v1/student', self.convert_from_student_data(student, "INSERT", additional_params))
         if response["results"] and response["results"]["insert_count"] == 1
@@ -87,7 +89,7 @@ module Bright
         end
         student
       end
-      
+
       def update_student(student, additional_params = {})
         response = self.request(:post, 'ws/v1/student', self.convert_from_student_data(student, "UPDATE", additional_params))
         if response["results"] and response["results"]["update_count"] == 1
@@ -98,11 +100,11 @@ module Bright
           student
         end
       end
-      
+
       def subscribe_student(student)
         raise NotImplementedError
       end
-      
+
       def get_schools(params = {}, options = {})
         params = self.apply_options(params, options)
 
@@ -113,32 +115,33 @@ module Bright
         end
 
         schools_response_hash = self.request(:get, 'ws/v1/district/school', params)
-        puts schools_response_hash.inspect
         schools_hsh = [schools_response_hash["schools"]["school"]].flatten
-        
+
         schools = schools_hsh.compact.collect {|st_hsh|
           School.new(convert_to_school_data(st_hsh))
         }
-        
+
         if options[:wrap_in_collection] != false
           api = self
           load_more_call = proc { |page|
             # pages start at one, so add a page here
-            api.get_schools(params, {:wrap_in_collection => false, :page => (page + 1)})
+            params[:page] = (page + 1)
+            api.get_schools(params, {:wrap_in_collection => false})
           }
 
           ResponseCollection.new({
-            :seed_page => schools, 
+            :seed_page => schools,
             :total => total_results,
-            :per_page => params[:pagesize], 
-            :load_more_call => load_more_call
+            :per_page => params[:pagesize],
+            :load_more_call => load_more_call,
+            :no_threads => options[:no_threads]
           })
         else
           schools
         end
       end
-      
-      def retrive_access_token
+
+      def retrieve_access_token
         connection = Bright::Connection.new("#{self.connection_options[:uri]}/oauth/access_token/")
         response = connection.request(:post, "grant_type=client_credentials", self.headers_for_access_token)
         if !response.error?
@@ -149,7 +152,7 @@ module Bright
         end
         response_hash
       end
-      
+
       def request(method, path, params = {})
         uri  = "#{self.connection_options[:uri]}/#{path}"
         body = nil
@@ -159,12 +162,14 @@ module Bright
         else
           body = JSON.dump(params)
         end
-        
-        headers = self.headers_for_auth
 
-        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)
         else
@@ -173,13 +178,13 @@ module Bright
         end
         response_hash
       end
-      
+
       protected
-      
+
       def map_student_search_params(params)
         params = params.dup
         default_params = {}
-        
+
         q = ""
         %w(first_name middle_name last_name).each do |f|
           if fn = params.delete(f.to_sym)
@@ -199,23 +204,23 @@ module Bright
 
         default_params.merge(params).reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
       end
-      
+
       def convert_to_student_data(attrs)
         cattrs = {}
-        
+
         if attrs["name"]
           cattrs[:first_name]  = attrs["name"]["first_name"]
           cattrs[:middle_name] = attrs["name"]["middle_name"]
           cattrs[:last_name]  = attrs["name"]["last_name"]
         end
-        
+
         cattrs[:api_id] = attrs["id"].to_s
         cattrs[:sis_student_id] = attrs["local_id"].to_s
-        cattrs[:state_student_id]   = attrs["state_province_id"].to_s
-        
+        cattrs[:state_student_id] = attrs["state_province_id"].to_s
+
         if attrs["demographics"]
           if attrs["demographics"]["birth_date"]
-            begin 
+            begin
               cattrs[:birth_date] = Date.strptime(attrs["demographics"]["birth_date"], DATE_FORMAT)
             rescue => e
               puts "#{e.inspect} #{bd}"
@@ -227,17 +232,48 @@ module Bright
           pg = attrs["demographics"]["projected_graduation_year"].to_i
           cattrs[:projected_graduation_year] = pg if pg > 0
         end
-        
+
+        #Student Address
         begin
-        cattrs[:addresses] = attrs["addresses"].to_a.collect{|a| self.convert_to_address_data(a)} if attrs["addresses"]
-      rescue
-      end
+          cattrs[:addresses] = attrs["addresses"].to_a.collect{|a| self.convert_to_address_data(a)}.select{|a| !a[:street].blank?}.uniq{|a| a[:street]} if attrs["addresses"]
+        rescue
+        end
+
+        #Ethnicity / Race Info
+        if attrs["ethnicity_race"].is_a?(Hash)
+          if !(race_hshs = attrs.dig("ethnicity_race", "races")).nil?
+            #this should be an array, but it doesn't appear PS always sends it as one
+            cattrs[:race] = [race_hshs].flatten.map{|race_hsh| race_hsh["district_race_code"]}.compact.uniq
+          end
+
+          if !attrs.dig("ethnicity_race", "federal_ethnicity").nil?
+            cattrs[:hispanic_ethnicity] = attrs.dig("ethnicity_race", "federal_ethnicity").to_bool
+          end
+        end
+
+        #Contacts Info
+        [1,2].each do |contact_id|
+          if !attrs.dig("contact", "emergency_contact_name#{contact_id}").blank? and !attrs.dig("contact", "emergency_phone#{contact_id}").blank?
+            cattrs[:contacts] ||= []
+            contact_attrs = {
+              :first_name => attrs.dig("contact", "emergency_contact_name#{contact_id}").to_s.split(",").last.strip,
+              :last_name => attrs.dig("contact", "emergency_contact_name#{contact_id}").to_s.split(",").first.strip,
+              :phone_numbers => [
+                {
+                  :phone_number => attrs.dig("contact", "emergency_phone#{contact_id}")
+                }
+              ]
+            }
+            cattrs[:contacts] << contact_attrs
+          end
+        end
+
         cattrs.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
       end
-      
+
       def convert_from_student_data(student, action = nil, additional_params = {})
         return {} if student.nil?
-        
+
         student_data = {
           :client_uid => student.client_id,
           :action => action,
@@ -245,7 +281,7 @@ module Bright
           :local_id => student.sis_student_id,
           :state_province_id => student.state_student_id,
           :name => {
-            :first_name => student.first_name,  
+            :first_name => student.first_name,
             :middle_name => student.middle_name,
             :last_name => student.last_name
           }.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?},
@@ -255,12 +291,12 @@ module Bright
             :projected_graduation_year => student.projected_graduation_year
           }.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
         }.merge(additional_params).reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
-        
+
         # apply enrollment info
         if student.enrollment
-          student_data.merge!(self.convert_from_enrollment_data(student.enrollment)) 
+          student_data.merge!(self.convert_from_enrollment_data(student.enrollment))
         end
-        
+
         # apply addresses
         address_data = {}
         if ph = student.addresses.detect{|a| a.type == "physical"}
@@ -275,12 +311,12 @@ module Bright
           address_data.merge!(self.convert_from_address_data(cany))
         end
         if address_data.size > 0
-          student_data.merge!({:addresses => address_data}) 
+          student_data.merge!({:addresses => address_data})
         end
-        
+
         {:students => {:student => student_data}}
       end
-      
+
       def convert_from_enrollment_data(enrollment)
         return {} if enrollment.nil?
         {:school_enrollment => {
@@ -294,17 +330,24 @@ module Bright
           }.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
         }
       end
-      
+
       def convert_to_school_data(attrs)
         cattrs = {}
-        
         cattrs[:api_id] = attrs["id"]
         cattrs[:name] = attrs["name"]
         cattrs[:number] = attrs["school_number"]
-        
+        cattrs[:low_grade] = attrs["low_grade"]
+        cattrs[:high_grade] = attrs["high_grade"]
+        if (address_attributes = attrs.dig("addresses"))
+          cattrs[:address] = convert_to_address_data(address_attributes)
+        end
+        if (phone_number_attributes = attrs.dig("phones", "main", "number"))
+          cattrs[:phone_number] = {:phone_number => phone_number_attributes}
+        end
+
         cattrs.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
       end
-      
+
       def convert_from_address_data(address)
         {
           (address.type || "physcial") => {
@@ -316,10 +359,10 @@ module Bright
           }.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
         }
       end
-      
+
       def convert_to_address_data(attrs)
         cattrs = {}
-        
+
         if attrs.is_a?(Array)
           if attrs.first.is_a?(String)
             cattrs[:type] = attrs.first
@@ -337,12 +380,12 @@ module Bright
         cattrs[:state] = attrs["state_province"]
         cattrs[:postal_code] = attrs["postal_code"]
         if attrs["grid_location"] and lat_lng = attrs["grid_location"].split(/,\s?/)
-          cattrs[:lattitude], cattrs[:longitude] = lat_lng
+          cattrs[:latitude], cattrs[:longitude] = lat_lng
         end
-        
+
         cattrs.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
       end
-      
+
       def apply_expansions(params)
         if self.expansion_options.empty?
           hsh = self.request(:get, 'ws/v1/district/student', {:pagesize => 1, :q => "local_id==0"})
@@ -359,22 +402,22 @@ module Bright
           :extensions => (%w(studentcorefields) & (self.expansion_options[:extensions] || [])).join(",")
         }.reject{|k,v| v.empty?})
       end
-      
+
       def apply_options(params, options)
         options[:per_page] = params[:pagesize] ||= params.delete(:per_page) || options[:per_page] || 100
         params[:page] ||= options[:page] || 1
         params
       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 headers_for_auth
-        self.retrive_access_token if self.connection_options[:access_token].nil?
+        self.retrieve_access_token if self.connection_options[:access_token].nil?
         {
           "Authorization" => "Bearer #{self.connection_options[:access_token]}",
           "Accept" => "application/json;charset=UTF-8",
@@ -383,4 +426,4 @@ module Bright
       end
     end
   end
-end
+end

data/lib/bright/sis_apis/skyward.rb

@@ -0,0 +1,276 @@
+module Bright
+  module SisApi
+    class Skyward < Base
+
+      @@description = "Connects to the Skyward API for accessing student information"
+      @@doc_url = "https://esdemo1.skyward.com/api/swagger/ui/index"
+      @@api_version = "v1"
+
+      attr_accessor :connection_options, :schools_cache
+
+      DEMOGRAPHICS_CONVERSION = {
+        "I"=>"American Indian Or Alaska Native",
+        "A"=>"Asian",
+        "B"=>"Black Or African American",
+        "P"=>"Native Hawaiian Or Other Pacific Islander",
+        "W"=>"White"
+      }
+
+      PHONE_TYPE_CONVERSION = {
+        "Cellular" => "Cell",
+        "Work" => "Work",
+        "Home" => "Home",
+        "Other" => "Other"
+      }
+
+      def initialize(options = {})
+        self.connection_options = options[:connection] || {}
+        # {
+        #   :client_id => "",
+        #   :client_secret => "",
+        #   :uri => "https://skywardinstall.com/API"
+        # }
+      end
+
+      def get_student_by_api_id(api_id, params = {})
+        st_hsh = self.request(:get, "v1/students/#{api_id}", params)[:parsed_body]
+        Student.new(convert_to_user_data(st_hsh, {:type => "Student"})) unless st_hsh.blank?
+      end
+
+      def get_students(params = {}, options = {})
+        params["paging.limit"] = params[:limit] || options[:limit] || 1000
+        students_response = self.request(:get, 'v1/students', params)
+        if !students_response[:parsed_body].blank?
+          students = students_response[:parsed_body].compact.collect {|st_hsh|
+            Student.new(convert_to_user_data(st_hsh, {:type => "Student"}))
+          }
+        end
+
+        next_cursor = nil
+        if students_response[:headers]["Link"]
+          students_response[:headers]["Link"].split(",").each do |part, index|
+            section = part.split(';')
+            url = section[0][/<(.*)>/,1]
+            name = section[1][/rel="(.*)"/,1].to_s
+            if name == "next"
+              next_cursor = CGI.parse(URI.parse(url).query)["cursor"].first
+            end
+          end
+        end
+        if options[:wrap_in_collection] != false
+          api = self
+          load_more_call = proc {|cursor|
+            params["paging.cursor"] = cursor
+            options = {:wrap_in_collection => false, :include_cursor => true}
+            api.get_students(params, options)
+          }
+          CursorResponseCollection.new({
+            :seed_page => students,
+            :load_more_call => load_more_call,
+            :next_cursor => next_cursor
+          })
+        elsif options[:include_cursor] == true
+          return {:objects => students, :next_cursor => next_cursor}
+        else
+          return students
+        end
+      end
+
+      def get_school_by_api_id(api_id, params = {})
+        sc_hsh = self.request(:get, "v1/schools/#{api_id}", params)[:parsed_body]
+        School.new(convert_to_school_data(sc_hsh)) unless sc_hsh.blank?
+      end
+
+      def get_schools(params = {}, options = {})
+        params["paging.limit"] = params[:limit] || options[:limit] || 10000
+        schools_hshs = self.request(:get, "v1/schools", params)[:parsed_body]
+        if !schools_hshs.blank?
+          schools = schools_hshs.compact.collect {|sc_hsh|
+            School.new(convert_to_school_data(sc_hsh))
+          }
+        end
+        return schools
+      end
+
+      def get_contact_by_api_id(api_id, params = {})
+        contact_hsh = self.request(:get, "v1/names/#{api_id}", params)[:parsed_body]
+        Contact.new(convert_to_user_data(contact_hsh, {:type => "Contact"})) unless contact_hsh.blank?
+      end
+
+      def get_guardians_by_api_id(api_id, params = {})
+        guardians = []
+        guardians_array = self.request(:get, "v1/guardians", params.merge({"studentNameId" => api_id}))[:parsed_body]
+        if !guardians_array.blank?
+          guardians_array.each do |guardian_hsh|
+            relationship_type = guardian_hsh.delete("Students").detect{|s_hsh| s_hsh["StudentNameId"].to_s == api_id.to_s}["RelationshipDesc"]
+            guardian_hsh["RelationshipType"] = relationship_type
+            guardian_hsh["NameId"] = guardian_hsh.delete("GuardianNameId")
+            guardians << Contact.new(convert_to_user_data(guardian_hsh, {:type => "Contact"}))
+          end
+        end
+        return guardians
+      end
+
+      def retrieve_access_token
+        connection = Bright::Connection.new("#{self.connection_options[:uri]}/token")
+        response = connection.request(:post,
+          {"grant_type" => "password",
+            "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 request(method, path, params = {})
+        uri  = "#{self.connection_options[:uri]}/#{path}"
+        body = nil
+        if method == :get
+          query = URI.encode_www_form(params)
+          uri += "?#{query}"
+        else
+          body = JSON.dump(params)
+        end
+
+        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)
+        else
+          puts "#{response.inspect}"
+          puts "#{response.body}"
+        end
+        return {:parsed_body => response_hash, :headers => response.headers}
+      end
+
+      protected
+
+      def convert_to_user_data(user_params, options = {})
+        # :type => "Contact" || "Student"
+        return {} if user_params.blank?
+
+        user_data_hsh = {
+          :api_id => user_params["NameId"],
+          :first_name => user_params["FirstName"],
+          :middle_name => user_params["MiddleName"],
+          :last_name => user_params["LastName"],
+          :sis_student_id => user_params["DisplayId"],
+          :state_student_id => user_params["StateId"],
+          :projected_graduation_year => user_params["GradYr"],
+          :gender => user_params["Gender"],
+          :hispanic_ethnicity => user_params["HispanicLatinoEthnicity"],
+          :relationship_type => user_params["RelationshipType"]
+        }.reject{|k,v| v.blank?}
+        unless user_params["DateOfBirth"].blank?
+          user_data_hsh[:birth_date] = Date.parse(user_params["DateOfBirth"]).to_s
+        end
+
+        DEMOGRAPHICS_CONVERSION.each do |demographics_key, demographics_value|
+          if user_params["FederalRace"].to_s.upcase.include?(demographics_key)
+            user_data_hsh[:race] ||= []
+            user_data_hsh[:race] << demographics_value
+          end
+        end
+
+        unless user_params["SchoolEmail"].blank?
+          user_data_hsh[:email_address] = {
+            :email_address => user_params["SchoolEmail"]
+          }
+        end
+
+        unless user_params["Email"].blank?
+          user_data_hsh[:email_address] = {
+            :email_address => user_params["Email"]
+          }
+        end
+
+        unless user_params["DefaultSchoolId"].blank?
+          self.schools_cache ||= {}
+          if (attending_school = self.schools_cache[user_params["DefaultSchoolId"]]).nil?
+            attending_school = self.get_school_by_api_id(user_params["DefaultSchoolId"])
+            self.schools_cache[attending_school.api_id] = attending_school
+          end
+          user_data_hsh[:school] = attending_school
+        end
+
+        unless user_params["StreetAddress"].blank?
+          user_data_hsh[:addresses] = [{
+            :street => user_params["StreetAddress"],
+            :city => user_params["City"],
+            :state => user_params["State"],
+            :postal_code => user_params["ZipCode"]
+          }]
+        end
+
+        ["PhoneNumber", "PhoneNumber2", "PhoneNumber3"].each do |phone_param|
+          if !user_params[phone_param].blank?
+            user_data_hsh[:phone_numbers] ||= []
+            user_data_hsh[:phone_numbers] << {
+              :phone_number => user_params[phone_param],
+              :type => PHONE_TYPE_CONVERSION[user_params["#{phone_param}Type"]]
+            }
+          end
+        end
+
+        if options[:type] == "Student"
+          #generate the contacts for a student
+          user_data_hsh[:contacts] = self.get_guardians_by_api_id(user_data_hsh[:api_id])
+        end
+
+        return user_data_hsh
+      end
+
+      def convert_to_school_data(school_params)
+        return {} if school_params.nil?
+
+        school_data_hsh = {
+          :api_id => school_params["SchoolId"],
+          :name => school_params["SchoolName"],
+          :low_grade => school_params["GradeLow"],
+          :high_grade => school_params["GradeHigh"],
+        }
+
+        unless school_params["StreetAddress"].blank?
+          school_data_hsh[:address] = {
+            :street => school_params["StreetAddress"],
+            :city => school_params["City"],
+            :state => school_params["State"],
+            :postal_code => school_params["ZipCode"]
+          }
+        end
+
+        return school_data_hsh
+      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 headers_for_auth
+        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
+  end
+end