smartsend-ruby 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 71c53eea4d23cd5fdbb44d988a4aa80d1b971ddb
-  data.tar.gz: e370c38f2f6c95faedc889116356278e835b405a
+SHA256:
+  metadata.gz: 5e338e7c9a7df4d21d802d3add16f25ff4f9215b01e251cac1f0cf0f6895325c
+  data.tar.gz: 694b44590d3806a8b4be161adbfcfd40bf32489325cb09d913a7b1974fa4bec7
 SHA512:
-  metadata.gz: b2baf4fd35f72dc9cf5e4773aaaebc74d5d52597e1a373f7c9aebc6f241e4078baed5e256421d854c81dc62b6b403e091e109c55132351323fdca95b62bcb0e1
-  data.tar.gz: 768aa3279001727ec340bc0dd162d46c1e3c9c76253fb7bfc2e5d186542e145bbebdecf55b701b32fd5d8867c78f77ef66452c4efcd09befc72fb897989999fd
+  metadata.gz: 0ae5e3227403d982d6a9f590af15cd654d93d0b10627ff301d3315ce13d666b19b8fd7123a6e4fd9751c3fe06df7d1ea95d9eb7a1d98617df8b078c025dd94c7
+  data.tar.gz: b4aa12989d2d520920a39e3b0c6d8b1a0485991f8e621dcfadf3cc06b0901cf057aa8d3c94b172733cfa4dbb4f2545cceb849ed6911e4b0d61126624d1401b02

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    smartsend-ruby (0.0.1)
+    smartsend-ruby (0.1.1)
       http (~> 2.2)
 
 GEM
@@ -9,6 +9,7 @@ GEM
   specs:
     addressable (2.5.2)
       public_suffix (>= 2.0.2, < 4.0)
+    coderay (1.1.2)
     domain_name (0.5.20170404)
       unf (>= 0.0.5, < 1.0.0)
     http (2.2.2)
@@ -20,6 +21,10 @@ GEM
       domain_name (~> 0.5)
     http-form_data (1.0.3)
     http_parser.rb (0.6.0)
+    method_source (0.9.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
     public_suffix (3.0.1)
     unf (0.1.4)
       unf_ext
@@ -29,7 +34,8 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  pry
   smartsend-ruby!
 
 BUNDLED WITH
-   1.14.6
+   1.16.1

data/README.md

@@ -15,67 +15,60 @@ gem install 'smartsend-ruby'
 
 ```ruby
 Smartsend.configure(
-  api_key: 'smartsend-api-key',
-  email: 'smartsend-username',
-  license: 'smartsend-license-key',
-  cms_system: 'Ruby on Rails',
-  cms_version: '5.0.0'
+  api_token: 'smart-send-api-token'
 )
 ```
 
 ## Usage
 
-### Creating an order
+### Creating a shipment
 
 This creates a label.
 
 ```ruby
-# initalize a new order
-order = Smartsend::Order.new(
-  id: "123123123", # your internal order id
-  order_number: "AC12345789",
-  carrier: "postnord", # postnord/gls/bring
-  method: "private",
-  return: false,
-  total_price: 199.75,
-  shipping_price: 49,
-  currency: "DKK",
-  sms_notification: "12345678",
-  email_notification: "contact@smartsend.io"
+# initalize a new shipment
+shipment = Smartsend::Shipment.new(
+  internal_id: "123123123", # your internal order id
+  internal_reference: "AC12345789", # your order number
+  shipping_carrier: "postnord", # postnord/gls/bring/dao
+  shipping_method: "agent",
+  shipping_date: "2018-02-28"
 )
 
-# set the receiver of the order
-order.receiver = Smartsend::Receiver.new(
-  id: "123456", # your internal customer id
+# set the receiver of the shipment
+shipment.receiver = Smartsend::Receiver.new(
+  internal_id: "123456", # your internal customer id
+  internal_reference: "123456",
   company: "Smart Send",
-  name1: "Henrik Hansen",
-  name2: "C/O Vivian Hansen",
-  address1: "Willemoesgade 42",
-  address2: "3.th.",
-  zip: "2100",
+  name_line1: "Henrik Hansen",
+  name_line2: "C/O Vivian Hansen",
+  address_line1: "Willemoesgade 42",
+  address_line2: "3.th.",
+  postal_code: "2100",
   city: "Copenhagen",
   country: "DK",
-  phone: "12345678",
-  mail: "contact@smartsend.io"
+  sms: "12345678",
+  email: "contact@smartsend.io"
 )
 
-# optionally set the sender of the order
-order.sender = Smartsend::Sender.new(
-  id: "123456",
+# optionally set the sender of the shipment
+shipment.sender = Smartsend::Sender.new(
+  internal_id: "123456",
+  internal_reference: "123456",
   company: "Smart Send",
-  name1: "Henrik Hansen",
-  name2: "C/O Vivian Hansen",
-  address1: "Willemoesgade 42",
-  address2: "3.th.",
-  zip: "2100",
+  name_line1: "Henrik Hansen",
+  name_line2: "C/O Vivian Hansen",
+  address_line1: "Willemoesgade 42",
+  address_line2: "3.th.",
+  postal_code: "2100",
   city: "Copenhagen",
   country: "DK",
-  phone: "12345678",
-  mail: "contact@smartsend.io"
+  sms: "12345678",
+  email: "contact@smartsend.io"
 )
 
 # optionally ship to a droppoint by setting an agent
-order.agent = Smartsend::Agent.new(
+shipment.agent = Smartsend::Agent.new(
   id: "2103", # droppoint id
   type: "PDK", # droppoint provider
   company: "Smart Send",
@@ -90,94 +83,68 @@ order.agent = Smartsend::Agent.new(
   mail: "contact@smartsend.io"
 )
 
-# add one or more parcels/fulfillments to the order
+# add one or more parcels/fulfillments to the shipment
 parcel = Smartsend::Parcel.new(
   shipped_at: DateTime.now,
-  reference: "123456789", # your internal parcel id
+  internal_id: "123456789", # your internal parcel id
+  internal_reference: "123456789",
   weight: 1.25,
   height: 21,
   width: 27,
   length: 35,
-  size: "large",
-  freetext_lines: [ # you can add up to 3 lines of freetext to be printed on the label
-    "Brians birthsday gift",
-    "Don't open this before your birthsday Brian",
-    "We look forward to seeing you soon Brian"
-  ]
+  freetext1: "Brians birthday gift",
+  freetext2: "Don't open this before your birthday Brian",
+  freetext3: "We look forward to seeing you soon Brian",
 )
 
 # add items to the parcel
 parcel_item = Smartsend::ParcelItem.new(
+  internal_id: "ABC123",
+  internal_reference: "ABC123",
   sku: "ABC123",
-  title: "ABC123",
+  name: "Product name",
   quantity: 2,
-  unit_weight: 1.25,
-  unit_price: 144.5,
-  currency: "DKK"
+  unit_weight: 1.25
 )
 
 parcel.items << parcel_item
-order.parcels << parcel
+shipment.parcels << parcel
 
-# send the order to Smartsend.io
-order.save!
+# send the shipment to Smartsend.io
+shipment.save!
 ```
 
-After saving, the order it is updated with a url for the label pdf and tracking codes for each parcel.
+After saving, the shipment it is updated with a url for the label pdf and tracking codes for each parcel.
 
 ```ruby
-order.label_url
+shipment.label_url
   => 'http://v70.api.smartsend.dk/...'
 
-order.parcels.first.tracking_code
+shipment.parcels.first.tracking_code
   => '1234...'
 
-order.parcels.first.tracking_url
+shipment.parcels.first.tracking_url
   => 'https://tracking.postnord.com/...'
 ```
 
-### Creating orders in batch
-
-You can create up to 10 orders in batch.
-
-This updates all orders with a label_url and also gives you a labels_url with the combined labels
-
-```ruby
-
-orders = Smartsend::Orders.new
-orders << Smartsend::Order.new(...)
-orders << Smartsend::Order.new(...)
-
-# send the orders to Smartsend.io
-orders.save_all!
-
-orders.labels_url
-  => 'http://v70.api.smartsend.dk/...'
-
-orders.first.label_url
-  => 'http://v70.api.smartsend.dk/...'
-```
-
 ### Using multiple accounts
 
 If your system requires multiple accounts you can pass an account instance when saving orders.
 
 ```ruby
-order = Smartsend::Order.new(...)
+shipment = Smartsend::Order.new(...)
 
 account = Smartsend::Account.new(
-  email: 'smartsend-username',
-  license: 'smartsend-license-key'
+  api_token: 'smartsend-api-token'
 )
 
-order.save!(account: account)
+shipment.save!(account: account)
 ```
 
 ### Validating account
 ```ruby
 account = Smartsend::Account.new(
-  email: 'wrong-username',
-  license: 'wrong-license-key'
+  api_token: 'wrong-smartsend-api-token'
 )
 
 account.valid?

data/lib/smartsend/account.rb

@@ -1,18 +1,12 @@
 class Smartsend::Account
-  attr_accessor :email, :license
+  attr_accessor :api_token
 
-  def initialize(email:, license:)
-    @email = email
-    @license = license
+  def initialize(api_token:)
+    @api_token = api_token
   end
 
   def valid?
-    begin
-      response = Smartsend::Client.new(self).get_plain('verify_user')
-      response.code.to_s == '200'
-    rescue Smartsend::AuthorizationError => e
-      false
-    end
+    raise NotImplementedError
   end
 
 end

data/lib/smartsend/address.rb

@@ -1,5 +1,7 @@
 class Smartsend::Address
-  attr_accessor :id, :company ,:name1 ,:name2 ,:address1 ,:address2 ,:zip ,:city ,:country ,:phone ,:mail
+  attr_accessor :internal_id, :internal_reference, :company, :name_line1,
+                :name_line2, :address_line1, :address_line2, :postal_code,
+                :city, :country, :sms, :email
 
   def initialize(args={})
     args.each do |k, v|
@@ -9,16 +11,18 @@ class Smartsend::Address
 
   def serialize
     {
-      :company  => @company,
-      :name1    => @name1,
-      :name2    => @name2,
-      :address1 => @address1,
-      :address2 => @address2,
-      :zip      => @zip,
-      :city     => @city,
-      :country  => @country,
-      :sms      => @phone,
-      :mail     => @mail
+      :internal_id        => internal_id,
+      :internal_reference => internal_reference,
+      :company            => company,
+      :name_line1         => name_line1,
+      :name_line2         => name_line2,
+      :address_line1      => address_line1,
+      :address_line2      => address_line2,
+      :postal_code        => postal_code,
+      :city               => city,
+      :country            => country,
+      :sms                => sms,
+      :email              => email
     }
   end
 

data/lib/smartsend/agent.rb

@@ -1,12 +1,28 @@
-class Smartsend::Agent < Smartsend::Address
-  attr_accessor :type
+class Smartsend::Agent
+ attr_accessor :internal_id, :internal_reference, :agent_no, :company,
+               :name_line1, :name_line2, :address_line1, :address_line2,
+               :postal_code, :city, :country
+
+  def initialize(args={})
+   args.each do |k, v|
+     instance_variable_set "@#{k}", v
+   end
+  end
 
   def serialize
-    super.merge(
-      id: @id,
-      agentno: @id,
-      agenttype: @type
-    )
+    {
+      :internal_id        => internal_id,
+      :internal_reference => internal_reference,
+      :agent_no           => agent_no,
+      :company            => company,
+      :name_line1         => name_line1,
+      :name_line2         => name_line2,
+      :address_line1      => address_line1,
+      :address_line2      => address_line2,
+      :postal_code        => postal_code,
+      :city               => city,
+      :country            => country,
+    }
   end
 
 end

data/lib/smartsend/client.rb

@@ -2,51 +2,55 @@ require 'http'
 
 class Smartsend::Client
 
-  BASE_URL = 'http://smartsend-prod.apigee.net/v7'.freeze
-
   def initialize(account=nil)
     @account = account || Smartsend.account
   end
 
   def post(path, params)
     request do
-      http.post("#{BASE_URL}/#{path}", json: params)
+      http.post(url(path), json: params)
     end
   end
 
   def get(path)
     request do
-      http.get("#{BASE_URL}/#{path}")
+      http.get(url(path))
     end
   end
 
   def get_plain(path)
-    http.get("#{BASE_URL}/#{path}")
+    http.get(url(path))
   end
 
   def request
     response = yield
 
-    Rails.logger.debug(response.to_s) if defined?(Rails)
+    logger.debug(response)
+    logger.debug(response.body.to_s)
 
-    case response.code.to_s
-    when '200'
-      Response.new(JSON.parse(response)).successful!
-    when '401'
+    case response.code
+    when (200..299)
+      Response.new(JSON.parse(response)).successful!(response.code)
+    when 401
       raise Smartsend::AuthorizationError, 'Unable to authorize'
+    when 404
+      raise Smartsend::NotFoundError, 'Resource not found'
     else
-      Response.new(response).failed!
+      Response.new(JSON.parse(response)).failed!(response.code)
     end
   end
 
   class Response < SimpleDelegator
+    attr_reader :http_code
 
-    def successful!
+    def successful!(http_code)
+      @http_code = http_code
       @success = true
       self
     end
 
-    def failed!
+    def failed!(http_code)
+      @http_code = http_code
       @success = false
       self
     end
@@ -63,20 +67,23 @@ class Smartsend::Client
 
   private
 
+  BASE_URL = 'http://smartsend-test.apigee.net/api/v1'.freeze
+
+  def url(path)
+    "#{BASE_URL}/#{path}"
+  end
+
+  def logger
+    Logger.new($stdout)
+  end
+
   def http
-    raise Smartsend::MissingConfigError, 'Missing api_key' if Smartsend.api_key.nil?
-    raise Smartsend::MissingConfigError, 'Missing email'   if @account.email.nil?
-    raise Smartsend::MissingConfigError, 'Missing license' if @account.license.nil?
-
-    HTTP.headers(
-      apikey: Smartsend.api_key,
-      smartsendmail: @account.email,
-      smartsendlicence: @account.license,
-      cmssystem: Smartsend.cms_system,
-      cmsversion: Smartsend.cms_version,
-      appversion: Smartsend.app_version,
-      test: Smartsend.test?
-    )
+    raise Smartsend::MissingConfigError, 'Missing api_token' if @account.api_token.nil?
+
+    HTTP.headers({
+      accept: 'application/json',
+      api_token: @account.api_token
+    })
   end
 
 end

data/lib/smartsend/parcel.rb

@@ -1,5 +1,8 @@
 class Smartsend::Parcel
-  attr_accessor :id, :tracking_code, :tracking_url, :shipped_at, :reference, :weight, :height, :width, :length, :size, :freetext_lines, :items
+  attr_accessor :internal_id, :internal_reference, :weight, :height, :width,
+                :length, :freetext1, :freetext2, :freetext3,
+                :total_price_excluding_tax, :total_price_including_tax,
+                :total_tax_amount, :items
 
   def initialize(args={})
     args.each do |k, v|
@@ -10,23 +13,21 @@ class Smartsend::Parcel
   end
 
   def serialize
-    params = {
-      :shipdate  => @shipped_at,
-      :reference => @reference,
-      :weight    => @weight,
-      :height    => @height,
-      :width     => @width,
-      :length    => @length,
-      :size      => @size,
-      :items     => @items.map(&:serialize)
+    {
+      :internal_id               => internal_id,
+      :internal_reference        => internal_reference,
+      :weight                    => weight,
+      :height                    => height,
+      :width                     => width,
+      :length                    => length,
+      :freetext1                 => freetext1,
+      :freetext2                 => freetext2,
+      :freetext3                 => freetext3,
+      :total_price_excluding_tax => total_price_excluding_tax,
+      :total_price_including_tax => total_price_including_tax,
+      :total_tax_amount          => total_tax_amount,
+      :items                     => items.map(&:serialize)
     }
-
-    freetext_lines.to_a.each_with_index do |line, i|
-      params["freetext#{i.next}".to_sym] = line
-    end
-
-    params
-
   end
 
 end

data/lib/smartsend/parcel_item.rb

@@ -1,5 +1,9 @@
 class Smartsend::ParcelItem
-  attr_accessor :sku, :title, :quantity, :unit_weight, :unit_price, :currency
+  attr_accessor :internal_id, :internal_reference, :sku, :name, :description,
+                :hs_code, :country_of_origin, :image_url, :unit_weight,
+                :unit_price_excluding_tax, :unit_price_including_tax, :quantity,
+                :total_price_excluding_tax, :total_price_including_tax,
+                :total_tax_amount
 
   def initialize(args={})
     args.each do |k, v|
@@ -9,12 +13,21 @@ class Smartsend::ParcelItem
 
   def serialize
     {
-      :sku        => @sku,
-      :title      => @title,
-      :quantity   => @quantity,
-      :unitweight => @unit_weight,
-      :unitprice  => @unit_price,
-      :currency   => @currency
+      :internal_id               => internal_id,
+      :internal_reference        => internal_reference,
+      :sku                       => sku,
+      :name                      => name,
+      :description               => description,
+      :hs_code                   => hs_code,
+      :country_of_origin         => country_of_origin,
+      :image_url                 => image_url,
+      :unit_weight               => unit_weight,
+      :unit_price_excluding_tax  => unit_price_excluding_tax,
+      :unit_price_including_tax  => unit_price_including_tax,
+      :quantity                  => quantity,
+      :total_price_excluding_tax => total_price_excluding_tax,
+      :total_price_including_tax => total_price_including_tax,
+      :total_tax_amount          => total_tax_amount,
     }
   end
 

data/lib/smartsend/receiver.rb

@@ -1,5 +1,2 @@
 class Smartsend::Receiver < Smartsend::Address
-  def serialize
-    super.merge(receiverid: @id)
-  end
 end

data/lib/smartsend/request_error.rb

@@ -0,0 +1,13 @@
+class Smartsend::RequestError
+  attr_accessor :links, :errors, :message, :code, :id
+
+  def self.build(response)
+    self.new.tap do |error|
+      error.id = response['id']
+      error.code = response['code']
+      error.message = response['message']
+      error.links = response['links']
+      error.errors = response['errors']
+    end
+  end
+end

data/lib/smartsend/sender.rb

@@ -1,5 +1,2 @@
 class Smartsend::Sender < Smartsend::Address
-  def serialize
-    super.merge(senderid: @id)
-  end
 end

data/lib/smartsend/services.rb

@@ -0,0 +1,18 @@
+class Smartsend::Services
+  attr_accessor :email_notification, :sms_notification, :flex_delivery
+
+  def initialize(args={})
+    args.each do |k, v|
+      instance_variable_set "@#{k}", v
+    end
+  end
+
+  def serialize
+    {
+      :email_notification => email_notification,
+      :sms_notification   => sms_notification,
+      :flex_delivery      => flex_delivery
+    }
+  end
+
+end

data/lib/smartsend/shipment.rb

@@ -0,0 +1,56 @@
+class Smartsend::Shipment
+  attr_accessor :internal_id, :internal_reference, :shipping_carrier,
+                :shipping_method, :shipping_date, :sender, :receiver, :agent,
+                :parcels, :services, :sub_total_price_excluding_tax,
+                :sub_total_price_including_tax, :shipping_price_excluding_tax,
+                :shipping_price_including_tax, :total_price_excluding_tax,
+                :total_price_including_tax, :total_tax_amount, :currency,
+                :success, :label_url, :error
+
+  def initialize(args={})
+    args.each do |k, v|
+      instance_variable_set "@#{k}", v
+    end
+
+    @parcels ||= []
+  end
+
+  def success?
+    success
+  end
+
+  def save!(account: nil)
+    response = Smartsend::Client.new(account).post('shipments/labels', self.serialize)
+
+    if response.success?
+      @success = true
+      @label_url = response.dig('data', 'pdf', 'link')
+    else
+      self.error = Smartsend::RequestError.build(response)
+    end
+  end
+
+  def serialize
+    {
+      :internal_id                   => internal_id,
+      :internal_reference            => internal_reference,
+      :shipping_carrier              => shipping_carrier,
+      :shipping_method               => shipping_method,
+      :shipping_date                 => shipping_date,
+      :sender                        => sender&.serialize,
+      :receiver                      => receiver&.serialize,
+      :agent                         => agent&.serialize,
+      :parcels                       => parcels.map(&:serialize),
+      :services                      => services&.serialize,
+      :sub_total_price_excluding_tax => sub_total_price_excluding_tax,
+      :sub_total_price_including_tax => sub_total_price_including_tax,
+      :shipping_price_excluding_tax  => shipping_price_excluding_tax,
+      :shipping_price_including_tax  => shipping_price_including_tax,
+      :total_price_excluding_tax     => total_price_excluding_tax,
+      :total_price_including_tax     => total_price_including_tax,
+      :total_tax_amount              => total_tax_amount,
+      :currency                      => currency
+    }
+  end
+
+end

data/lib/smartsend/version.rb

@@ -1,3 +1,3 @@
 module Smartsend
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end