bright 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 381169bba4d0de609bb9650455e7d8e4568d9de4
+  data.tar.gz: 53b5f910b2a5655a194b6a913f75c5a67b1753c5
+SHA512:
+  metadata.gz: 1d8fe64474322364c96ebb6f51d30a944b7cb0ba1e3f207f5dba7cb99cb415cbb01a197155c5af9d4f8444354277debc97713c5ea2011a10eba671ce8068ec45
+  data.tar.gz: 8f0a9ea2b0f0299deb7bb3be69713d42b3d315f120af8a045882befa92f992436eae8b5b7690a93db8258de13bfb073ca0b2c3369cc0b3cfaea121ea0c15cfe4

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bright.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Stephen Heuer
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Bright
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bright'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bright
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/bright/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bright.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bright/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bright"
+  spec.version       = Bright::VERSION
+  spec.authors       = ["Arux Software"]
+  spec.email         = ["sheuer@aruxsoftware.com"]
+  spec.summary       = "Framework and tools for dealing with Student Information Systems"  
+  spec.description   = "Bright is a simple Student Information System API abstraction library used in and sponsored by FeePay. It is written by Stephen Heuer, Steven Novotny, and contributors. The aim of the project is to abstract as many parts as possible away from the user to offer a consistent interface across all supported Student Information System APIs."
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "httpi", "~> 2.1"
+  spec.add_runtime_dependency "json", ">= 0"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/bright.rb

@@ -0,0 +1,20 @@
+require "bright/version"
+require "bright/errors"
+
+require "bright/model"
+require "bright/student"
+require "bright/address"
+require "bright/enrollment"
+require "bright/school"
+
+require "bright/connection"
+require "bright/response_collection"
+
+require "bright/sis_apis/base.rb"
+require "bright/sis_apis/tsis.rb"
+require "bright/sis_apis/power_school.rb"
+require "bright/sis_apis/aeries.rb"
+
+module Bright
+
+end

data/lib/bright/address.rb

@@ -0,0 +1,17 @@
+module Bright
+  class Address < Model
+    @attribute_names = [:street, :apt, :city, :state, :postal_code, :lattitude, :longitude, :type]
+    attr_accessor *@attribute_names
+    
+    alias lat lattitude
+    alias lng longitude
+    
+    def geographical_coordinates
+      if self.lattitude and self.longitude
+        "#{self.lattitude},#{self.longitude}"
+      end
+    end
+  end
+end
+
+

data/lib/bright/connection.rb

@@ -0,0 +1,119 @@
+require 'uri'
+require 'httpi'
+require 'benchmark'
+
+module Bright
+  class Connection
+    OPEN_TIMEOUT = 60
+    READ_TIMEOUT = 60
+    VERIFY_PEER = true
+
+    attr_accessor :endpoint
+    attr_accessor :open_timeout
+    attr_accessor :read_timeout
+    attr_accessor :verify_peer
+    attr_accessor :ssl_version
+    attr_accessor :pem
+    attr_accessor :pem_password
+    attr_accessor :logger
+    attr_accessor :tag
+    attr_accessor :ignore_http_status
+    attr_accessor :proxy_address
+    attr_accessor :proxy_port
+
+    def initialize(endpoint)
+      @endpoint     = endpoint.is_a?(URI) ? endpoint : URI.parse(endpoint)
+      @open_timeout = OPEN_TIMEOUT
+      @read_timeout = READ_TIMEOUT
+      @verify_peer  = VERIFY_PEER
+      @ignore_http_status = false
+      @ssl_version = nil
+      @proxy_address = nil
+      @proxy_port = nil
+    end
+
+    def request(method, body, headers = {})
+      request_start = Time.now.to_f
+
+      begin
+        info "connection_http_method=#{method.to_s.upcase} connection_uri=#{endpoint}", tag
+
+        result = nil
+
+        realtime = Benchmark.realtime do
+          request = HTTPI::Request.new(endpoint.to_s)
+          request.headers = headers
+          request.body = body if body
+          request.auth.ssl.verify_mode = :none if !@verify_peer
+          configure_proxy(request)
+          configure_timeouts(request)
+          
+          result = case method
+          when :get
+            raise ArgumentError, "GET requests do not support a request body" if body
+            HTTPI.get(request)
+          when :post
+            debug body
+            HTTPI.post(request)
+          when :put
+            debug body
+            HTTPI.put(request)
+          when :patch
+            debug body
+            HTTPI.patch(request)
+          when :delete
+            HTTPI.delete(request)
+          else
+            raise ArgumentError, "Unsupported request method #{method.to_s.upcase}"
+          end
+        end
+
+        info "--> %d (%d %.4fs)" % [result.code, result.body ? result.body.length : 0, realtime], tag
+        debug result.body
+        result
+      end
+    ensure
+      info "connection_request_total_time=%.4fs" % [Time.now.to_f - request_start], tag
+    end
+
+    private
+    def configure_proxy(http)
+      http.proxy = "#{proxy_address}:#{proxy_port}" if proxy_address
+    end
+    
+    def configure_timeouts(http)
+      http.open_timeout = open_timeout
+      http.read_timeout = read_timeout
+    end
+
+    def handle_response(response)
+      if @ignore_http_status then
+        return response.body
+      else
+        case response.code.to_i
+        when 200...300
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+
+    def debug(message, tag = nil)
+      log(:debug, message, tag)
+    end
+
+    def info(message, tag = nil)
+      log(:info, message, tag)
+    end
+
+    def error(message, tag = nil)
+      log(:error, message, tag)
+    end
+
+    def log(level, message, tag)
+      message = "[#{tag}] #{message}" if tag
+      logger.send(level, message) if logger
+    end
+  end
+end

data/lib/bright/enrollment.rb

@@ -0,0 +1,7 @@
+module Bright
+  class Enrollment < Model
+    @attribute_names = [:entry_date, :entry_comment, :exit_date, :exit_comment, :grade]
+    attr_accessor *@attribute_names
+    attr_accessor :student, :school
+  end
+end

data/lib/bright/errors.rb

@@ -0,0 +1,24 @@
+module Bright
+  class ResponseError < StandardError
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+
+  class UnknownAttributeError < NoMethodError
+    attr_reader :record, :attribute
+
+    def initialize(record, attribute)
+      @record = record
+      @attribute = attribute
+      super("unknown attribute '#{attribute}' for #{@record.class}.")
+    end
+  end
+end

data/lib/bright/model.rb

@@ -0,0 +1,47 @@
+module Bright
+  class Model
+    @attribute_names = []
+    
+    def initialize(attributes={})
+      assign_attributes(attributes) if attributes
+
+      super()
+    end
+    
+    def assign_attributes(new_attributes)
+      if !new_attributes.is_a?(Hash)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
+      end
+      return if new_attributes.empty?
+
+      attributes = Hash[new_attributes.collect{|k,v| [k.to_sym, v]}]
+      _assign_attributes(attributes)
+    end
+    
+    def self.attribute_names
+      @attribute_names
+    end
+    
+    def to_json
+      Hash[self.class.attribute_names.collect do |n|
+        [n, self.send(n)]
+      end].to_json
+    end
+    
+    private
+
+    def _assign_attributes(attributes)
+      attributes.each do |k, v|
+        _assign_attribute(k, v)
+      end
+    end
+
+    def _assign_attribute(k, v)
+      if respond_to?("#{k}=")
+        public_send("#{k}=", v)
+      else
+        raise UnknownAttributeError.new(self, k)
+      end
+    end
+  end
+end

data/lib/bright/response_collection.rb

@@ -0,0 +1,55 @@
+class ResponseCollection
+  include Enumerable
+  
+  attr_accessor :paged_objects
+  attr_accessor :total
+  attr_accessor :per_page
+  attr_accessor :load_more_call
+  
+  # seed_page, total, per_page, load_more_call
+  def initialize(options = {})
+    @paged_objects = {0 => options[:seed_page]}
+    @total = options[:total].to_i
+    @per_page = options[:per_page].to_i
+    @pages = @per_page > 0 ? (@total.to_f / @per_page.to_f).ceil : 0
+    @load_more_call = options[:load_more_call]
+  end
+  
+  def each
+    current_page = -1
+    while (current_page += 1) < @pages do
+      objects = [@paged_objects[current_page]].flatten.compact
+      next_page_no = current_page + 1
+      if load_more_call and @paged_objects[next_page_no].nil? and next_page_no < @pages
+        next_page_thread = Thread.new do
+          load_more_call.call(next_page_no)
+        end
+      else
+        next_page_thread = nil
+      end
+      objects.each do |obj|
+        yield obj
+      end
+      @paged_objects[next_page_no] = next_page_thread.value if next_page_thread
+    end
+  end
+  
+  def last
+    last_page_no = @pages - 1
+    if load_more_call and (last_page = @paged_objects[last_page_no]).nil?
+      last_page = @paged_objects[last_page_no] = load_more_call.call(last_page_no)
+    end
+    last_page.last
+  end
+  
+  def loaded_results
+    @paged_objects.values.flatten
+  end
+  
+  alias size total
+  alias length total
+
+  def empty?
+    total <= 0
+  end
+end

data/lib/bright/school.rb

@@ -0,0 +1,17 @@
+module Bright
+  class School < Model
+    @attribute_names = [:api_id, :name, :number]
+    attr_accessor *@attribute_names
+    attr_accessor :address
+    
+    def address=(address)
+      if address.is_a?(Address)
+        @address = address
+      elsif address.is_a?(Hash)
+        @address = Address.new(address)
+      end
+      @address
+    end
+    
+  end
+end

data/lib/bright/sis_apis/aeries.rb

@@ -0,0 +1,145 @@
+module Bright
+  module SisApi
+    class Aeries < Base
+      DATE_FORMAT = '%Y-%m-%dT%H:%M:%S'
+      
+      @@description = "Connects to the Aeries API for accessing student information"
+      @@doc_url = "http://www.aeries.com/downloads/docs.1234/TechnicalSpecs/Aeries_API_Documentation.pdf"
+      @@api_version = ""
+      
+      attr_accessor :connection_options
+      
+      def initialize(options = {})
+        self.connection_options = options[:connection] || {}
+        # {
+        #   :certficate => "", 
+        #   :uri => ""
+        # }
+      end
+      
+      def get_student_by_api_id(api_id)
+        get_students({:api_id => api_id, :limit => 1}).first
+      end
+      
+      def get_student(params)
+        get_students(params.merge(:limit => 1)).first
+      end
+      
+      def get_students(params)
+        if params.has_key?(:school) or params.has_key?(:school_api_id)
+          school_api_id = params.delete(:school) || params.delete(:school_api_id)
+          students = get_students_by_school(school_api_id, params)
+        else
+          threads = []
+          get_schools.each do |school|
+            threads << Thread.new do 
+              get_students_by_school(school, params)
+            end
+          end
+          students = threads.collect(&:value).flatten.compact
+        end
+        filter_students_by_params(students, params)
+      end
+      
+      def get_students_by_school(school, params = {})
+        school_api_id = school.is_a?(School) ? school.api_id : school
+        if params.has_key?(:api_id)
+          path = "api/schools/#{school_api_id}/students/#{params[:api_id]}"
+        elsif params.has_key?(:sis_student_id)
+          path = "api/schools/#{school_api_id}/students/sn/#{params[:sis_student_id]}"
+        else
+          path = "api/schools/#{school_api_id}/students"
+        end
+        students_response_hash = self.request(:get, path, self.map_student_search_params(params))
+        students_response_hash.collect{|shsh| Student.new(convert_to_student_data(shsh))}
+      end
+      
+      def create_student(student, additional_params = {})
+        raise NotImplementedError
+      end
+      
+      def update_student(student, additional_params = {})
+        raise NotImplementedError
+      end
+      
+      def get_schools(params = {})
+        schools_response_hash = self.request(:get, 'api/v2/schools', params)
+        
+        schools_response_hash.collect{|h| School.new(convert_to_school_data(h))}
+      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
+        
+        headers = self.headers_for_auth
+
+        connection = Bright::Connection.new(uri)
+        response = connection.request(method, body, headers)
+        
+        if !response.error?
+          response_hash = JSON.parse(response.body)
+        else
+          puts "#{response.inspect}"
+          puts "#{response.body}"
+        end
+        response_hash
+      end
+      
+      protected
+      
+      def map_student_search_params(attrs)
+        attrs
+      end
+      
+      def convert_to_student_data(attrs)
+        cattrs = {}
+        
+        cattrs[:first_name]        = attrs["FirstName"]
+        cattrs[:middle_name]       = attrs["MiddleName"]
+        cattrs[:last_name]         = attrs["LastName"]
+        
+        cattrs[:api_id]           = attrs["PermanentID"]
+        cattrs[:sis_student_id]   = attrs["StudentNumber"]
+        cattrs[:state_student_id] = attrs["StateStudentID"]
+        
+        cattrs[:gender]           = attrs["Sex"]
+        if attrs["Birthdate"]
+          begin 
+            cattrs[:birth_date] = Date.strptime(attrs["Birthdate"], DATE_FORMAT)
+          rescue => e
+            puts "#{e.inspect} #{bd}"
+          end
+        end
+        
+        #SchoolCode
+        
+        cattrs.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
+      end
+      
+      def convert_to_school_data(attrs)
+        cattrs = {}
+        
+        cattrs[:api_id] = attrs["SchoolCode"]
+        cattrs[:name] = attrs["Name"]
+        cattrs[:number] = attrs["SchoolCode"]
+        
+        cattrs.reject{|k,v| v.respond_to?(:empty?) ? v.empty? : v.nil?}
+      end
+      
+      def headers_for_auth
+        {
+            'AERIES-CERT' => self.connection_options[:certificate],
+            'Content-Type' => "application/json"
+        }
+      end
+            
+    end
+  end
+end