openapply 0.2.10 → 0.3.0

data/examples/demo/demo_site.rb

@@ -1,92 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'httparty'
-require 'openapply'
-
-class MySite < Openapply::Client
-  include HTTParty
-
-  # Defines OpenApply domain name from ENV-VARS
-  API_URL        = ENV['MY_API_BASE_URI']
-
-  # Defines the OpenApply path from ENV-VARS - default is 5 seconds
-  API_TIMEOUT    = (ENV['MY_API_TIMEOUT'].to_i || 5)
-
-  base_uri API_URL
-  default_timeout API_TIMEOUT
-
-  # Makes OpenApply domain name visible:
-  def api_url
-    API_URL
-  end
-
-  # make OpenApply timeout visible
-  def api_timeout
-    API_TIMEOUT
-  end
-
-  # Defines & makes visible OpenApply secret access key with ENV-VARS
-  def api_key
-    ENV['MY_API_AUTH_TOKEN']
-  end
-
-  # Defines and makes visib le the OpenApply path with ENV-VARS
-  def api_path
-    ENV['MY_API_PATH'] || "/api/v1/students/"
-  end
-
-  # Defines and makes visible the maximum records OpenApply should return
-  # (code default is 50 - OA default is 10 - doc says 100)
-  def api_records
-    ENV['MY_API_RECORDS'] || '50'
-  end
-
-  def initialize
-    @my_flatten_keys = [:custom_fields]
-    @my_reject_keys  = [:parent_guardian]
-  end
-
-  # defines remote host to recieve openapply data
-  REMOTE_HOSTNAME    = ENV['REMOTE_HOSTNAME'].freeze
-  REMOTE_USERNAME    = ENV['REMOTE_USERNAME'].freeze
-  REMOTE_PATH_FILE   = ENV['REMOTE_PATH_FILE'].freeze
-  REMOTE_PERMISSIONS = ENV['REMOTE_PERMISSIONS'].freeze
-
-  # custom code to prepare my.openapply.com data for remote host recieving data
-  def records_as_csv_to_file( status, flatten_keys=[],
-                                reject_keys=[], student_keys=[],
-                                guardian_info={}, payment_info={}, file )
-    data = students_as_csv_by_status( status, flatten_keys, reject_keys,
-                                student_keys, guardian_info, payment_info)
-    # save csv string as a file
-    open(file, 'w') { |f| f.puts data }
-  end
-
-  def records_as_csv_to_server( status, flatten_keys=[],
-                                reject_keys=[], student_keys=[],
-                                guardian_info={}, payment_info={})
-    data = students_as_csv_by_status( status, flatten_keys, reject_keys,
-                                student_keys, guardian_info, payment_info)
-    send_data_to_remote_server( data, REMOTE_HOSTNAME, REMOTE_USERNAME,
-                                "#{REMOTE_PATH_FILE}.csv", REMOTE_PERMISSIONS)
-  end
-
-  # DISABLED UNTIL AXLSX works with rubyzip 1.2.1 or later
-  # def records_as_xlsx_to_file( status, flatten_keys=[],
-  #                               reject_keys=[], student_keys=[],
-  #                               guardian_info={}, payment_info={}, file )
-  #   data = students_as_xlsx_by_status( status, flatten_keys, reject_keys,
-  #                               student_keys, guardian_info, payment_info)
-  #   data.serialize(file)
-  # end
-  #
-  # def records_as_xlsx_to_server( status, flatten_keys=[],
-  #                               reject_keys=[], student_keys=[],
-  #                               guardian_info={}, payment_info={})
-  #   data = students_as_xlsx_by_status( status, flatten_keys, reject_keys,
-  #                               student_keys, guardian_info, payment_info)
-  #   send_data_to_remote_server( data, REMOTE_HOSTNAME, REMOTE_USERNAME,
-  #                               "#{REMOTE_PATH_FILE}.xlsx", REMOTE_PERMISSIONS)
-  # end
-
-end

data/lib/openapply/convert_to_array.rb

@@ -1,215 +0,0 @@
-# require 'net/scp'
-# require 'net/ssh'
-
-# CODE THAT TRANSFORMS STUDENT DATA
-###################################
-
-module ConvertToArray
-
-
-  # Queries by status to get a list of students details of a given status
-  # and converts the result to an array with headers (based on keys sent)
-  #
-  # ==== Attributes
-  # * +status+ - hash to convert to an array
-  # * +flatten_keys+ - an array of keys to bring to the top level
-  # (with this key prepened) -- default (blank does nothing)
-  # * +reject_keys+ - an array of keys to remove from the data -- default (blank does nothing)
-  # * +student_keys+ - [:id, :name] - include student record keys
-  # * +guardian_info+ - include guardian record info {count: 2, keys: [:id, :name]}
-  # * +payment_info+ - include payment info {count: 2, order: :newest, keys: [:date, :amount]}
-  # * guardian & payment info options:
-  #  count: 2 -- how many parent or payment records to return)
-  #  keys: [:id, :date] -- an array of keys of data to return
-  #  order: :newest -- the order to return payments :newest (most recent first - default) or :oldest
-  def students_as_array_by_status(status,
-                                  flatten_keys=[], reject_keys=[],
-                                  student_keys=[],
-                                  guardian_info={}, payment_info={})
-    #
-    check = check_details_keys_validity(flatten_keys, reject_keys)
-    return check           unless check.nil? # or check[:error].nil?
-    #
-    # by default get payment info (unless no payment info is requested)
-    get_payments    = true
-    get_payments    = false    if payment_info.nil? or payment_info.empty?
-    # go get student details from api
-    students_hash   = students_details_by_status( status,
-                                  flatten_keys, reject_keys, get_payments )
-    #
-    students_array  = students_hash_to_array( students_hash,
-                                  student_keys, guardian_info, payment_info)
-  end
-  alias_method :students_as_array_by_statuses, :students_as_array_by_status
-
-
-
-  # ARRAY CODE
-  ############
-
-  # Given an hash of students_details converts to an arrary
-  #
-  # ==== Attributes
-  # * +students+ - hash to convert to an array
-  # * +student_keys+ - [:id, :name] - include student record keys
-  # * +guardian_info+ - include guardian record info {count: 2, keys: [:id, :name]}
-  # * +payment_info+ - include payment info {count: 2, order: :newest, keys: [:date, :amount]}
-  # * guardian & payment info options:
-  #  count: 2 -- how many parent or payment records to return)
-  #  keys: [:id, :date] -- an array of keys of data to return
-  #  order: :newest -- the order to return payments :newest (most recent first - default) or :oldest
-  def students_hash_to_array(students, student_keys=[], guardian_info={}, payment_info={})
-
-    check = check_header_keys_validity(student_keys, guardian_info, payment_info)
-    return check    unless check.nil?
-
-    array   = []
-    array  << create_headers( student_keys, guardian_info, payment_info )
-    return array      if students.nil? or students.empty?
-
-    students[:students].each do |student|
-      row = []
-
-      # next if student.nil? or student.empty? or
-      #         student[:record].nil? or student[:record].empty?
-
-      # when student summary data
-      if student[:record].nil?
-        kid_record = student
-        guardians  = []
-        payments   = []
-      end
-      # when student detailed data
-      if student[:record]
-        kid_record = student[:record]
-        guardians  = student[:guardians]
-        payments   = student[:payments]
-      end
-
-      # inject student record info into the array
-      student_keys.each{ |key| row << kid_record[key] }
-
-      # inject guardian record info into the array
-      if process_key_info?(guardian_info)
-        count = info_count(guardian_info).to_i - 1
-        # loop through the correct number of parents
-        (0..count).each do |i|
-          # add info if parent record exists
-          guardian_info[:keys].each{ |key| row << guardians[i][key] } if guardians[i]
-          # add nils if there isn't a parent record
-          guardian_info[:keys].each{ |key| row << nil }           unless guardians[i]
-        end
-      end
-
-      # inject guardian record info (most recent - last to oldest) into the array
-      if process_key_info?(payment_info)
-        if payment_info[:order].nil? or payment_info[:order].eql? :newest
-          # get the newest records first
-          count = info_count(payment_info).to_i
-          # loop through the correct number of parents
-          (1..count).each do |index|
-            i = index * -1
-            # puts "INDEX #{i}"
-            payment_info[:keys].each{ |key| row << payments[i][key] } if payments[i]
-            payment_info[:keys].each{ |key| row << nil }          unless payments[i]
-          end
-        else
-          # start with the oldest records
-          count = info_count(payment_info).to_i - 1
-          # loop through the correct number of parents
-          (0..count).each do |i|
-            payment_info[:keys].each{ |key| row << payments[i][key] } if payments[i]
-            payment_info[:keys].each{ |key| row << nil }          unless payments[i]
-          end
-        end
-      end
-      array << row
-    end
-    return array
-  end
-
-  # internal key to process given info or not
-  def process_key_info?(info)
-    return true unless info.nil? or info.empty? or
-                        info[:keys].nil? or info[:keys].empty?
-    return false
-  end
-
-  # determine count - may extend later to self-discover max number of records
-  def info_count(info)
-    info[:count] || 1
-  end
-
-  # Given the parameters passed in create the create csv / arrary headers
-  #
-  # ==== Attributes
-  # * +students+ - hash to convert to an array
-  # * +student_keys+ - include student record keys
-  # * +guardian_info+ - include guardian record info {count: 2, keys: [:id, :name]}
-  # * +payment_info+ - include payment info {count: 2, order: :newest, keys: [:date, :amount]}
-  # * guardian & payment info options:
-  #  count: 2 -- how many parent or payment records to return)
-  #  keys: [:id, :date] -- an array of keys of data to return
-  #  order: :newest -- the order to return payments :newest (most recent first - default) or :oldest
-  def create_headers( student_keys=[], guardian_info={}, payment_info={} )
-    headers  = []
-    # figure out student headers
-    student_keys = [:id]    if student_keys.nil? or student_keys.empty?
-    headers  = student_keys.map{ |k| "student_" + k.to_s }
-    # figure out guardian headers
-    if process_key_info?(guardian_info)
-      guardian_count = info_count(guardian_info)
-      # add the correct headers
-      (1..guardian_count).each do |i|
-        headers += guardian_info[:keys].map{|k| "guardian#{i}_" + k.to_s }
-      end
-    end
-    # calculate payment headers
-    if process_key_info?(payment_info)
-      payment_count = info_count(payment_info)
-      # add the correct headers
-      (1..payment_count).each do |i|
-        headers += payment_info[:keys].map{|k| "payment#{i}_" + k.to_s }
-      end
-    end
-    return headers
-  end
-
-  # Check header info before processing
-  #
-  # === Attributes
-  # * +student_keys+ - that this is an arrary of symbols
-  # * +guardian_info+ - that this is a hash with keys: using symbols
-  # * +payment_info+ - that this is a hash with keys: using symbols
-  def check_header_keys_validity(student_keys, guardian_info, payment_info)
-    # prepare keys for testing
-    student_keys  ||= []
-    #
-    #
-    guardian_info ||= {}
-    return {error: "invalid guardian_info - use hash"}  unless guardian_info.is_a? Hash
-    guardian_keys   = guardian_info[:keys]              #unless guardian_keys[:keys].nil?
-    guardian_keys ||= []
-    #
-    payment_info  ||= {}
-    return {error: "invalid payment_info - use hash"}   unless payment_info.is_a? Hash
-    payment_keys    = payment_info[:keys]               #unless payment_keys[:keys].nil?
-    payment_keys  ||= []
-
-    # be sure keys are in an array
-    return {error: "invalid student_keys - need array"}  unless student_keys.is_a? Array
-    return {error: "invalid guardian_keys - need array"} unless guardian_keys.is_a? Array
-    return {error: "invalid payment_keys - need array"}  unless payment_keys.is_a? Array
-
-    # test if any key values are non-symbols (remain after removing symbols)
-    return {error: "invalid student_keys - use symbols"}     if student_keys.reject{|k| k.is_a? Symbol}.count > 0
-    return {error: "invalid guardian_keys - use symbols"}    if guardian_keys.reject{|k| k.is_a? Symbol}.count > 0
-    return {error: "invalid payment_keys - use symbols"}     if payment_keys.reject{|k| k.is_a? Symbol}.count > 0
-
-    # check that if guardian info is given - it also has keys
-    return {error: "invalid guardian_keys - keys missing"}   if not guardian_info.empty? and guardian_info[:keys].nil?
-    return {error: "invalid payment_keys - keys missing"}    if not payment_info.empty? and payment_info[:keys].nil?
-
-  end
-
-end

data/lib/openapply/convert_to_csv.rb

@@ -1,59 +0,0 @@
-require 'csv'
-
-# CODE THAT TRANSFORMS STUDENT DATA
-###################################
-
-module ConvertToCsv
-
-
-  # Queries by status to get a list of students details of a given status
-  # and converts the result to a CSV string with headers (based on keys sent)
-  #
-  # ==== Attributes
-  # * +status+ - hash to convert to an array
-  # * +flatten_keys+ - an array of keys to bring to the top level
-  # (with this key prepened) -- default (blank does nothing)
-  # * +reject_keys+ - an array of keys to remove from the data -- default (blank does nothing)
-  # * +student_keys+ - [:id, :name] - include student record keys
-  # * +guardian_info+ - include guardian record info {count: 2, keys: [:id, :name]}
-  # * +payment_info+ - include payment info {count: 2, order: :newest, keys: [:date, :amount]}
-  # * guardian & payment info options:
-  #  count: 2 -- how many parent or payment records to return)
-  #  keys: [:id, :date] -- an array of keys of data to return
-  #  order: :newest -- the order to return payments :newest (most recent first - default) or :oldest
-  def students_as_csv_by_status(  status,
-                                  flatten_keys=[], reject_keys=[],
-                                  student_keys=[],
-                                  guardian_info={}, payment_info={})
-    #
-    check = check_details_keys_validity(flatten_keys, reject_keys)
-    return check           unless check.nil? # or check[:error].nil?
-    # check = check_header_keys_validity(student_keys, guardian_info, payment_info)
-    # return check    unless check.nil?
-    #
-    students_array  = students_as_array_by_status(  status,
-                                  flatten_keys, reject_keys,
-                                  student_keys, guardian_info, payment_info )
-    #
-    return students_array      if students_array.is_a? Hash
-    #
-    student_csv_txt = students_array_to_csv( students_array )
-  end
-  alias_method :students_as_csv_by_statuses, :students_as_csv_by_status
-
-  # Given an array convert to CSV string
-  #
-  # ==== Attributes
-  # +array+ - expects a hash of students_details (should be flattened to use custom fields)
-  def students_array_to_csv(array)
-    return ""              if array.nil? or array.empty?
-    # https://stackoverflow.com/questions/4822422/output-array-to-csv-in-ruby
-    csv_string = CSV.generate do |csv|
-      array.each do |row|
-        csv << row
-      end
-    end
-    return csv_string
-  end
-
-end

data/lib/openapply/convert_to_xlsx.rb

@@ -1,80 +0,0 @@
-require 'axlsx'
-
-# CODE THAT TRANSFORMS STUDENT DATA INTO XLSX DATA
-##################################################
-
-module ConvertToXlsx
-
-  # XLSX CODE
-  ###########
-
-  # Queries by status to get a list of students details of a given status
-  # and converts the result to a XLSX Object (Axlsx::Package) with headers
-  # (based on keys sent)
-  #
-  # ==== Attributes
-  # * +status+ - hash to convert to an array
-  # * +flatten_keys+ - an array of keys to bring to the top level
-  # (with this key prepened) -- default (blank does nothing)
-  # * +reject_keys+ - an array of keys to remove from the data -- default (blank does nothing)
-  # * +student_keys+ - [:id, :name] - include student record keys
-  # * +guardian_info+ - include guardian record info {count: 2, keys: [:id, :name]}
-  # * +payment_info+ - include payment info {count: 2, order: :newest, keys: [:date, :amount]}
-  # * guardian & payment info options:
-  #  count: 2 -- how many parent or payment records to return)
-  #  keys: [:id, :date] -- an array of keys of data to return
-  #  order: :newest -- the order to return payments :newest (most recent first - default) or :oldest
-  def students_as_xlsx_by_status( status,
-                                  flatten_keys=[], reject_keys=[],
-                                  student_keys=[],
-                                  guardian_info={}, payment_info={})
-    #
-    check = check_details_keys_validity(flatten_keys, reject_keys)
-    return check           unless check.nil? # or check[:error].nil?
-    # check = check_header_keys_validity(student_keys, guardian_info, payment_info)
-    # return check    unless check.nil?
-    #
-    students_array  = students_as_array_by_status(  status,
-                                  flatten_keys, reject_keys,
-                                  student_keys, guardian_info, payment_info )
-    #
-    return students_array      if students_array.is_a? Hash
-    #
-    students_xlsx    = students_array_to_xlsx( students_array )
-
-    # example how to save the xlsx object as a file
-    # students_xlsx.serialize("spec/data/xlsx/students_from_oa.xlsx")
-
-    return students_xlsx
-  end
-  alias_method :students_as_xlsx_by_statuses, :students_as_xlsx_by_status
-
-
-  # Given an array convert to XLSX Object (Axlsx::Package)
-  #
-  # ==== Attributes
-  # +array+ - expects a hash of students_details (should be flattened to use custom fields)
-  def students_array_to_xlsx(student_array)
-    xlsx_obj = Axlsx::Package.new do |p|
-      p.workbook.add_worksheet(:name => "Students from OpenApply") do |sheet|
-        student_array.each{ |r| sheet.add_row r }
-      end
-      # to save the xlsx object as a file
-      # p.serialize("spec/data/xlsx/students_from_oa.xlsx")
-    end
-    return xlsx_obj
-  end
-
-  def send_xlsx_to_remote_server( data, srv_hostname, srv_username,
-                                  srv_path_file, srv_file_permissions="0750",
-                                  ssl_options={}
-                                )
-    return false                  unless data.is_a? Axlsx::Package
-    xfer = data.to_stream()           if data.is_a? Axlsx::Package
-    send_data_to_remote_server( xfer, srv_hostname, srv_username,
-                                srv_path_file, srv_file_permissions,
-                                ssl_options
-                              )
-  end
-
-end