workarea-flow_io 1.2.1

data/app/models/workarea/pricing/shipping_totals.decorator

@@ -0,0 +1,24 @@
+module Workarea
+  decorate Pricing::ShippingTotals, with: :flow_io do
+    def total
+      super
+
+      return unless @shipping.experience.present?
+
+      set_flow_shipping_total
+      set_flow_tax_total
+    end
+
+    def flow_price_adjustments
+      @flow_price_adjustments ||= PriceAdjustmentSet.new(@shipping.flow_price_adjustments)
+    end
+
+    def set_flow_shipping_total
+      @shipping.flow_shipping_total = flow_price_adjustments.adjusting('shipping').sum
+    end
+
+    def set_flow_tax_total
+      @shipping.flow_tax_total = flow_price_adjustments.adjusting('tax').sum
+    end
+  end
+end

data/app/models/workarea/pricing/sku.decorator

@@ -0,0 +1,46 @@
+module Workarea
+  decorate Pricing::Sku, with: :flow_io do
+    decorated do
+      embeds_many :flow_io_local_items, class_name: "Workarea::FlowIo::LocalItem"
+    end
+
+    # @return Money
+    def msrp_for_experience(experience)
+      local_item = flow_io_local_items.detect do |item|
+        item.experience.key == experience.key
+      end
+
+      local_item&.msrp&.price
+    end
+
+    # Find the price to sell at for a specific options.
+    #
+    # Takes options :quantity, :experience (::Io::Flow::V0::Models::ExperienceSummary || ::Io::Flow::V0::Models::ExperienceGeo)
+    #
+    # @param [Hash]
+    # @return [Pricing::Price]
+    #
+    def find_price(options = {})
+      return super unless options[:experience].present?
+
+      quantity = options[:quantity] || 1
+
+      local_item = flow_io_local_items.detect do |item|
+        item.experience.key == options[:experience].key
+      end
+
+      local_item&.to_price(quantity) ||
+        Pricing::Price.new(regular: 0.to_m(options[:experience].currency))
+    end
+
+    # @param Io::Flow::V0::Models::Item
+    def import_flow_item(flow_item)
+      local_item = flow_io_local_items.detect { |li| li.experience.key == flow_item.local.experience.key } ||
+        flow_io_local_items.new
+
+      local_item.update_from_flow_item(flow_item)
+
+      Sidekiq::Callbacks.disable(Workarea::FlowIo::ItemExporter) { save! }
+    end
+  end
+end

data/app/models/workarea/search/settings.decorator

@@ -0,0 +1,8 @@
+module Workarea
+  decorate Search::Settings, with: :flow_io do
+    decorated do
+      # price facets for currencies other than the default transacting currency
+      field :currency_localized_facets, type: Hash, default: {}
+    end
+  end
+end

data/app/models/workarea/search/storefront/product.decorator

@@ -0,0 +1,25 @@
+module Workarea
+  decorate Search::Storefront::Product, with: :flow_io do
+    def numeric
+      super.merge(localized_selling_prices)
+    end
+
+    def sorts
+      super.merge(localized_sort_prices)
+    end
+
+    private
+
+      def localized_sort_prices
+        pricing.localized_min_sell_prices.map do |experience_key, price|
+          ["price_#{experience_key}".systemize, price]
+        end.to_h
+      end
+
+      def localized_selling_prices
+        pricing.localized_selling_prices.map do |experience_key, prices|
+          ["price_#{experience_key}".systemize, prices.compact.uniq]
+        end.to_h
+      end
+  end
+end

data/app/models/workarea/shipping.decorator

@@ -0,0 +1,28 @@
+module Workarea
+  decorate Shipping, with: :flow_io do
+    decorated do
+      field :flow_shipping_total, type: Money
+      field :flow_tax_total, type: Money
+      field :delivery_duty, type: String
+
+      embeds_one :experience, class_name: "Workarea::FlowIo::ExperienceGeo", as: :experienceable
+
+      embeds_many :flow_price_adjustments,
+        class_name: 'Workarea::PriceAdjustment',
+        extend: PriceAdjustmentExtension
+    end
+
+    def adjust_flow_pricing(options = {})
+      flow_price_adjustments.build(options)
+    end
+
+    # @param ::Io::Flow::V0::Models::DeliveryOption flow_shipping_method
+    def set_flow_shipping!(flow_shipping_method)
+      # clear the default shipping service.
+      self.shipping_service = nil
+      self.delivery_duty = flow_shipping_method.delivered_duty.value
+      self.build_shipping_service(name: flow_shipping_method.tier.name)
+      save!
+    end
+  end
+end

data/app/queries/workarea/order_metrics.decorator

@@ -0,0 +1,23 @@
+module Workarea
+  decorate OrderMetrics, with: :flow do
+    def discount_adjustments
+      return super unless order.flow?
+
+      PriceAdjustmentSet.new(all_price_adjustments.discounts.flat_map do |adjustment|
+        next adjustment unless adjustment.data['original_discounts'].present?
+
+        adjustment.data['original_discounts'].map do |adjustment_hash|
+          amount = Money.demongoize(adjustment_hash["amount"])
+
+          PriceAdjustment.new(
+            amount: amount,
+            quantity: adjustment_hash["quantity"],
+            data: {
+              "discount_id" => adjustment_hash["id"]
+            }
+          )
+        end
+      end)
+    end
+  end
+end

data/app/queries/workarea/search/product_search.decorator

@@ -0,0 +1,14 @@
+module Workarea
+  decorate Search::ProductSearch, with: :flow_io do
+    def selected_sort
+      return super unless params[:experience].present? &&
+        (params[:sort] == "price_asc" || params[:sort] == "price_desc")
+
+      if params[:sort] == "price_asc"
+        Sort.new(I18n.t('workarea.sorts.price_asc'), :price_asc, :"sorts.price_#{params[:experience].key.systemize}", :asc)
+      elsif params[:sort] == "price_desc"
+        sort.new(I18n.t('workarea.sorts.price_asc'), :price_asc, :"sorts.price_#{params[:experience].key.systemize}", :asc)
+      end
+    end
+  end
+end

data/app/queries/workarea/search/storefront_search/response.decorator

@@ -0,0 +1,40 @@
+module Workarea
+  decorate Search::StorefrontSearch::Response, with: :flow_io do
+    decorated { attr_reader :experience }
+
+    def initialize(options = {})
+      @template = options.fetch(:template, 'show')
+      @message = options[:message]
+      @redirect = options[:redirect]
+
+      @params = options.fetch(:params, {})
+      @experience = @params[:experience]
+      @params[:terms_facets] = terms_facets
+      @params[:range_facets] = range_facets
+      @params[:experience] = options[:experience]
+      @original_params = @params.deep_dup
+
+      @customization = options[:customization]
+      @trace = []
+
+      reset!(@params)
+    end
+
+
+    private
+
+    def default_range_facets
+      Search::Settings.current.range_facets
+    end
+
+    def range_facets
+      return default_range_facets unless experience.present?
+
+      localized_price_facets = Search::Settings.current.currency_localized_facets.fetch(experience.currency, {})
+
+      default_range_facets
+        .except("price")
+        .merge("price-#{experience.key}" => localized_price_facets)
+    end
+  end
+end

data/app/services/workarea/flow_io/checkout.rb

@@ -0,0 +1,242 @@
+module Workarea
+  module FlowIo
+    class Checkout
+      include Workarea::ApplicationHelper
+
+      attr_reader :order, :flow_order
+
+      # @param flow_order [::Io::Flow::V0::Models::Order]
+      # @param order [::Workarea::Order]
+      #
+      def initialize(flow_order, order)
+        @order = order
+        @flow_order = flow_order
+      end
+
+      def place_order
+        return false unless shipping.valid?
+        return false unless payment.valid?
+
+        inventory.purchase
+        return false unless inventory.captured?
+
+        result = order.place
+
+        if result
+          CreateFulfillment.new(order).perform
+        end
+
+        result
+      end
+
+      def build
+        order.update_attributes!(
+          experience: {
+            key: experience.key,
+            name: experience.name,
+            region: experience.region.to_hash,
+            country: experience.country,
+            currency: experience.currency,
+            language: experience.language,
+            measurement_system: experience.measurement_system
+          },
+          flow: true,
+          email: customer.email
+        )
+
+        FlowIo::PriceApplier.perform(order: pricing_order, flow_order: flow_order, shipping: pricing_shipping)
+        shipping.update_attributes!(pricing_shipping.as_document)
+
+        # set the shipping service.
+        shipping.set_flow_shipping!(flow_shipping_method)
+
+        # set the shipping and billing addresses
+        shipping.set_address(shipping_address_params(flow_order.destination))
+        payment.set_address(billing_address_params(flow_billing_address))
+
+        # use the flow payment processor for this order going forward.
+        # this allows for using a differnt payment processor for
+        # domestic orders
+        payment.operation_tender_type = 'FlowPayment'
+
+        # build a flow payment so we can refund later if needed.
+        flow_payments.each do |flow_payment|
+          payment.build_flow_payment(
+            details: flow_payment.to_hash,
+            payment_type: flow_payment.type,
+            description: flow_payment.description,
+            amount: Money.from_amount(flow_payment.total.base.amount, flow_payments.first.total.base.currency),
+            flow_amount: Money.from_amount(flow_payment.total.amount, flow_payments.first.total.currency)
+          )
+        end
+
+        # build a capture transaction for each
+        payment.tenders.each do |tender|
+
+          response = ActiveMerchant::Billing::Response.new(
+            true,
+            'Flow Payment Transaction',
+            { response: tender.details }
+          )
+          transaction = payment.flow_payment.build_transaction(
+            tender_id: tender.id.to_s,
+            action: Workarea.config.flow_io.default_payment_action,
+            amount: tender.amount,
+            flow_amount: tender.flow_amount,
+            success: true,
+            response: response
+          )
+
+          transaction.save!
+        end
+
+        payment.save!
+
+        total_order
+
+        order.update_attributes!(pricing_order.as_document.reverse_merge(items: []))
+      end
+
+      private
+
+        def experience
+          @experience ||=
+            Workarea::FlowIo.client.experiences.get_by_key(
+              Workarea::FlowIo.organization_id,
+              flow_order.experience.key
+          )
+        end
+
+        # creates a clone of the persisted shipping
+        def pricing_shipping
+          @pricing_shipping ||=
+            begin
+              result = shipping.clone
+              result.id = shipping.id # Ensure this isn't persisted
+              result.reset_adjusted_shipping_pricing
+              result
+            end
+        end
+
+        def pricing_order
+          @pricing_order ||=
+            begin
+              result = @order.clone
+              result.id = @order.id # Ensure this isn't persisted
+              result.attributes = clone_order_attributes
+              result
+            end
+        end
+
+        def clone_order_attributes
+          @order.as_document.except('_id', 'id')
+        end
+
+        def shipping_address_params(address)
+          country = Country.find_country_by_alpha3(address.country)
+          region = get_region_by_name(country, address.province)
+
+          {
+            first_name: address.contact.name.first,
+            last_name: address.contact.name.last,
+            street: address.streets.first,
+            street_2: address.streets.second,
+            city: address.city,
+            region: region,
+            postal_code: address.postal,
+            country: country,
+            phone_number: address.contact.phone,
+            flow: true
+          }
+        end
+
+        def billing_address_params(address)
+          country = Country.find_country_by_alpha3(address.country)
+          region = get_region_by_name(country, address.province)
+          {
+            first_name: customer.name.first,
+            last_name: customer.name.last,
+            street: address.streets.first,
+            street_2: address.streets.second,
+            city: address.city,
+            region: region,
+            postal_code: address.postal,
+            country: country,
+            flow: true
+          }
+        end
+
+        def flow_payments
+          flow_order.payments
+        end
+
+        def customer
+          @customer ||= flow_order.customer
+        end
+
+        def get_region_by_name(country, region_name)
+          reg, _reg_struct = country.subdivisions.detect { |k, v| v.name == region_name }
+          reg
+        end
+
+        def flow_shipping_method_ids
+          @flow_shipping_method_ids ||= flow_order.selections
+        end
+
+        # @return ::Io::Flow::V0::Models::DeliveryOption
+        def flow_shipping_method
+          method_id = flow_shipping_method_ids.first
+
+          delivery = flow_order.deliveries.detect do |d|
+            d.options.detect do  |o|
+              o.id == method_id
+            end
+          end
+
+          delivery.options.detect { |o|  o.id == method_id }
+        end
+
+        def payment
+          @payment ||= Payment.find_or_create_by(id: order.id)
+        end
+
+        def shipping
+          @shippipng ||=
+          begin
+            # get rid of anything that could be a holdover from the
+            # workarea checkout
+            Workarea::Shipping.where(order_id: order.id).destroy_all
+            Shipping.create(order_id: order.id)
+          end
+        end
+
+        # @return [::Io::Flow::V0::Models::OrderPriceDetail]
+        def flow_shipping_prices
+          flow_order.prices.reject { |p| p.name == 'Item subtotal' }
+        end
+
+        def total_order
+          Pricing::ShippingTotals.new(shipping).total
+          Pricing::OrderTotals.new(pricing_order, [shipping]).total
+
+          order.save!
+          shipping.save!
+        end
+
+        def inventory
+          @inventory ||= Inventory::Transaction.from_order(
+            order.id,
+            order.items.inject({}) do |memo, item|
+              memo[item.sku] ||= 0
+              memo[item.sku] += item.quantity
+              memo
+            end
+          )
+        end
+
+        def flow_billing_address
+          flow_payments.first.address || flow_order.destination
+        end
+    end
+  end
+end