fastbound-ruby 1.0.0

data/lib/fastbound-ruby/contact.rb

@@ -0,0 +1,123 @@
+require 'fastbound-ruby/api'
+
+module FastBound
+  class Contact < Base
+
+    include FastBound::API
+
+    CREATE_AND_EDIT_ATTRS = {
+      permitted: %i(
+        external_id ffl_number ffl_expires lookup_ffl license_name trade_name sotein sot_class business_type
+        organization_name first_name middle_name last_name premise_address_1 premise_address_2 premise_city
+        premise_county premise_state premise_zip_code premise_country phone_number fax email_address
+      ).freeze,
+      required:  %i( ffl_number ffl_expires premise_address_1 premise_city premise_state premise_zip_code ).freeze
+    }
+
+    CREATE_AND_EDIT_LICENSE_ATTRS = {
+      permitted: %i( type number expiration copy_on_file ).freeze,
+      required:  %i( type number ).freeze
+    }
+
+    MERGE_ATTRS = {
+      permitted: %i( winning_contact_id losing_contact_id ).freeze,
+      required:  %i( winning_contact_id losing_contact_id ).freeze
+    }
+
+    ENDPOINTS = {
+      list:                 "contacts?%s".freeze,
+      create:               "contacts".freeze,
+      edit:                 "contacts/%s".freeze,
+      fetch:                "contacts/%s".freeze,
+      fetch_by_external_id: "contacts/getbyexternalid/%s".freeze,
+      delete:               "contacts/%s".freeze,
+      merge:                "contacts/merge".freeze,
+      create_license:       "contacts/%s/licenses".freeze,
+      edit_license:         "contacts/%s/licenses/%s".freeze,
+      fetch_license:        "contacts/%s/licenses/%s".freeze,
+      delete_license:       "contacts/%s/licenses/%s".freeze,
+    }
+
+    def initialize(client)
+      @client = client
+    end
+
+    def list(params = {})
+      endpoint = ENDPOINTS[:list] % convert_params_to_request_query(params)
+
+      get_request(@client, endpoint)
+    end
+
+    def create(contact_data)
+      requires!(contact_data, CREATE_AND_EDIT_ATTRS[:required])
+
+      endpoint = ENDPOINTS[:create]
+      contact_data = standardize_body_data(contact_data, CREATE_AND_EDIT_ATTRS[:permitted])
+
+      post_request(@client, endpoint, contact_data)
+    end
+
+    def edit(contact_id, contact_data)
+      endpoint = ENDPOINTS[:edit] % contact_id
+      contact_data = standardize_body_data(contact_data, CREATE_AND_EDIT_ATTRS[:permitted])
+
+      put_request(@client, endpoint, contact_data)
+    end
+
+    def fetch(contact_id)
+      endpoint = ENDPOINTS[:fetch] % contact_id
+
+      get_request(@client, endpoint)
+    end
+
+    def fetch_by_external_id(external_id)
+      endpoint = ENDPOINTS[:fetch_by_external_id] % external_id
+
+      get_request(@client, endpoint)
+    end
+
+    def delete(contact_id)
+      endpoint = ENDPOINTS[:delete] % contact_id
+
+      delete_request(@client, endpoint)
+    end
+
+    def merge(merge_data)
+      requires!(merge_data, MERGE_ATTRS[:required])
+
+      endpoint = ENDPOINTS[:merge]
+      merge_data = standardize_body_data(merge_data, MERGE_ATTRS[:permitted])
+
+      post_request(@client, endpoint, merge_data)
+    end
+
+    def create_license(contact_id, license_data)
+      requires!(license_data, CREATE_AND_EDIT_LICENSE_ATTRS[:required])
+
+      endpoint = ENDPOINTS[:create_license] % contact_id
+      license_data = standardize_body_data(license_data, CREATE_AND_EDIT_LICENSE_ATTRS[:permitted])
+
+      post_request(@client, endpoint, license_data)
+    end
+
+    def edit_license(contact_id, license_data)
+      endpoint = ENDPOINTS[:edit_license] % contact_id
+      license_data = standardize_body_data(license_data, CREATE_AND_EDIT_LICENSE_ATTRS[:permitted])
+
+      put_request(@client, endpoint, license_data)
+    end
+
+    def fetch_license(contact_id, license_id)
+      endpoint = ENDPOINTS[:fetch_license] % [contact_id, license_id]
+
+      get_request(@client, endpoint)
+    end
+
+    def delete_license(contact_id, license_id)
+      endpoint = ENDPOINTS[:delete_license] % [contact_id, license_id]
+
+      delete_request(@client, endpoint)
+    end
+
+  end
+end

data/lib/fastbound-ruby/disposition.rb

@@ -0,0 +1,222 @@
+require 'fastbound-ruby/api'
+
+module FastBound
+  class Disposition < Base
+
+    include FastBound::API
+
+    CREATE_ATTRS = {
+      permitted: %i(
+        external_id date type note ttsn generate_ttsn otsn purchase_order_number invoice_number
+        shipment_tracking_number is_manufacturing_disposition
+      ).freeze,
+      required: %i( type ).freeze
+    }
+
+    CREATE_AS_NFA_ATTRS = {
+      permitted: %i(
+        external_id date submission_date type note ttsn generate_ttsn otsn purchase_order_number
+        invoice_number shipment_tracking_number
+      ).freeze,
+      required: %i( type ).freeze
+    }
+
+    CREATE_AS_THEFT_LOSS_ATTRS = %i(
+      external_id date note theft_loss_discovered_date theft_loss_type theft_loss_police_incident_number
+      theft_loss_atf_issued_incident_number
+    ).freeze
+
+    CREATE_AS_DESTROYED_ATTRS = %i(
+      external_id date note destroyed_date destroyed_description destroyed_witness_1 destroyed_witness_2
+    ).freeze
+
+    EDIT_AND_CREATE_COMMIT_ATTRS = [
+      %i( request_type contact_id contact_external_id ),
+      CREATE_ATTRS[:permitted],
+      CREATE_AS_NFA_ATTRS[:permitted],
+      CREATE_AS_THEFT_LOSS_ATTRS,
+      CREATE_AS_DESTROYED_ATTRS
+    ].flatten.uniq.freeze
+
+    ITEM_ATTRS = {
+      add: %i( id price ).freeze,
+      add_by_external_id: %i( external_id price ).freeze
+    }
+
+    COMMIT_ATTRS = %i(
+      change_manufacturer change_country_of_manufacture change_importer change_model change_caliber
+      change_type change_barrel_length change_overall_length change_condition change_cost change_price
+      change_mpn change_upc change_location change_item_note manufacturer country_of_manufacture importer
+      model caliber type barrel_length overall_length condition cost price mpn upc location item_note
+    ).freeze
+
+    ENDPOINTS = {
+      list:                       "dispositions".freeze,
+      list_only_with_4473:        "dispositions/only4473s".freeze,
+      create:                     "dispositions".freeze,
+      create_as_nfa:              "dispositions/nfa".freeze,
+      create_as_theft_loss:       "dispositions/theftloss".freeze,
+      create_as_destroyed:        "dispositions/destroyed".freeze,
+      edit:                       "dispositions/%s".freeze,
+      fetch:                      "dispositions/%s".freeze,
+      fetch_by_external_id:       "dispositions/getbyexternalid/%s".freeze,
+      delete:                     "dispositions/%s".freeze,
+      commit:                     "dispositions/%s/commit".freeze,
+      create_and_commit:          "dispositions/createandcommit".freeze,
+      add_items:                  "dispositions/%s/items".freeze,
+      add_items_by_external_id:   "dispositions/%s/items/addbyexternalid".freeze,
+      fetch_items:                "dispositions/%s/items".freeze,
+      edit_item_price:            "dispositions/%s/items/%s".freeze,
+      remove_item:                "dispositions/%s/items/remove/%s".freeze,
+      remove_item_by_external_id: "dispositions/%s/items/removebyexternalid/%s".freeze,
+      attach_contact:             "dispositions/%s/attachcontact/%s".freeze
+    }
+
+    def initialize(client)
+      @client = client
+    end
+
+    def list(params = {})
+      endpoint = ENDPOINTS[:list] % convert_params_to_request_query(params)
+
+      get_request(@client, endpoint)
+    end
+
+    def list_only_with_4473(params = {})
+      endpoint = ENDPOINTS[:list_only_with_4473] % convert_params_to_request_query(params)
+
+      get_request(@client, endpoint)
+    end
+
+    def create(disposition_data)
+      requires!(disposition_data, CREATE_ATTRS[:required])
+
+      endpoint = ENDPOINTS[:create]
+      disposition_data = standardize_body_data(disposition_data, CREATE_ATTRS[:permitted])
+
+      post_request(@client, endpoint, disposition_data)
+    end
+
+    def create_as_nfa(disposition_data)
+      requires!(disposition_data, CREATE_AS_NFA_ATTRS[:required])
+
+      endpoint = ENDPOINTS[:create_as_nfa]
+      disposition_data = standardize_body_data(disposition_data, CREATE_AS_NFA_ATTRS[:permitted])
+
+      post_request(@client, endpoint, disposition_data)
+    end
+
+    def create_as_theft_loss(disposition_data)
+      endpoint = ENDPOINTS[:create_as_theft_loss]
+      disposition_data = standardize_body_data(disposition_data, CREATE_AS_THEFT_LOSS_ATTRS)
+
+      post_request(@client, endpoint, disposition_data)
+    end
+
+    def create_as_destroyed(disposition_data)
+      endpoint = ENDPOINTS[:create_as_destroyed]
+      disposition_data = standardize_body_data(disposition_data, CREATE_AS_DESTROYED_ATTRS)
+
+      post_request(@client, endpoint, disposition_data)
+    end
+
+    def edit(disposition_id, disposition_data)
+      endpoint = ENDPOINTS[:edit] % disposition_id
+      disposition_data = standardize_body_data(disposition_data, EDIT_AND_CREATE_COMMIT_ATTRS)
+
+      put_request(@client, endpoint, disposition_data)
+    end
+
+    def fetch(disposition_id)
+      endpoint = ENDPOINTS[:fetch] % disposition_id
+
+      get_request(@client, endpoint)
+    end
+
+    def fetch_by_external_id(external_id)
+      endpoint = ENDPOINTS[:fetch_by_external_id] % external_id
+
+      get_request(@client, endpoint)
+    end
+
+    def delete(disposition_id)
+      endpoint = ENDPOINTS[:delete] % disposition_id
+
+      delete_request(@client, endpoint)
+    end
+
+    def commit(disposition_id, commit_data = {})
+      endpoint = ENDPOINTS[:commit] % disposition_id
+      commit_data = { manufacturingChanges: standardize_body_data(commit_data, COMMIT_ATTRS) }
+
+      post_request(@client, endpoint, commit_data)
+    end
+
+    def create_and_commit(disposition_data, items_data, contact_data, commit_data = {})
+      requires!(contact_data, Contact::CREATE_AND_EDIT_ATTRS[:required])
+      items_data.each { |item| requires!(item, :id) }
+
+      endpoint = ENDPOINTS[:create_and_commit]
+      disposition_data = standardize_body_data(disposition_data, EDIT_AND_CREATE_COMMIT_ATTRS)
+      items_data = items_data.map { |item| standardize_body_data(item, ITEM_ATTRS[:add]) }
+      contact_data = standardize_body_data(contact_data, Contact::CREATE_AND_EDIT_ATTRS[:permitted])
+      request_data = disposition_data.merge(
+        contact: contact_data,
+        items: items_data,
+        manufacturingChanges: commit_data
+      )
+
+      post_request(@client, endpoint, request_data)
+    end
+
+    def add_items(disposition_id, items_data)
+      items_data.each { |item| requires!(item, :id) }
+
+      endpoint = ENDPOINTS[:add_items] % disposition_id
+      items_data = { items: items_data.map { |item| standardize_body_data(item, ITEM_ATTRS[:add]) } }
+
+      post_request(@client, endpoint, items_data)
+    end
+
+    def add_items_by_external_id(disposition_id, items_data)
+      items_data.each { |item| requires!(item, :external_id) }
+
+      endpoint = ENDPOINTS[:add_items_by_external_id] % disposition_id
+      items_data = { items: items_data.map { |item| standardize_body_data(item, ITEM_ATTRS[:add_by_external_id]) } }
+
+      post_request(@client, endpoint, items_data)
+    end
+
+    def fetch_items(disposition_id)
+      endpoint = ENDPOINTS[:fetch_items] % disposition_id
+
+      get_request(@client, endpoint)
+    end
+
+    def edit_item_price(disposition_id, item_id, price)
+      endpoint = ENDPOINTS[:edit_item_price] % [disposition_id, item_id]
+      item_data = { price: price }
+
+      put_request(@client, endpoint, item_data)
+    end
+
+    def remove_item(disposition_id, item_id)
+      endpoint = ENDPOINTS[:remove_item] % [disposition_id, item_id]
+
+      delete_request(@client, endpoint)
+    end
+
+    def remove_item_by_external_id(disposition_id, external_id)
+      endpoint = ENDPOINTS[:remove_item_by_external_id] % [disposition_id, external_id]
+
+      delete_request(@client, endpoint)
+    end
+
+    def attach_contact(disposition_id, contact_id)
+      endpoint = ENDPOINTS[:attach_contact] % [disposition_id, contact_id]
+
+      put_request(@client, endpoint)
+    end
+
+  end
+end

data/lib/fastbound-ruby/error.rb

@@ -0,0 +1,11 @@
+module FastBound
+  class Error < StandardError
+
+    class NoContent < FastBound::Error; end
+    class NotAuthorized < FastBound::Error; end
+    class NotFound < FastBound::Error; end
+    class RequestError < FastBound::Error; end
+    class TimeoutError < FastBound::Error; end
+
+  end
+end

data/lib/fastbound-ruby/item.rb

@@ -0,0 +1,89 @@
+require 'fastbound-ruby/api'
+
+module FastBound
+  class Item < Base
+
+    include FastBound::API
+
+    CREATE_AND_EDIT_ATTRS = {
+      permitted: %i(
+        external_id item_number do_not_dispose note manufacturer importer country_of_manufacture serial model caliber type
+        barrel_length total_length condition cost price mpn upc location location_verified_utc ttsn otsn submission_date
+        acquisition_type acquire_date acquire_purchase_order_number acquire_invoice_number acquire_shipment_tracking_number
+        disposition_type dispose_date dispose_purchase_order_number dispose_invoice_number dispose_shipment_tracking_number
+        theft_loss_discovered_date theft_loss_type theft_loss_atf_issued_incident_number theft_loss_police_incident_number
+        destroyed_date destroyed_description destroyed_witness_1 destroyed_witness_2
+        lightspeed_system_id lightspeed_serial_id lightspeed_sale_id
+      ).freeze,
+      required: %i( manufacturer model serial caliber type ).freeze
+    }
+
+    ENDPOINTS = {
+      list:                 "items".freeze,
+      fetch:                "items/%s".freeze,
+      edit:                 "items/%s".freeze,
+      delete:               "items/%s".freeze,
+      fetch_by_external_id: "items/getbyexternalid/%s".freeze,
+      undispose:            "items/%s/undispose".freeze,
+      set_external_id:      "items/%s/setexternalid".freeze,
+      set_external_ids:     "items/setexternalids".freeze,
+    }
+
+    def initialize(client)
+      @client = client
+    end
+
+    def list
+      endpoint = ENDPOINTS[:list]
+
+      get_request(@client, endpoint)
+    end
+
+    def fetch(item_id)
+      endpoint = ENDPOINTS[:fetch] % item_id
+
+      get_request(@client, endpoint)
+    end
+
+    def edit(item_id, item_data)
+      endpoint = ENDPOINTS[:edit] % item_id
+      item_data = standardize_body_data(item_data, CREATE_AND_EDIT_ATTRS[:permitted])
+
+      put_request(@client, endpoint, item_data)
+    end
+
+    def delete(item_id)
+      endpoint = ENDPOINTS[:delete] % item_id
+
+      delete_request(@client, endpoint)
+    end
+
+    def fetch_by_external_id(external_id)
+      endpoint = ENDPOINTS[:fetch_by_external_id] % external_id
+
+      get_request(@client, endpoint)
+    end
+
+    def undispose(item_id)
+      endpoint = ENDPOINTS[:undispose] % item_id
+
+      put_request(@client, endpoint)
+    end
+
+    def set_external_id(item_id, external_id)
+      endpoint = ENDPOINTS[:set_external_id] % item_id
+      item_data = { externalId: external_id }
+
+      put_request(@client, endpoint, item_data)
+    end
+
+    def set_external_ids(item_id, items)
+      endpoint = ENDPOINTS[:set_external_ids] % item_id
+      items = items.is_a?(Array) ? items : items[:items]
+      item_data = { items: items.each { |h| h[:externalId] ||= h.delete(:external_id) } }
+
+      put_request(@client, endpoint, item_data)
+    end
+
+  end
+end

data/lib/fastbound-ruby/response.rb

@@ -0,0 +1,48 @@
+module FastBound
+  class Response
+
+    attr_accessor :success
+
+    def initialize(response)
+      @response = response
+
+      case @response
+      when Net::HTTPUnauthorized
+        raise FastBound::Error::NotAuthorized.new(@response.body)
+      when Net::HTTPNotFound
+        raise FastBound::Error::NotFound.new(@response.body)
+      when Net::HTTPNoContent
+        raise FastBound::Error::NoContent.new(@response.body)
+      when Net::HTTPOK, Net::HTTPSuccess
+        self.success = true
+        _data = (JSON.parse(@response.body) if @response.body.present?)
+
+        @data = case
+        when _data.is_a?(Hash)
+          _data.deep_symbolize_keys
+        when _data.is_a?(Array)
+          _data.map(&:deep_symbolize_keys)
+        end
+      else
+        raise FastBound::Error::RequestError.new(@response.body)
+      end
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def body
+      @data
+    end
+
+    def fetch(key)
+      @data.fetch(key)
+    end
+
+    def success?
+      !!success
+    end
+
+  end
+end

data/lib/fastbound-ruby/smart_list.rb

@@ -0,0 +1,34 @@
+require 'fastbound-ruby/api'
+
+module FastBound
+  class SmartList < Base
+
+    include FastBound::API
+
+    ENDPOINTS = {
+      acquire_type:               "smartlists/acquiretype".freeze,
+      caliber:                    "smartlists/caliber".freeze,
+      condition:                  "smartlists/condition".freeze,
+      country_of_manufacture:     "smartlists/countryofmanufacture".freeze,
+      delete_type:                "smartlists/deletetype".freeze,
+      dispose_type:               "smartlists/disposetype".freeze,
+      importer:                   "smartlists/importer".freeze,
+      item_type:                  "smartlists/itemtype".freeze,
+      license_type:               "smartlists/licensetype".freeze,
+      location:                   "smartlists/location".freeze,
+      theft_loss_type:            "smartlists/theftlosstype".freeze,
+      manufacturer:               "smartlists/manufacturer".freeze,
+      manufacturing_dispose_type: "smartlists/manufacturingdisposetype".freeze,
+      manufacturing_acquire_type: "smartlists/manufacturingacquiretype".freeze
+    }
+
+    def initialize(client)
+      @client = client
+    end
+
+    ENDPOINTS.keys.each do |endpoint|
+      define_method(endpoint) { get_request(@client, ENDPOINTS[endpoint]) }
+    end
+
+  end
+end

data/lib/fastbound-ruby/version.rb

@@ -0,0 +1,3 @@
+module FastBound
+  VERSION = "1.0.0"
+end

data/lib/fastbound-ruby/webhook.rb

@@ -0,0 +1,60 @@
+require 'fastbound-ruby/api'
+
+module FastBound
+  class Webhook < Base
+
+    include FastBound::API
+
+    CREATE_AND_EDIT_ATTRS = {
+      permitted: %i( name url description events ).freeze,
+      required:  %i( name url events ).freeze
+    }
+
+    ENDPOINTS = {
+      create: "webhooks".freeze,
+      edit:   "webhooks/%s".freeze,
+      fetch:  "webhooks/%s".freeze,
+      delete: "webhooks/%s".freeze,
+      events: "webhooks/events".freeze
+    }
+
+    def initialize(client)
+      @client = client
+    end
+
+    def create(webhook_data)
+      requires!(webhook_data, CREATE_AND_EDIT_ATTRS[:required])
+
+      endpoint = ENDPOINTS[:create]
+      webhook_data = standardize_body_data(webhook_data, CREATE_AND_EDIT_ATTRS[:permitted])
+
+      post_request(@client, endpoint, webhook_data)
+    end
+
+    def edit(webhook_name, webhook_data)
+      endpoint = ENDPOINTS[:edit] % webhook_name
+      webhook_data = standardize_body_data(webhook_data, CREATE_AND_EDIT_ATTRS[:permitted])
+
+      put_request(@client, endpoint, webhook_data)
+    end
+
+    def fetch(webhook_name)
+      endpoint = ENDPOINTS[:fetch] % webhook_name
+
+      get_request(@client, endpoint)
+    end
+
+    def delete(webhook_name)
+      endpoint = ENDPOINTS[:delete] % webhook_name
+
+      delete_request(@client, endpoint)
+    end
+
+    def events
+      endpoint = ENDPOINTS[:events]
+
+      get_request(@client, endpoint)
+    end
+
+  end
+end

data/lib/fastbound-ruby.rb

@@ -0,0 +1,18 @@
+require 'fastbound-ruby/base'
+require 'fastbound-ruby/version'
+
+require 'fastbound-ruby/api'
+require 'fastbound-ruby/account'
+require 'fastbound-ruby/acquisition'
+require 'fastbound-ruby/attachment'
+require 'fastbound-ruby/client'
+require 'fastbound-ruby/contact'
+require 'fastbound-ruby/disposition'
+require 'fastbound-ruby/error'
+require 'fastbound-ruby/item'
+require 'fastbound-ruby/response'
+require 'fastbound-ruby/smart_list'
+require 'fastbound-ruby/webhook'
+
+module FastBound
+end

data/rakefile

@@ -0,0 +1,20 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+task :default => :spec
+
+desc 'Run the specs'
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'Generate API docs'
+YARD::Rake::YardocTask.new(:docs) do |t|
+  t.files = ['lib/**/*.rb']
+end
+
+namespace :docs do
+  desc 'Run the docs server'
+  task :server do
+    $stdout.puts `yard server --reload --bind 0.0.0.0`
+  end
+end