workarea-global_e 1.2.1

data/app/assets/javascripts/workarea/storefront/global_e/modules/checkout_info_validator.js

@@ -0,0 +1,122 @@
+WORKAREA.registerModule('globalECheckoutInfoValidator', (function () {
+    var cartToken = function() {
+            return WORKAREA.cookie.read("GlobalECartId");
+        },
+
+        checkoutInfo = function() {
+            return $.getJSON(WORKAREA.routes.storefront.globalECheckoutCartInfoPath({cartToken: cartToken()}));
+        },
+
+        verifyProductPrices = function(product, discounts) {
+            var productContainer = $("[data-ge-basket-cartitemid='" + product.CartItemId + "']"),
+                salePrice, listPrice, subtotalPrice, totalPrice;
+
+            assertDom(productContainer, "Missing product container for " + product.CartItemId);
+
+            if (!_.isUndefined(productContainer.data('geBasketFreegift'))) {
+                return;
+            }
+
+            salePrice = $("[data-ge-basket-productsaleprice]", productContainer);
+            listPrice = $("[data-ge-basket-productlistprice]", productContainer);
+            subtotalPrice = $("[data-ge-basket-productsubtotalprice]", productContainer);
+            totalPrice = $("[data-ge-basket-producttotalprice]", productContainer);
+
+            assertDom(salePrice, "Missing sale price for " + product.Name + " : " + product.CartItemId);
+            assertPrice(salePrice, product.OriginalSalePrice);
+
+            assertDom(totalPrice, "Missing total price for " + product.Name + " : " + product.CartItemId);
+
+            if (product.OriginalListPrice === product.OriginalSalePrice) {
+                refuteDom(listPrice, "Expected not to find list price for " + product.Name + " : " + product.CartItemId);
+            } else {
+                assertDom(listPrice, "Expected to find list price for " + product.Name + " : " + product.CartItemId);
+                assertPrice(listPrice, product.OriginalListPrice);
+            }
+
+            _.forEach(productDiscounts(product.CartItemId, discounts), verifyProductDiscount);
+            if (productHasDiscounts(product.CartItemId, discounts)) {
+                assertDom(subtotalPrice, "Missing subtotalPrice " + product.Name + " : " + product.CartItemId);
+                assertPrice(subtotalPrice, product.OriginalSalePrice * product.OrderedQuantity);
+            } else {
+                refuteDom(subtotalPrice, "Expected not to find subtotalPrice for " + product.Name + " : " + product.CartItemId);
+            }
+        },
+
+        productDiscounts = function(cartItemId, discounts) {
+            return _.filter(discounts, { "ProductCartItemId": cartItemId });
+        },
+
+        verifyProductDiscount = function(discount) {
+            var discountPrice = $("[data-ge-basket-productdiscountsprice='" + discount.DiscountCode + "']");
+
+            assertDom(discountPrice, "Expected to find discount " + discount.name + " : " + discount.DiscountCode);
+            assertPrice(discountPrice, discount.OriginalDiscountValue);
+        },
+
+        productHasDiscounts = function(cartItemId, discounts) {
+            return !_.isUndefined(_.find(discounts, { "ProductCartItemId": cartItemId }));
+        },
+
+        verifyOrderPrices = function(products, discounts) {
+            var subtotal = $("[data-ge-basket-subtotals]"),
+                total = $("[data-ge-basket-totals]");
+
+            assertDom(subtotal, "Expected to find order subtotal");
+            assertDom(total, "Expected to find order total");
+
+            _.forEach(orderDiscounts(discounts), verifyOrderDiscount);
+        },
+
+        verifyOrderDiscount = function(discount) {
+            var element = $("[data-ge-basket-discounts='" + discount.DiscountCode + "']");
+
+            assertDom(element, "Expected to find order discount " + discount.Name + " : " + discount.DiscountCode);
+            assertPrice(element, discount.OriginalDiscountValue);
+        },
+
+        orderDiscounts = function(discounts) {
+            return _.filter(discounts, function(discount) { return _.isUndefined(discount.ProductCartItemId); });
+        },
+
+        assertDom = function(element, errorMessage) {
+            if (_.isEmpty(element)) {
+                throw errorMessage;
+            }
+        },
+
+        refuteDom = function(element, errorMessage) {
+            try {
+                assertDom(element, errorMessage);
+                throw errorMessage;
+            }
+            catch(error) { return true; }
+        },
+
+        assertPrice = function(element, expected) {
+            var actual = parseFloat(element.text().replace(/-?\$/, ""));
+            if (actual !== expected) {
+                throw "Expected " + actual + " to equal " + expected;
+            }
+        },
+
+        init = function() {
+            if (WORKAREA.url.parse(WORKAREA.url.current()).path !== "/cart") {
+                return;
+            }
+
+            checkoutInfo().done(function(cart) {
+                _.forEach(cart.productsList, function(product) {
+                    verifyProductPrices(product, cart.discountsList);
+                });
+
+                if (!_.isEmpty(cart.productsList)) {
+                    verifyOrderPrices(cart.productsList, cart.discountsList);
+                }
+            });
+        };
+
+    return {
+        init: init
+    };
+}()));

data/app/assets/javascripts/workarea/storefront/global_e/modules/suppress_price_ranges.js

@@ -0,0 +1,19 @@
+/**
+ * @namespace WORKAREA.global_e
+ */
+
+WORKAREA.registerModule('global_e_price_filter', (function () {
+    var  isOperatedByGlobalE = function() {
+            return WORKAREA.cookie.read('GlobalE_IsOperated') === "true";
+        },
+
+        init = function($scope) {
+            if (!isOperatedByGlobalE()) { return; }
+
+            $('.result-filters__section--price', $scope).hide();
+        };
+
+    return {
+        init: init
+    };
+}()));

data/app/controllers/workarea/admin/country_exceptions_controller.rb

@@ -0,0 +1,67 @@
+module Workarea
+  class Admin::CountryExceptionsController < Admin::ApplicationController
+    required_permissions :catalog
+    helper GlobalEHelpers
+
+    before_action :find_product
+    before_action :find_country_exception, except: [:index, :new]
+
+    def index
+    end
+
+    def new
+      @country_exception = GlobalE::CountryException.new
+    end
+
+    def create
+      if @country_exception.save
+        flash.now[:error] = t('workarea.admin.country_exceptions.flash_messages.saved')
+        redirect_to catalog_product_country_exceptions_path(@product)
+      else
+        @product.reload
+        flash.now[:error] = t('workarea.admin.country_exceptions.flash_messages.create_error')
+        render :new
+      end
+    end
+
+    def edit; end
+
+    def update
+      if @country_exception.update_attributes(country_exception_params)
+        flash[:success] = t('workarea.admin.country_exceptions.flash_messages.saved')
+        redirect_to catalog_product_country_exceptions_path(@product)
+      else
+        flash.now[:error] = t('workarea.admin.country_exceptions.flash_messages.update_error')
+        render :edit, status: :unprocessable_entity
+      end
+    end
+
+    def destroy
+      @country_exception.destroy
+
+      flash[:success] = t('workarea.admin.country_exceptions.flash_messages.deleted')
+      redirect_to catalog_product_country_exceptions_path(@product)
+    end
+
+    private
+
+      def find_product
+        model = Catalog::Product.find_by(slug: params[:catalog_product_id])
+        @product = Admin::ProductViewModel.new(model, view_model_options)
+      end
+
+      def find_country_exception
+        @country_exception ||= if params[:id].present?
+                                 @product.country_exceptions.find_or_create_by(id: params[:id])
+                               else
+                                 @product.country_exceptions.build(country_exception_params)
+                               end
+      end
+
+      def country_exception_params
+        @country_exception_params ||= params
+          .fetch(:country_exception, {})
+          .permit(:country, :restricted, :vat_rate)
+      end
+  end
+end

data/app/controllers/workarea/admin/fixed_prices_controller.rb

@@ -0,0 +1,89 @@
+module Workarea
+  module Admin
+    class FixedPricesController < ApplicationController
+      required_permissions :catalog
+      helper GlobalEHelpers
+
+      before_action :find_sku
+      before_action :find_price, except: [:index, :new]
+
+      def index
+      end
+
+      def new
+        @fixed_price = GlobalE::FixedPrice.new(fixed_price_params)
+      end
+
+      def create
+        if @fixed_price.save
+          flash[:success] = t('workarea.admin.fixed_prices.flash_messages.saved', sku: @sku.id)
+          redirect_to pricing_sku_fixed_prices_path(@sku)
+        else
+          @sku.reload
+          flash.now[:error] = t('workarea.admin.fixed_prices.flash_messages.create_error')
+          render :new
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @fixed_price.update_attributes(fixed_price_params)
+          flash[:success] = t('workarea.admin.fixed_prices.flash_messages.saved', sku: @sku.id)
+          redirect_to pricing_sku_fixed_prices_path(@sku)
+        else
+          flash.now[:error] = t('workarea.admin.fixed_prices.flash_messages.update_error')
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @fixed_price.destroy
+
+        flash[:success] = t('workarea.admin.fixed_prices.flash_messages.deleted', sku: @sku.id)
+        redirect_to pricing_sku_fixed_prices_path(@sku)
+      end
+
+      private
+
+        def fixed_price_params
+          @fixed_price_params ||=
+            begin
+              permitted = params.fetch(:fixed_price, {}).permit(:country, :currency_code, :sale, :regular, :active)
+              currency_code = permitted[:currency_code]
+
+              permitted[:regular] =
+                if permitted[:regular].present? && currency_code.present?
+                  permitted[:regular].to_m(currency_code)
+                else
+                  nil
+                end
+
+              permitted[:sale] =
+                if permitted[:sale].present? && currency_code.present?
+                  permitted[:sale].to_m(currency_code)
+                else
+                  nil
+                end
+
+              permitted
+            end
+        end
+
+        def find_sku
+          @sku = PricingSkuViewModel.wrap(
+            Pricing::Sku.find(params[:pricing_sku_id])
+          )
+        end
+
+        def find_price
+          @fixed_price = if params[:id].present?
+                     @sku.fixed_prices.find_or_create_by(id: params[:id])
+                   else
+                     @sku.fixed_prices.build(fixed_price_params)
+                   end
+        end
+    end
+  end
+end

data/app/controllers/workarea/admin/orders_controller.decorator

@@ -0,0 +1,6 @@
+module Workarea
+  decorate Admin::OrdersController, with: :global_e do
+    def global_e
+    end
+  end
+end

data/app/controllers/workarea/storefront/application_controller.decorator

@@ -0,0 +1,30 @@
+module Workarea
+  decorate Storefront::ApplicationController, with: :global_e do
+    decorated do
+      after_action :set_global_e_cart_id_cookie
+    end
+
+    def current_order
+      @current_order ||= super.tap do |order|
+        order.assign_attributes(
+          currency: global_e_cookie["currencyCode"] || order.currency,
+          shipping_country: Country[global_e_cookie["countryISO"]] || order.shipping_country
+        )
+      end
+    end
+
+    private
+
+      def global_e_cookie
+        @global_e_cookie ||= JSON.parse cookies[:GlobalE_Data] rescue {}
+      end
+
+      def set_global_e_cart_id_cookie
+        if current_order.persisted?
+          cookies["GlobalECartId"] = current_order.global_e_token
+        else
+          cookies.delete "GlobalECartId"
+        end
+      end
+  end
+end

data/app/controllers/workarea/storefront/checkouts_controller.decorator

@@ -0,0 +1,22 @@
+module Workarea
+  decorate Storefront::CheckoutsController, with: :global_e do
+    decorated { before_action :route_global_e_order, if: :is_operated_by_global_e? }
+
+    private
+
+      def route_global_e_order
+        current_checkout.reset!
+        current_order.update_attributes(user_id: current_user.id) if current_user.present?
+        Pricing.perform(current_order)
+        redirect_to ge_checkout_path
+      end
+
+      def global_e_cookie
+        JSON.parse cookies[:GlobalE_Data] rescue {}
+      end
+
+      def is_operated_by_global_e?
+        cookies.fetch(:GlobalE_IsOperated, 'false').casecmp?('true')
+      end
+  end
+end

data/app/controllers/workarea/storefront/ge_checkouts_controller.rb

@@ -0,0 +1,10 @@
+module Workarea
+  module Storefront
+    class GeCheckoutsController < Storefront::ApplicationController
+      layout 'workarea/storefront/checkout'
+
+      def show
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/global_e_controller.rb

@@ -0,0 +1,42 @@
+module Workarea
+  module Storefront
+    class GlobalEController < ApplicationController
+      def get_checkout_cart_info
+        if checkout_cart_info_params[:countryCode].present? || checkout_cart_info_params[:MerchantGUID].present?
+          order.update_attribute(:checkout_started_at, Time.current)
+        end
+
+        if checkout_cart_info_params[:IsStockValidation]
+          InventoryAdjustment.new(order).tap(&:perform)
+        end
+
+        # GlobalE overriding fixed pricing for the order
+        #
+        if checkout_cart_info_params[:isFixedPriceSupported].present? &&
+            checkout_cart_info_params[:isFixedPriceSupported].to_s == "false"
+          order.update_attribute(:fixed_pricing, false)
+        end
+
+        render json: Workarea::GlobalE::CheckoutCartInfo.new(order).to_json
+      end
+
+      private
+
+        def order
+          @order ||= Order.find_by(
+            global_e_token: checkout_cart_info_params.require(:cartToken)
+          )
+        end
+
+        def checkout_cart_info_params
+          params.permit(
+            :cartToken,
+            :countryCode,
+            :IsStockValidation,
+            :MerchantGUID,
+            :isFixedPriceSupported
+          )
+        end
+    end
+  end
+end

data/app/controllers/workarea/storefront/globale/api_controller.rb

@@ -0,0 +1,108 @@
+module Workarea
+  module Storefront
+    module Globale
+      class ApiController < Storefront::ApplicationController
+        before_action :parse_merchant_order
+        before_action :validate_merchant_guid
+        before_action :find_order
+        after_action :log_api_event
+
+        rescue_from Exception, with: :api_error_response
+
+        # After this step is completed the order can be included in
+        # order history in the customer’s “My Account” section on the
+        # merchant’s site. It is also recommended to reserve the inventory
+        # for this order after the first step is completed, as long as usually
+        # the second step will follow too.
+        #
+        def receive_order
+          @response = GlobalE::Api::SendOrderToMerchant.new(@order, @merchant_order).response
+          render json: @response.to_json
+        end
+
+        # Posts order payment details for the order to the Merchant and performs
+        # the payment. Only order.OrderId and order.PaymentDetails members are
+        # mandatory for this method.
+        #
+        def receive_payment
+          @response = GlobalE::Api::PerformOrderPayment.new(@order, @merchant_order).response
+          render json: @response.to_json
+        end
+
+        def update_order_status
+          @response = GlobalE::Api::UpdateOrderStatus.new(@order, @merchant_order).response
+          render json: @response.to_json
+        end
+
+        # Updates order international shipping information on the Merchant’s
+        # site. Only order.OrderId and order.InternationalDetails members are
+        # mandatory for this method.
+        #
+        def receive_shipping_info
+          @response = GlobalE::Api::UpdateOrderShippingInfo.new(@order, @merchant_order).response
+          render json: @response.to_json
+        end
+
+        # Remove products from the order marked as restricted on Global-E's side.
+        def remove_restricted_products
+          @job = GlobalE::Api::RemoveRestrictedProducts.perform(
+            @order,
+            params['RemovedProductCodes']
+          )
+
+          render json: @job.response
+        end
+
+        private
+
+          def api_error_response(error)
+            GlobalE.report_error error
+            @response = GlobalE::Merchant::ResponseInfo.error(message: error.message, order: @order)
+            GlobalE::OrderApiEvents.upsert_one(
+              @order.id,
+              set: {
+                "#{params[:action]}" => @merchant_order.to_h,
+                "#{params[:action]}_response" => @response.to_h
+              }
+            )
+            render json: @response.to_json, status: :internal_server_error
+          end
+
+          def parse_merchant_order
+            @merchant_order = Workarea::GlobalE::Merchant::Order.new(
+              params.to_unsafe_hash.except(:controller, :action, :api)
+            )
+          end
+
+          def validate_merchant_guid
+            return if @merchant_order.merchant_guid == GlobalE.merchant_guid
+
+            head :bad_request
+          end
+
+          def find_order
+            @order ||=
+              if @merchant_order.cart_id.present?
+                Order.find_by(global_e_token: @merchant_order.cart_id)
+              elsif @merchant_order.merchant_order_id.present?
+                Order.find(@merchant_order.merchant_order_id)
+              elsif @merchant_order.order_id.present?
+                Order.find_by(global_e_id: @merchant_order.order_id)
+              end
+          end
+
+          def log_api_event
+            return unless @order && @response
+
+            GlobalE::OrderApiEvents.upsert_one(
+              @order.id,
+              set: {
+                "#{params[:action]}" => @merchant_order.to_h,
+                "#{params[:action]}_response" => @response.to_h
+              }
+            )
+          end
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/globale/refund_controller.rb

@@ -0,0 +1,65 @@
+module Workarea
+  module Storefront
+    module Globale
+      class RefundController < Storefront::ApplicationController
+        before_action :parse_order_refund
+        before_action :validate_merchant_guid
+        before_action :find_order
+        after_action :log_api_event
+
+        def receive_order_refund
+          @response = GlobalE::Api::NotifyOrderRefunded.new(@order, @order_refund).response
+          render json: @response.to_json
+        end
+
+        private
+
+          def api_error_response(error)
+            GlobalE.report_error error
+            @response = GlobalE::Merchant::ResponseInfo.error(message: error.message, order: @order)
+            GlobalE::OrderApiEvents.upsert_one(
+              @order.id,
+              set: {
+                "#{params[:action]}" => @order_refund.to_h,
+                "#{params[:action]}_response" => @response.to_h
+              }
+            )
+            render json: @response.to_json, status: :internal_server_error
+          end
+
+          def parse_order_refund
+            @order_refund = Workarea::GlobalE::Merchant::OrderRefund.new(
+              params.to_unsafe_hash.except(:controller, :action, :api)
+            )
+          end
+
+          def validate_merchant_guid
+            return if @order_refund.merchant_guid == GlobalE.merchant_guid
+
+            head :bad_request
+          end
+
+          def find_order
+            @order ||=
+              if @order_refund.merchant_order_id.present?
+                Order.find(@order_refund.merchant_order_id)
+              elsif @order_refund.order_id.present?
+                Order.find_by(global_e_id: @order_refund.order_id)
+              end
+          end
+
+          def log_api_event
+            return unless @order && @response
+
+            GlobalE::OrderApiEvents.upsert_one(
+              @order.id,
+              set: {
+                "#{params[:action]}" => @order_refund.to_h,
+                "#{params[:action]}_response" => @response.to_h
+              }
+            )
+          end
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/users/logins_controller.decorator

@@ -0,0 +1,13 @@
+module Workarea
+  decorate Storefront::Users::LoginsController, with: :global_e do
+    decorated { after_action :set_global_e_culture_code_cookie }
+
+    private
+
+      def set_global_e_culture_code_cookie
+        return unless current_user&.global_e_culture_code.present?
+
+        cookies["GlobalECultureCode"] = current_user.global_e_culture_code
+      end
+  end
+end

data/app/helpers/workarea/admin/global_e_helpers.rb

@@ -0,0 +1,28 @@
+module Workarea
+  module Admin
+    module GlobalEHelpers
+      def currency_options(filtered_currencies = [])
+        filtered_currencies += [Money.default_currency]
+
+        [["---", nil]] + (all_currencies - filtered_currencies).map do |currency|
+          ["#{currency.name} (#{currency.symbol})", currency.iso_code]
+        end.compact
+      end
+
+      def global_e_country_options
+        [["---", nil]] + GlobalE.config.countries.map do |alpha2|
+          next unless country = Country[alpha2]
+          [country.name, alpha2]
+        end.compact
+      end
+
+      private
+
+        def all_currencies
+          @all_currencies ||= GlobalE.config.currencies.map do |iso_code|
+            Money::Currency.find iso_code
+          end
+        end
+    end
+  end
+end

data/app/models/workarea/address.decorator

@@ -0,0 +1,11 @@
+module Workarea
+  decorate Address, with: :global_e do
+    decorated do
+      field :skip_region_presence, type: Boolean
+    end
+
+    def region_presence
+      skip_region_presence || super
+    end
+  end
+end

data/app/models/workarea/catalog/product.decorator

@@ -0,0 +1,14 @@
+module Workarea
+  decorate Catalog::Product, with: :global_e do
+    decorated do
+      field :global_e_forbidden, type: Boolean
+      embeds_many :country_exceptions,
+        class_name: "Workarea::GlobalE::CountryException",
+        inverse_of: :product
+    end
+
+    def global_e_forbidden
+      super || (Plugin.installed?(:gift_cards) && gift_card?)
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Workarea
+  class Fulfillment
+    module Status
+      class PartiallyRefunded
+        include StatusCalculator::Status
+
+        def in_status?
+          order.items.any? { |i| i.quantity_refunded >= i.quantity }
+        end
+      end
+    end
+  end
+end