workarea-flow_io 1.2.1

data/app/models/workarea/payment/refund/flow_payment.rb

@@ -0,0 +1,42 @@
+module Workarea
+  class Payment
+    class Refund
+      class FlowPayment
+        include OperationImplementation
+        include FlowPaymentOperation
+        include FlowPaymentData
+
+        def complete!
+          validate_reference!
+
+          transaction.response = handle_active_merchant_errors do
+            gateway.refund(
+              transaction.amount.to_f,
+              nil,
+              transaction_options
+            )
+          end
+        end
+
+        def cancel!
+          # noop
+        end
+
+        private
+
+        def transaction_options
+          {
+            currency: currency_code,
+            authorization_id: authorization
+          }
+        end
+
+        def authorization
+          response = transaction.reference.response.params["response"]
+
+          response["authorization"].present? ? response["authorization"]["id"] : response["reference"]
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment/store_flow_credit_card.rb

@@ -0,0 +1,34 @@
+module Workarea
+  class Payment
+    class StoreFlowCreditCard
+      include FlowPaymentOperation
+
+      def initialize(credit_card, options = {})
+        @credit_card = credit_card
+        @options = options
+      end
+
+      def perform!
+        return true if @credit_card.token.present?
+
+        response = handle_active_merchant_errors do
+          gateway.store(@credit_card.to_active_merchant)
+        end
+
+        # gateway will return a string if successful and an
+        # active merchant error if it fails
+        if response.is_a? String
+          @credit_card.token = response
+          true
+        else
+          false
+        end
+      end
+
+      def save!
+        perform!
+        @credit_card.save
+      end
+    end
+  end
+end

data/app/models/workarea/payment/tender.decorator

@@ -0,0 +1,8 @@
+module Workarea
+  decorate Payment::Tender, with: :flow_io do
+    decorated do
+      field :flow_amount, type: Money, default: 0
+    end
+  end
+end
+

data/app/models/workarea/payment/tender/flow_payment.rb

@@ -0,0 +1,15 @@
+module Workarea
+  class Payment
+    class Tender
+      class FlowPayment < Tender
+        field :details, type: Hash
+        field :payment_type, type: String
+        field :description, type: String
+
+        def slug
+          :flow_payment
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment/transaction.decorator

@@ -0,0 +1,12 @@
+module Workarea
+  decorate Payment::Transaction, with: :flow_io do
+    decorated do
+      field :flow_amount, type: Money, default: 0
+    end
+
+    def tender_type
+      tender.payment.operation_tender_type ||  super
+    end
+  end
+end
+

data/app/models/workarea/pricing/calculators/flow_localization_calculator.rb

@@ -0,0 +1,30 @@
+module Workarea
+  module Pricing
+    module Calculators
+      class FlowLocalizationCalculator
+        include Calculator
+
+        def adjust
+          return unless order.experience.present? && order.items.present?
+
+          order_put_form = FlowIo::OrderPutForm.from(order: order, shippings: shippings, discounts: discounts)
+
+          flow_order = FlowIo.client.orders.put_by_number(
+            FlowIo.organization_id,
+            order.id,
+            order_put_form,
+            experience: order.experience.key
+          )
+
+          FlowIo::PriceApplier.perform(order: order, flow_order: flow_order)
+        rescue => exception
+          if defined?(::Raven)
+            Raven.capture_exception(exception)
+          else
+            Rails.logger.warn "Error in FlowLocalizationCalculator: #{exception}"
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/pricing/calculators/item_calculator.decorator

@@ -0,0 +1,39 @@
+module Workarea
+  decorate Pricing::Calculators::ItemCalculator, with: :flow_io do
+    def adjust
+      return super unless order.experience.present?
+
+      order.items.each do |item|
+        price = pricing.for_sku(item.sku, quantity: item.quantity)
+
+        item.adjust_pricing(
+          price: 'item',
+          quantity: item.quantity,
+          calculator: self.class.name,
+          amount: price.sell * item.quantity,
+          description: 'Item Subtotal',
+          data: {
+            'on_sale' => price.on_sale?,
+            'original_price' => price.regular.to_f,
+            'tax_code' => price.tax_code
+          }
+        )
+
+        local_price = pricing.for_sku(item.sku, quantity: item.quantity, experience: order.experience)
+
+        item.adjust_flow_pricing(
+          price: 'item',
+          quantity: item.quantity,
+          calculator: self.class.name,
+          amount: local_price.sell * item.quantity,
+          description: 'Item Subtotal',
+          data: {
+            'on_sale' => local_price.on_sale?,
+            'original_price' => local_price.regular.to_f,
+            'tax_code' => local_price.tax_code
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+module Workarea
+  decorate Pricing::Collection, with: :flow_io do
+    decorated { attr_accessor :flow_experience }
+
+    def regular_min_price
+      return super unless flow_experience.present?
+
+      @regular_min_price ||= records
+        .map { |pricing_sku| pricing_sku.find_price(experience: flow_experience).regular }
+        .sort
+        .first
+    end
+
+    def regular_max_price
+      return super unless flow_experience.present?
+
+      @regular_max_price ||= records
+        .map { |pricing_sku| pricing_sku.find_price(experience: flow_experience).regular }
+        .sort
+        .last
+    end
+
+    def sale_min_price
+      return super unless flow_experience.present?
+
+      @sale_min_price ||= records
+        .map { |pricing_sku| pricing_sku.find_price(experience: flow_experience).sale }
+        .compact
+        .sort
+        .first
+    end
+
+    def sale_max_price
+      return super unless flow_experience.present?
+
+      @sale_max_price ||= records
+        .map { |pricing_sku| pricing_sku.find_price(experience: flow_experience).sale }
+        .compact
+        .sort
+        .last
+    end
+
+    def sell_min_price
+      return super unless flow_experience.present?
+
+      @sell_min_price ||= records
+        .map { |pricing_sku| pricing_sku.find_price(experience: flow_experience).sell }
+        .sort
+        .first
+    end
+
+    def sell_max_price
+      return super unless flow_experience.present?
+
+      @sell_max_price ||= records
+        .map { |pricing_sku| pricing_sku.find_price(experience: flow_experience).sell }
+        .sort
+        .last
+    end
+
+    def msrp_min_price
+      return super unless flow_experience.present?
+
+      @msrp_min_price ||= records
+        .map { |pricing_sku| pricing_sku.msrp_for_experience(flow_experience) }
+        .compact
+        .sort
+        .first
+    end
+
+    def msrp_max_price
+      return super unless flow_experience.present?
+
+      @msrp_max_price ||= records
+        .map { |pricing_sku| pricing_sku.msrp_for_experience(flow_experience) }
+        .compact
+        .sort
+        .last
+    end
+
+    # All localized selling prices grouped by experience_key
+    # eg. { "europe" => [12.4, 34], "canada" => [11.8, 9] }
+    #
+    # @return [::Hash]
+    def localized_selling_prices
+      records.each_with_object({}) do |sku, memo|
+        sku.flow_io_local_items.each do |local_item|
+          memo[local_item.experience.key] ||= []
+          memo[local_item.experience.key] << local_item.to_price.sell.to_f
+        end
+      end
+    end
+
+    # All localized minimum selling pricea grouped by experience_key
+    # eg. { "europe" => 12.4, "canada" => 11.8 }
+    #
+    # @return [::Hash]
+    def localized_min_sell_prices
+      records.each_with_object({}) do |sku, memo|
+        sku.flow_io_local_items.each do |local_item|
+          sell_price = local_item.to_price.sell.to_f
+          experience_key = local_item.experience.key
+
+          memo[experience_key] ||= sell_price
+
+          if sell_price < memo[experience_key]
+            memo[experience_key] = sell_price
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Workarea
+  decorate Pricing::OrderTotals, with: :flow_io do
+    def total
+      super
+
+      return unless @order.experience.present?
+
+      set_flow_item_totals
+      set_flow_subtotal
+      set_flow_shipping_totals
+      set_flow_tax_totals
+      set_flow_total
+      set_flow_total_value
+    end
+
+    private
+
+      def flow_price_adjustments
+        @flow_price_adjustments ||= @order.flow_price_adjustments +
+          @shippings.map(&:flow_price_adjustments).reduce(:+)
+      end
+
+      def set_flow_item_totals
+        @order.items.each do |item|
+          item.flow_total_value = item.flow_price_adjustments.reject do |adjustment|
+            adjustment.price.in?(%w(tax shipping))
+          end.sum(&:amount)
+
+          item.flow_total_price = item.flow_price_adjustments.adjusting('item').sum
+        end
+      end
+
+      def set_flow_subtotal
+        @order.flow_subtotal_price = flow_price_adjustments.adjusting('item').sum
+      end
+
+      def set_flow_shipping_totals
+        @order.flow_shipping_total = flow_price_adjustments.adjusting('shipping').sum
+      end
+
+      def set_flow_tax_totals
+        @order.flow_tax_total = flow_price_adjustments.adjusting('tax').sum
+      end
+
+      def set_flow_total
+        @order.flow_total_price = flow_price_adjustments.sum
+      end
+
+      def set_flow_total_value
+        @order.flow_total_value = @order.flow_total_price - @order.flow_shipping_total - @order.flow_tax_total
+      end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Workarea
+  decorate Pricing::Price, with: :flow_io do
+    decorated do
+      before_validation :guard_negative_prices
+    end
+
+    def guard_negative_prices
+      if regular < 0
+        self.regular = regular.abs
+      end
+
+      if sale.present? && sale < 0
+        self.sale = sale.abs
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Workarea
+  decorate Pricing::PriceDistributor, with: :flow_io do
+    class_methods do
+      def for_flow_order(price, order)
+        units = []
+
+        order.items.each do |item|
+          item.quantity.times do
+            units << { id: item.id, price: item.current_flow_unit_price }
+          end
+        end
+
+        new(price, units, order.currency)
+      end
+    end
+
+    def initialize(total_value, units, currency_code = nil)
+      super(total_value, units)
+      @currency_code = currency_code
+    end
+
+    private
+
+      def distributed_results
+        tmp = Hash.new(0.to_m(@currency_code))
+
+        @units.each do |unit|
+          next if @total_value.to_f.zero? ||
+                  unit[:price].to_f.zero? ||
+                  @total_price.to_f.zero?
+
+          unit_value = @total_value.to_f *
+            (unit[:price].to_f / @total_price.to_f)
+
+          @total_price -= unit[:price]
+          @total_value -= unit_value.to_m(@currency_code)
+
+          tmp[unit[:id]] += unit_value.to_m(@currency_code)
+        end
+
+        tmp
+      end
+
+      def empty_results
+        @units.inject({}) do |memo, unit|
+          memo[unit[:id]] ||= 0.to_m(@currency_code)
+          memo
+        end
+      end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Workarea
+  decorate Pricing::Request, with: :flow_io do
+    private
+      def clone_order_attributes
+        attributes = @persisted_order.as_document.except('_id','id')
+
+        if attributes['items'].present?
+          attributes['items'].each do |item|
+            item['price_adjustments'] = []
+            item['flow_price_adjustments'] = []
+          end
+        end
+
+        attributes
+      end
+  end
+end