stbaldricks 1.5.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 89031d9008272a99db9a47cb356428979b58b64e
+  data.tar.gz: 50d2a0da749db09d23d977eb0a6ba021ae2a2c75
+SHA512:
+  metadata.gz: 8d993165175669738d5e83af5a114af6401b4e77789184b1c0e6bb1c119ea7d5ee269b974b355657b93edf7821caa697842f17baae823af151898928dc4e7aaf
+  data.tar.gz: 5cc7a1ad9ef8a1982aed71cf21e1bbbd101201406fb6ba60c1f96f73f4677a632149e36d3ca4cb252a9728f891cfe629a0b9904b74ca5f2fd7db7120de5f0ff8

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 St. Baldrick's Foundation
+
+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/lib/stbaldricks.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.realpath(File.dirname(__FILE__))
+require 'stbaldricks/request'

data/lib/stbaldricks/api.rb

@@ -0,0 +1,7 @@
+module SBF
+  module Client
+    module Api
+      VERSION = 'v2'.freeze
+    end
+  end
+end

data/lib/stbaldricks/api_connector.rb

@@ -0,0 +1,47 @@
+module SBF
+  module APIConnector
+    # Executes API request with attempts to auto login the configured user on the API.
+    def with_auto_connect
+      # Check if we still need to attempt the initial login
+      if SBF::Client::Configuration.user_token.nil?
+        login_response = SBF::Client::User.login!(SBF::APIConnector::Configuration.username, SBF::APIConnector::Configuration.password)
+        error login_response.http_code, login_response.error.to_json if login_response.error?
+      end
+
+      # Yield to the block to execute the request
+      response = yield
+
+      if response.error? && response.http_code == 401
+        # If the user token is expired, try to login and refresh the token and try again
+        SBF::Client::LOG.debug { 'User session has expired attempting re-login.' }
+        login_response = SBF::Client::User.login!(SBF::APIConnector::Configuration.username, SBF::APIConnector::Configuration.password)
+        error login_response.http_code, login_response.error.to_json if login_response.error?
+
+        # Try request again
+        response = yield
+      end
+
+      response
+    end
+
+    class Configuration
+      class << self
+        attr_writer :username, :password
+      end
+
+      def self.username
+        @username || raise(SBF::APIConnector::Configuration::Error.new('username', 'must be set'))
+      end
+
+      def self.password
+        @password || raise(SBF::APIConnector::Configuration::Error.new('password', 'must be set'))
+      end
+
+      class Error < ::StandardError
+        def initialize(setting, message) # :nodoc:
+          super "SBF::APIConnector::Configuration.#{setting} #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/stbaldricks/client.rb

@@ -0,0 +1,7 @@
+module SBF
+  module Client
+    def self.use_relative_model_naming?
+      true
+    end
+  end
+end

data/lib/stbaldricks/configuration.rb

@@ -0,0 +1,47 @@
+require 'stbaldricks/log'
+require 'logger'
+require 'stbaldricks/default_logger'
+require 'securerandom'
+
+module SBF
+  module Client
+    class Configuration
+      DEFAULT_API_ENDPOINT = 'http://api:443'
+
+      @_logger = nil
+
+      class << self
+        attr_writer :base_uri, :user_token, :general_token, :request_id
+        attr_accessor :user_token
+      end
+
+      def self.base_uri
+        @base_uri ||= ENV['API_ENDPOINT'] || DEFAULT_API_ENDPOINT
+      end
+
+      def self.general_token
+        @general_token ||= ENV['API_KEY'] || raise(SBF::Client::Configuration::Error.new('general_token', 'must be set'))
+      end
+
+      def self.request_id
+        @request_id ||= SecureRandom.uuid
+      end
+
+      def self.logger=(new_logger)
+        missing_methods = SBF::Client::LOG::REQUIRED_METHODS.select { |method| !new_logger.respond_to?(method) }
+        raise SBF::Client::Configuration::Error.new('logger', "must respond to: #{missing_methods.join(', ')}") unless missing_methods.empty?
+        @_logger = new_logger
+      end
+
+      def self.logger
+        @_logger ||= SBF::Client::DefaultLogger.instance
+      end
+
+      class Error < ::StandardError
+        def initialize(setting, message) # :nodoc:
+          super "SBF::Client::Configuration.#{setting} #{message}"
+        end
+      end
+    end
+  end
+end

data/lib/stbaldricks/default_logger.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+module SBF
+  module Client
+    module DefaultLogger
+      def self.instance(default_stream = STDOUT)
+        formatter = proc { |severity, datetime, _, msg|
+          # ruby logger docs suggested this method for escaping messages since messages may contain user input
+          # and are not escaped by default.
+          #
+          # I am allowing newlines, however, for formatting purposes
+          "\n#{datetime}: #{severity} - #{msg.to_s.dump.gsub('\\n', "\n")}\n"
+        }
+
+        logger = ::Logger.new(default_stream)
+
+        logger.formatter = formatter
+        logger.level = ::Logger::DEBUG
+        logger.level = ENV['SBF_CLIENT_LOG_LEVEL'] || ::Logger::DEBUG
+        logger
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/communicate.rb

@@ -0,0 +1,67 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class CommunicateEndpoint < SBF::Client::EntityEndpoint
+      def categories(_ = nil)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/categories")
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        handle_parsed_response(parsed_response_body, response)
+      end
+
+      def years(category)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/years", category: category)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        handle_parsed_response(parsed_response_body, response)
+      end
+
+      def groups(category, year)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/groups", category: category, year: year)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        handle_parsed_response(parsed_response_body, response)
+      end
+
+      def compose(entity, with = {})
+        raise SBF::Client::Error, 'Invalid Entity' unless entity.is_a?(SBF::Client::BaseEntity)
+
+        with = normalize_with(with)
+
+        create_data = entity.to_hash
+        create_data.store(:with, with)
+
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/compose", create_data)
+
+        error = SBF::Client::ErrorEntity.new(response.body) unless ok?(response)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+
+      def contacts(category, year, group_type, group_id)
+        response = SBF::Client::Api::Request.post_request(
+          "#{base_uri}/contacts",
+          category: category,
+          year: year,
+          group_type: group_type,
+          group_id: group_id
+        )
+        parsed_response_body = JSON.parse(response.body).symbolize!
+        parsed_response_body.map! { |c| SBF::Client::Contact.new(c) } if ok?(response)
+
+        handle_parsed_response(parsed_response_body, response)
+      end
+
+      def handle_parsed_response(data, response)
+        unless ok?(response)
+          error = SBF::Client::ErrorEntity.new(data)
+          data = nil
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+      private :handle_parsed_response
+    end
+  end
+end

data/lib/stbaldricks/endpoints/config.rb

@@ -0,0 +1,18 @@
+require 'stbaldricks/endpoints/lib/entity'
+require 'stbaldricks/request'
+
+module SBF
+  module Client
+    class ConfigEndpoint < SBF::Client::EntityEndpoint
+      def reload(entity)
+        response = SBF::Client::Api::Request.public_get_request("#{base_uri}/get")
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        raise SBF::Client::StandardError, 'Unable to retrieve settings from the api' unless ok?(response)
+
+        # re-call initalize with the new api data. This should re-set all of the instance variables on the instance
+        entity.send(:initialize, parsed_response_body)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/contact.rb

@@ -0,0 +1,12 @@
+require 'stbaldricks/api'
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class ContactEndpoint < SBF::Client::EntityEndpoint
+      def base_uri
+        "/#{SBF::Client::Api::VERSION}/contact"
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/event.rb

@@ -0,0 +1,39 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class EventEndpoint < SBF::Client::EntityEndpoint
+      def get(id, year, with = {})
+        super("#{id}/#{year}", with)
+      end
+
+      def save(entity_or_hash, with = {})
+        if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+          return create(entity_or_hash, with) if entity_or_hash.id.nil?
+          return update(entity_or_hash.id, entity_or_hash.year, entity_or_hash, with)
+        else
+          return create(entity_or_hash, with) if entity_or_hash[:id].nil?
+          return update(entity_or_hash[:id], entity_or_hash[:year], entity_or_hash, with)
+        end
+      end
+
+      def update(id, year, data, with = {})
+        super("#{id}/#{year}", data, with)
+      end
+
+      def invite(id, year, participant_data)
+        event_data = {id: id, year: year}
+        participant_data.store(:event, event_data)
+
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/invite", participant_data)
+
+        unless ok?(response)
+          parsed_response_body = JSON.parse(response.body).symbolize!
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/event_application.rb

@@ -0,0 +1,32 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class EventApplicationEndpoint < SBF::Client::EntityEndpoint
+      def create(entity, with = {})
+        raise SBF::Client::Error, 'Invalid Entity' unless entity.is_a?(SBF::Client::BaseEntity)
+
+        with = normalize_with(with)
+
+        create_data = entity.to_hash
+        create_data.store(:with, with)
+
+        entity.errors.clear
+
+        response = SBF::Client::Api::Request.public_post_request("#{base_uri}/create", create_data)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        if ok?(response)
+          # Re-initialize the entity using the existing data as a base and overwriting with all data returned from the response
+          # This will populate fields that have been auto-populated (e.g. id) into the original object
+          entity.attributes = create_data.merge(parsed_response_body)
+        else
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+          entity.add_errors(error)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: entity, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/fund.rb

@@ -0,0 +1,24 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class FundEndpoint < EntityEndpoint
+      def allowed_entities(params)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/allowed_entities", params)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        if ok?(response)
+          data = parsed_response_body
+          model_type = SBF::Client::ModelType.list[params[:dest_model_type]].capitalize
+          entity_class = "SBF::Client::Full#{model_type}".to_class
+          data[:results].map! { |entity| entity_class.new(entity) }
+        else
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+          data = nil
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/kid.rb

@@ -0,0 +1,24 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class KidEndpoint < SBF::Client::EntityEndpoint
+      def find_random(filter = [], limit = 20, with = {})
+        filter = filter.to_json unless filter.is_a? String
+        with = normalize_with(with)
+
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/find_random", filter: filter, limit: limit, with: with)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        if ok?(response)
+          parsed_response_body[:results].map! { |entity_data| target_class.new(entity_data) }
+          data = parsed_response_body
+        else
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/kid_honor.rb

@@ -0,0 +1,17 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class KidHonorEndpoint < EntityEndpoint
+      def delete(params)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/delete", params)
+
+        unless ok?(response)
+          error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/lib/entity.rb

@@ -0,0 +1,247 @@
+require 'stbaldricks/version'
+require 'stbaldricks/api'
+require 'stbaldricks/entities/lib/error'
+require 'stbaldricks/entities/response'
+require 'stbaldricks/patches/hash'
+require 'stbaldricks/patches/array'
+require 'json'
+
+module SBF
+  module Client
+    class EntityEndpoint
+      attr_reader :orig_target_class
+      attr_reader :base_uri
+
+      def initialize(target_class)
+        @orig_target_class = target_class
+      end
+
+      # Calls create if the id field is empty. Otherwise it calls update.
+      def save(entity_or_hash, with = {})
+        if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+          return create(entity_or_hash, with) if entity_or_hash.id.nil?
+          return update(entity_or_hash.id, entity_or_hash, with)
+        else
+          return create(entity_or_hash, with) if entity_or_hash[:id].nil?
+          return update(entity_or_hash[:id], entity_or_hash, with)
+        end
+      end
+
+      # Calls the create route for the entity. Uses the class name to generate the uri
+      # @param with [Hash] The optional entity fields to include in the response
+      # @return entity [SBF::Client::BaseEntity]
+      def create(entity, with = {})
+        raise SBF::Client::Error, 'Invalid Entity' unless entity.is_a?(SBF::Client::BaseEntity)
+
+        with = normalize_with(with, entity)
+        create_data = entity.to_hash
+        create_data.store(:with, with)
+
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/create", create_data)
+
+        entity, error = hydrate_entity(response, create_data, entity)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: entity, error: error)
+      end
+
+      # Calls the update route for the entity. Uses the class name to generate the uri
+      # @param with [Hash] The optional entity fields to include in the response
+      # @return entity [SBF::Client::BaseEntity]
+      def update(id = nil, entity_or_hash = nil, with = {})
+        if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+          # If someone has passed in an entity, just convert it to a hash
+          data = entity_or_hash.to_hash
+        elsif entity_or_hash.is_a?(Hash)
+          # If someone has passed in a hash, make sure all of it's values match fields in the entity class
+          data = sanitize(entity_or_hash)
+        else
+          raise SBF::Client::Error, 'Invalid Data'
+        end
+
+        with = normalize_with(with, entity_or_hash)
+        data.store(:with, with)
+
+        uri = id ? "#{base_uri}/update/#{id}" : "#{base_uri}/update"
+        response = SBF::Client::Api::Request.post_request(uri, data)
+
+        data, error = hydrate_entity(response, data, entity_or_hash)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      # Calls the get route for the entity. Uses the class name to generate the uri.
+      # @param id [integer]
+      # @return [SBF::Client::BaseEntity]
+      def get(id, with = {})
+        with = normalize_with(with)
+
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/get/#{id}", with: with)
+
+        data, error = hydrate_entity(response, {}, nil)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      # Calls the find route for the entity.
+      def find(filter = [], order = {}, limit = 20, offset = 0, with = {})
+        filter = filter.to_json unless filter.is_a? String
+        order = order.to_json unless order.is_a? String
+        with = normalize_with(with)
+
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/find", filter: filter, order: order, limit: limit, offset: offset, with: with)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        if ok?(response)
+          parsed_response_body[:results].map! { |entity_data| target_class.new(entity_data) }
+          data = parsed_response_body
+        else
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      # Calls the find route for the entity.
+      def find_first(filter = [], order = {}, with = {})
+        api_response = find(filter, order, 1, 0, with)
+        api_response.data = api_response.data[:results].first unless api_response.error?
+        api_response
+      end
+
+      # Calls the aggregate route for the entity.
+      def aggregate(filter = [], aggregate = {})
+        filter = filter.to_json unless filter.is_a? String
+        aggregate = aggregate.to_json unless aggregate.is_a? String
+
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/aggregate", filter: filter, aggregate: aggregate)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+        if ok?(response)
+          data = parsed_response_body[:aggregate]
+        else
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      # Calls the delete route for the entity
+      def delete(id)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/delete/#{id}")
+
+        unless ok?(response)
+          error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+
+      def target_class
+        class_name_pieces = @orig_target_class.to_s.split('::')
+        full_name = (class_name_pieces[0..-2] + ['Full' + class_name_pieces.last]).join('::')
+        Object.const_defined?(full_name) ? Object.const_get(full_name) : @orig_target_class
+      end
+      private :target_class
+
+      def base_uri
+        class_name_pieces = @orig_target_class.to_s.split('::')
+        class_name_pieces[-1] = class_name_pieces[-1].gsub(/(Full|Partial)/, '')
+        "/#{SBF::Client::Api::VERSION}/#{class_name_pieces.last.snake_case}"
+      end
+      private :base_uri
+
+      def ok?(response)
+        response.code.to_s.start_with?('2')
+      end
+      private :ok?
+
+      # Remove all data that doesn't map to an appropriate field for the object type
+      def sanitize(data, entity_class = nil)
+        klass = entity_class || target_class
+
+        return sanitize(data, klass) if klass.attributes.empty?
+
+        {}.tap do |hsh|
+          data.each do |key, value|
+            next unless klass.attributes.include?(key)
+
+            # We need to sanitize the sub objects if the value is a sub-entity
+            if klass.entity_attributes.include?(key)
+              value = sanitize_entity(key, value, klass)
+            elsif klass.collection_attributes.include?(key)
+              value = value.map { |value_item| sanitize_entity(key, value_item, klass) }
+            end
+
+            hsh[key] = value
+          end
+        end
+      end
+      private :sanitize
+
+      def sanitize_entity(key, value, klass = target_class)
+        entity_class_selector_method = :"select_#{key}_class"
+        entity_class = klass.send(entity_class_selector_method, value)
+
+        return nil if entity_class == NilClass
+        entity_class.nil? ? value : sanitize(value, entity_class)
+      end
+      private :sanitize_entity
+
+      def reconstitute_with(entity)
+        return {} if entity.nil?
+
+        {}.tap do |hsh|
+          entity.class.optional_attributes.each do |attribute|
+            next if entity.not_provided_attributes.include?(attribute)
+
+            attribute_value = entity.send(attribute)
+            next if attribute_value.class.demodulize.start_with?('Partial')
+
+            hsh[attribute] = reconstitute_with(attribute_value)
+          end
+        end
+      end
+      private :reconstitute_with
+
+      def normalize_with(with, entity_or_hash = nil)
+        with ||= {}
+        with = {}.tap { |hsh| with.each { |key| hsh[key] = nil } } if with.is_a? Array
+        with = reconstitute_with(entity_or_hash).merge(with) if entity_or_hash.is_a? SBF::Client::BaseEntity
+        with = with.to_json unless with.is_a? String
+        with
+      end
+      private :normalize_with
+
+      def hydrate_entity(response, data, entity_or_hash)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        entity_or_hash.errors.clear if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+
+        if ok?(response)
+          # Re-initialize the entity using the existing data as a base and overwriting with all data returned from the response
+          # This will populate fields that have been auto-populated or defaulted on the db (e.g. id) into the original object
+
+          new_data = parsed_response_body
+          new_data = data.merge(parsed_response_body) if data.is_a?(Hash)
+          data = target_class.new(new_data)
+
+          if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+            entity_or_hash.attributes = new_data
+            data = entity_or_hash
+          end
+
+          return [data, nil]
+        else
+          data = entity_or_hash if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+          data = nil if data == {}
+          data = target_class.new(entity_or_hash) if entity_or_hash.is_a?(Hash)
+
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+          data.add_errors(error) if data.is_a?(SBF::Client::BaseEntity)
+
+          [data, error]
+        end
+      end
+      private :hydrate_entity
+    end
+  end
+end