fixably 0.1.0

data/lib/fixably/load_from_response.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Fixably
+  module LoadFromResponse
+    # Fixably returns collections as hashes which confuses Active Resource
+    # rubocop:disable Style/OptionalBooleanParameter
+    def load(attributes, remove_root = false, persisted = false)
+      super(attributes, remove_root, persisted)
+      load_nested_paginated_collections
+      remove_empty_associations
+      self
+    end
+    # rubocop:enable Style/OptionalBooleanParameter
+
+    protected
+
+    def load_attributes_from_response(response)
+      resp = response.dup
+
+      if response_code_allows_body?(resp.code)
+        body = self.class.format.decode(resp.body)
+        body = decontruct_array_response(body)
+        body.deep_transform_keys!(&:underscore)
+        resp.body = self.class.format.encode(body)
+      end
+
+      super(resp)
+    end
+
+    private
+
+    def decontruct_array_response(attributes)
+      return attributes if attributes.respond_to?(:to_hash)
+
+      if attributes.length > 1
+        raise(
+          ArgumentError,
+          "Unable to unpack an array response with more than 1 record"
+        )
+      end
+
+      attributes.first
+    end
+
+    def load_nested_paginated_collections
+      reflections.each do |name, specs|
+        if specs.macro.equal?(:has_many)
+          load_has_many(name)
+        else
+          load_has_one(name)
+        end
+      end
+    end
+
+    def load_has_many(name)
+      collection = attributes[name]
+      return unless ActiveResource::PaginatedCollection.paginatable?(collection)
+
+      resource = reflections.fetch(name).klass
+      paginated_collection = resource.
+        __send__(:instantiate_collection, collection_attributes(collection))
+      paginated_collection.parent_resource = self
+      paginated_collection.parent_association = name
+      attributes[name] = paginated_collection
+    end
+
+    def collection_attributes(collection)
+      collection.attributes.transform_values do |value|
+        if value.respond_to?(:map)
+          value.map(&:attributes)
+        else
+          value
+        end
+      end
+    end
+
+    def load_has_one(name)
+      element = attributes[name]
+      return unless element.class.name.include?("::Item::")
+
+      resource = reflections.fetch(name).klass
+      attributes[name] = resource.new(element.attributes, true)
+    end
+
+    # Fixably may send back empty records with a href but that causes
+    # Active Record to think there is an actual record and removes the ability
+    # to perform actions that would either retrieve or create those records
+    def remove_empty_associations
+      reflections.each do |name, spec|
+        next unless attributes.key?(name)
+        next unless empty_association?(attributes.fetch(name))
+
+        attributes.delete(name)
+        if instance_variable_defined?(:"@#{name}")
+          remove_instance_variable(:"@#{name}")
+        end
+
+        create_empty_collection(name) if spec.macro.equal?(:has_many)
+      end
+    end
+
+    def empty_association?(record)
+      return false unless record.respond_to?(:attributes)
+
+      record.attributes.keys.eql?(%w[href])
+    end
+
+    def create_empty_collection(name)
+      attributes[name] = self.class.collection_parser.new.tap do |collection|
+        collection.resource_class = reflections.fetch(name).klass
+        collection.parent_resource = self
+        collection.parent_association = name
+      end
+    end
+  end
+end

data/lib/fixably/logger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "logger"
+
+module Fixably
+  module Logger
+    extend SingleForwardable
+
+    def_delegators :logger, *::Logger.instance_methods(false)
+
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||=
+          if defined?(Rails.logger)
+            Rails.logger
+          else
+            ruby_logger
+          end
+      end
+
+      private
+
+      def ruby_logger
+        log = ::Logger.new($stdout)
+        log.level = ::Logger::WARN
+        log
+      end
+    end
+  end
+end

data/lib/fixably/resource_lazy_loader.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Fixably
+  class ResourceLazyLoader
+    attr_reader :model
+    attr_reader :associations_to_expand
+
+    def initialize(model:)
+      if !model.respond_to?(:ancestors) ||
+          !model.ancestors.include?(ApplicationResource)
+        raise(
+          ArgumentError,
+          "The model is expected to be a class that extend ApplicationResource"
+        )
+      end
+
+      @model = model
+      @associations_to_expand = Set.new
+    end
+
+    def includes(association)
+      unless model.reflections.key?(association)
+        raise(
+          ArgumentError,
+          "#{association} is not a known association of #{model}"
+        )
+      end
+
+      associations_to_expand << association
+
+      self
+    end
+
+    def find(*args)
+      id = args.slice(0)
+      options = expand_associations(args.slice(1) || {})
+      arguments = [options].concat(args[2..] || [])
+
+      model.find(id, *arguments)
+    end
+
+    def first(*args)
+      options = expand_associations(args.slice(0) || {})
+      arguments = [options].concat(args[1..] || [])
+
+      model.first(*arguments)
+    end
+
+    def last(*args)
+      options = expand_associations(args.slice(0) || {})
+      arguments = [options].concat(args[1..] || [])
+
+      model.last(*arguments)
+    end
+
+    def all(*args)
+      options = expand_associations(args.slice(0) || {})
+      arguments = [options].concat(args[1..] || [])
+
+      model.all(*arguments)
+    end
+
+    def where(clauses = {})
+      arguments = expand_associations(clauses)
+      model.where(arguments)
+    end
+
+    private
+
+    def expand_associations(args)
+      expand = args[:expand].to_a.to_set
+      args[:expand] = expand.merge(associations_to_expand)
+      args
+    end
+  end
+end

data/lib/fixably/resources/customer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Fixably
+  class Customer < ApplicationResource
+    actions %i[create list show update]
+
+    validate :either_email_or_phone_set
+
+    schema do
+      string :first_name
+      string :last_name
+      string :company
+      string :phone
+      string :email
+      string :business_id
+      string :language
+      string :provider
+      string :identifier
+    end
+
+    has_one :billing_address, class_name: "fixably/customer/billing_address"
+    has_one :shipping_address, class_name: "fixably/customer/shipping_address"
+
+    has_many :children, class_name: "fixably/customer/child"
+
+    def either_email_or_phone_set
+      return if email.present? || phone.present?
+
+      errors.add(:base, "Either email or phone must be present")
+    end
+
+    def remove_on_encode = super().concat(%w[tags])
+
+    class ShippingAddress < ApplicationResource
+      schema do
+        string :name
+        string :address1
+        string :address2
+        string :address3
+        string :zip
+        string :city
+        string :state
+        string :country
+      end
+    end
+
+    class BillingAddress < ApplicationResource
+      schema do
+        string :name
+        string :address1
+        string :address2
+        string :address3
+        string :zip
+        string :city
+        string :state
+        string :country
+      end
+    end
+
+    class Child < Customer
+      actions %i[show]
+    end
+  end
+end

data/lib/fixably/resources/device.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fixably
+  class Device < ApplicationResource
+    actions %i[create list show]
+
+    validates :name, presence: true
+    validate :either_serial_number_or_imei_set
+
+    schema do
+      string :serial_number
+      string :imei_number1
+      string :imei_number2
+      string :name
+      string :configuration
+      string :brand
+      string :purchase_country
+      date :purchase_date
+    end
+
+    def either_serial_number_or_imei_set
+      return if serial_number.present? || imei_number1.present?
+
+      errors.add(:base, "Either serial number or IMEI must be present")
+    end
+  end
+end

data/lib/fixably/resources/order.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Fixably
+  class Order < ApplicationResource
+    actions %i[create list show]
+
+    schema do
+      string :internal_location
+      boolean :is_draft
+      string :reference
+    end
+
+    has_one :contact, class_name: "fixably/order/contact"
+    has_one :customer, class_name: "fixably/customer"
+    has_one :device, class_name: "fixably/device"
+    has_one :handled_by, class_name: "fixably/customer"
+    has_one :ordered_by, class_name: "fixably/customer"
+    has_one :queue, class_name: "fixably/queue"
+    has_one :status, class_name: "fixably/status"
+
+    has_many :lines, class_name: "fixably/order/line"
+    has_many :notes, class_name: "fixably/order/note"
+    has_many :tasks, class_name: "fixably/order/task"
+
+    # TODO
+    # has_one :location
+    # has_one :store
+
+    ALLOWED_INTERNAL_LOCATIONS =
+      %w[CUSTOMER DEALER_SHOP IN_TRANSIT SERVICE STORE].freeze
+
+    validates(
+      :internal_location,
+      inclusion: {
+        in: ALLOWED_INTERNAL_LOCATIONS,
+        message: "should be one of " + # rubocop:disable Style/StringConcatenation
+          ALLOWED_INTERNAL_LOCATIONS.to_sentence(last_word_connector: " or "),
+      },
+      allow_nil: true
+    )
+
+    class Contact < ApplicationResource
+      schema do
+        string :full_name
+        string :company
+        string :phone_number
+        string :email_address
+      end
+    end
+
+    class Line < ApplicationResource
+      actions %i[list show]
+    end
+
+    class Note < ApplicationResource
+      actions %i[create list show]
+
+      ALLOWED_TYPES = %w[DIAGNOSIS INTERNAL ISSUE RESOLUTION].freeze
+
+      validates(
+        :type,
+        inclusion: {
+          in: ALLOWED_TYPES,
+          message: "should be one of " \
+                   "#{ALLOWED_TYPES.to_sentence(last_word_connector: " or ")}",
+        }
+      )
+
+      schema do
+        string :title
+        string :text
+        string :type
+      end
+    end
+
+    class Task < ApplicationResource
+      actions %i[list show update]
+
+      # TODO
+      # has_one :task
+
+      def update
+        raise "Updating order tasks has not been implemented"
+      end
+    end
+  end
+end

data/lib/fixably/resources/queue.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Fixably
+  class Queue < ApplicationResource
+    actions %i[list show]
+
+    has_many :statuses, class_name: "fixably/status"
+  end
+end

data/lib/fixably/resources/status.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Fixably
+  class Status < ApplicationResource
+    actions %i[list show]
+
+    has_one :custom, class_name: "fixably/status/custom"
+    has_one :queue, class_name: "fixably/queue"
+
+    class Custom < ApplicationResource; end
+  end
+end

data/lib/fixably/resources/user.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Fixably
+  class User < ApplicationResource
+    actions :show
+
+    schema do
+      integer :id
+      string :first_name
+      string :last_name
+      string :email
+      string :phone
+    end
+  end
+end