Flow is the next-generation solution for simplifying global e-commerce.

Landed Cost Ruby
# Products in Flow are localized (duty, tax, and currency calculated) by
# experience; usually by country. The ruby code below will find the
# best experience and localized items for Canada, in this example.
 
require 'flowcommerce'
 
ORG = 'playground'
client = FlowCommerce.instance(:token = 'HlGgfflLamiTQJ')
 
client.experiences.get_items(ORG, :country ='CAN', :number = ['sku-1', 'sku-2']).each do |i|
puts i.number
i.local.prices.each do |price|
case price.key
when localized_item_price
puts - Price: #{price.label}
when localized_item_vat
puts - #{price.name}: #{price.label}
when localized_item_duty
puts - Duty: #{price.label}
end
end
end

Landed Cost Scala
# Products in Flow are localized (duty, tax, and currency calculated) by
# experience; usually by country. The scala code below will find the
# best experience and localized items for Canada, in this example.
 
import io.flow.v0.{Authorization, Client}
import io.flow.v0.models._
 
object Main extends App {
 
import scala.concurrent.ExecutionContext.Implicits.global
 
val client = new Client(auth = Some(Authorization.Basic(HlGgfflLamiTQJ)))
val org = playground
 
client.experiences.getItems(
org,
country = Some(CAN),
number = Some(Seq(sku-1, sku-2))
).map { items =
 
items.foreach { i =
println(i.number)
i.local.map(_.prices).get foreach {
case p: LocalizedItemPrice =
println(s - Price: ${p.label})
 
case p: LocalizedItemVat =
println(s - ${p.name}: ${p.label})
 
case p: LocalizedItemDuty =
println(s - Duty: ${p.label})
 
case p: LocalizedTotal =
println(s- Total: ${p.label})
 
case LocalizedPriceUndefinedType(_) =
// Placeholder for future types
}
}
 
client.closeAsyncHttpClient()
 
}
 
}

Payments Ruby
# Add a card
 
require 'flowcommerce'
 
ORG = 'playground'
client = FlowCommerce.instance(:token = 'HlGgfflLamiTQJ')
 
card = client.cards.post(ORG,
::Io::Flow::V0::Models::CardForm.new(
:number = 4012888888881881,
:name = Joe Smith,
:expiration_month = 1,
:expiration_year = 2020,
:cvv = 737
)
)
 
puts Card created - secure token is: %s % card.token
 
auth = client.authorizations.post(ORG,
::Io::Flow::V0::Models::MerchantOfRecordAuthorizationForm.new(
:order_number = 'R726941',
:token = card.token
)
)
 
puts Authorization created for %s %s [id: %s] % [auth.amount, auth.currency, auth.id]
 
capture = client.captures.post(ORG,
::Io::Flow::V0::Models::CaptureForm.new(
:authorization_id = auth.id
))
puts Capture created for %s %s [id: %s] % [capture.amount, capture.currency, capture.id]

Payments Scala
# Add a card
import io.flow.v0.{Authorization, Client}
import io.flow.v0.models._
 
object Main extends App {
 
import scala.concurrent.ExecutionContext.Implicits.global
 
val client = new Client(auth = Some(Authorization.Basic(HlGgfflLamiTQJ)))
val org = playground
 
import scala.concurrent.Future
 
for {
card - client.cards.post( org, CardForm( number = Some(4012888888881881), name = Joe Smith, expirationMonth = 1, expirationYear = 2020, cvv = 737 ) ).recoverWith { case ex = Future.successful {
client.closeAsyncHttpClient()
println(s ERROR: ${ex})
throw ex
}
}
 
auth - client.authorizations.post( org, MerchantOfRecordAuthorizationForm( orderNumber = R726941, token = card.token ) ).recoverWith { case ex = Future.successful {
client.closeAsyncHttpClient()
println(s ERROR: ${ex})
throw ex
}
}
 
capture - client.captures.post( org, CaptureForm( authorizationId = auth.id ) ).recoverWith { case ex = Future.successful {
client.closeAsyncHttpClient()
println(s ERROR: ${ex})
throw ex
}
}
 
} yield {
println(s Card created - secure token is ${card.token})
println(s Authorization created for ${auth.amount} ${auth.currency} [id ${auth.id}])
println(s Capture created for ${capture.amount} ${capture.currency} [id ${capture.id}])
 
client.closeAsyncHttpClient()
}
 
}

Orders Ruby
# Create an order with two units of sku-2
 
require 'flowcommerce'
 
ORG = 'playground'
client = FlowCommerce.instance(:token = 'HlGgfflLamiTQJ')
 
order = client.orders.put_by_number(ORG, 'R726941',
::Io::Flow::V0::Models::OrderPutForm.new(
:items = [
{ :number = sku-2, :quantity = 2 }
],
:destination ={
:streets = [123 Yonge Street],
:city = Toronto,
:province = Ontario,
:postal = M5C 1W4,
:country = CAN
}
),
:country = CAN
)
 
puts Order %s % order.number
order.prices.each do |p|
puts - #{p.name}: #{p.label}
end
puts - TOTAL: #{order.total.label}

Orders Scala
# Create an order with two units of sku-2
 
import io.flow.v0.{Authorization, Client}
import io.flow.v0.models._
 
object Main extends App {
 
import scala.concurrent.ExecutionContext.Implicits.global
 
val client = new Client(auth = Some(Authorization.Basic(HlGgfflLamiTQJ)))
val org = playground
 
client.orders.putByNumber(
org,
R726941,
orderPutForm = OrderPutForm(
items = Seq(
LineItemForm(number = sku-2, quantity = 2)
),
destination = Some(
OrderAddress(
streets = Some(Seq(123 Yonge Street)),
city = Some(123 Yonge Street),
province = Some(Ontario),
postal = Some(M5C 1W4),
country = Some(CAN)
)
)
),
country = Some(CAN)
).map { order =
 
println(Order ${order.number})
 
order.prices.foreach { p =
println(s - ${p.name.getOrElse(price)}: ${p.label})
}
 
println(s - TOTAL: ${order.total.label})
 
client.closeAsyncHttpClient()
}
 
}