alula-ruby 0.50.1

data/docker-compose.yml

@@ -0,0 +1,11 @@
+version: "3"
+services:
+  alula-ruby:
+    build: ./
+    image: alula-ruby
+    volumes:
+      - .:/workdir
+    working_dir: /workdir
+    environment:
+      - API_URL=http://172.17.0.1:8800
+      - ALULA_SWARM_TEST_HELPER_URL=http://172.17.0.1:8850

data/lib/alula/alula_response.rb

@@ -0,0 +1,20 @@
+module Alula
+  class AlulaResponse
+    attr_accessor :data, :http_body, :http_headers, :http_status, :raw, :rate_limit
+
+    def ok?
+      (200..299).cover?(self.http_status)
+    end
+
+    def self.from_httparty_response(response)
+      resp = AlulaResponse.new
+      resp.data = response.parsed_response
+      resp.http_body = response.body
+      resp.http_headers = response.headers
+      resp.rate_limit = Alula::RateLimit.new(response.headers)
+      resp.http_status = response.code
+      resp.raw = response
+      resp
+    end
+  end
+end

data/lib/alula/api_operations/delete.rb

@@ -0,0 +1,52 @@
+module Alula
+  module ApiOperations
+    module Delete
+      def self.extended(base)
+        base.include(InstanceMethods)
+      end
+
+      module InstanceMethods
+        def delete
+          # payload = {
+          #   data: {
+          #     id: id,
+          #     attributes: as_patchable_json
+          #   }
+          # }
+
+          response = Alula::Client.request(:delete, resource_url)
+
+          return true if response.ok?
+
+          handle_errors(response)
+        end
+
+        private
+
+        def handle_errors(response)
+          # Should never see a 300-range response code
+          if (300..399).cover?(response.http_status)
+            raise Alula::UnknownError, "The Alula-Ruby gem encountered a response code of #{response.code}, that should not happen"
+
+          # Server errors, malformed crap, etc
+          elsif (500..599).cover?(response.http_status)
+            return AlulaError.for_response(response)
+
+          # Validation errors usually
+          elsif (400..499).cover?(response.http_status)
+            model_errors = Util.model_errors_from_response(response)
+
+            if model_errors
+              annotate_errors(model_errors)
+              return false
+            else
+              return AlulaError.for_response(response)
+            end
+          else
+            raise Alula::UnknownError, "Unknown HTTP response code, aborting. Code: #{response.http_status}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alula/api_operations/list.rb

@@ -0,0 +1,45 @@
+module Alula
+  module ApiOperations
+    module List
+      def self.extended(base)
+        base.include(InstanceMethods)
+      end
+
+    	def method_missing(method, *args, &block)
+        QueryInterface.new(self).send(method, *args, &block)
+      end
+
+      def list(filters = {}, opts = {})
+        response = Alula::Client.request(:get, resource_url, filters, opts)
+        if response.ok?
+        	list = ListObject.construct_from_response(self, response, opts)
+          list = build_and_merge_list_relationships(list, response.data['included']) if response.data['included']
+          list
+        else
+        	error_class = AlulaError.for_response(response)
+        	raise error_class
+        end
+      end
+
+      def build_and_merge_list_relationships(collection, relations)
+        relations.each do |relation|
+          model = Alula.class_from_resource_type(relation['type'])
+          model = model.new.construct_from(relation)
+          key = { type: model.get_type, id: model.id }.freeze
+
+          #
+          # TODO: Remove this line. This makes us ignore unknown relationships
+          unless get_relationship(model.get_type).nil?
+            collection.select{ |m| m.link_matchers.include?(key) }
+                      .each { |m| m.add_model_to_relationship(model) }
+          end
+        end
+
+        collection
+      end
+
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/alula/api_operations/request.rb

@@ -0,0 +1,44 @@
+module Alula
+  module ApiOperations
+    module Request
+      def self.extended(base)
+        base.include(InstanceMethods)
+      end
+
+      # Load a single model by ID
+      def retrieve(id, built_filters = {})
+        response = Alula::Client.request(:get, self.resource_url(id), built_filters, {})
+        if response.ok?
+          item = self.new.construct_from(response.data['data'])
+          item = build_and_merge_item_relationships(item, response.data['included']) if response.data['included']
+          item.rate_limit = response.rate_limit
+          item
+        else
+          error_class = AlulaError.for_response(response)
+          raise error_class
+        end
+      end
+
+      def build_and_merge_item_relationships(item, relations)
+        relations.each do |relation|
+          model = Alula.class_from_resource_type(relation['type'])
+          model = model.new.construct_from(relation)
+
+          #
+          # TODO: Remove this line. This makes us ignore unknown relationships
+          unless get_relationship(model.get_type).nil?
+            item.add_model_to_relationship(model)
+          end
+        end
+
+        item
+      end
+
+      module InstanceMethods
+        def request(method, url, params, opts)
+          Alula::Client.request(method, url, params, opts)
+        end
+      end
+    end
+  end
+end

data/lib/alula/api_operations/save.rb

@@ -0,0 +1,81 @@
+module Alula
+  module ApiOperations
+    module Save
+      def self.extended(base)
+        base.include(InstanceMethods)
+      end
+
+      module InstanceMethods
+        def save
+          payload = {
+            data: {
+              id: id,
+              attributes: as_patchable_json
+            }
+          }
+
+          response = Alula::Client.request(:patch, resource_url, payload, {})
+
+          if response.ok?
+            construct_from(response.data['data'])
+            return true
+          end
+
+          handle_errors(response)
+        end
+
+        def create
+          data = {
+            attributes: as_patchable_json
+          }
+          #
+          # Most creations _won't_ have an ID, but the Alula API utlizes a shared GUID strategy for a few resources
+          # We need to conditionally include this ID in the data array even though the record 'doesnt exist'
+          # 
+          # - Dealer Branding shares the same primary ID as the Dealer record
+          # - Dealer Contact info shares the same primary ID as the Dealer record
+          data[:id] = id if id
+
+          payload = {
+            data: data
+          }
+
+          response = Alula::Client.request(:post, self.class.resource_url, payload, {})
+
+          if response.ok?
+            construct_from(response.data['data'])
+            return true
+          end
+
+          handle_errors(response)
+        end 
+
+        private
+
+        def handle_errors(response)
+          # Should never see a 300-range response code
+          if (300..399).cover?(response.http_status)
+            raise Alula::UnknownError, "The Alula-Ruby gem encountered a response code of #{response.code}, that should not happen"
+
+          # Server errors, malformed crap, etc
+          elsif (500..599).cover?(response.http_status)
+            return AlulaError.for_response(response)
+
+          # Validation errors usually
+          elsif (400..499).cover?(response.http_status)
+            model_errors = Util.model_errors_from_response(response)
+
+            if model_errors
+              annotate_errors(model_errors)
+              return false
+            else
+              return AlulaError.for_response(response)
+            end
+          else
+            raise Alula::UnknownError, "Unknown HTTP response code, aborting. Code: #{response.http_status}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alula/api_resource.rb

@@ -0,0 +1,196 @@
+module Alula
+  # Parent class for all API objects
+  class ApiResource
+    attr_accessor :id, :raw_data, :values, :dirty_attributes, :errors, :links, :link_matchers, :rate_limit
+
+    def self.class_name
+      name.split("::")[-1]
+    end
+
+    def initialize(id = nil, attributes = {})
+      @raw_data = {}
+      @values = {}
+      @dirty_attributes = Set.new
+      @errors = ModelErrors.new(self.class)
+
+      construct_from(
+        'id' => id,
+        'attributes' => attributes
+      )
+    end
+
+    #
+    # Construct a new resource, ready to receive attributes, with
+    # empty values for all attrs.
+    # Useful for making New resources
+    # TODO: This will need testing and probably more work when we
+    #       actually use it, at the moment we're only retrieving and
+    #       modifying existing models.
+    def self.build
+      fields = self.get_fields.keys.map{ |k| Util.camelize(k) }
+      empty_shell = fields.each_with_object({}) { |f, obj| obj[f] = nil }
+      self.new(nil, empty_shell)
+    end
+
+    def construct_from(json_object)
+      @raw_data = json_object.dup
+      @values = json_object['attributes']
+
+      self.id = json_object['id'] unless [nil, ''].include?(json_object['id'])
+
+      @dirty_attributes = Set.new
+      @errors = ModelErrors.new(self.class)
+
+      @related_models = {}
+      cache_links(json_object['relationships'] || {})
+
+      self
+    end
+
+    #
+    # Take a hash of attributes and apply them to the model
+    def apply_attributes(attributes)
+      attributes.each do |key, value|
+        self.send("#{key}=", value)
+      end
+    end
+
+    def reconstruct_from(json_object)
+      construct_from(json_object)
+    end
+
+    def dirty?(attribute_name = nil)
+      return @dirty_attributes.any? if attribute_name.nil?
+
+      @dirty_attributes.include? attribute_name.to_sym
+    end
+
+    def errors?
+      @errors.any?
+    end
+
+    def refresh
+      response = Alula::Client.request(:get, resource_url, {}, {})
+      if response.ok?
+        model = construct_from(response.data['data'])
+        model.rate_limit = response.rate_limit
+        model
+      else
+        error_class = AlulaError.for_response(response)
+        raise error_class
+      end
+    end
+
+    #
+    # Fetch known attributes out of the object, collected into a Hash in camelCase format
+    # Intended for eventually making its way back up to the API
+    def as_json
+      self.field_names.each_with_object({}) do |ruby_key, obj|
+        key      = Util.camelize(ruby_key)
+        val = self.send(ruby_key)
+
+        if self.date_fields.include?(ruby_key) && ![nil, ''].include?(val)
+          if val.respond_to? :strftime
+            obj[key] = val.strftime('%Y-%m-%dT%H:%M:%S.%L%z')
+          else
+            obj[key] = val.to_s
+          end
+        else
+          obj[key] = val
+        end
+      end
+    end
+
+    #
+    # Reduce as_json to a set that can be updated, removing any fields
+    # that are not patchable by the user
+    def as_patchable_json
+      values = as_json.each_pair.each_with_object({}) do |(key, value), collector|
+        ruby_key = Util.underscore(key).to_sym
+        collector[key] = value if !read_only_attributes.include?(ruby_key) && dirty?(ruby_key)
+      end
+
+      # Remove blank values if creating a new record
+      values = values.select{ |k, v| !v.nil? } unless persisted?
+      values
+    end
+
+    def annotate_errors(model_errors)
+      @errors = ModelErrors.new(self.class)
+      model_errors.each_pair do |field_name, error|
+        errors.add(field_name, error)
+      end
+    end
+
+    #
+    # Links are hashes that identify any included models, they are used to
+    # distribute included models when also including relationships
+    # See list.rb#build_and_merge_relationships for details on usage
+    def cache_links(links)
+      @links = links
+
+      @link_matchers = links.each_pair.each_with_object([]) do |(type, link), collection|
+        data = link['data']
+        next if data.nil?
+
+        if data.is_a?(Array)
+          data.each do |nested_link|
+            collection << { type: nested_link['type'], id: nested_link['id'] }.freeze
+          end
+        else
+          collection << { type: data['type'], id: data['id'] }.freeze
+        end
+      end
+    end
+
+    #
+    # Return an instance of QueryEngine annotated with the correct model attributes
+    def filter_builder
+      Alula::FilterBuilder.new(self.class)
+    end
+    alias fb filter_builder
+
+    def model_name
+      self.class
+    end
+
+    private
+
+    class ModelErrors
+      include Enumerable
+
+      def initialize(model_class)
+        @model_class = model_class
+        @details = {}
+      end
+
+      def each
+        @details.each do |field, error|
+          yield({ field => error })
+        end
+      end
+
+      def any?
+        @details.any?
+      end
+
+      def add(field_name, error_message)
+        @details[field_name] = error_message
+      end
+
+      def [](field_name)
+        @details[field_name.to_sym]
+      end
+
+      def full_messages
+        @details.map { |field, error| "#{field}: #{error}" }
+      end
+
+      def full_messages_for(attribute_name)
+        return nil unless @details[attribute_name.to_sym].present?
+
+        "#{attribute_name}: #{@details[attribute_name.to_sym]}"
+      end
+    end
+  end
+end

data/lib/alula/client.rb

@@ -0,0 +1,142 @@
+require 'httparty'
+require 'alula/monkey_patches'
+
+module Alula
+  class Client
+    include HTTParty
+    class << self
+      # Has pseudo accessors :api_key, :api_url, :user_agent, :debug
+      DEFAULT_CUSTOM_OPTIONS = {
+        omitRelationships: true
+      }
+
+      def request(http_method, resource_path, filters = {}, opts = {})
+        ensure_api_key_set
+        ensure_role_set if %i[patch post put].include? http_method
+        ensure_method_allowable(http_method)
+
+        raise Alula::NotConfiguredError, 'did you forget to set the Alula::Client.api_url config option?' unless api_url
+
+        request_opts = {
+          headers: {
+            'Authorization': "Bearer #{api_key}",
+            'User-Agent': "#{user_agent || 'No Agent Set'}/alula-ruby v#{Alula::VERSION}"
+          }
+        }.merge(opts)
+
+        request_opts[:headers]['Content-Type'] = 'application/json' unless opts[:multipart]
+        case http_method
+        when :patch,
+             :post
+          request_opts[:body] = opts[:multipart] ? filters : JSON.generate(filters)
+        when :get
+          if resource_path.match(%r{^/rest})
+            request_opts = request_opts.merge build_rest_options(filters)
+          elsif resource_path.match(%r{^/rpc})
+            request_opts = request_opts.merge build_rest_options(filters)
+          end
+        when :delete
+          # Nothing special
+        end
+
+        if debug == true
+          request_opts[:debug_output] = Alula.logger
+          logger Alula.logger, :info
+        end
+
+        # TODO: Handle network failures
+        response = make_request(http_method, api_url + resource_path, request_opts)
+
+        begin
+          resp = AlulaResponse.from_httparty_response(response)
+        rescue JSON::ParserError
+          # TODO: Should be able to send better info up with this
+          raise 'Unable to decode JSON'
+        end
+
+        resp
+      end
+
+      def make_request(http_method, full_url, request_opts)
+        send(http_method, full_url, request_opts)
+      end
+
+      #
+      # Using RequestStore so we're thread safe even with our non-thread-safe architecture :(
+      %i[api_key api_url user_agent debug].each do |prop|
+        define_method(prop) do
+          RequestStore.store["alula_#{prop}"]
+        end
+
+        define_method("#{prop}=") do |value|
+          RequestStore.store["alula_#{prop}"] = value
+        end
+      end
+
+      #
+      # Stash the user type as a role for us to infer from later
+      # You can set a symbolized role via role = :user, or provide the string userType
+      # We cast to a symbolized role for ease of use in consumers.
+      def role=(user_type)
+        unless user_type.is_a?(Symbol) || user_type.is_a?(String)
+          raise Alula::InvalidRoleError, 'Role must be symbol or string'
+        end
+
+        RequestStore.store['alula_role'] = Util.underscore(user_type).to_sym
+      end
+
+      def role
+        RequestStore.store['alula_role']
+      end
+
+      def ensure_api_key_set
+        if api_key.nil?
+          raise Alula::NotConfiguredError,
+                'Set your API access token before making requests with Alula::Client.api_key = {access_token}'
+        end
+      end
+
+      def ensure_method_allowable(http_method)
+        unless %i[get post put patch delete].include?(http_method)
+          raise "Unable to send a request with #{http_method} http method in #{self::OBJECT_NAME} class"
+        end
+      end
+
+      def ensure_role_set
+        if role.nil?
+          message = 'User role not configured! You must set '\
+                    'Alula::Client.role '\
+                    'before attempting to save any resources'
+
+          raise Alula::NotConfiguredError, message
+        end
+      end
+
+      private
+
+      def build_rest_options(filters)
+        request_opts = {}
+
+        custom_options = filters.delete(:customOptions)
+        pagination = filters.delete(:page)
+        relationships = filters.delete(:include)
+        sort = filters.delete(:sort)
+
+        request_opts[:query] = {
+          filter: filters
+        }
+
+        request_opts[:query][:customOptions] = Util.deep_merge(DEFAULT_CUSTOM_OPTIONS, custom_options)
+        request_opts[:query][:page] = pagination if pagination
+        request_opts[:query][:include] = relationships if relationships
+        request_opts[:query][:sort] = sort if sort
+
+        request_opts
+      end
+
+      def build_rpc_options(filters)
+        filters
+      end
+    end
+  end
+end