whitehouse 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a6d7e235ec57af1cf16316c8dc68db684a1276b5
+  data.tar.gz: db7299985bfb54caa505228c8a6f0f3f665cba97
+SHA512:
+  metadata.gz: b6e56a35c6cff590da279b07b43194ec50fff942becbdd00e7b8456e48ad28a199039f720a2cb4f8884820576b06a4f2384db282ac3caa6c4d84f0d318e24771
+  data.tar.gz: 9d0116ccbe9b8b6b7269a20d0fe29c7b89738f2b8c5142508aa88c7250c0e00917aeac42b218d2405ca2a0c3bf514236c0661149c761c17daf73784ba4cc6f7a

data/.env.test

@@ -0,0 +1,4 @@
+# Test keys
+WHCC_API_ENDPOINT='https://sandbox.apps.whcc.com/api/'
+WHCC_CONSUMER_KEY='FA2DBC52662850A7B53B'
+WHCC_CONSUMER_SECRET='rPTa7aIydCI='

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.env
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.2
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in whitehouse.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Travis Dahlke
+
+MIT License
+
+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/README.md

@@ -0,0 +1,84 @@
+# Whitehouse [![Build Status](https://travis-ci.org/whcc/whcc_ruby.svg?branch=master)](https://travis-ci.org/whcc/whcc_ruby)
+
+Ruby client for the WHCC API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'whitehouse'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install whitehouse
+
+## Usage
+
+### Authentication
+Configuration can be done at the module level:
+```ruby
+Whitehouse.configure do |c|
+  c.consumer_key = 'FA2DBC52662850A7B53B'
+  c.consumer_secret = 'rPTa7aIydCI='
+end
+```
+
+at the client instance level:
+```ruby
+client = Whitehouse::Client.new(consumer_key: 'FA2DBC52662850A7B53B', consumer_secret: 'rPTa7aIydCI=')
+```
+
+or via environment variables:
+```
+WHCC_CONSUMER_KEY='FA2DBC52662850A7B53B'
+WHCC_CONSUMER_SECRET='rPTa7aIydCI='
+```
+
+### Fetch the catalog
+```ruby
+Whitehouse.request_catalog
+```
+
+### Submitting an Order
+```ruby
+# Build the order object
+order = Whitehouse::Order.new
+order.entry_id = '123abc'
+order.order_attributes = [95,97]
+
+# Set the shipping address
+shipping_address = Whitehouse::Order::Address.new("Bob","123 Fake St","","Somewhere","MN","55121")
+order.to_address = shipping_address
+
+# Add the line items
+item = Whitehouse::Order::OrderItem.new(3,"http://lab.whcc.com/ApostleIslandMarina.jpg","60ee3ed946def317eae764516b727f50", [5,1])
+order.add_item(item)
+
+# Submit order
+confirm = Whitehouse.submit_order(order)
+
+# Confirm order
+if (confirm)
+  confirmed = Whitehouse.confirm_order(confirm)
+end
+```
+
+### Creating Webhooks
+```ruby
+Whitehouse.create_webhook('http://example.com/webhook')
+
+# WHCC will POST to the uri provided with a 'verifier' token.
+Whitehouse.verify_webhook(verifier)
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/whcc/whcc_ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "rspec/core/rake_task"
+require "bundler/gem_tasks"
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color']
+end
+
+task :default => :spec

data/lib/whitehouse/authentication.rb

@@ -0,0 +1,22 @@
+module Whitehouse
+
+  # Methods for the Request Client Access Token API
+  #
+  # @see https://developers.whcc.com/API/OrderSubmit/RequestToken.aspx
+  module Authentication
+
+    def access_token
+      @access_token ||= begin
+        init_connection unless @connection
+        response = @connection.get 'AccessToken', {grant_type: 'consumer_credentials',
+                                                   consumer_key: consumer_key,
+                                                   consumer_secret: consumer_secret}
+        response.body.fetch("Token")
+      end
+    rescue StandardError => ex
+      raise Whitehouse::Error, "Failed to authenticate with WHCC. Check your credentials."
+    end
+    private :access_token
+
+  end
+end

data/lib/whitehouse/client/catalog.rb

@@ -0,0 +1,17 @@
+module Whitehouse
+  class Client
+
+    # Methods for the Request Catalog API
+    #
+    # @see https://developers.whcc.com/API/OrderSubmit/RequestCatalog.aspx
+    module Catalog
+
+      # List entire catalog for account
+      def request_catalog
+        response = get 'Catalog'
+        response.body
+      end
+
+    end
+  end
+end

data/lib/whitehouse/client/order.rb

@@ -0,0 +1,57 @@
+require 'tempfile'
+
+module Whitehouse
+  class Client
+
+    # Methods for the Order Submit API
+    #
+    # @see https://developers.whcc.com/API/OrderSubmit/OrderSubmit.aspx
+    module Order
+
+      BOUNDARY = "-----------RubyMultipartPost"
+
+      # Submit order
+      # @param order [Whitehouse::Order]
+      # @return [Integer, false] Confirmation ID of order if successful, otherwise false
+      def submit_order(order)
+        file = Tempfile.new('entry.json')
+        file.write(order.to_json)
+        file.close
+        response = post 'OrderImport', {entry: Faraday::UploadIO.new(file.path, "application/json")}
+        file.unlink
+        if response.success? && !response.body.ErrorNumber
+          response.body.ConfirmationID
+        else
+          false
+        end
+      end
+
+      # Confirm order
+      # @param [String] The confirmation id received when the order was submitted
+      # @return [Boolean] Success
+      def confirm_order(confirmation_id)
+        # Couldn't get faraday to build this request correctly
+        # connection.post "OrderImport/Submit/#{confirmation_id}"
+        url = connection.url_prefix + URI.parse("OrderImport/Submit/#{confirmation_id}")
+
+        header = {"Accept" => "application/json", "Content-Type"=> "multipart/form-data; boundary=#{BOUNDARY}"}
+
+        post_body = []
+        post_body << "--#{BOUNDARY}\r\n"
+        post_body << "Content-Disposition: form-data; name=\"access_token\"\r\n\r\n"
+        post_body << access_token
+        post_body << "\r\n--#{BOUNDARY}--\r\n"
+
+        # Create the HTTP objects
+        request = Net::HTTP::Post.new(url.path, header)
+        request.body = post_body.join
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true
+        res = http.request(request)
+        body = JSON.parse(res.body)
+        return res.is_a?(Net::HTTPSuccess) && !body["ErrorNumber"]
+      end
+
+    end
+  end
+end

data/lib/whitehouse/client/webhook.rb

@@ -0,0 +1,41 @@
+module Whitehouse
+  class Client
+
+    # Methods for the Request Catalog API
+    #
+    # @see https://developers.whcc.com/API/OrderSubmit/Webhooks.aspx
+    module Webhook
+
+      # Create a callback
+      # @param [String] Callback URI
+      # @return [Boolean] Success
+      def create_webhook(uri)
+        response = post 'callback/create', {callbackUri: uri}
+        response.body
+        response.success? && !response.body.ErrorNumber
+      end
+
+      # Verify callback
+      # @param [String] Verifier token provided by WHCC POSTing to the callback uri upon creation.
+      # @return [Boolean] Success
+      def verify_webhook(verifier)
+        # This endpoint does not respond with json, so not using faraday connection
+        # response = connection.post 'callback/create', {callbackUri: uri}
+        # response.body
+        # response.success? && !response.body.ErrorNumber
+
+        url = connection.url_prefix + URI.parse("callback/verify")
+        header = {"Accept" => "text/xml"}
+
+        # Create the HTTP objects
+        request = Net::HTTP::Post.new(url.path, header)
+        request.set_form_data(access_token: access_token, verifier: verifier)
+        http = Net::HTTP.new(url.host, url.port)
+        http.use_ssl = true
+        res = http.request(request)
+        return res.is_a?(Net::HTTPSuccess) && res.body.scan('Failed').empty?
+      end
+
+    end
+  end
+end

data/lib/whitehouse/client.rb

@@ -0,0 +1,107 @@
+require "faraday"
+require "faraday_middleware"
+require "whitehouse/error"
+require "whitehouse/configurable"
+require "whitehouse/authentication"
+require "whitehouse/client/catalog"
+require "whitehouse/client/order"
+require "whitehouse/client/webhook"
+
+module Whitehouse
+
+  # Client for the WHCC API
+  #
+  # @see https://developers.whcc.com
+  class Client
+
+    include Whitehouse::Configurable
+    include Whitehouse::Authentication
+    include Whitehouse::Client::Catalog
+    include Whitehouse::Client::Order
+    include Whitehouse::Client::Webhook
+
+    def initialize(options = {})
+      Whitehouse::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || Whitehouse.instance_variable_get(:"@#{key}"))
+      end
+    end
+
+    def connection
+      @connection || init_connection(:oauth2)
+    end
+
+    # Compares client options to a Hash of requested options
+    # 
+    # @param opts [Hash] Options to compare with current client options
+    # @return [Boolean]
+    def same_options?(opts)
+      opts.hash == options.hash
+    end
+
+    # Text representation of the client, masking tokens
+    #
+    # @return [String]
+    def inspect
+      inspected = super
+
+      # Only show last 4 of token, secret
+      if @access_token
+        inspected = inspected.gsub! @access_token, "#{'*'*8}#{@access_token[8..-1]}"
+      end
+      if @consumer_secret
+        inspected = inspected.gsub! @consumer_secret, "#{'*'*8}#{@consumer_secret[8..-1]}"
+      end
+
+      inspected
+    end
+
+    def get(*args)
+      request :get, *args
+    end
+
+    def post(*args)
+      request :post, *args
+    end
+
+    private
+
+    def reset_connection
+      @connection = nil
+      @access_token = nil
+    end
+
+    def request(method, *args)
+      tries ||= 2
+      response = connection.public_send(method, *args)
+      check_errors(response)
+      response
+    rescue Error::AuthorizationExpired => ex
+      reset_connection
+      if (tries -= 1) > 0
+        retry
+      else
+        raise ex
+      end
+    end
+
+    def check_errors(response)
+      raise Error, response.status unless response.success?
+      raise Error::CODES[response.body.ErrorNumber], response.body.Message if response.body.ErrorNumber
+    end
+
+    def init_connection(oauth = false)
+      @connection = Faraday.new(api_endpoint, connection_options) do |faraday|
+        faraday.request :multipart
+        faraday.request :url_encoded
+        faraday.request :oauth2, access_token if oauth
+
+        # faraday.response :logger
+        faraday.response :mashify
+        faraday.response :json, :content_type => /\bjson$/
+        # faraday.response :raise_error
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+  end
+end

data/lib/whitehouse/configurable.rb

@@ -0,0 +1,65 @@
+module Whitehouse
+  module Configurable
+    # @!attribute access_token
+    #   @return [String] Client access token
+    # @!attribute api_endpoint
+    #   @return [String] Base URL for API requests. default: https://apps.whcc.com/api
+    # @!attribute connection_options
+    #   @see https://github.com/lostisland/faraday
+    #   @return [Hash] Configure connection options for Faraday
+    # @!attribute consumer_key
+    #   @return [String] Configure OAuth app key
+    # @!attribute [w] consumer_secret
+    #   @return [String] Configure OAuth app secret
+    # @!attribute default_media_type
+    #   @return [String] Configure preferred media type
+    # @!attribute user_agent
+    #   @return [String] Configure User-Agent header for requests.
+
+    attr_accessor :access_token, :api_endpoint, :connection_options, :consumer_key,
+                  :consumer_secret, :default_media_type, :user_agent
+
+    class << self
+
+      # List of configurable keys for {Whitehouse::Client}
+      # @return [Array] of option keys
+      def keys
+        @keys ||= [
+          :access_token,
+          :api_endpoint,
+          :connection_options,
+          :consumer_key,
+          :consumer_secret,
+          :default_media_type,
+          :user_agent
+        ]
+      end
+    end
+
+    # Set configuration options using a block
+    def configure
+      yield self
+    end
+
+    # Reset configuration options to default values
+    def reset!
+      Whitehouse::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Whitehouse::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    def api_endpoint
+      File.join(@api_endpoint, "")
+    end
+
+    private
+
+    def options
+      Hash[Whitehouse::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+  end
+
+end

data/lib/whitehouse/default.rb

@@ -0,0 +1,71 @@
+require 'whitehouse/version'
+
+module Whitehouse
+  class Default
+
+    # Default API Endpoint
+    API_ENDPOINT = 'https://apps.whcc.com/api/'.freeze
+
+    # Default User Agent
+    USER_AGENT = "Whitehouse Ruby Gem #{Whitehouse::VERSION}".freeze
+
+    # Default Media Type
+    MEDIA_TYPE = "application/json"
+
+    class << self
+      # Configuration options
+      # @return [Hash]
+      def options
+        Hash[Whitehouse::Configurable.keys.map{|key| [key, send(key)]}]
+      end
+
+      # Default API endpoint from ENV or {API_ENDPOINT}
+      # @return [String]
+      def api_endpoint
+        ENV['WHCC_API_ENDPOINT'] || API_ENDPOINT
+      end
+
+      # Default User-Agent header string from ENV or {USER_AGENT}
+      # @return [String]
+      def user_agent
+        ENV['WHCC_USER_AGENT'] || USER_AGENT
+      end
+
+      # Default media type from ENV or {MEDIA_TYPE}
+      # @return [String]
+      def default_media_type
+        ENV['WHCC_DEFAULT_MEDIA_TYPE'] || MEDIA_TYPE
+      end
+
+      # Default access token from ENV
+      # @return [String]
+      def access_token
+        ENV['WHCC_ACCESS_TOKEN']
+      end
+
+      # Default OAuth app key from ENV
+      # @return [String]
+      def consumer_key
+        ENV['WHCC_CONSUMER_KEY']
+      end
+
+      # Default OAuth app secret from ENV
+      # @return [String]
+      def consumer_secret
+        ENV['WHCC_CONSUMER_SECRET']
+      end
+
+      # Default options for Faraday::Connection
+      # @return [Hash]
+      def connection_options
+        {
+          :headers => {
+            :accept => default_media_type,
+            :user_agent => user_agent
+          }
+        }
+      end
+    end
+
+  end
+end

data/lib/whitehouse/error.rb

@@ -0,0 +1,22 @@
+module Whitehouse
+  class Error < StandardError
+    ConfigurationError = Class.new(::ArgumentError)
+
+    NotAuthorized = Class.new(self)
+    AuthorizationExpired = Class.new(NotAuthorized)
+
+    InvalidOrder = Class.new(self)
+    IncorrectOrderImport = Class.new(InvalidOrder)
+    InvalidBusinessRules = Class.new(InvalidOrder)
+    InvalidConfirmationId = Class.new(InvalidOrder)
+    EntryAlreadySubmitted = Class.new(InvalidOrder)
+
+    CODES = {
+      "403.01" => AuthorizationExpired,
+      "412.01" => IncorrectOrderImport,
+      "412.02" => InvalidBusinessRules,
+      "412.03" => InvalidConfirmationId,
+      "412.04" => EntryAlreadySubmitted,
+    }.freeze
+  end
+end

data/lib/whitehouse/order.rb

@@ -0,0 +1,112 @@
+require 'json'
+
+module Whitehouse
+  class Order
+
+    attr_accessor :entry_id, :drop_ship, :from_address_value, :sequence_number,
+                  :from_address, :to_address, :order_attributes
+    attr_reader :items
+
+    def initialize
+      defaults
+      yield self if block_given?
+    end
+
+    OrderItem = Struct.new(:uid, :url, :md5, :attributes, :rotation) do
+      def assets
+        [{"AssetPath" => url,
+          "PrintedFileName" => "",
+          "ImageHash" => md5,
+          "DP2NodeID" => 10000,
+          "OffsetX" => 50,
+          "OffsetY" => 50,
+          "X" => 50,
+          "Y" => 50,
+          "ZoomX" => 100,
+          "ZoomY" => 100,
+          "ImageRotation" => 0,
+          "isCoverAsset" => false,
+          "isJacketAsset" => false,
+          "ColorCorrect" => false}]
+      end
+
+      def item_attributes
+        return [] unless attributes
+        attributes.map{|attr| {"AttributeUID" => attr}}
+      end
+    end
+
+    Address = Struct.new(:name, :addr1, :addr2, :city, :state, :zip, :country) do
+      def to_hash
+        {"Name" => name,
+         "Addr1" => addr1,
+         "Addr2" => addr2,
+         "City" => city,
+         "State" => state,
+         "Zip" => zip,
+         "Country" => country || 'US'
+        }
+      end
+    end
+
+
+    def add_item(item)
+      @items << item
+    end
+
+    def to_json
+      {"EntryID" => entry_id,
+       "Orders" => [
+         {"DropShipFlag" => drop_ship,
+           "FromAddressValue" => from_address_value,
+           "OrderAttributes" => order_attributes,
+           # "Reference" => reference,
+           # "Instructions" => instructions,
+           "SequenceNumber" => sequence_number,
+           "ShipToAddress" => to_address,
+           # "ShipFromAddress" => from_address,
+           "OrderItems" => order_items
+        }
+      ]
+      }.to_json
+    end
+
+    private
+
+    def defaults
+      self.drop_ship = 1
+      self.from_address_value = 1
+      self.sequence_number = 1
+      self.order_attributes = []
+      @items = []
+    end
+
+    def order_attributes
+      @order_attributes.map{|attr| {"AttributeUID" => attr}}
+    end
+
+    def order_items
+      items.each_with_index.map do |item, i|
+        {"ItemAssets" => item.assets,
+         "ItemAttributes" => item.item_attributes,
+         "ProductUID" => item.uid,
+         "Quantity" => 1,
+         "LineItemID" => i,
+         "LayoutRotation" => item.rotation}
+      end
+    end
+
+    def to_address
+      (@to_address || default_address).to_hash
+    end
+
+    def from_address
+      (@from_address || default_address).to_hash
+    end
+
+    def default_address
+      Address.new
+    end
+
+  end
+end

data/lib/whitehouse/version.rb

@@ -0,0 +1,3 @@
+module Whitehouse
+  VERSION = "0.0.1"
+end