Connect a restaurant that already uses Listo

# Asks a restaurant that already runs on Listo, with an account of its own, to
# connect that account to you, and gets back the link to send its owner to.
#
# Live keys only: there is no test version of a real restaurant's real account,
# so a test key gets `not_found` here.
#
#   LISTO_API_KEY=lst_live_... ruby connect_request.rb
#
require "json"
require "net/http"
require "securerandom"
require "time"
require "uri"

BASE_URL = ENV.fetch("LISTO_API_BASE_URL", "https://api.listo.delivery")
API_KEY = ENV.fetch("LISTO_API_KEY")

# The refusal envelope every Listo error carries, or a stand-in built from the
# status when the body is not that envelope at all. Something between you and
# Listo, a proxy or a load balancer, can answer with an HTML error page or with
# JSON of some other shape, and the code that handles a failure must not itself
# fail trying to read it.
def parse_error(response)
  stand_in = {"code" => "HTTP #{response.code}", "param" => nil}
  body = JSON.parse(response.body.to_s)
  error = body["error"] if body.is_a?(Hash)
  error.is_a?(Hash) ? error : stand_in
rescue JSON::ParserError
  stand_in
end

# Your own value, sent back untouched on the redirect whichever way the owner
# decides. Keep it with the session that is asking, and when the browser comes
# back, act only on a redirect carrying the `state` you stored for it.
state = SecureRandom.urlsafe_base64(24)

uri = URI("#{BASE_URL}/v1/connect_requests")

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{API_KEY}"
request["Content-Type"] = "application/json"
request.body = JSON.generate(
  {
    # The address the restaurant's owner signs in to Listo with. Listo works
    # out which account it belongs to and tells you nothing about it here.
    "owner_email" => "rosa@lataqueria.mx",
    # Must be registered, character for character, on the Redirect URIs page
    # of the partner dashboard, or this call is refused naming `redirect_uri`.
    "redirect_uri" => "https://partner.example.com/listo/callback",
    "state" => state
  }
)

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

# Check the status BEFORE parsing the body. `error.param` names the field that
# was refused: `owner_email` when no account of its own signs in with that
# address, or more than one does; `redirect_uri` when it is not registered.
unless response.code == "201"
  error = parse_error(response)
  field = error["param"] ? " (#{error["param"]})" : ""
  abort("connect request refused: #{error["code"]}#{field}")
end

body = JSON.parse(response.body)

# `url` is the Listo page the owner signs in on and approves from. In your own
# product this is a redirect, a link or a button. It carries a token, so treat
# it like a password reset link: it goes to the owner and nowhere else, and it
# stays out of your logs. This sample prints its host and nothing more.
link = URI(body["url"])

# `expires_at` is an ISO-8601 instant in UTC, like every timestamp on this API.
# The link stops working then. Minting another one is free, so an expired link
# is a button to render again rather than an error to handle.
expires_at = Time.iso8601(body["expires_at"])
minutes_left = ((expires_at - Time.now) / 60).round

puts "send the owner to #{link.host}"
puts "the link expires in #{minutes_left} minutes"

# Trades the code an owner's approval produced for the store it connected. The
# code arrives on your redirect URI as `?code=pcc_...`, beside the `state` you
# sent when you asked for the link.
#
#   LISTO_API_KEY=lst_live_... LISTO_CONNECTION_CODE=pcc_... ruby exchange_connection.rb
#
require "json"
require "net/http"
require "uri"

BASE_URL = ENV.fetch("LISTO_API_BASE_URL", "https://api.listo.delivery")
API_KEY = ENV.fetch("LISTO_API_KEY")
CODE = ENV.fetch("LISTO_CONNECTION_CODE")

# The refusal envelope every Listo error carries, or a stand-in built from the
# status when the body is not that envelope at all. Something between you and
# Listo, a proxy or a load balancer, can answer with an HTML error page or with
# JSON of some other shape, and the code that handles a failure must not itself
# fail trying to read it.
def parse_error(response)
  stand_in = {"code" => "HTTP #{response.code}", "param" => nil}
  body = JSON.parse(response.body.to_s)
  error = body["error"] if body.is_a?(Hash)
  error.is_a?(Hash) ? error : stand_in
rescue JSON::ParserError
  stand_in
end

uri = URI("#{BASE_URL}/v1/connections")

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{API_KEY}"
request["Content-Type"] = "application/json"
request.body = JSON.generate({"code" => CODE})

# Safe to repeat. The same code answers with the same store for 24 hours from
# the approval, so an exchange whose response never reached you is retried
# rather than lost.
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
  http.request(request)
end

# Check the status BEFORE parsing the body. `code_expired` means the 24 hours
# are up, but the connection itself happened when the owner approved: read the
# store from GET /v1/stores (it was also sent to you as `store.connected`), and
# do not start a new connect request, which that account would now refuse.
# `not_found` is a code that does not exist for your key, or a test key: this
# flow is live only.
unless response.code == "201"
  abort("exchange refused: #{parse_error(response)["code"]}")
end

store = JSON.parse(response.body)

# The same store object `POST /v1/stores` answers with. Keep its `id`: it is the
# `store_id` for every delivery you send for this restaurant from now on.
puts "store #{store["id"]}"
puts "name: #{store["name"]}"

# A connected restaurant keeps its own console and its own balance, and the
# deliveries you create for it are paid from that balance.
puts "access_tier: #{store["access_tier"]}"
puts "billing: #{store["billing"]}"