Flow the next generation for cross-border 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(s"Order ${order.number}")
 
 order.prices.foreach { p =>
 println(s" - ${p.name.getOrElse("price")}: ${p.label}")
 }
 
 println(s" - TOTAL: ${order.total.label}")
 
 client.closeAsyncHttpClient()
 }

}