ship_compliant 0.1.0

data/lib/ship_compliant/client.rb

@@ -0,0 +1,54 @@
+module ShipCompliant
+  class << self
+    attr_accessor :ship_compliant_client
+  end
+
+  # Returns an instance of +Client+.
+  def self.client
+    self.ship_compliant_client ||= new_client_from_wsdl(configuration.wsdl)
+  end
+
+  # Replaces #client with custom WSDL
+  #
+  #   ShipCompliant.wsdl = 'https://ws-dev.shipcompliant.com/Services/1.2/ProductService.asmx?WSDL'
+  def self.wsdl=(wsdl)
+    self.ship_compliant_client = new_client_from_wsdl(wsdl)
+  end
+
+  private
+
+  # Creates a new client from a WSDL url.
+  def self.new_client_from_wsdl(wsdl)
+    Client.new(wsdl: wsdl, log: configuration.log, filters: %W[PartnerKey Username Password])
+  end
+
+  class Client < Savon::Client
+    # "Backup" original #call from Savon::Client
+    alias_method :savon_call, :call
+
+    # Adds the required security credentials and formats
+    # the message to match the ShipCompliant structure.
+    #
+    #   ShipCompliant.client.call(:some_operation, {
+    #     'SomeKey' => 'SomeValue'
+    #   })
+    def call(operation, locals = {})
+      locals['Security'] = ShipCompliant.configuration.credentials
+
+      response = savon_call(operation, message: {
+        'Request' => locals
+      })
+
+      get_result_from_response(operation, response)
+    end
+
+    private
+
+    def get_result_from_response(operation, response)
+      key = operation.to_s
+      resp_key = (key + '_response').to_sym
+      result_key = (key + '_result').to_sym
+      response.to_hash.fetch(resp_key, {}).fetch(result_key, {})
+    end
+  end
+end

data/lib/ship_compliant/commit_sales_order.rb

@@ -0,0 +1,48 @@
+module ShipCompliant
+  # == ShipCompliant::CommitSalesOrder
+  #
+  # This method takes in a Sales Order Key in the request and saves the order
+  # if it has previously been checked for compliance.
+  #
+  # - If the CommitOption is set to “AllShipments”, all the shipments in the sales order will be committed.
+  # - If it is set to “CompliantShipments”, just the non-committed compliant sales orders will be committed.
+  #
+  # Please keep in mind that if “CompliantShipments” is selected, it will be of
+  # great value to the customer if the non-compliant, non-committed orders were
+  # flagged as such for further review.
+  #
+  # If the CommitOption is not specified, zero shipments will be committed.
+  # This allows the integrator to get the commit status of the shipments in a
+  # sales order without committing any of them.
+  #
+  #   result = ShipCompliant::CommitSalesOrder.call({
+  #     commit_options: 'AllShipments',
+  #     payments: nil,
+  #     sales_tax_collected: 0,
+  #     sales_order_key: 'ORDER-KEY'
+  #   })
+  #
+  #   puts result.success? #=> true
+  #   puts "The following shipments were committed."
+  #
+  #   puts result.committed_shipments #=> ['1', '2', ...]
+  class CommitSalesOrder
+
+    # Marks a SalesOrder as committed.
+    #
+    # Returns an instance of ShipCompliant::CommitSalesOrderResult.
+    #
+    #   ShipCompliant::CommitSalesOrder.call({
+    #     commit_options: 'CompliantShipments',
+    #     payments: nil,
+    #     sales_tax_collected: 0,
+    #     sales_order_key: 'ORDER-KEY'
+    #   })
+    def self.call(commit_data)
+      commit_data.deep_transform_keys! { |key| key.to_s.camelize }
+      result = ShipCompliant.client.call(:commit_sales_order, commit_data)
+      CommitSalesOrderResult.new(result)
+    end
+
+  end
+end

data/lib/ship_compliant/commit_sales_order_result.rb

@@ -0,0 +1,30 @@
+module ShipCompliant
+  # == ShipCompliant::CommitSalesOrderResult
+  #
+  # Wraps the response of +CommitSalesOrder+ and provides methods to quickly
+  # access shipments, and the committed shipment keys.
+  class CommitSalesOrderResult < Struct.new(:response)
+    include BaseResult
+
+    # Returns an array of shipment objects.
+    # 
+    #   puts result.shipments #=> [
+    #     {
+    #       key: 'SHIPMENT-KEY',
+    #       is_committed: true/false
+    #     }
+    #   ]
+    def shipments
+      Array.wrap(response[:shipments][:shipment_commit_response])
+    end
+
+    # Gets the keys for committed shipments.
+    #
+    #   puts result.committed_shipments #=> ['SHIPMENT-1', 'SHIPMENT-2', ...]
+    def committed_shipments
+      shipments
+        .select { |s| s[:is_committed] == true }
+        .map { |s| s[:key] }
+    end
+  end
+end

data/lib/ship_compliant/compliance_rule.rb

@@ -0,0 +1,30 @@
+module ShipCompliant
+  class ComplianceRule < Struct.new(:response)
+
+    # Returns the +ComplianceDescription+.
+    def compliance_description
+      response[:compliance_description]
+    end
+
+    # Checks if the current compliance rule was met.
+    def compliant?
+      response[:is_compliant]
+    end
+
+    # Returns the +RuleDescription+.
+    def rule_description
+      response[:rule_description]
+    end
+
+    # Returns the +LicenseRelationship+.
+    def license_relationship
+      response[:license_relationship]
+    end
+
+    # Returns the +RuleType+.
+    def rule_type
+      response[:rule_type]
+    end
+
+  end
+end

data/lib/ship_compliant/configuration.rb

@@ -0,0 +1,46 @@
+module ShipCompliant
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Stores runtime configuration to authenticate user.
+  #
+  #   ShipCompliant.configure do |c|
+  #     c.partner_key = 'XXXX-XX-XXXXX'
+  #     c.username = 'bob@example.com'
+  #     c.password = 'secret'
+  #     c.log = true # savon log
+  #   end
+  class Configuration
+    attr_accessor :partner_key, :username, :password
+    attr_accessor :wsdl, :log
+
+    def initialize
+      @log = true
+      @wsdl = 'https://ws-dev.shipcompliant.com/services/1.2/coreservice.asmx?WSDL'
+    end
+
+    # Returns a +Hash+ for authenticating each API request.
+    #
+    #   {
+    #     'PartnerKey' => 'XXXX-XX-XXXXX',
+    #     'Username' => 'bob@example.com',
+    #     'Password' => 'secret'
+    #   }
+    def credentials
+      {
+        'PartnerKey' => partner_key,
+        'Username' => username,
+        'Password' => password
+      }
+    end
+  end
+end

data/lib/ship_compliant/error_result.rb

@@ -0,0 +1,41 @@
+module ShipCompliant
+  class ErrorResult < Struct.new(:error)
+
+    # Gets the error code as an integer.
+    #
+    #   puts "ERROR ##{error.code}" #=> 404
+    def code
+      error[:code].to_i
+    end
+
+    # Gets the key of the item with an error.
+    #
+    #   puts error.key #=> 'ORDER-123'
+    def key
+      error[:key]
+    end
+
+    # Gets the error message.
+    #
+    #   puts "ERROR: #{error.message}" #=> 'I don't think it's a good idea,
+    #   Yogi'
+    def message
+      error[:message]
+    end
+
+    # The object type that had the error.
+    #
+    #   puts error.target #=> 'SalesOrder'
+    def target
+      error[:target]
+    end
+
+    # The type of error that occured.
+    #
+    #   puts error.type #=> 'Validation'
+    def type
+      error[:type]
+    end
+
+  end
+end

data/lib/ship_compliant/freight_sales_tax_rate.rb

@@ -0,0 +1,8 @@
+module ShipCompliant
+  # == ShipCompliant::FreightSalesTaxRate
+  #
+  # FreightSalesTaxRate wraps the SalesTaxRate value object. It currently
+  # doesn't do anything special.
+  class FreightSalesTaxRate < SalesTaxRate
+  end
+end

data/lib/ship_compliant/get_inventory_details.rb

@@ -0,0 +1,31 @@
+module ShipCompliant
+  # == ShipCompliant::GetInventoryDetails
+  #
+  # Provides inventory details for each Product on a Fulfillment Location,
+  # Fulfillment Account basis.
+  #
+  #   result = ShipCompliant::GetInventoryDetails.call
+  #   product = result.products_for_location('WineShipping').first
+  #
+  #   product.inventory_levels #=> {
+  #     available: 25,
+  #     reserved: 13
+  #   }
+  class GetInventoryDetails
+
+    # Returns inventory details for the specified criteria. The method may be
+    # called without any parameters to return all products with Available
+    # inventory.
+    #
+    #   ShipCompliant::GetInventoryDetails.call({
+    #     brand_key: 'BRAND-KEY',
+    #     fulfillment_location: 'WineShipping'
+    #   })
+    def self.call(query = {})
+      query.deep_transform_keys! { |k| k.to_s.camelize }
+      result = ShipCompliant.client.call(:get_inventory_details, query)
+      GetInventoryDetailsResult.new(result)
+    end
+
+  end
+end

data/lib/ship_compliant/get_inventory_details_result.rb

@@ -0,0 +1,41 @@
+module ShipCompliant
+  # == ShipCompliant::GetInventoryDetailsResult
+  #
+  # Wraps the result of +GetInventoryDetails+ and provides methods to access
+  # locations and products for a location
+  class GetInventoryDetailsResult < Struct.new(:response)
+    include BaseResult
+
+    # Returns an array of +InventoryLocation+ nodes.
+    #
+    #   result.locations[0][:sub_inventory_code] #=> 'SUB-CODE'
+    def locations
+      Array.wrap(response[:inventory_locations]).map do |location|
+        location[:inventory_location]
+      end
+    end
+
+    # Finds a location by +FulfillmentLocation+.
+    #
+    #   result.location('WineShipping')[:supplier] #=> 'LOCATION-SUPPLIER'
+    def location(key)
+      location = locations.select { |l| l[:fulfillment_location] == key }.first
+
+      return {} if location.nil?
+      location
+    end
+
+    # Returns an array of ShipCompliant::InventoryProduct.
+    #
+    #   result.products_for_location('WineShipping').each do |product|
+    #     puts product.product_key
+    #     puts "\t#{product.description}"
+    #     puts "---\n"
+    #   end
+    def products_for_location(key)
+      Array.wrap(location(key)[:inventory_products]).map do |product|
+        InventoryProduct.new(product[:inventory_product])
+      end
+    end
+  end
+end

data/lib/ship_compliant/get_sales_order_extended.rb

@@ -0,0 +1,23 @@
+module ShipCompliant
+  # == ShipCompliant::GetSalesOrderExtended
+  # 
+  # This method takes in a Sales Order Key and returns detailed data about the
+  # sales order, including compliance status.
+  #
+  # Use this method to query the full details of a sales order and the
+  # shipments in the sales order.
+  class GetSalesOrderExtended
+
+    # Finds a +SalesOrder+ by the +SalesOrderKey+.
+    #
+    # Returns an instance of ShipCompliant::GetSalesOrderExtendedResult.
+    def self.by_order_key(order_key)
+      result = ShipCompliant.client.call(:get_sales_order_extended, {
+        'SalesOrderKey' => order_key
+      })
+
+      GetSalesOrderExtendedResult.new(result)
+    end
+
+  end
+end

data/lib/ship_compliant/get_sales_order_extended_result.rb

@@ -0,0 +1,65 @@
+module ShipCompliant
+  # == ShipCompliant::GetSalesOrderExtendedResult
+  #
+  # Wraps the response of +GetSalesOrderExtended+ and provides methods to
+  # quickly access compliace rules of a shipment, the billing address,
+  # shipments, and channel details.
+  class GetSalesOrderExtendedResult < Struct.new(:response)
+    include BaseResult
+
+    # Returns an array of the +ShipmentComplianceResponse+ node as a Hash.
+    #
+    #   sales_order.shipment_compliance_rules.each do |shipment|
+    #     puts "SHIPMENT '#{shipment[:key]}' IS NOT COMPLIANT" unless shipment[:is_compliant]
+    #   end
+    def shipment_compliance_rules
+      Array.wrap(response[:compliance_results][:sales_order][:shipments][:shipment_compliance_response]).map do |shipment|
+        shipment
+      end
+    end
+
+    # Finds all the compliance rules for a shipment.
+    # Returns an instance of ShipmentCompliance.
+    #
+    #   shipment_compliance = sales_order.compliance_rules_for_shipment('SHIPMENT-KEY')
+    #   puts shipment_compliance.compliant? #=> false
+    def compliance_rules_for_shipment(shipment_key)
+      shipment = shipment_compliance_rules.select { |s| s[:key] == shipment_key }.first
+      ShipmentCompliance.new(shipment)
+    end
+
+    # Returns a ShipCompliant::Address with the customer's billing information.
+    #
+    #   puts sales_order.bill_to.state #=> 'AK'
+    def bill_to
+      Address.new(response[:sales_order][:bill_to])
+    end
+
+    # Returns an array of +Shipment+ nodes as a Hash.
+    #
+    #   sales_order.shipments.each do |shipment|
+    #     puts shipment[:ship_date] #=> DateTime
+    #   end
+    def shipments
+      Array.wrap(response[:sales_order][:shipments]).map do |shipment|
+        shipment[:shipment]
+      end
+    end
+
+    # Finds a shipment by +ShipmentKey+. Returns an instance of ShipCompliant::Shipment.
+    #
+    #   shipment = sales_order.find_shipment('1')
+    #   puts shipment.ship_date #=> DateTime
+    def find_shipment(shipment_key)
+      shipment = shipments.select { |s| s[:shipment_key] == shipment_key }.first
+      Shipment.new(shipment)
+    end
+
+    # Returns the +OrderChannelDetails+ node as an instance of ShipCompliant::ChannelDetails.
+    #
+    #   puts sales_order.channel_details.order_channel #=> 'MyOrders'
+    def channel_details
+      ChannelDetails.new(response[:order_channel_details])
+    end
+  end
+end

data/lib/ship_compliant/inventory_product.rb

@@ -0,0 +1,95 @@
+module ShipCompliant
+  # == ShipCompliant::InventoryProduct
+  #
+  # InventoryProduct is a value object that has methods to access product data from GetInventoryDetails.
+  #   
+  #  products = @inventory_results.products_for_location('WineShipping')
+  #  
+  #  products.each do |product|
+  #    puts "[%s] %s" % [product.product_key, product.description]
+  #  
+  #    product.inventory_levels.each do |type, quantity|
+  #      puts "%s are %s" % [quantity, type]
+  #    end
+  #  end
+  class InventoryProduct < Struct.new(:product)
+
+    # Returns the +DefaultCase+ of a product.
+    def default_case
+      product[:default_case]
+    end
+
+    # Returns the +ProductKey+ of a product.
+    def product_key
+      product[:product_key]
+    end
+
+    # Returns the +ProductType+ of a product.
+    def product_type
+      product[:product_type]
+    end
+
+    # Returns the +Description+ of a product.
+    def description
+      product[:description]
+    end
+
+    # Returns the +UnitPrice+ of a product as a float.
+    def unit_price
+      product[:unit_price].to_f
+    end
+
+    # Returns the +FulfillmentSku+ of a product.
+    def fulfillment_sku
+      product[:fulfillment_sku]
+    end
+
+    # Returns the +PercentAlcohol+ of a product as a float.
+    def percent_alcohol
+      product[:percent_alcohol].to_f
+    end
+
+    # Returns the +Vintage+ of a product as an integer.
+    def vintage
+      product[:vintage].to_i
+    end
+
+    # Returns the +VolumeAmount+ of a product as a float.
+    def volume_amount
+      product[:volume_amount].to_f
+    end
+
+    # Returns the +VolumeML+ of a product as a float.
+    def volume_ml
+      product[:volume_ml].to_f
+    end
+
+    # Returns the +VolumeUnit+ of a product.
+    def volume_unit
+      product[:volume_unit]
+    end
+
+    # Returns a Hash of inventory levels.
+    #
+    # - The key is the +InventoryType+.
+    # - The value is +Quantity+ as a float.
+    #
+    #     product.inventory_levels #=> {
+    #       available: 2,
+    #       on_hold: 2,
+    #       back_order: 4
+    #     }
+    def inventory_levels
+      levels = {}
+      
+      product[:inventory_levels][:inventory_level].each do |level|
+        key = level[:inventory_type].underscore.to_sym
+        value = level[:quantity].to_f
+
+        levels[key] = value
+      end
+
+      levels
+    end
+  end
+end