eleyo 1.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 170b2376f7b75538e3b100684a2b6c08a1350d6768a65f5b8debe9bfda63db44
+  data.tar.gz: 5a46b65846bc02f0b6710defd9d5b16cac0ed0ba9c5f46b7dfc75f977ffd7bbc
+SHA512:
+  metadata.gz: b0f7b450b293dd8fd9e2275cce7480091091ec357b7e5bc6b74075e628c82e1052e0a8b940c92f728e0207fa18d095e9540f01d3064f4371c42ca4b9079a2b30
+  data.tar.gz: 26d07ee30efb47dbea6e1a38e988aefad1d73f19ef69d8d5f7fda157f1528a289174964bca67fd6c2021cfc9c8d5016244e16af03a3926fc1017ed84e7cc97ea

data/.gitignore

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

data/.ruby-gemset

@@ -0,0 +1 @@
+eleyo_gem

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.5.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fee-pay.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,49 @@
+# Eleyo Gem
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'eleyo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eleyo
+
+## Usage
+
+Here is an example of how to get bank information for ACH purposes:
+```ruby
+bi = Eleyo::API::BankInfo.new
+bi.get("091000019")
+=> {"city"=>"MINNEAPOLIS", "addr1"=>"255 2ND AVE SOUTH", "name"=>"WELLS FARGO BANK NA  (MINNESOTA)", "zip"=>"55479", "routing_number"=>"091000019", "id"=>"1cb7cd2e-c1c6-11e2-8fb0-12313d062143", "zip_ext"=>"0000", "office_type"=>"Main", "last_updated"=>"2004-02-20T00:00:00+00:00", "phone"=>"(800) 745-2426", "state"=>"MN"}
+```
+
+Here is an example of setting up an oauth2 flow:
+```ruby
+class LoginController < ActionController::Base
+  API_CONFIG = {client_id: "EXAMPLE-CLIENT-ID", client_secret: "EXAMPLE-CLIENT-SECRET", district_subdomain: "test", redirect_uri: "https://example.org/login"}
+
+  def login
+    code = params[:code]
+  
+    if code.blank?
+      redirect_to Eleyo::API::Auth.new(API_CONFIG).authorization_url and return
+    else
+      auth = Eleyo::API::Auth.new(API_CONFIG)
+      access_token = auth.access_token(code)
+
+      user_data = access_token.user_data
+      # log the user in based on the user_data json
+    end
+  end
+end
+```

data/Rakefile

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

data/eleyo.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name           = "eleyo"
+  spec.version        = "1.2.0"
+  spec.authors        = ["Arux Software"]
+  spec.email          = ["sheuer@aruxsoftware.com"]
+  spec.summary        = "Ruby gem for interacting with the Eleyo Switchboard 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.4"
+  spec.add_runtime_dependency "json", ">= 0"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 12.0"
+end

data/lib/eleyo/api/account.rb

@@ -0,0 +1,229 @@
+module Eleyo
+  module API
+    class Account
+      def self.server_uri
+        if Eleyo::API.standardmode?
+          "https://acc.reg.eleyo.com"
+        elsif Eleyo::API.testmode?
+          "https://acc.reg.eleyo.green"
+        elsif Eleyo::API.devmode?
+          "https://acc.#{HOSTNAME}"
+        end
+      end
+
+      attr_accessor :auth, :access_token, :api_version
+
+      def initialize(options = {})
+        self.auth         = options[:auth]
+        self.access_token = options[:access_token]
+        self.api_version  = options[:api_version] || 1.2
+
+        raise API::InitializerError.new(:auth_or_access_token, "can't be blank") if self.auth.nil? and self.access_token.nil?
+        raise API::InitializerError.new(:auth, "must be of class type Eleyo::API::Auth") if self.auth and !self.auth.is_a?(Eleyo::API::Auth)
+        raise API::InitializerError.new(:access_token, "must be of class type Eleyo::API::Auth::AccessToken") if self.access_token and !self.access_token.is_a?(Eleyo::API::Auth::AccessToken)
+      end
+
+      def list(params = {})
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users"
+        request.query = URI.encode_www_form(params)
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def get(uuid, params = {})
+        uuid = URI.escape(uuid.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/#{uuid}"
+        request.query = URI.encode_www_form(params)
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def create(params)
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/"
+        request.body = params.to_json
+        request.headers = self.generate_headers
+
+        response = HTTPI.post(request)
+
+        if response.code == 201
+          true
+        elsif !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def update(uuid, params)
+        uuid = URI.escape(uuid.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/#{uuid}"
+        request.body = params
+        request.headers = self.generate_headers
+
+        response = HTTPI.put(request)
+
+        if response.code == 204
+          true
+        elsif !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def merge(uuid1, uuid2)
+        uuid1 = URI.escape(uuid1)
+        uuid2 = URI.escape(uuid2)
+
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/merge/#{uuid1}/#{uuid2}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.put(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def delete(uuid)
+        uuid = URI.escape(uuid.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/#{uuid}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.delete(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def owner(params = {})
+        raise API::RequirementError.new(:access_token, "can't be blank") if self.access_token.nil?
+
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/owner"
+        request.query = URI.encode_www_form(params)
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def list_user_locks(user_uuid)
+        uuid = URI.escape(user_uuid.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/#{user_uuid}/locks"
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def add_user_lock(user_uuid, scope, reason = "")
+        uuid = URI.escape(user_uuid.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/#{uuid}/locks"
+        request.body = {
+          user_lock: {
+            scope: scope,
+            reason: reason
+          }
+        }.to_json
+        request.headers = self.generate_headers
+
+        response = HTTPI.post(request)
+
+        if response.code == 201
+          true
+        elsif !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def delete_user_lock(user_uuid, lock_id)
+        uuid = URI.escape(user_uuid.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{api_route}/users/#{uuid}/locks/#{lock_id}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.delete(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      # TODO:: create mapping for relationships api endpoints
+      def list_relationships
+      end
+
+      def add_relationship
+      end
+
+      def update_relationship
+      end
+
+      def delete_relationship
+      end
+
+      protected
+
+      def api_route
+        "#{self.class.server_uri}/api/v#{api_version}"
+      end
+
+      def generate_headers
+        if self.access_token
+          {'User-Agent' => USER_AGENT, 'Authorization' => self.access_token.token, 'Content-Type' => "application/json"}
+        else
+          {'User-Agent' => USER_AGENT, 'Client-Secret' => self.auth.client_secret, 'Client-Id' => self.auth.client_id, 'Content-Type' => "application/json"}
+        end
+      end
+
+    end
+  end
+end

data/lib/eleyo/api/auth.rb

@@ -0,0 +1,113 @@
+module Eleyo
+  module API
+    class Auth
+      class InvalidGrantError < API::Error; end
+      class InvalidClientError < API::Error; end
+
+      class AccessToken
+        attr_accessor :token, :auth
+
+        def initialize(options = {})
+          self.token = options[:token]
+          self.auth = options[:auth]
+
+          raise API::InitializerError.new(:token, "can't be blank") if self.token.to_s.empty?
+          raise API::InitializerError.new(:auth, "can't be blank") if self.auth.nil?
+          raise API::InitializerError.new(:auth, "must be of class type Eleyo::API::Auth") if !self.auth.is_a?(Eleyo::API::Auth)
+        end
+
+        def user_data(params = {})
+          if @user_data.nil? and !@token.nil?
+            acc = Eleyo::API::Account.new(:access_token => self)
+            @user_data = acc.owner(params)["user"]
+          end
+          @user_data
+        end
+      end
+
+      def self.server_uri
+        if Eleyo::API.standardmode?
+          "https://sso.reg.eleyo.com"
+        elsif Eleyo::API.testmode?
+          "https://sso.reg.eleyo.green"
+        elsif Eleyo::API.devmode?
+          "https://sso.#{HOSTNAME}"
+        end
+      end
+
+      attr_accessor :client_id, :client_secret, :redirect_uri, :js_callback, :district_subdomain, :current_user_uuid, :login_mechanism, :element
+
+      def initialize(options = {})
+        self.client_id = options[:client_id]
+        self.client_secret = options[:client_secret]
+        self.redirect_uri = options[:redirect_uri]
+        self.js_callback = options[:js_callback]
+        self.login_mechanism = options[:login_mechanism] || 'redirect'
+        self.element = options[:element]
+        self.district_subdomain = options[:district_subdomain]
+        self.current_user_uuid = options[:current_user_uuid]
+
+        raise API::InitializerError.new(:client_id, "can't be blank") if self.client_id.to_s.empty?
+        raise API::InitializerError.new(:client_secret, "can't be blank") if self.client_secret.to_s.empty?
+        raise API::InitializerError.new(:redirect_uri, "can't be blank") if self.redirect_uri.to_s.empty?
+      end
+
+      def authorization_url
+        %(#{self.class.server_uri}/authorize?client_id=#{self.client_id}&redirect_uri=#{self.redirect_uri}&district=#{self.district_subdomain})
+      end
+
+      def registration_url
+        %(#{self.class.server_uri}/register?client_id=#{self.client_id}&redirect_uri=#{self.redirect_uri}&district=#{self.district_subdomain})
+      end
+
+      def access_token(code)
+        data = {
+          :code => code,
+          :grant_type => "authorization_code",
+          :redirect_uri => self.redirect_uri,
+          :client_secret => self.client_secret,
+          :client_id => self.client_id
+        }
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}/access_token"
+        request.body = data
+        request.headers = {'User-Agent' => USER_AGENT}
+
+        response = HTTPI.post(request)
+
+        if !response.error?
+          return AccessToken.new(:token => JSON.parse(response.body)['access_token'], :auth => self)
+        else
+          begin
+            resp_data = JSON.parse(response.body)
+          rescue
+          end
+          if resp_data and resp_data["error"] == "invalid_grant"
+            raise(API::Auth::InvalidGrantError.new(response.code, response.body))
+          elsif resp_data and resp_data["error"] == "invalid_client"
+            raise(API::Auth::InvalidClientError.new(response.code, response.body))
+          else
+            raise(API::Error.new(response.code, response.body))
+          end
+        end
+      end
+
+      def javascript
+        options = {
+          district: self.district_subdomain,
+          element: self.element,
+          login: {
+            current_uuid: self.current_user_uuid,
+            client_id: self.client_id,
+            redirect_uri: self.redirect_uri,
+            login_mechanism: self.login_mechanism,
+            callback: self.js_callback
+          }
+        }
+        return %(new SwitchBoardIOLogin(#{options.to_json});)
+      end
+
+    end
+  end
+end

data/lib/eleyo/api/bank_info.rb

@@ -0,0 +1,26 @@
+module Eleyo
+  module API
+    class BankInfo
+      def self.server_uri
+        "https://banks.api.eleyo.com"
+      end
+
+      def get(routing_number)
+        routing_number = URI.escape(routing_number.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}/#{routing_number}"
+        request.headers = {'User-Agent' => USER_AGENT}
+
+        response = HTTPI.get(request)
+        
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+    end
+  end
+end

data/lib/eleyo/api/cart.rb

@@ -0,0 +1,159 @@
+module Eleyo
+  module API
+    class Cart
+      def self.server_uri
+        if Eleyo::API.standardmode?
+          "https://cart.reg.eleyo.com"
+        elsif Eleyo::API.testmode?
+          "https://cart.reg.eleyo.green"
+        elsif Eleyo::API.devmode?
+          "https://cart.#{HOSTNAME}"
+        end
+      end
+
+      attr_accessor :auth, :access_token
+
+      def initialize(options = {})
+        self.access_token = options[:access_token]
+        self.auth = self.access_token.auth
+
+        raise API::InitializerError.new(:access_token, "can't be blank") if self.access_token.nil?
+        raise API::InitializerError.new(:access_token, "must be of class type Eleyo::API::Auth::AccessToken") if !self.access_token.is_a?(Eleyo::API::Auth::AccessToken)
+      end
+
+      def get(uuid = nil)
+        if uuid
+          path = %(/api/#{URI.escape(uuid)})
+        else
+          path = %(/api/#{self.generate_cart_path})
+        end
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}#{path}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, JSON.parse(response.body)["message"]))
+        end
+      end
+
+      def get_status
+        path = %(/api/#{self.generate_cart_path}/status)
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}#{path}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, JSON.parse(response.body)["message"]))
+        end
+      end
+
+      def get_items
+        path = %(/api/#{self.generate_cart_path}/items)
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}#{path}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, JSON.parse(response.body)["message"]))
+        end
+      end
+
+      def get_item(item_identifier)
+        path = %(/api/#{self.generate_cart_path}/items/#{item_identifier})
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}#{path}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, JSON.parse(response.body)["message"]))
+        end
+      end
+
+      def add_item(params)
+        path = %(/api/#{self.generate_cart_path}/items)
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}#{path}"
+        if params.keys.first.to_s != 'item'
+          params = {:item => params}
+        end
+        request.body = params.to_json
+        request.headers = self.generate_headers
+
+        response = HTTPI.post(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, JSON.parse(response.body)["message"]))
+        end
+      end
+
+      def update_item(item_identifier, params)
+        path = %(/api/#{self.generate_cart_path}/items/#{URI.escape(item_identifier)})
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}#{path}"
+        if params.keys.first.to_s != 'item'
+          params = {:item => params}
+        end
+        request.body = params.to_json
+        request.headers = self.generate_headers
+
+        response = HTTPI.put(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, JSON.parse(response.body)["message"]))
+        end
+      end
+
+      def delete_item(item_identifier)
+        path = %(/api/#{self.generate_cart_path}/items/#{URI.escape(item_identifier)})
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}#{path}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.delete(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, JSON.parse(response.body)["message"]))
+        end
+      end
+
+      protected
+
+      def generate_cart_path
+        %(#{URI.escape(self.auth.district_subdomain)}/#{URI.escape(self.access_token.token)})
+      end
+
+      def generate_headers
+        {'User-Agent' => USER_AGENT, 'Client-Id' => self.auth.client_id, 'Content-Type' => 'application/json'}
+      end
+    end
+  end
+end

data/lib/eleyo/api/config.rb

@@ -0,0 +1,64 @@
+module Eleyo
+  module API
+    class Config
+      def self.server_uri
+        if Eleyo::API.standardmode?
+          "https://config.reg.eleyo.com"
+        elsif Eleyo::API.testmode?
+          "https://config.reg.eleyo.green"
+        elsif Eleyo::API.devmode?
+          "https://config.#{HOSTNAME}"
+        end
+      end
+
+      attr_accessor :auth
+
+      def initialize(options = {})
+        self.auth = options[:auth]
+
+        raise API::InitializerError.new(:auth, "can't be blank") if self.auth.nil?
+        raise API::InitializerError.new(:auth, "must be of class type Eleyo::API::Auth") if !self.auth.is_a?(Eleyo::API::Auth)
+      end
+
+      def get(subdomain_or_sn)
+        subdomain_or_sn = URI.escape(subdomain_or_sn.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}/v1/customers/#{subdomain_or_sn}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def get_by(key, value)
+        key = URI.escape(key.to_s)
+        value = URI.escape(value.to_s)
+
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}/v1/customers/by/#{key}/#{value}"
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      protected
+
+      def generate_headers
+        {'User-Agent' => USER_AGENT, 'Client-Secret' => self.auth.client_secret, 'Client-Id' => self.auth.client_id}
+      end
+
+    end
+  end
+end

data/lib/eleyo/api/nav.rb

@@ -0,0 +1,29 @@
+module Eleyo
+  module API
+    class Nav
+
+      attr_accessor :auth
+
+      def initialize(options = {})
+        self.auth = options[:auth]
+
+        raise API::InitializerError.new(:auth, "can't be blank") if self.auth.nil?
+        raise API::InitializerError.new(:auth, "must be of class type Eleyo::API::Auth") if !self.auth.is_a?(Eleyo::API::Auth)
+      end
+
+      def javascript
+        options = {
+          district: self.auth.district_subdomain,
+          login: {
+            current_uuid: self.auth.current_user_uuid,
+            client_id: self.auth.client_id,
+            redirect_uri: self.auth.redirect_uri,
+            callback: self.auth.js_callback
+          }
+        }
+        return %(new SwitchBoardIONav(#{options.to_json});)
+      end
+
+    end
+  end
+end

data/lib/eleyo/api/student.rb

@@ -0,0 +1,43 @@
+module Eleyo
+  module API
+    class Student < Account
+
+      def lookup_district_student_id(params)
+        # accepted lookup attributes
+        # firstname & lastname & birthdate
+        # state_student_id
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}/api/v1/students/lookup/district_student_id/#{URI.escape(self.auth.district_subdomain)}"
+        request.query = params
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+      def lookup_state_student_id(params)
+        # accepted lookup attributes
+        # firstname & lastname & birthdate
+        # district_student_id
+        request = HTTPI::Request.new
+        request.url = "#{self.class.server_uri}/api/v1/students/lookup/state_student_id/#{URI.escape(self.auth.district_subdomain)}"
+        request.query = params
+        request.headers = self.generate_headers
+
+        response = HTTPI.get(request)
+
+        if !response.error?
+          JSON.parse(response.body)
+        else
+          raise(API::Error.new(response.code, response.body))
+        end
+      end
+
+    end
+  end
+end

data/lib/eleyo/api.rb

@@ -0,0 +1,46 @@
+module Eleyo
+  module API
+    class << self
+      @@mode = :standard
+      [:test, :dev, :standard].each do |m|
+        define_method("#{m}mode?") do
+          @@mode == m
+        end
+        
+        define_method("#{m}mode") do
+          @@mode == m
+        end
+        
+        define_method("#{m}mode=") do |b|
+          @@mode = b ? m : :standard
+        end
+      end
+    end
+    
+    class Error < StandardError
+      attr_accessor :http_status_code
+      def initialize(code, message)
+        self.http_status_code = code.to_i
+        begin
+          self.json = JSON.parse(message)
+        rescue
+        end
+        
+        super "(#{code}) #{message}"
+      end
+    end
+    
+    class InitializerError < StandardError
+      def initialize(method, message)        
+        super "#{method} #{message}"
+      end
+    end
+
+    class RequirementError < StandardError
+      def initialize(method, message)        
+        super "#{method} #{message}"
+      end
+    end
+
+  end
+end

data/lib/eleyo.rb

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'httpi'
+require 'json'
+
+require "eleyo/api"
+
+require "eleyo/api/bank_info"
+require "eleyo/api/config"
+require "eleyo/api/auth"
+require "eleyo/api/nav"
+require "eleyo/api/account"
+require "eleyo/api/student"
+require "eleyo/api/cart"
+
+module Eleyo
+  VERSION = "1.2.0"
+  USER_AGENT = "Eleyo GEM #{VERSION}"
+end
+
+if ENV['ELEYO_GEM_TEST_MODE'].to_s == "true"
+  Eleyo::API.testmode = true
+end
+
+if ENV['ELEYO_GEM_DEV_MODE'].to_s == "true"
+  Eleyo::API.devmode = true
+end
+
+if ENV.has_key?("DEV_HOST")
+  HOSTNAME = ENV.fetch("DEV_HOST")
+elsif RUBY_PLATFORM =~ /darwin/
+  HOSTNAME = "#{`scutil --get LocalHostName`.downcase.strip}.local"
+else
+  HOSTNAME = `hostname`.downcase.strip
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: eleyo
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+platform: ruby
+authors:
+- Arux Software
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+description:
+email:
+- sheuer@aruxsoftware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- eleyo.gemspec
+- lib/eleyo.rb
+- lib/eleyo/api.rb
+- lib/eleyo/api/account.rb
+- lib/eleyo/api/auth.rb
+- lib/eleyo/api/bank_info.rb
+- lib/eleyo/api/cart.rb
+- lib/eleyo/api/config.rb
+- lib/eleyo/api/nav.rb
+- lib/eleyo/api/student.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.9
+signing_key:
+specification_version: 4
+summary: Ruby gem for interacting with the Eleyo Switchboard APIs.
+test_files: []