workarea-global_e 1.2.1

data/app/models/workarea/fulfillment/status/refunded.rb

@@ -0,0 +1,15 @@
+module Workarea
+  class Fulfillment
+    module Status
+      class Refunded
+        include StatusCalculator::Status
+
+        def in_status?
+          # Need some items in the fulfillment
+          order.items.any? &&
+            order.items.all? { |i| i.quantity_refunded >= i.quantity }
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/fulfillment.decorator

@@ -0,0 +1,55 @@
+module Workarea
+  decorate Fulfillment, with: :global_e do
+    decorated do
+      field :global_e_tracking_url, type: String
+      field :global_e, type: Boolean, default: false
+    end
+
+    def ship_items(tracking_number, shipped_items, send_to_global_e: true)
+      result = super(tracking_number, shipped_items)
+      if result && send_to_global_e && global_e?
+        GlobalE::UpdateOrderDispatch.perform_async(id, tracking_number)
+      end
+      result
+    end
+
+    # Refund items in the fulfillment
+    #
+    # The hashes should contain 'id', the order_item_id and 'quantity' the amount
+    # to be canceled, any other key/values will be stored on the Fulfillment::Event#data
+    #
+    # refund_items([
+    #   { 'id' => '1234', 'quantity' => 4, 'replacement_sku' => '9999' },
+    #   { 'id' => '4321', 'quantity' => 1 }
+    # ])
+    #
+    # @param [Array<Hash>] refunded_items
+    # @return [Boolean]
+    #
+    def refund_items(refunded_items)
+      return false unless refunded_items.present?
+
+      occured_at = Time.current
+
+      refunded_items = refunded_items.map do |refunded_item|
+        refunded_item = refunded_item.with_indifferent_access
+        next unless refunded_item['quantity'].to_i > 0
+
+        item = items.detect { |i| i.order_item_id == refunded_item['id'].to_s }
+        next unless item.present?
+
+        item.events.build(
+          status: 'refunded',
+          quantity: refunded_item['quantity'],
+          created_at: occured_at,
+          updated_at: occured_at,
+          data: refunded_item.except('id', 'quantity')
+        )
+      end.compact
+
+      return false unless refunded_items.present?
+
+      save
+    end
+  end
+end

data/app/models/workarea/global_e/country_exception.rb

@@ -0,0 +1,37 @@
+module Workarea
+  module GlobalE
+    class CountryException
+      include ApplicationDocument
+
+      field :country, type: Country
+      field :restricted, type: Boolean, default: false
+      field :vat_rate, type: Float
+
+      embedded_in :product, class_name: "Workarea::Catalog::Product"
+
+      validates_presence_of :country
+      validate :unique_country
+      validate :restricted_or_vat_rate_presence
+
+      private
+
+        def unique_country
+          return unless product.present? && country.present?
+
+          country_exists = product.country_exceptions.any? do |country_exception|
+            country_exception != self && country_exception.country == country
+          end
+
+          if country_exists
+            errors.add(:base, I18n.t('workarea.country_exception.errors.country_must_be_unique'))
+          end
+        end
+
+        def restricted_or_vat_rate_presence
+          return if restricted.present? || vat_rate.present?
+
+          errors.add(:base, I18n.t('workarea.country_exception.errors.restricted_or_vat_rate_required'))
+        end
+    end
+  end
+end

data/app/models/workarea/global_e/fixed_price.rb

@@ -0,0 +1,93 @@
+module Workarea
+  module GlobalE
+    class FixedPrice
+      include ApplicationDocument
+      include Releasable
+
+      field :country, type: Country
+      field :currency_code, type: String
+      field :regular, type: Money
+      field :sale, type: Money
+      field :msrp, type: Money
+
+      embedded_in :pricing_sku, inverse_of: :fixed_prices
+
+      validates_presence_of :regular, :currency
+      validate :validate_foreign_currency
+      validate :valid_currency
+      validate :currencies_match
+      validate :unique_currency
+      validate :unique_country
+
+      delegate :on_sale?, to: :pricing_sku
+
+      def currency
+        Money::Currency.find currency_code
+      end
+
+      def sell
+        if on_sale? && sale.present?
+          sale
+        else
+          regular
+        end
+      end
+
+      private
+
+        def validate_foreign_currency
+          if regular.present? && regular.currency == Money.default_currency
+            errors.add(:regular, I18n.t('workarea.fixed_price.errors.invalid_fixed_price_currency'))
+          end
+
+          if sale.present? && sale.currency == Money.default_currency
+            errors.add(:sale, I18n.t('workarea.fixed_price.errors.invalid_fixed_price_currency'))
+          end
+        end
+
+        def valid_currency
+          return unless currency_code.present?
+
+          if Money::Currency.find(currency_code).blank?
+            errors.add(:currency_code, I18n.t('workarea.fixed_price.errors.invalid_currency'))
+          end
+        end
+
+        def currencies_match
+          if currency.present? && regular.present? && regular.currency != currency
+            errors.add(:base, I18n.t('workarea.fixed_price.errors.currency_and_regular_mistmatch'))
+          end
+
+          if sale.present? && regular.present? && regular.currency != sale.currency
+            errors.add(:base, I18n.t('workarea.fixed_price.errors.sale_and_regular_currency_mismatch'))
+          end
+        end
+
+        def unique_currency
+          return unless pricing_sku.present? && currency_code.present?
+
+          currency_exists = pricing_sku.fixed_prices.any? do |fixed_price|
+            fixed_price != self &&
+              fixed_price.currency_code == currency_code &&
+              fixed_price.country == country
+          end
+
+          if currency_exists
+            errors.add(:base, I18n.t('workarea.fixed_price.errors.currency_must_be_unique'))
+          end
+        end
+
+        def unique_country
+          return unless pricing_sku.present? && country.present?
+
+          country_exists = pricing_sku.fixed_prices.any? do |fixed_price|
+            fixed_price != self && fixed_price.country == country
+          end
+
+          if country_exists
+            errors.add(:base, I18n.t('workarea.fixed_price.errors.country_must_be_unique'))
+          end
+        end
+    end
+  end
+end

data/app/models/workarea/global_e/order_api_events.rb

@@ -0,0 +1,29 @@
+module Workarea
+  module GlobalE
+    class OrderApiEvents
+      include ApplicationDocument
+
+      field :receive_order, type: Hash
+      field :receive_order_response, type: Hash
+      field :receive_payment, type: Hash
+      field :receive_payment_response, type: Hash
+      field :update_order_status, type: Hash
+      field :update_order_status_response, type: Hash
+      field :receive_shipping_info, type: Hash
+      field :receive_shipping_info_response, type: Hash
+
+      def self.upsert_one(id, set: {})
+        timestamp = Time.current
+
+        collection.update_one(
+          { _id: id.to_s },
+          {
+            '$setOnInsert' => { created_at: timestamp },
+            '$set' => { updated_at: timestamp }.merge(set),
+          },
+          upsert: true
+        )
+      end
+    end
+  end
+end

data/app/models/workarea/order/item.decorator

@@ -0,0 +1,46 @@
+module Workarea
+  decorate Order::Item, with: :global_e do
+    decorated do
+      field :international_total_value, type: Money
+      field :international_total_price, type: Money
+      field :discounted_price_for_customs, type: Money
+      field :generic_hs_code, type: String
+
+      embeds_many :international_price_adjustments,
+        class_name: 'Workarea::PriceAdjustment',
+        extend: PriceAdjustmentExtension
+    end
+
+    def international_discounted_price
+      international_total_value
+    end
+
+    # The original item calculator price adjustment amount before GlobalE 
+    # adjusting
+    #
+    # @return [nil, Money]
+    #
+    def nonadjusted_amount
+      return if price_adjustments.first.data["nonadjusted_amount"].nil?
+
+      Money.demongoize(price_adjustments.first.data["nonadjusted_amount"])
+    end
+
+    # The original item calculator price adjustment price before GlobalE 
+    # adjusting
+    #
+    # @return [nil, Float]
+    #
+    def nonadjusted_price
+      price_adjustments.first.data["nonadjusted_price"]
+    end
+
+    # Adds an international price adjustment to the item. Does not persist.
+    #
+    # @return [self]
+    #
+    def adjust_international_pricing(options = {})
+      international_price_adjustments.build(options)
+    end
+  end
+end

data/app/models/workarea/order/status/pending_global_e_fraud_check.rb

@@ -0,0 +1,12 @@
+module Workarea
+  class Order::Status::PendingGlobalEFraudCheck
+    include StatusCalculator::Status
+
+    def in_status?
+      order.global_e? &&
+        order.placed? &&
+        order.global_e_approved_at.blank? &&
+        !order.canceled?
+    end
+  end
+end

data/app/models/workarea/order.decorator

@@ -0,0 +1,64 @@
+module Workarea
+  decorate Order, with: :global_e do
+    decorated do
+      field :currency, type: String, default: -> { Money.default_currency.iso_code }
+      field :shipping_country, type: Country
+      field :fixed_pricing, type: Boolean, default: false
+
+      field :global_e, type: Boolean, default: false
+      field :global_e_id, type: String
+      field :global_e_token, type: String, default: -> { SecureRandom.hex(5).upcase }
+      field :global_e_approved_at, type: Time
+
+      field :duties_guaranteed, type: Boolean, default: false
+
+      field :international_subtotal_price, type: Money
+      field :international_shipping_total, type: Money
+      field :discounted_international_shipping_total, type: Money
+      field :total_duties_price, type: Money
+      field :international_total_price, type: Money
+      field :contains_clearance_fees_price, type: Money
+
+      embeds_many :discount_adjustments,
+        class_name: 'Workarea::PriceAdjustment',
+        extend: PriceAdjustmentExtension
+
+      embeds_many :international_discount_adjustments,
+        class_name: 'Workarea::PriceAdjustment',
+        extend: PriceAdjustmentExtension
+
+      index({ global_e_token: 1 })
+      index({ global_e_id: 1 })
+    end
+
+    # All international price adjustments on this order.
+    #
+    # @return [PriceAdjustmentSet]
+    #
+    def international_price_adjustments
+      PriceAdjustmentSet.new(items.flat_map(&:international_price_adjustments))
+    end
+
+    # Do not run callbacks if global_e order, they will be run after
+    # PerformOrderPayment
+    def place
+      return super unless purchasable? && global_e?
+
+      self.placed_at = Time.current
+      with(write: { w: "majority", j: true }) { save }
+    end
+
+    def global_e_approve!
+      run_callbacks :place do
+        update_attributes(global_e_approved_at: Time.current)
+      end
+    end
+
+    def discount_ids
+      super + discount_adjustments
+        .map { |pa| pa.data['discount_id'] }
+        .compact
+        .uniq
+    end
+  end
+end

data/app/models/workarea/payment/status/global_e_appoved.rb

@@ -0,0 +1,9 @@
+module Workarea
+  class Payment::Status::GlobalEApproved
+    include StatusCalculator::Status
+
+    def in_status?
+      model.global_e_payment.present? && model.global_e_approved_at.present?
+    end
+  end
+end

data/app/models/workarea/payment/status/pending_global_e_fraud_check.rb

@@ -0,0 +1,9 @@
+module Workarea
+  class Payment::Status::PendingGlobalEFraudCheck
+    include StatusCalculator::Status
+
+    def in_status?
+      model.global_e_payment.present? && model.global_e_approved_at.blank?
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Workarea
+  class Payment
+    class Tender
+      class GlobalEPayment < Tender
+        field :name, type: String
+        field :payment_method_code, type: String
+        field :last_four, type: String
+        field :expiration_date, type: String
+
+        def slug
+          :global_e_payment
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment.decorator

@@ -0,0 +1,10 @@
+module Workarea
+  decorate Payment, with: :global_e do
+    decorated do
+      field :global_e_approved_at, type: Time
+
+      embeds_one :global_e_payment,
+        class_name: "Workarea::Payment::Tender::GlobalEPayment"
+    end
+  end
+end

data/app/models/workarea/price_adjustment.decorator

@@ -0,0 +1,13 @@
+module Workarea
+  decorate PriceAdjustment, with: :global_e do
+    def global_e_discount_code
+      return unless discount?
+
+      if price == "item"
+        "#{data['discount_id']}-#{_parent.id.to_s}"
+      else
+        data['discount_id']
+      end
+    end
+  end
+end

data/app/models/workarea/price_adjustment_set.decorator

@@ -0,0 +1,25 @@
+module Workarea
+  decorate PriceAdjustmentSet, with: :global_e do
+    def group_discounts_by_id
+      reduce({}) do |memo, adjustment|
+        if adjustment.discount?
+          memo[adjustment.data["discount_id"]] ||= PriceAdjustment.new(
+            quantity: adjustment.quantity,
+            data: adjustment.data.merge("discount_value" => 0.0),
+            price: adjustment.price,
+            description: adjustment.description,
+            calculator: adjustment.calculator,
+            amount: 0.to_m(adjustment.amount.currency)
+          )
+
+          memo[adjustment.data["discount_id"]].amount += adjustment.amount
+          memo[adjustment.data["discount_id"]].data["discount_value"] += adjustment.data["discount_value"]
+        else
+          memo[adjustment.id] = adjustment
+        end
+
+        memo
+      end.values
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Workarea
+  decorate Pricing::Calculators::ItemCalculator, with: :global_e do
+    def adjust
+      order.fixed_pricing = is_fixed_price?
+
+      return super unless is_fixed_price?
+
+      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
+          }
+        )
+
+        fixed_price = pricing.fixed_price_for_sku(item.sku, currency_code: order.currency, country: order.shipping_country)
+
+        item.adjust_international_pricing(
+          price: 'item',
+          quantity: item.quantity,
+          calculator: self.class.name,
+          amount: fixed_price.sell * item.quantity,
+          description: 'Item Subtotal',
+          data: {
+            'on_sale' => fixed_price.on_sale?,
+            'original_price' => fixed_price.regular.to_f,
+            'tax_code' => price.tax_code
+          }
+        )
+      end
+    end
+
+    private
+
+      def is_fixed_price?
+        pricing.records.present? &&
+          pricing.records.all? { |sku| sku.fixed_price_for(currency_code: order.currency, country: order.shipping_country) }
+      end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Workarea
+  decorate Pricing::Collection, with: :global_e do
+    # GlobalE sell min fixed prices
+    # Returns a hash of:
+    # { defualts: { Currency: Price }, Country: Price }
+    #
+    # @return [::Hash]
+    #
+    def sell_min_fixed_prices
+      sell_min_defaults = default_fixed_prices.map do |currency, prices|
+        [currency, prices.map { |p| p.sell.to_f }.sort.first]
+      end.to_h.presence
+
+      sell_min_country_prices = country_fixed_prices.map do |country, prices|
+        [country.alpha2, prices.map { |p| p.sell.to_f }.sort.first]
+      end.to_h
+
+
+      { defaults: sell_min_defaults }.merge(sell_min_country_prices).compact
+    end
+
+    # GlobalE sell max fixed prices
+    # Returns a hash of:
+    # { defualts: { Currency: Price }, Country: Price }
+    #
+    # @return [::Hash]
+    #
+    def sell_max_fixed_prices
+      sell_min_defaults = default_fixed_prices.map do |currency, prices|
+        [currency, prices.map { |p| p.sell.to_f }.sort.last]
+      end.to_h.presence
+
+      sell_min_country_prices = country_fixed_prices.map do |country, prices|
+        [country.alpha2, prices.map { |p| p.sell.to_f }.sort.last]
+      end.to_h
+
+
+      { defaults: sell_min_defaults }.merge(sell_min_country_prices).compact
+    end
+
+    def original_min_fixed_prices
+      original_min_defaults = default_fixed_prices.map do |currency, prices|
+        [currency, prices.map { |p| [p.msrp&.to_f, p.regular.to_f].compact.max }.sort.first]
+      end.to_h.presence
+
+      original_min_country_prices = country_fixed_prices.map do |country, prices|
+        [country.alpha2, prices.map { |p| [p.msrp&.to_f, p.regular.to_f].compact.max }.sort.first]
+      end.to_h
+
+      { defaults: original_min_defaults }.merge(original_min_country_prices).compact
+    end
+
+    def original_max_fixed_prices
+      original_max_defaults = default_fixed_prices.map do |currency, prices|
+        [currency, prices.map { |p| [p.msrp&.to_f, p.regular.to_f].compact.max }.sort.last]
+      end.to_h.presence
+
+      original_max_country_prices = country_fixed_prices.map do |country, prices|
+        [country.alpha2, prices.map { |p| [p.msrp&.to_f, p.regular.to_f].compact.max }.sort.last]
+      end.to_h
+
+      { defaults: original_max_defaults }.merge(original_max_country_prices).compact
+    end
+
+    # @ return [Workarea::GlobalE::FixedPrice, nil]
+    #
+    def fixed_price_for_sku(sku, currency_code:, country:)
+      return unless sku = records.detect { |r| r.id == sku }
+      sku.fixed_price_for(currency_code: currency_code, country: country)
+    end
+
+    private
+
+      def fixed_prices
+        @fixed_prices ||= records.flat_map(&:fixed_prices)
+      end
+
+      def default_fixed_prices
+        @default_fixed_prices ||= fixed_prices.select do |fixed_price|
+          fixed_price.country.blank?
+        end.group_by(&:currency_code)
+      end
+
+      def country_fixed_prices
+        @country_fixed_prices ||= fixed_prices.select do |fixed_price|
+          fixed_price.country.present?
+        end.group_by(&:country)
+      end
+  end
+end

data/app/models/workarea/pricing/discount/appliation_group.decorator

@@ -0,0 +1,16 @@
+module Workarea
+  decorate Pricing::Discount::ApplicationGroup, with: :global_e do
+    def apply
+      return super unless order.fixed_pricing?
+
+      discounts.each do |discount|
+        discount_order = Pricing::Discount::Order.new(order, shippings, discount)
+        next unless discount.qualifies?(discount_order)
+
+        discount.apply(discount_order)
+        international_discount_order = Pricing::Discount::InternationalOrder.new(order, shippings, discount)
+        discount.apply(international_discount_order)
+      end
+    end
+  end
+end

data/app/models/workarea/pricing/discount/international_item_proxy.rb

@@ -0,0 +1,27 @@
+module Workarea
+  module Pricing
+    class Discount
+      class InternationalItemProxy
+        attr_reader :order_item
+        delegate_missing_to :order_item
+
+        def initialize(order_item)
+          @order_item = order_item
+        end
+
+        def current_unit_price
+          return 0.to_m(order.currency) if international_price_adjustments.blank?
+          international_price_adjustments.adjusting('item').map(&:unit).sum.to_m
+        end
+
+        # Adds an international price adjustment to the item. Does not persist.
+        #
+        # @return [self]
+        #
+        def adjust_pricing(options = {})
+          international_price_adjustments.build(options)
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/pricing/discount/international_order.rb

@@ -0,0 +1,29 @@
+module Workarea
+  module Pricing
+    class Discount
+      class InternationalOrder < Discount::Order
+        # Only return items that are discountable.
+        #
+        # TODO this needs update in 3.4
+        #
+        # @return [Array<Workarea::Order::Item>]
+        #
+        def items
+          @order.items.select(&:discountable?).select do |item|
+            allow_sale_items? || !item.on_sale?
+          end.map { |item| InternationalItemProxy.new(item) }
+        end
+
+        # The subtotal, not including items that cannot be discounted.
+        #
+        # @return [Money]
+        #
+        def subtotal_price
+          items.reduce(0.to_m(@order.currency)) do |memo, item|
+            memo + item.international_price_adjustments.sum
+          end
+        end
+      end
+    end
+  end
+end