ps_utilities 0.3.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4abd4b17bf893e811f7e920887cc881baad21ffc7b43e112de022ac5240269e2
-  data.tar.gz: da43f677c4b59e491e352894061a96290406dea47ad6c6bb0f395715ebead669
+  metadata.gz: 30083f1244c4e8ea1a53ab81b8f88ac3c10d177fb651218cfcbe9dca8bdc219f
+  data.tar.gz: c7f3991b61f85c224c48ca2bb3c172b8a2b24b50d28a8e14e1b80e9e5f831c4d
 SHA512:
-  metadata.gz: 299bbefec900eef22d92c605838e90358f6cae6a561828ba2229d813e0e5fcdccc0df95d145c13e2e40d6b7b0b03d79e54f9c03e531ddfb90c5911a6622f1382
-  data.tar.gz: edb76484fc23806fd56b1dd67573a8e2466513023340535f79437751c808423bb0a30025a182ba4141221eb8483efc0b2f5a22d80f1d08fed2faec0f0c4ae238
+  metadata.gz: 848cfcbb6cf7b71d1e205ac04c21ac14a7b75be92b47db43effa58d6d455ac5b20a90e0d022070e0f9c0e4e1925599fca75493ec5a8f30047205b13a758fbae3
+  data.tar.gz: f72b28802331533bb855536a2dcbf1ece95bab2fc3a4d09b7aeca883b4a1003c9d3ef1d2d403dd86d55b64ff5e641467f84125b86766370f8e10de41cdda0f66

data/lib/ps_utilities/connection.rb

@@ -24,30 +24,32 @@ module PsUtilities
 
   class Connection
 
-    attr_reader :credentials, :headers, :base_uri
-    attr_reader :auth_path, :auth_token
+    attr_reader :auth_path, :auth_token, :auth_info, :headers
+    attr_reader :api_data, :base_uri, :auth_path
+    attr_reader :client, :client_id, :client_secret
     attr_reader :version
 
     include PsUtilities::PreBuiltGet
     include PsUtilities::PreBuiltPut
     include PsUtilities::PreBuiltPost
 
-    # @param attributes: [Hash] -  options include: { base_uri: ENV['PS_URL'], auth_endpoint: (ENV['PS_AUTH_ENDPOINT'] || '/oauth/access_token'), client_id: ENV['PS_CLIENT_ID'], client_secret: ENV['PS_CLIENT_SECRET'] }
+    # @param attributes: [Hash] -  options include: { base_uri: ENV['PS_BASE_URL'], auth_endpoint: (ENV['PS_AUTH_ENDPOINT'] || '/oauth/access_token'), client_id: ENV['PS_CLIENT_ID'], client_secret: ENV['PS_CLIENT_SECRET'] }
     # @param headers: [Hash] - allows to change from json to xml (only do this if you are doing direct api calls and not using pre-built calls) returns and use a different useragent: { 'User-Agent' => "PsUtilities - #{version}", 'Accept' => 'application/json', 'Content-Type' => 'application/json'}
     # @note preference is to use environment variables to initialize your server.
-    def initialize(attributes: {}, headers: {})
-      @version     = "v#{PsUtilities::Version::VERSION}"
-      @credentials = attr_defaults.merge(attributes)
-      @base_uri    = credentials[:base_uri]
-      @auth_path   = credentials[:auth_endpoint]
-      @headers     = header_defaults.merge(headers)
-
-      raise ArgumentError, "missing client_secret" if credentials[:client_secret].nil?  or
-                                                      credentials[:client_secret].empty?
-      raise ArgumentError, "missing client_id"     if credentials[:client_id].nil?  or
-                                                      credentials[:client_id].empty?
-      raise ArgumentError, "missing base_uri"      if credentials[:base_uri].nil?  or
-                                                      credentials[:base_uri].empty?
+    def initialize( header_info: {}, api_info: {}, client_info: {})
+      @version       = "v#{PsUtilities::Version::VERSION}"
+      @client        = client_defaults.merge(client_info)
+      @client_id     = client[:client_id]
+      @client_secret = client[:client_secret]
+      @api_data      = api_defaults.merge(api_info)
+      @base_uri      = api_data[:base_uri]
+      @auth_path     = api_data[:auth_endpoint]
+      @headers       = header_defaults.merge(header_info)
+
+      raise ArgumentError, "missing client_secret" if client_secret.nil? or client_secret.empty?
+      raise ArgumentError, "missing client_id"     if client_id.nil? or client_id.empty?
+      raise ArgumentError, "missing auth endpoint" if auth_path.nil? or auth_path.empty?
+      raise ArgumentError, "missing base_uri"      if base_uri.nil? or base_uri.empty?
     end
 
     # this runs the various options:
@@ -57,12 +59,14 @@ module PsUtilities
     # @param params: [Hash] - this is the data needed for using pre-built commands - see the individual command for details
     # @note with no command an authenticatation check is done
     def run(command: nil, api_path: "", options: {}, params: {})
-      authenticate   unless token_valid?
-      @headers[:headers].merge!('Authorization' => 'Bearer ' + authorized_token)
+      authenticate                            unless auth_valid?
+
       case command
       when nil, :authenticate
+        authenticate
       when :delete, :get, :patch, :post, :put
-        api(command, api_path, options)         unless api_path.empty?
+        api(command, api_path, options)       unless api_path.empty?
+        # TODO: panick if api_path empty
       else
         send(command, params)
       end
@@ -71,7 +75,7 @@ module PsUtilities
     private
 
     def authorized_token
-      "#{credentials[:access_token]}"
+      "#{auth_info['access_token']}"
     end
 
     # verb = :delete, :get, :patch, :post, :put
@@ -81,10 +85,6 @@ module PsUtilities
       retries = 3
       ps_url  = base_uri + api_path
       options = options.merge(headers)
-      pp "api-url"
-      pp ps_url
-      pp "api-options"
-      pp options
       begin
         HTTParty.send(verb, ps_url, options)
       rescue Net::ReadTimeout, Net::OpenTimeout
@@ -101,7 +101,8 @@ module PsUtilities
       { headers:
         { 'User-Agent' => "PsUtilities - #{version}",
           'Accept' => 'application/json',
-          'Content-Type' => 'application/json'}
+          'Content-Type' => 'application/json'
+        }
       }
     end
 
@@ -110,46 +111,52 @@ module PsUtilities
       ps_url   = base_uri + auth_path
       response = HTTParty.post(ps_url, {headers: auth_headers,
                                         body: 'grant_type=client_credentials'})
-
-      @credentials[:token_expires] = Time.now + response.parsed_response['expires_in'].to_i
-      @credentials[:access_token]  = response.parsed_response['access_token'].to_s
-      # @headers[:headers].merge!('Authorization' => 'Bearer ' + credentials[:access_token])
-
-      # throw error if no token returned -- nothing else will work
-      raise AuthError.new("No Auth Token Returned",
-                          ps_url, credentials
-                         ) if credentials[:access_token].empty?
+      if response.code.to_s.eql? "200"
+        @auth_info = response.parsed_response
+        @auth_info['token_expires'] = Time.now + response.parsed_response['expires_in'].to_i
+        @headers[:headers].merge!('Authorization' => 'Bearer ' + auth_info['access_token'])
+        return auth_info
+      else
+        # throw error if - error returned -- nothing else will work
+        raise AuthError.new("No Auth Token Returned", ps_url, client )
+      end
     end
 
-    def token_valid?(tokens = credentials)
-      return false if tokens[:access_token].nil?
-      return false if tokens[:access_token].empty?
-      return false if tokens[:token_expires].nil?
-      return false if tokens[:token_expires] <= Time.now
+    def auth_valid?(auth = auth_info)
+      return false if auth.nil?
+      return false if auth.empty?
+      return false if auth['access_token'].nil?
+      return false if auth['access_token'].empty?
+      return false if auth['token_expires'].nil?
+      return false if auth['token_expires'] < Time.now
       return true
     end
 
-    def auth_headers(creds64 = encode_credentials)
+    def auth_headers(credentials = client)
       { 'ContentType' => 'application/x-www-form-urlencoded;charset=UTF-8',
         'Accept' => 'application/json',
-        'Authorization' => 'Basic ' + creds64
+        'Authorization' => 'Basic ' + encode64_client(credentials)
       }
+      # with(headers: {'Authorization' => "Basic #{ Base64.strict_encode64('user:pass').chomp}"})
     end
 
-    def encode_credentials(creds = credentials)
-      ps_auth_text = [ creds[:client_id],
-                       creds[:client_secret]
-                     ].join(':')
-      Base64.encode64(ps_auth_text).gsub(/\n/, '')
+    def encode64_client(credentials = client)
+      ps_auth_text = [ credentials[:client_id], credentials[:client_secret] ].join(':')
+      Base64.encode64(ps_auth_text).chomp
+      # Base64.encode64(ps_auth_text).gsub(/\n/, '')
     end
 
-    def attr_defaults
-      { base_uri:       ENV['PS_URL'],
-        auth_endpoint:  ENV['PS_AUTH_ENDPOINT'] || '/oauth/access_token',
-        client_id:      ENV['PS_CLIENT_ID'],
+    def client_defaults
+      { client_id:      ENV['PS_CLIENT_ID'],
         client_secret:  ENV['PS_CLIENT_SECRET'],
       }
     end
 
+    def api_defaults
+      { base_uri:       ENV['PS_BASE_URL'],
+        auth_endpoint:  ENV['PS_AUTH_ENDPOINT'] || '/oauth/access_token',
+      }
+    end
+
   end
 end

data/lib/ps_utilities/pre_built_get.rb

@@ -3,11 +3,11 @@ module PsUtilities
   module PreBuiltGet
 
     # return all active students within the district (special case of #get_all_matching_students) - a recursive search
-    # @param params [Hash] - ignored - only included for the api standard
+    # @param params [Hash] - page_size: is the only parameter accepted - default is 100
     # @return - (see #get_all_matching_students)
     def get_all_active_students(params={})
-      params = {status_code: 0}
-      # params[:status_code] = 0
+      page_size = params[:page_size] || 100
+      params    = {status_code: 0, page_size: page_size}
       get_all_matching_students(params)
     end
     alias_method :all_active_students, :get_all_active_students
@@ -117,12 +117,32 @@ module PsUtilities
       return {"errorMessage"=>{"message"=>"A valid dcid must be entered."}} if "#{ps_dcid.to_i}".eql? "0"
 
       answer = api(:get, api_path, options)
-      { student: (answer["student"] || []) }
+      return { student: (answer["student"] || []) }  if answer.code.to_s.eql? "200"
+      # return { student: (answer.parsed_response["student"] || []) } if answer.code.to_s.eql? "200"
+      return {"errorMessage"=>"#{answer.response}"}
     end
     alias_method :get_student, :get_one_student
 
     private
 
+    # build the api query - you can use splats to match any character
+    # @param params [Hash] - valid keys include: :status_code (or :enroll_status), :username, :last_name, :first_name, :student_id (or :local_id), :id (or :dcid)
+    # @return [String] - "id==345;name.last_name==BA*"
+    def build_query(params)
+      query  = []
+      query << "school_enrollment.enroll_status_code==#{params[:status_code]}" if params.has_key?(:status_code)
+      query << "school_enrollment.enroll_status==#{params[:enroll_status]}"    if params.has_key?(:enroll_status)
+      query << "student_username==#{params[:username]}"  if params.has_key?(:username)
+      query << "name.last_name==#{params[:last_name]}"   if params.has_key?(:last_name)
+      query << "name.first_name==#{params[:first_name]}" if params.has_key?(:first_name)
+      query << "local_id==#{params[:local_id]}"          if params.has_key?(:local_id)
+      query << "local_id==#{params[:student_id]}"        if params.has_key?(:student_id)
+      query << "id==#{params[:dcid]}"                    if params.has_key?(:dcid)
+      query << "id==#{params[:id]}"                      if params.has_key?(:id)
+      answer = query.join(";")
+      answer
+    end
+
     # given the number of students and page size calculate pages needed to return all students
     # @param count [Integer] - total number of students matching filter
     # @param page_size [Integer] - total number of students to be return per page
@@ -185,25 +205,9 @@ module PsUtilities
       options[:query]["q"] = query     unless query.empty?
       return {"errorMessage"=>{"message"=>"A valid parameter must be entered."}} if query.empty?
       # pp options
-      api(:get, api_path, options)
-    end
-
-    # build the api query - you can use splats to match any character
-    # @param params [Hash] - valid keys include: :status_code (or :enroll_status), :username, :last_name, :first_name, :student_id (or :local_id), :id (or :dcid)
-    # @return [String] - "id==345;name.last_name==BA*"
-    def build_query(params)
-      query  = []
-      query << "school_enrollment.enroll_status_code==#{params[:status_code]}" if params.has_key?(:status_code)
-      query << "school_enrollment.enroll_status==#{params[:enroll_status]}"    if params.has_key?(:enroll_status)
-      query << "student_username==#{params[:username]}"  if params.has_key?(:username)
-      query << "name.last_name==#{params[:last_name]}"   if params.has_key?(:last_name)
-      query << "name.first_name==#{params[:first_name]}" if params.has_key?(:first_name)
-      query << "local_id==#{params[:local_id]}"          if params.has_key?(:local_id)
-      query << "local_id==#{params[:student_id]}"        if params.has_key?(:student_id)
-      query << "id==#{params[:dcid]}"                    if params.has_key?(:dcid)
-      query << "id==#{params[:id]}"                      if params.has_key?(:id)
-      answer = query.join(";")
-      answer
+      answer = api(:get, api_path, options)
+      return answer.parsed_response         if answer.code.to_s.eql? "200"
+      return {"errorMessage"=>"#{answer.response}"}
     end
 
   end

data/lib/ps_utilities/pre_built_post.rb

@@ -30,28 +30,36 @@ module PsUtilities
     #     ]
     #   }
     # }
+    # @note create_students REQUIRED params are: :id
+    # @note create_students OPTIONAL params are:
+    # @note create_students INVALID params are:
     def create_students(params)
       action   = "INSERT"
       kids_api_array = build_kids_api_array(action, params)
       options  = { body: { students: { student: kids_api_array } }.to_json }
       answer = api(:post, "/ws/v1/student", options)
+      return answer.parsed_response   if answer.code.to_s.eql? "200"
+      return {"errorMessage"=>"#{answer.response}"}
     end
     alias_method :create_student, :create_students
 
     # this updates and existing student record within PowerSchool
     # (see #create_students)
+    # @note update_students REQUIRED params are: :last_name, :first_name, :entry_date, :exit_date, :school_number, :grade_level
+    # @note update_students OPTIONAL params are: :
+    # @note update_students INVALID params are:
     def update_students(params)
-      pp "update students"
-      pp params
       action = "UPDATE"
       kids_api_array = build_kids_api_array(action, params)
-      pp kids_api_array
       options  = { body: { students: { student: kids_api_array } }.to_json }
-      pp options
       answer = api(:post, "/ws/v1/student", options)
+      return answer.parsed_response   if answer.code.to_s.eql? "200"
+      return {"errorMessage"=>"#{answer.response}"}
     end
     alias_method :update_student, :update_students
 
+    private
+
     # @param action [String] - either "INSERT" or "UPDATE"
     # @param params [Array of Hashes] - in this format -- students: [{kid_1_info}, {kid_2_info}]
     # @return [Array of Hashes] - with data like below:
@@ -85,14 +93,12 @@ module PsUtilities
     #]
     # @note this is then sent to the API call with a body tag
     def build_kids_api_array(action, params)
-      pp "build_kids_api_array"
-      pp params
       students  = []
       api_array = []
-      students <<  params[:student]  if params[:student]
-      students  =  params[:students] if params[:students]
-      unless students.is_a? Array
-        return {"errorMessage"=>{"message"=>"Student Data (in Hash format) must be in an Array."}}
+      # students  = [params[:student]] if not params[:student].nil?  && params[:student].is_a?(Hash)
+      students  =  params[:students] #if not params[:students].nil? && params[:students].is_a?(Array)
+      if students.empty?
+        return {"errorMessage"=>{"message"=>"Bad student data - USE: {students: [{kid_data1}, {kid_data2}]}"}}
       end
       students.each do |kid|
         # kid[:las_extensions] = true if params[:las_extensions]
@@ -174,13 +180,10 @@ module PsUtilities
     #     ]
     #   }
     def build_kid_attributes(action, kid)
-      pp "build_kid_attributes"
-      pp kid
       # ALWAYS NEEDED INFO
       attribs                        = {action: action}
-      attribs[:id]                   = kid[:id] || kid[:dcid]
       attribs[:client_uid]           = kid[:student_id].to_s
-      attribs[:student_username]     = kid[:username]
+      attribs[:student_username]     = kid[:username]        if kid[:username]
 
       # REQUIRED ON ENROLLMENT (optional later)
       attribs[:name]                 = {}
@@ -206,6 +209,7 @@ module PsUtilities
         attribs[:school_enrollment][:school_id]      = kid[:school_id]     if kid[:school_id]
       when 'UPDATE'
         # don't allow nil / blank name updates
+        attribs[:id]                 = kid[:id] || kid[:dcid]
         attribs[:name][:last_name]   = kid[:last_name]   if kid[:last_name]
         attribs[:name][:first_name]  = kid[:first_name]  if kid[:first_name]
         attribs[:name][:middle_name] = kid[:middle_name] if kid[:middle_name]
@@ -278,9 +282,9 @@ module PsUtilities
       # Update LAS Database Extensions as needed
       attribs["_extension_data"] = { "_table_extension" => [] }
       # built-in extensions by PowerSchool
-      attribs["_extension_data"]["_table_extension"] << u_studentsuserfields(kid[:u_studentsuserfields])
+      attribs["_extension_data"]["_table_extension"] << u_studentsuserfields(kid[:u_studentsuserfields]) if kid[:u_studentsuserfields]
       # school defined database extensions
-      attribs["_extension_data"]["_table_extension"] << u_students_extension(kid[:u_students_extension])
+      attribs["_extension_data"]["_table_extension"] << u_students_extension(kid[:u_students_extension]) if kid[:u_students_extension]
       # if no extension data present make it empty
       attribs["_extension_data"] = {}                if attribs["_extension_data"]["_table_extension"].empty?
 

data/lib/ps_utilities/version.rb

@@ -1,5 +1,5 @@
 module PsUtilities
   module Version
-    VERSION = "0.3.2"
+    VERSION = "1.0.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ps_utilities
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Lee Weisbecker
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-27 00:00:00.000000000 Z
+date: 2018-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -67,6 +67,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 description: 'Uses oauth2 to connection to the Powerschool API. Heavily refactored
   code (not dependent on Rails) starting with: https://github.com/TomK32/powerschool'
 email: