workarea-global_e 1.2.1

data/app/services/workarea/global_e/api/send_order_to_merchant/item_pricer.rb

@@ -0,0 +1,147 @@
+module Workarea
+  module GlobalE
+    module Api
+      class SendOrderToMerchant::ItemPricer
+        def self.perform(order_item, merchant_product, discounts, currency, international_currency)
+          new(order_item, merchant_product, discounts, currency, international_currency).perform!
+        end
+
+        attr_reader :order_item, :merchant_product, :discounts, :currency, :international_currency
+
+        def initialize(order_item, merchant_product, discounts, currency, international_currency)
+          @order_item = order_item
+          @merchant_product = merchant_product
+          @discounts = discounts
+          @currency = currency
+          @international_currency = international_currency
+        end
+
+        def perform!
+          order_item.update_attributes(
+            price_adjustments: base_currency_adjustments,
+            international_price_adjustments: international_currency_adjustments,
+
+            total_value: discounted_price,
+            international_total_value: international_discounted_price,
+
+            total_price: base_currency_adjustments.adjusting("item").sum,
+            international_total_price: international_currency_adjustments.adjusting("item").sum,
+
+            discounted_price_for_customs: discounted_price_for_customs,
+            generic_hs_code: merchant_product.generic_hs_code
+          )
+        end
+
+        private
+
+          delegate :order, to: :order_item
+
+          def base_currency_adjustments
+            original_item_price_adjustment = order_item.price_adjustments.first
+
+            PriceAdjustmentSet.new(
+              [PriceAdjustment.new(
+                price: "item",
+                quantity: order_item.quantity,
+                description: "Item Subtotal",
+                calculator: self.class.name,
+                data: {
+                  "on_sale" => base_currency_sell_price < base_currency_list_price,
+                  "original_price" => base_currency_list_price.to_f,
+                  "nonadjusted_amount" => original_item_price_adjustment.amount,
+                  "nonadjusted_price" => original_item_price_adjustment.data["original_price"]
+                },
+                amount: base_currency_sell_price * order_item.quantity
+              )]
+            ) + base_currency_discount_adjustments
+          end
+
+          def international_currency_adjustments
+            PriceAdjustmentSet.new(
+              [PriceAdjustment.new(
+                price: "item",
+                quantity: order_item.quantity,
+                description: "Item Subtotal",
+                calculator: self.class.name,
+                data: {
+                  "on_sale" => international_currency_sell_price < international_currency_list_price,
+                  "original_price" => international_currency_list_price.to_f
+                },
+                amount: international_currency_sell_price * order_item.quantity
+              )]
+            ) + international_currency_discount_adjustments
+          end
+
+          def base_currency_list_price
+            Money.from_amount(merchant_product.list_price, currency)
+          end
+
+          def base_currency_sell_price
+            Money.from_amount(merchant_product.price, currency)
+          end
+
+          def international_currency_list_price
+            Money.from_amount(merchant_product.international_list_price, international_currency)
+          end
+
+          def international_currency_sell_price
+            Money.from_amount(merchant_product.international_price, international_currency)
+          end
+
+          def discounted_price
+            Money.from_amount(merchant_product.discounted_price, currency)
+          end
+
+          def international_discounted_price
+            Money.from_amount(merchant_product.international_discounted_price, international_currency)
+          end
+
+          def product_discounts
+            discounts.select do |discount|
+              discount.product_cart_item_id == order_item.id.to_s
+            end
+          end
+
+          def base_currency_discount_adjustments
+            product_discounts.map do |discount|
+
+              original_price_adjustment = order
+                .price_adjustments
+                .discounts
+                .detect { |pa| pa.global_e_discount_code == discount.discount_code }
+
+              PriceAdjustment.new(
+                price: "item",
+                quantity: order_item.quantity,
+                description: discount.description,
+                calculator: self.class.name,
+                amount: -Money.from_amount(discount.price, currency),
+                data: original_price_adjustment.data
+                  .merge("dicount_value" => -Money.from_amount(discount.price, currency))
+                  .merge(discount.hash)
+              )
+            end
+          end
+
+          def international_currency_discount_adjustments
+            product_discounts.map do |discount|
+              PriceAdjustment.new(
+                price: "item",
+                quantity: order_item.quantity,
+                description: discount.description,
+                calculator: self.class.name,
+                amount: -Money.from_amount(discount.international_price, international_currency),
+                data: discount.hash
+              )
+            end
+          end
+
+          def discounted_price_for_customs
+            return unless merchant_product.discounted_price_for_customs
+
+            Money.from_amount(merchant_product.discounted_price_for_customs, currency)
+          end
+      end
+    end
+  end
+end

data/app/services/workarea/global_e/api/send_order_to_merchant/save_user.rb

@@ -0,0 +1,59 @@
+module Workarea
+  module GlobalE
+    module Api
+      class SendOrderToMerchant::SaveUser
+        attr_reader :user_id, :shipping_details, :billing_details, :culture_code
+
+        def self.perform!(user_id, shipping_details:, billing_details:, culture_code:)
+          new(
+            user_id,
+            shipping_details: shipping_details,
+            billing_details: billing_details,
+            culture_code: culture_code
+          ).perform!
+        end
+
+        # @param user_id [String, BSON::ObjectId]
+        # @param shipping_details [Workarea::GlobalE::Merchant::CustomerDetails]
+        # @param billing_details [Workarea::GlobalE::Merchant::CustomerDetails]
+        # @param culture_code [String]
+        #
+        def initialize(user_id, shipping_details:, billing_details:, culture_code:)
+          @user_id = user_id
+          @shipping_details = shipping_details
+          @billing_details = billing_details
+          @culture_code = culture_code
+        end
+
+        def perform!
+          return if user.nil?
+          upsert_address(shipping_details)
+          upsert_address(billing_details)
+          user.global_e_culture_code = culture_code
+
+          user.save
+        end
+
+        private
+
+          def user
+            @user ||= Workarea::User.find user_id rescue nil
+          end
+
+          # @param customer_details [Workarea::GlobalE::Merchant::CustomerDetails]
+          #
+          def upsert_address(customer_details)
+            existing_address = user.addresses.detect do |user_address|
+              user_address.id.to_s == customer_details.address_book_id.to_s
+            end
+
+            if existing_address.present?
+              existing_address.attributes = customer_details.workarea_address_attributes
+            else
+              user.addresses.build customer_details.workarea_address_attributes
+            end
+          end
+      end
+    end
+  end
+end

data/app/services/workarea/global_e/api/send_order_to_merchant.rb

@@ -0,0 +1,359 @@
+module Workarea
+  module GlobalE
+    module Api
+      class SendOrderToMerchant
+        attr_reader :order, :merchant_order, :order_discount_price_adjustments
+
+        def initialize(order, merchant_order)
+          @order = order
+          @merchant_order = merchant_order
+          @order_discount_price_adjustments = order
+            .price_adjustments
+            .discounts
+            .select { |pa| pa.price == "order" }
+            .group_discounts_by_id
+        end
+
+        def response
+          @response ||=
+            begin
+              with_order_lock do
+                set_product_prices
+                set_order_discounts
+                update_order
+                save_shippings
+                save_payment
+                save_user
+
+                raise GlobalE::UnpurchasableOrder, order.errors.full_messages.join("\n") unless @order.valid?(:purchasable)
+
+                capture_invetory
+                place_order
+                place_order_side_effects
+
+                Workarea::GlobalE::Merchant::ResponseInfo.new(order: order)
+              end
+            end
+        end
+
+        private
+
+          delegate :international_details, :discounts, to: :merchant_order
+
+          def place_order
+            order.place
+          end
+
+          def place_order_side_effects
+            CreateFulfillment.new(order, global_e: true).perform
+            SaveOrderAnalytics.new(order).perform
+          end
+
+          def update_order
+            order.assign_attributes(
+              global_e: true,
+              currency: international_details.currency_code,
+              global_e_id: merchant_order.order_id,
+              email: shipping_details.email,
+
+              subtotal_price: order.price_adjustments.adjusting('item').sum,
+              international_subtotal_price: order.international_price_adjustments.adjusting('item').sum,
+
+              shipping_total: discounted_shipping_price,
+              international_shipping_total: discounted_international_shipping_price,
+              discounted_international_shipping_total: discounted_international_shipping_price,
+
+              total_value: order.items.sum(&:total_value),
+              total_price: order.items.sum(&:total_price) - order.discount_adjustments.sum { |pa| pa.amount.abs },
+              international_total_price: international_total_price,
+
+              tax_total: total_duties_and_taxes_price,
+              total_duties_price: total_duties_price,
+              contains_clearance_fees_price: contains_clearance_fees_price,
+              duties_guaranteed: international_details.duties_guaranteed
+            )
+          end
+
+          def international_subtotal_price
+            subtotal = merchant_order.products.sum(&:international_discounted_price)
+            Money.from_amount(
+              subtotal,
+              merchant_order.international_details.currency_code
+            )
+          end
+
+          def international_total_price
+            Money.from_amount(
+              merchant_order.international_details.total_price,
+              merchant_order.international_details.currency_code
+            )
+          end
+
+          def total_duties_price
+            Money.from_amount(
+              merchant_order.international_details.total_duties_price,
+              merchant_order.international_details.currency_code
+            )
+          end
+
+          def international_shipping_price
+            Money.from_amount(
+              international_details.total_shipping_price,
+              international_details.currency_code
+            )
+          end
+
+          def discounted_shipping_price
+            Money.from_amount(
+              merchant_order.discounted_shipping_price,
+              merchant_order.currency_code
+            )
+          end
+
+          def discounted_international_shipping_price
+            Money.from_amount(
+              international_details.discounted_shipping_price,
+              international_details.currency_code
+            )
+          end
+
+          def total_duties_and_taxes_price
+            Money.from_amount(
+              merchant_order.total_duties_and_taxes_price,
+              merchant_order.currency_code
+            )
+          end
+
+          def contains_clearance_fees_price
+            Money.from_amount(
+              merchant_order.contains_clearance_fees_price,
+              merchant_order.currency_code
+            )
+          end
+
+          def save_shippings
+            Workarea::Shipping.where(order_id: order.id).destroy_all
+            shipping.update_attributes(
+              international_shipping_total: discounted_international_shipping_price,
+              address: shipping_address,
+              shipping_service: shipping_service,
+              price_adjustments: [
+                {
+                  price: 'shipping',
+                  amount: merchant_order.discounted_shipping_price.to_m,
+                  description: shipping_service[:name],
+                  calculator: self.class.name
+                }
+              ] + shipping_discount_adjustments,
+              international_price_adjustments: [
+                {
+                  price: 'shipping',
+                  amount: discounted_international_shipping_price,
+                  description: shipping_service[:name],
+                  calculator: self.class.name
+                }
+              ] + shipping_international_discount_adjustments
+            )
+          end
+
+          def shipping_discounts
+            discounts.select(&:shipping?)
+          end
+
+          def shipping_discount_adjustments
+            shipping_discounts.map do |discount|
+              {
+                price: "shipping",
+                quantity: 1,
+                description: discount.description,
+                calculator: self.class.name,
+                amount: -Money.from_amount(discount.price, merchant_order.currency_code),
+                data: discount.hash.merge(
+                  "dicount_value" => -Money.from_amount(discount.price, merchant_order.currency_code)
+                )
+              }
+            end
+          end
+
+          def shipping_international_discount_adjustments
+            shipping_discounts.map do |discount|
+              {
+                price: "shipping",
+                quantity: 1,
+                description: discount.description,
+                calculator: self.class.name,
+                amount: -Money.from_amount(discount.international_price, international_details.currency_code),
+                data: discount.hash
+              }
+            end
+          end
+
+          def save_payment
+            payment.update_attributes(
+              address: billing_address,
+              global_e_payment: {
+                name: international_details.payment_method_name,
+                payment_method_code: international_details.payment_method_code,
+                last_four: international_details.card_number_last_four_digits,
+                expiration_date: international_details.expiration_date,
+                amount: Money.from_amount(
+                  international_details.transaction_total_price,
+                  international_details.currency_code
+                )
+              }
+            )
+          end
+
+          def save_user
+            return unless order.user_id.present?
+
+            SaveUser.perform!(
+              order.user_id,
+
+              shipping_details: shipping_details,
+              billing_details: billing_details,
+              culture_code: merchant_order.culture_code
+            )
+          end
+
+          # @raise [Workarea::GlobalE::InventoryCaptureFailure]
+          #
+          def capture_invetory
+            inventory.purchase
+            raise InventoryCaptureFailure, inventory.errors.full_messages.join("\n") unless inventory.captured?
+          end
+
+          def set_product_prices
+            merchant_order.products.each do |merchant_product|
+              order_item = order.items.find merchant_product.cart_item_id
+
+              ItemPricer.perform(
+                order_item,
+                merchant_product,
+                discounts,
+                merchant_order.currency_code,
+                international_details.currency_code
+              )
+            end
+          end
+
+          def set_order_discounts
+            order.discount_adjustments = order_discounts.map do |discount|
+              original_price_adjustment = order_discount_price_adjustments
+                .detect { |pa| pa.global_e_discount_code == discount.discount_code }
+
+              {
+                price: "order",
+                quantity: 1,
+                description: discount.description,
+                calculator: self.class.name,
+                amount: -Money.from_amount(discount.price, merchant_order.currency_code),
+                data: (original_price_adjustment&.data || {})
+                .merge("dicount_value" => -Money.from_amount(discount.price, merchant_order.currency_code))
+                .merge(discount.hash)
+              }
+            end
+
+            order.international_discount_adjustments = order_discounts.map do |discount|
+              {
+                price: "order",
+                quantity: 1,
+                description: discount.description,
+                calculator: self.class.name,
+                amount: -Money.from_amount(discount.international_price, international_details.currency_code),
+                data: discount.hash
+              }
+            end
+          end
+
+          def order_discounts
+            discounts.select do |merchant_discount|
+              merchant_discount.product_cart_item_id.blank? && !merchant_discount.shipping?
+            end
+          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
+
+          # @return [Workarea::GlobalE::Merchant::CustomerDetails]
+          #
+          def shipping_details
+            if merchant_order.customer.is_end_customer_primary
+              merchant_order.primary_shipping
+            else
+              merchant_order.secondary_shipping
+            end
+          end
+
+          def shipping_address
+            {
+              first_name:           shipping_details.first_name,
+              last_name:            shipping_details.last_name,
+              street:               shipping_details.address1,
+              street_2:             shipping_details.address2,
+              city:                 shipping_details.city,
+              region:               shipping_details.state_code,
+              postal_code:          shipping_details.zip,
+              country:              Country[shipping_details.country_code],
+              phone_number:         shipping_details.phone1,
+              skip_region_presence: true
+            }
+          end
+
+          def shipping_service
+            {
+              carrier:      merchant_order.international_details.shipping_method_name,
+              name:         merchant_order.international_details.shipping_method_type_name,
+              service_code: merchant_order.international_details.shipping_method_code
+            }
+          end
+
+          def shipping
+            @shippipng ||= Shipping.create(order_id: order.id)
+          end
+
+          def billing_details
+            if merchant_order.customer.is_end_customer_primary
+              merchant_order.primary_billing
+            else
+              merchant_order.secondary_billing
+            end
+          end
+
+          def billing_address
+            {
+              first_name:           billing_details.first_name,
+              last_name:            billing_details.last_name,
+              street:               billing_details.address1,
+              street_2:             billing_details.address2,
+              city:                 billing_details.city,
+              region:               billing_details.state_code,
+              postal_code:          billing_details.zip,
+              country:              Country[billing_details.country_code],
+              phone_number:         billing_details.phone1,
+              skip_region_presence: true
+            }
+          end
+
+          def payment
+            @payment ||= Payment.find_or_create_by(id: order.id)
+          end
+
+          def with_order_lock
+            order.lock!
+            yield
+          ensure
+            order.unlock! if order
+          end
+      end
+    end
+  end
+end

data/app/services/workarea/global_e/api/update_order_shipping_info.rb

@@ -0,0 +1,38 @@
+module Workarea
+  module GlobalE
+    module Api
+      class UpdateOrderShippingInfo
+        attr_reader :order, :merchant_order
+
+        def initialize(order, merchant_order)
+          @order = order
+          @merchant_order = merchant_order
+        end
+
+        def response
+          @response ||=
+            begin
+              ship_items
+              Merchant::ResponseInfo.new(order: order)
+            end
+        end
+
+        private
+
+          def fulfillment
+            @fulfillment ||= Fulfillment.find order.id
+          end
+
+          def ship_items
+            fulfillment.ship_items(
+              merchant_order.international_details.order_tracking_number,
+              order.items.map do |item|
+                { 'id' => item.id.to_s, 'quantity' => item.quantity }
+              end,
+              send_to_global_e: false
+            )
+          end
+      end
+    end
+  end
+end

data/app/services/workarea/global_e/api/update_order_status/canceled.rb

@@ -0,0 +1,42 @@
+module Workarea
+  module GlobalE
+    module Api
+      class UpdateOrderStatus::Canceled
+        attr_reader :order
+
+        def self.perform(order)
+          new(order).perform
+        end
+
+        def initialize(order)
+          @order = order
+        end
+
+        def perform
+          restock
+          update_fulfillment
+          order.cancel
+        end
+
+        private
+
+          def restock
+            transaction = Inventory::Transaction.captured_for_order(order.id)
+            transaction.rollback unless transaction.blank?
+          end
+
+          def fulfillment
+            @fulfillment ||= Fulfillment.find_or_initialize_by(id: order.id)
+          end
+
+          def update_fulfillment
+            cancellations = order.items.map do |item|
+              { 'id' => item.id.to_s, 'quantity' => item.quantity }
+            end
+
+            fulfillment.cancel_items(cancellations)
+          end
+      end
+    end
+  end
+end

data/app/services/workarea/global_e/api/update_order_status.rb

@@ -0,0 +1,28 @@
+module Workarea
+  module GlobalE
+    module Api
+      class UpdateOrderStatus
+        attr_reader :order, :merchant_order
+
+        def initialize(order, merchant_order)
+          @order = order
+          @merchant_order = merchant_order
+        end
+
+        def response
+          @response ||=
+            begin
+              klass.perform(order)
+              Merchant::ResponseInfo.new(order: order)
+            end
+        end
+
+        private
+
+          def klass
+            "Workarea::GlobalE::Api::UpdateOrderStatus::#{merchant_order.status_code.classify}".constantize
+          end
+      end
+    end
+  end
+end