workarea-flow_io 1.2.1

data/config/routes.rb

@@ -0,0 +1,21 @@
+Workarea::Storefront::Engine.routes.draw do
+  post :flow_webhook, as: :flow_io_webhook, controller: 'flow_io_webhook', action: 'event'
+end
+
+Workarea::Admin::Engine.routes.draw do
+  scope '(:locale)', constraints: Workarea::I18n.routes_constraint do
+    resources :flow_imports, only: :index
+
+    resources :orders, only: [] do
+      member do
+        get :flow
+      end
+    end
+
+    resources :pricing_skus, only: [] do
+      member do
+        get :flow
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/bogus_flow_gateway.rb

@@ -0,0 +1,16 @@
+module ActiveMerchant
+  module Billing
+    class BogusFlowGateway < BogusGateway
+      def store(paysource, options = {})
+        case normalize(paysource)
+        when /1$/
+          Response.new(true, SUCCESS_MESSAGE, { token: '1' }, test: true, authorization: AUTHORIZATION)
+        when /2$/
+          Response.new(false, FAILURE_MESSAGE, { token: nil, error: FAILURE_MESSAGE }, test: true, error_code: STANDARD_ERROR_CODE[:processing_error])
+        else
+          raise Error, error_message(paysource)
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/flow_gateway.rb

@@ -0,0 +1,48 @@
+module ActiveMerchant
+  module Billing
+    module FlowGatewayFixes
+      FORM_TYPES = [
+        :authorization_copy_form, :direct_authorization_form, :merchant_of_record_authorization_form,
+        :paypal_authorization_form, :redirect_authorization_form, :inline_authorization_form,
+        :card_authorization_form, :ach_authorization_form
+      ]
+
+      def purchase(credit_card, order_number, options = {})
+        response = authorize(credit_card, order_number, options)
+        capture(options[:amount], response.authorization, options)
+      end
+
+      # Create a new authorization.
+      # https://docs.flow.io/module/payment/resource/authorizations#post-organization-authorizations
+      def authorize(cc_or_token, order_number, opts = {})
+        unless opts[:currency]
+          return error_response('Currency is a required option')
+        end
+
+        unless opts[:discriminator]
+          return error_response 'Discriminator is not defined, please choose one [%s]' % FORM_TYPES.join(', ')
+        end
+
+        unless FORM_TYPES.include?(opts[:discriminator].to_sym)
+          return error_response 'Discriminator [%s] not found, please choose one [%s]' % [opts[:discriminator], FORM_TYPES.join(', ')]
+        end
+
+        body = {
+          amount:        opts[:amount] || 0.0,
+          currency:      opts[:currency],
+          discriminator: opts[:discriminator],
+          token:         store(cc_or_token),
+          order_number:  order_number
+        }
+
+        response = flow_instance.authorizations.post @flow_organization, body
+
+        # This is the only changed line, it just sets the response.id as Response#authorizzation
+        Response.new true, 'Flow authorize - Success', { response: response }, { authorization: response.id }
+      rescue => exception
+        error_response exception
+      end
+    end
+    FlowGateway.prepend FlowGatewayFixes
+  end
+end

data/lib/tasks/flow_io.rake

@@ -0,0 +1,117 @@
+namespace :workarea do
+  namespace :flow_io do
+    desc 'export products'
+    task export_products: :environment do
+      puts "Exporting products..."
+      client = FlowCommerce.instance(token: Workarea::FlowIo.api_token)
+      organization_id = Workarea::FlowIo.organization_id
+
+      Workarea::Catalog::Product.all.each_by(100) do |product|
+        product.variants.each do |variant|
+          item = Workarea::FlowIo::Item.new(product, variant.sku)
+
+          puts "Adding #{variant.sku}"
+          client.items.put_by_number(organization_id, variant.sku, item.form)
+        end
+      end
+    end
+
+    desc 'create localization attributes'
+    task create_localization_attributes: :environment do
+      puts "Creating localization attributes..."
+      client = Workarea::FlowIo.client
+      organization_id = Workarea::FlowIo.organization_id
+
+      Workarea::FlowIo.config.localization_attributes.each do |localization_attribute|
+        puts "Adding attribute #{localization_attribute[:label]}"
+        client.attributes.put_by_key(
+          organization_id,
+          localization_attribute[:key],
+          localization_attribute
+        )
+      end
+    end
+
+    desc 'create webhooks'
+    task create_webhooks: :environment do
+      puts "Creating webhook shared secret..."
+      client = Workarea::FlowIo.client
+      secret = Workarea::FlowIo::Webhook::SharedSecret.first_or_create!
+      organization_id = Workarea::FlowIo.organization_id
+      client.webhook_settings.put(
+        organization_id,
+        secret: secret.token,
+        retry_max_attempts: 5,
+        retry_sleep_ms: 30,
+        sleep_ms: 30
+      )
+
+      puts "Creating webhooks..."
+      host = Workarea.config.host
+
+      webhook_url = Workarea::Storefront::Engine
+        .routes
+        .url_helpers
+        .flow_io_webhook_url(host: host, protocol: "https")
+
+      client.webhooks.post(
+        organization_id,
+        Io::Flow::V0::Models::WebhookForm.new(
+          events: Workarea::FlowIo.config.webhook_events,
+          url: webhook_url
+        )
+      )
+    end
+
+    desc 'Initialize Flow Plugin'
+    task install: :environment do
+      Rake::Task['workarea:flow_io:create_localization_attributes'].execute
+      Rake::Task['workarea:flow_io:create_webhooks'].execute
+      Rake::Task['workarea:flow_io:export_products'].execute
+    end
+
+    desc 'Delete items'
+    task delete_products: :environment do
+      client = FlowCommerce.instance(token: Workarea::FlowIo.api_token)
+      organization_id = Workarea::FlowIo.organization_id
+
+      Workarea::Catalog::Product.all.each_by(100) do |product|
+
+        product.variants.each do |variant|
+          client.items.delete_by_number(organization_id, variant.sku)
+        end
+      end
+    end
+
+    desc 'import local items'
+    task import_local_items: :environment do
+      organization = Workarea::FlowIo.organization_id
+      experiences = Workarea::FlowIo.client.experiences.get(organization)
+
+      experiences.each do |experience|
+        next unless experience.status.value == "active"
+
+        page_size  = 100
+        offset     = 0
+        items      = []
+
+        while offset == 0 || items.length == 100
+          # show current list size
+          puts "\nGetting items: %s, rows %s - %s" % [experience.key, offset, offset + page_size]
+
+          items = Workarea::FlowIo.client.experiences.get_items organization, experience: experience.key, limit: page_size, offset: offset
+          offset += page_size
+
+          items.each do |item|
+            puts item.number
+            begin
+              Workarea::FlowIo::ItemImporter.perform!(item)
+            rescue Mongoid::Errors::DocumentNotFound => _error
+              puts "Missing pricing sku: #{item.number}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workarea/flow_io.rb

@@ -0,0 +1,73 @@
+require 'flowcommerce'
+require 'flowcommerce-activemerchant'
+require 'active_merchant/billing/bogus_flow_gateway'
+require 'active_merchant/billing/flow_gateway'
+require 'net/sftp'
+
+require 'workarea'
+require 'workarea/storefront'
+require 'workarea/admin'
+require 'workarea/freedom_patches/flow_io'
+require 'workarea/flow_io/controller_log_subscriber'
+
+require 'workarea/flow_io/engine'
+require 'workarea/flow_io/version'
+require 'workarea/flow_io/http_handler'
+require 'workarea/flow_io/bogus_client'
+
+module Workarea
+  module FlowIo
+    FTP_HOST = 'ftp.flow.io'
+
+    def self.credentials
+      (Rails.application.secrets.flow_io || config.to_h).deep_symbolize_keys
+    end
+
+    def self.config
+      Workarea.config.flow_io
+    end
+
+    def self.api_token
+      credentials[:api_token]
+    end
+
+    def self.organization_id
+      credentials[:organization_id]
+    end
+
+    def self.image_sizes
+      config.image_sizes
+    end
+
+    def self.client(timeout: nil, open_timeout: nil, read_timeout: nil, logger: nil, **options)
+      timeout ||= config.default_timeout
+      read_timeout ||= timeout
+      open_timeout ||= timeout
+
+      if api_token.present?
+        FlowCommerce.instance(
+          token: Workarea::FlowIo.api_token,
+          http_handler: Workarea::FlowIo::HttpHandler.new(open_timeout: open_timeout, read_timeout: read_timeout, logger: logger, **options)
+        )
+      else
+        FlowIo::BogusClient.new
+      end
+    end
+
+    def self.webhook_shared_secret
+      Workarea::FlowIo::Webhook::SharedSecret.first.try(:token)
+    end
+
+    # Conditionally use the real gateway when secrets are present.
+    # Otherwise, use the bogus gateway.
+    #
+    # @return [ActiveMerchant::Billing::Gateway]
+    def self.gateway
+      if credentials.present?
+        ActiveMerchant::Billing::FlowGateway.new(api_key: Workarea::FlowIo.api_token, organization: Workarea::FlowIo.organization_id)
+      else
+        ActiveMerchant::Billing::BogusGateway.new
+      end
+    end
+  end
+end

data/lib/workarea/flow_io/bogus_client.rb

@@ -0,0 +1,57 @@
+module Workarea
+  module FlowIo
+    class BogusClient
+      require 'workarea/flow_io/bogus_client/proxy_client'
+      require 'workarea/flow_io/bogus_client/checkout_tokens'
+      require 'workarea/flow_io/bogus_client/experiences'
+      require 'workarea/flow_io/bogus_client/fulfillments'
+      require 'workarea/flow_io/bogus_client/items'
+      require 'workarea/flow_io/bogus_client/orders'
+      require 'workarea/flow_io/bogus_client/organizations'
+      require 'workarea/flow_io/bogus_client/sessions'
+      require 'workarea/flow_io/bogus_client/shipping_notifications'
+      require 'workarea/flow_io/bogus_client/webhooks'
+      require 'workarea/flow_io/bogus_client/webhook_settings'
+
+      thread_cattr_accessor :requests, :store_requests
+
+
+      def self.reset_requests!
+        self.requests = Hash.new do |client_hash, client_class|
+          client_hash[client_class] = Hash.new do |method_hash, method_name|
+            method_hash[method_name] = []
+          end
+        end
+      end
+
+      def self.total_request_count
+        self.requests.sum do |client, method_calls|
+          method_calls.sum { |_method, calls| calls.size }
+        end
+      end
+
+      self.store_requests = false
+      self.reset_requests!
+
+      def method_missing(method)
+        client_class = client(method)
+
+        if client_class
+          ProxyClient.new(method, client_class.new)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_all = false)
+        client(method).present? || super
+      end
+
+      private
+
+        def client(client_name)
+          BogusClient.const_get(client_name.to_s.camelize) rescue nil
+        end
+    end
+  end
+end

data/lib/workarea/flow_io/bogus_client/checkout_tokens.rb

@@ -0,0 +1,25 @@
+module Workarea
+  module FlowIo
+    class BogusClient
+      class CheckoutTokens
+        def post_checkout_and_tokens_by_organization(organization, checkout_token_form)
+          unless checkout_token_form.is_a? ::Io::Flow::V0::Models::CheckoutTokenForm
+            checkout_token_form = ::Io::Flow::V0::Models::CheckoutTokenForm.new(checkout_token_form)
+          end
+
+          ::Io::Flow::V0::Models::CheckoutToken.new(
+            id: SecureRandom.hex(20),
+            organization: { id: organization },
+            order: { number: checkout_token_form.order_number },
+            session: { id: checkout_token_form.session_id },
+            urls: {
+              continue_shopping: checkout_token_form.urls.continue_shopping
+            },
+            expires_at: 1.day.from_now.utc.iso8601(3),
+            checkout: { id: 'foo' }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/workarea/flow_io/bogus_client/experiences.rb

@@ -0,0 +1,152 @@
+module Workarea
+  module FlowIo
+    class BogusClient
+      class Experiences
+        def get(_organization_id)
+          [canada_experience, canada_2_experience, china_experience, europe_experience]
+        end
+
+        # @param organization_id [String]
+        # @param key [String]
+        #
+        def get_by_key(_organization_id, key)
+          case key
+          when "canada" then canada_experience
+          when "canada2" then canada_2_experience
+          when "china" then china_experience
+          when "europe" then europe_experience
+          else europe_experience
+          end
+        end
+
+        private
+
+          def china_experience
+            ::Io::Flow::V0::Models::Experience.new(
+              "id" => "exp-5af698539a884d568dcdb950ed01521c",
+              "key" => "china",
+              "name" => "China",
+              "delivered_duty" => "paid",
+              "region" => { "id" => "chn" },
+              "country" => "CHN",
+              "currency" => "CNY",
+              "language" => "zh",
+              "measurement_system" => "metric",
+              "subcatalog" => {
+                "id" => "sca-c06ac78fe14c4618b025d922bb1b5594",
+                "discriminator" => "subcatalog_reference"
+              },
+              "position" => 2,
+              "settings" => {
+                "delivered_duty" => {
+                  "default" => "paid",
+                  "available" => ["paid", "unpaid"],
+                  "display" => "all"
+                },
+                "pricing_settings" => {
+                  "editable" => true,
+                  "default_tax_display" => "included",
+                  "default_duty_display" => "ignored"
+                },
+                "logistics_settings" => { "shipping_configuration" => { "key" => "001" } },
+                "checkout_settings" => {
+                  "configuration" => { "id" => "chc-5dd603d15c9c4f5fbf8c96b98d66eeda" }
+                }
+              },
+              "status" => "active",
+              "discriminator" => "experience"
+            )
+          end
+
+          def europe_experience
+            ::Io::Flow::V0::Models::Experience.new(
+              "id" => "exp-5af698539a884d568dcdb950ed01521c",
+              "key" => "europe",
+              "name" => "Europe",
+              "delivered_duty" => "paid",
+              "region" => { "id" => "eur" },
+              "country" => "GBR",
+              "currency" => "EUR",
+              "language" => "eu",
+              "measurement_system" => "metric",
+              "subcatalog" => {
+                "id" => "sca-c06ac78fe14c4618b025d922bb1b5594",
+                "discriminator" => "subcatalog_reference"
+              },
+              "position" => 2,
+              "settings" => {
+                "delivered_duty" => {
+                  "default" => "paid",
+                  "available" => ["paid", "unpaid"],
+                "display" => "all"
+                },
+                "pricing_settings" => {
+                  "editable" => true,
+                  "default_tax_display" => "included",
+                  "default_duty_display" => "ignored"
+                },
+                "logistics_settings" => { "shipping_configuration" => { "key" => "001" } },
+                "checkout_settings" => {
+                  "configuration" => { "id" => "chc-5dd603d15c9c4f5fbf8c96b98d66eeda" }
+                }
+              },
+              "status" => "active",
+              "discriminator" => "experience"
+            )
+          end
+
+          def canada_experience
+            ::Io::Flow::V0::Models::Experience.new(
+              id: "exp-95889ba1ff4b449f8a3c0e0a7a4fb23b",
+              key: "canada",
+              name: "Canada",
+              delivered_duty: "paid",
+              region: { id: "can" },
+              country: "CAN",
+              currency: "CAD",
+              language: "en",
+              measurement_system: "metric",
+              subcatalog: { id: "sca-e866a54205db401ca0d5add025d4706b",
+              discriminator: "subcatalog_reference" },
+              position: 0,
+              settings: {
+                delivered_duty: {
+                  default: "paid",
+                  available: ["paid", "unpaid"],
+                  display: "all"
+                }
+              },
+              status: "active",
+              discriminator: "experience"
+            )
+          end
+
+          def canada_2_experience
+            ::Io::Flow::V0::Models::Experience.new(
+              id: "exp-2d65a4a036e9480196bc36554b6a2b99",
+              key: "canada-2",
+              name: "Canada 2",
+              delivered_duty: "paid",
+              region: { id: "can" },
+              country: "CAN",
+              currency: "CAD",
+              language: "en",
+              measurement_system: "metric",
+              subcatalog: { id: "sca-fc951797454d4431a4d73efee56f3d67",
+              discriminator: "subcatalog_reference" },
+              position: 1,
+              settings: {
+                delivered_duty: {
+                  default: "paid",
+                  available: ["paid", "unpaid"],
+                  display: "all"
+                }
+              },
+              status: "active",
+              discriminator: "experience"
+            )
+          end
+      end
+    end
+  end
+end