workarea-flow_io 1.2.1

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

@@ -0,0 +1,62 @@
+module Workarea
+  module FlowIo
+    class OrderPutForm
+      # @param order [Workarea::Order]
+      # @param shippings [Array<Workarea::Shipping>, nil]
+      # @param discounts [Array<Workarea::Pricing::Discount>, nil]
+      #
+      def self.from(order:, shippings: nil, discounts: nil)
+        new(order: order, shippings: shippings).to_flow_model
+      end
+
+      attr_reader :order, :shippings, :discounts
+
+      # @param order [Workarea::Order]
+      # @param shippings [Array<Workarea::Shipping>, nil]
+      # @param discounts [Array<Workarea::Pricing::Discount>, nil]
+      #
+      def initialize(order:, shippings: nil, discounts: nil)
+        @order = order
+        @shippings = shippings || []
+        @discounts = discounts || []
+      end
+
+      # @return [::Io::Flow::V0::Models::OrderPutForm]
+      #
+      def to_flow_model
+        ::Io::Flow::V0::Models::OrderPutForm.new(
+          {
+            attributes: { number: order.id },
+            customer: customer,
+            items: items
+          }
+        )
+      end
+
+      private
+
+        def customer
+          return nil unless user.present?
+
+          {
+            email: user.email,
+            name: {
+              first: user.first_name,
+              last: user.last_name
+            },
+            phone: user.default_shipping_address&.phone_number
+          }
+        end
+
+        def user
+          return unless order.user_id.present?
+
+          @user ||= Workarea::User.find(order.user_id) rescue nil
+        end
+
+        def items
+          order.items.map { |item| FlowIo::LineItemForm.from(order_item: item, discounts: discounts) }
+        end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Workarea
+  module FlowIo
+    class PriceApplier
+      def self.perform(order:, flow_order:, shipping: nil)
+        new(order: order, flow_order: flow_order, shipping: shipping).perform!
+      end
+
+      attr_reader :order, :flow_order, :shipping
+
+      # @param order [Workarea::Order]
+      # @param flow_order [::Io::Flow::V0::Models::Order]
+      # @param shipping [Array<Workarea::Shipping>]
+      #
+      def initialize(order:, flow_order:, shipping: nil)
+        @order = order
+        @flow_order = flow_order
+        @shipping = shipping
+      end
+
+      def perform!
+        adjust_items
+        adjust_shipping
+      end
+
+      private
+
+        # @return [Array<Workarea::Pricing::Discount>]
+        #
+        def discounts
+          @discounts ||= Workarea::Pricing::Discount
+            .where(:_id.in => order.discount_ids)
+            .to_a
+        end
+
+        def adjust_shipping
+          return unless shipping.present? && order.requires_shipping?
+
+          # Prices are of types: adjustment, subtotal, vat, duty, shipping,
+          # insurance, discount.  Filter out subtotal and discount prices
+          flow_prices = flow_order.prices.reject do |order_price_detail|
+            ["subtotal", "discount"].include? order_price_detail.key.value
+          end
+
+          flow_prices.each do |price|
+            price_slug = price.name == "Shipping" ? "shipping" : "tax"
+            shipping.adjust_pricing(
+              price: price_slug,
+              description: price.name,
+              calculator: self.class.name,
+              amount: price.base.to_m,
+              data: { "order_price_detail" => price.to_hash }
+            )
+
+            # build price adjustments in the currency the user checked out in.
+            shipping.adjust_flow_pricing(
+              price: price_slug,
+              description: price.name,
+              calculator: self.class.name,
+              amount: price.to_m
+            )
+          end
+        end
+
+        # update each Order::Item pricing with new prices from Flow.io
+        #
+        def adjust_items
+          order.items.each do |order_item|
+            flow_item = flow_order.items.detect do |localized_line_item|
+              localized_line_item.number == order_item.sku
+            end
+
+            ItemApplier.perform(
+              order_item: order_item,
+              localized_line_item: flow_item,
+              discounts: discounts
+            )
+          end
+        end
+    end
+  end
+end

data/app/services/workarea/flow_io/price_applier/item_applier.rb

@@ -0,0 +1,157 @@
+module Workarea
+  module FlowIo
+    # Updates a `Wokrarea::Order::Item` pricing with information from a
+    # `::Io::Flow::V0::Models::LocalizedLineItem`.
+    #
+    class PriceApplier::ItemApplier
+      def self.perform(order_item:, localized_line_item:, discounts:)
+        new(
+          order_item: order_item,
+          localized_line_item: localized_line_item,
+          discounts: discounts
+        ).perform!
+      end
+
+      attr_reader :order_item,
+        :localized_line_item,
+        :discounts,
+        :item_calculator_data,
+        :flow_item_calculator_data
+
+      # @param order_item [::Worakrea::Order::Item]
+      # @param localized_line_item [::Io::Flow::V0::Models::LocalizedLineItem]
+      #
+      def initialize(order_item:, localized_line_item:, discounts:)
+        @order_item = order_item
+        @localized_line_item = localized_line_item
+        @discounts = discounts
+        @item_calculator_data = order_item.price_adjustments&.first&.data || {}
+        @flow_item_calculator_data = order_item.flow_price_adjustments&.first&.data || {}
+      end
+
+      def perform!
+        order_item.reset_price_adjustments
+        order_item.reset_flow_price_adjustments
+
+        add_base_adjustments
+        add_line_item_discounts
+        add_unit_price_rounding
+      end
+
+      private
+
+        def add_base_adjustments
+          order_item.adjust_pricing(
+            item_adjustment_data.merge(
+              quantity: order_item.quantity,
+              amount: localized_item_price.base.to_m * order_item.quantity,
+              description: 'Item Subtotal',
+              data: item_calculator_data.merge(
+                "localized_item_price" => localized_item_price.to_hash,
+                "description" => 'Flow Localized Item Price Base'
+              ).deep_stringify_keys
+            )
+          )
+
+          order_item.adjust_flow_pricing(
+            item_adjustment_data.merge(
+              quantity: order_item.quantity,
+              amount: localized_item_price.to_m * order_item.quantity,
+              description: 'Item Subtotal',
+              data: flow_item_calculator_data.merge(
+                "description" => 'Flow Localized Item Price'
+              ).deep_stringify_keys
+            )
+          )
+        end
+
+        def add_line_item_discounts
+          return unless localized_line_item.discounts.present?
+
+          localized_line_item.discounts.each do |localized_line_item_discount|
+            discount = discounts.detect do |pricing_discount|
+              pricing_discount.name == localized_line_item_discount.discount_label
+            end
+
+            price_level = discount&.class&.price_level || "item"
+
+            order_item.adjust_pricing(
+              item_adjustment_data.merge(
+                quantity: order_item.quantity,
+                price: price_level,
+                amount: localized_line_item_discount.base.to_m,
+                description: localized_line_item_discount.discount_label,
+                data: {
+                  "localized_line_item_discount" => localized_line_item_discount.to_hash,
+                  "discount_id" => discount&.id&.to_s,
+                  "description" => localized_line_item_discount.discount_label,
+                  "discount_amount" => localized_line_item_discount.base.to_m.abs
+                }.deep_stringify_keys.compact
+              )
+            )
+
+            order_item.adjust_flow_pricing(
+              item_adjustment_data.merge(
+                quantity: order_item.quantity,
+                price: price_level,
+                amount: localized_line_item_discount.to_m,
+                description: localized_line_item_discount.discount_label,
+                data: {
+                  "description" => localized_line_item_discount.discount_label,
+                  "discount_amount" => localized_line_item_discount.to_m.abs
+                }
+              )
+            )
+            end
+        end
+
+        # flow will add or subtract money to make the line item price
+        # have an even unit price we do the same thing and roll it into the discount
+        # adjustment
+        def add_unit_price_rounding
+          return unless needs_unti_price_rounding?
+
+          value = unit_quantity_price - order_item_total_value
+
+          item_adjustment_data.merge(
+            quantity: order_item.quantity,
+            amount: value,
+            description: "Discount",
+            data: {
+              description: 'Flow Localized Line Item Discount',
+              discount_amount: value.abs
+            }
+          )
+        end
+
+        def needs_unti_price_rounding?
+          unit_quantity_price != order_item_total_value
+        end
+
+        def unit_quantity_price
+          order_item.current_flow_unit_price * order_item.quantity
+        end
+
+        def order_item_total_value
+          order_item
+            .flow_price_adjustments
+            .adjusting("item")
+            .sum
+        end
+
+        def localized_item_price
+          @localized_item_price ||= localized_line_item
+          .local
+          .prices
+          .detect { |localized_price| localized_price.key == "localized_item_price" }
+        end
+
+        def item_adjustment_data
+          {
+            price: 'item',
+            calculator: self.class.name
+          }
+        end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Workarea
+  module FlowIo
+    class RoutingContraints
+      def matches?(request)
+        request.params[:locale].blank? ||
+          FlowIo::Countries.all.any? { |c| c.iso_3166_3.downcase == request.params[:locale] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Workarea
+  module FlowIo
+    class Session
+      attr_reader :request
+
+      def initialize(env)
+        @request = ActionDispatch::Request.new(env)
+        @set_f60_session_cookie = false
+      end
+
+      def experience
+        if cookies.key?("flow_experience")
+          experience_from_cookies
+        else
+          session.experience
+        end
+      end
+
+      def flow_country
+        if cookies.key?("flow_country")
+          cookies["flow_country"]
+        else
+          session&.geo&.country&.iso_3166_3&.downcase
+        end
+      end
+
+      def id
+        session.id
+      end
+
+      def session
+        @session ||= session_from_cookies || create_session!
+      end
+
+      def set_f60_session_cookie?
+        @set_f60_session_cookie || !cookies.key?('_f60_session')
+      end
+
+      def set_flow_experience_cookie?
+        !cookies.key?('flow_experience')
+      end
+
+      def set_flow_country_cookie?
+        !cookies.key?('flow_country')
+      end
+
+      private
+
+        delegate :params, to: :request
+
+        # gets session id from cookies and pulls it from Flow API
+        # if the request 404s creates a new session
+        def session_from_cookies
+          return unless cookies['_f60_session'].present?
+
+          FlowIo.client.sessions.get_by_session(cookies['_f60_session'])
+        rescue ::Io::Flow::V0::HttpClient::ServerError => error
+          if error.code == 404
+            @set_f60_session_cookie = true
+            return create_session!
+          else
+            raise error
+          end
+        end
+
+        def create_session!
+          Workarea::FlowIo.client.sessions.post_organizations_by_organization(
+            Workarea::FlowIo.organization_id,
+            { ip: request.remote_ip, country: country }.compact
+          )
+        end
+
+        def experience_from_cookies
+          return unless cookies["flow_experience"].present?
+
+          ::Io::Flow::V0::Models::ExperienceGeo.new(JSON.parse(cookies[:flow_experience]))
+        rescue
+          nil
+        end
+
+        def country
+          request.env['HTTP_GEOIP_CITY_COUNTRY_CODE3']
+        end
+
+        def cookies
+          request.cookie_jar
+        end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Workarea
+  module FlowIo
+    class Webhook
+      class Error < RuntimeError; end
+      class Error::NotFound < RuntimeError; end
+      class Error::UnhandledWebhook < RuntimeError; end
+
+      # @param ::Io::Flow::V0::Models::Event
+      def self.process(event)
+        begin
+          klass = "Workarea::FlowIo::Webhook::#{event.discriminator.classify}".constantize
+        rescue NameError => _error
+          raise Error::UnhandledWebhook, "no class defined to handle #{event.discriminator.classify}"
+        end
+
+        klass.new(event).process
+      end
+
+      attr_reader :event
+
+      def initialize(event)
+        @event = event
+      end
+
+      def process; end
+    end
+  end
+end

data/app/services/workarea/flow_io/webhook/experience_deleted_v2.rb

@@ -0,0 +1,9 @@
+module Workarea
+  module FlowIo
+    class Webhook::ExperienceDeletedV2 < Webhook
+      def process
+        FlowIo::Experiences.refresh_cache
+      end
+    end
+  end
+end

data/app/services/workarea/flow_io/webhook/experience_upserted_v2.rb

@@ -0,0 +1,9 @@
+module Workarea
+  module FlowIo
+    class Webhook::ExperienceUpsertedV2 < Webhook
+      def process
+        FlowIo::Experiences.refresh_cache
+      end
+    end
+  end
+end