workarea-flow_io 1.2.1

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

@@ -0,0 +1,36 @@
+module Workarea
+  module FlowIo
+    class CheckoutTokenForm
+      def self.from(order:, session_id:)
+        new(order: order, session_id: session_id).to_flow_model
+      end
+
+      attr_reader :order, :session_id
+
+      def initialize(order:, session_id:)
+        @order = order
+        @session_id = session_id
+      end
+
+      def to_flow_model
+        ::Io::Flow::V0::Models::CheckoutTokenReferenceForm.new(attributes)
+      end
+
+      def attributes
+        {
+          order_number: order.id,
+          session_id: session_id,
+          urls: {
+            continue_shopping: continue_shopping_url
+          }
+        }
+      end
+
+      private
+
+        def continue_shopping_url
+         "https://#{Workarea.config.host}"
+        end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Workarea
+  module FlowIo
+    class Countries
+      def self.all
+        # @return [Io::Flow::V0::Models::Country]
+        Rails.cache.fetch('flow-countries', expires_in: Workarea.config.cache_expirations.flow_io_country_cache) do
+          FlowIo.client
+            .organizations
+            .get_countries_by_organization(Workarea::FlowIo.organization_id)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+module Workarea
+  module FlowIo
+    class DetailedShippingNotificationForm
+      attr_reader :id, :fulfillment
+
+      def self.from(id:, tracking_number:)
+        order = Workarea::Order.find id
+        shipping = Workarea::Shipping.find_by_order id
+        fulfillment = Workarea::Fulfillment.find id
+
+        new(order: order, shipping: shipping, fulfillment: fulfillment, tracking_number: tracking_number).to_flow_model
+      end
+
+      attr_reader :order, :shipping, :fulfillment, :tracking_number
+
+      def initialize(order:, shipping:, fulfillment:, tracking_number:)
+        @order = order
+        @shipping = shipping
+        @fulfillment = fulfillment
+        @tracking_number = tracking_number
+      end
+
+      # @return ::Io::Flow::V0::Models::DetailedShippingNotificationForm
+      def to_flow_model
+        ::Io::Flow::V0::Models::DetailedShippingNotificationForm.new(
+          attributes: { number: order.id },
+          carrier_tracking_number: tracking_number,
+          destination: {
+            contact: {
+              name: {
+                first: shipping_address.first_name,
+                last: shipping_address.last_name
+              },
+              phone: shipping_address.phone_number
+            },
+            location: {
+              streets: [shipping_address.street, shipping_address.street_2].compact,
+              city: shipping_address.city,
+              province: shipping_address.region,
+              postal: shipping_address.postal_code,
+              country: shipping_address.country.alpha3
+            }
+          },
+          order_number: order.id,
+          package: package,
+          service: shipping.shipping_service.service_code
+        )
+      end
+
+      private
+
+        def shipping_address
+          shipping&.address
+        end
+
+        def workarea_package
+          @workarea_package ||= Storefront::PackageViewModel.wrap(
+            fulfillment.find_package(tracking_number),
+            order: order
+          )
+        end
+
+        def discounts
+          @discounts ||= Pricing::Discount
+            .where(:_id.in => order.discount_ids)
+            .to_a
+        end
+
+        # TODO - IMPROVEMENT if using workarea-oms send package information
+        #
+        def package
+          {
+            dimensions: {},
+            items: workarea_package.items.map do |fulfillment_item_view_model|
+              FlowIo::LineItemForm.from(
+                order_item: fulfillment_item_view_model,
+                discounts: discounts
+              )
+            end
+          }
+        end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Workarea
+  module FlowIo
+    class Experiences
+      def self.all
+        # @return [::Io::Flow::V0::Models::Experience]
+        Rails.cache.fetch("flow-expereinces-#{FlowIo.organization_id}", expires_in: 1.hour) do
+          FlowIo.client.experiences.get(FlowIo.organization_id).select do |experience|
+            experience.status.value == "active"
+          end
+        end
+      end
+
+      def self.refresh_cache
+        Rails.cache.delete("flow-expereinces-#{FlowIo.organization_id}")
+        Experiences.all
+      end
+
+      # @return [String]
+      def self.all_currencies
+        Experiences.all.map(&:currency).uniq
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Workarea
+  module FlowIo
+    class FulfillmentCancellationForm
+      def self.from(id:, quantities:)
+        order = Workarea::Order.find id
+
+        new(order: order, quantities: quantities).to_flow_model
+      end
+
+      attr_reader :order, :quantities
+
+      def initialize(order:, quantities:)
+        @order = order
+        @quantities = quantities
+      end
+
+      # @return ::Io::Flow::V0::Models::FulfillmentCancellationForm
+      def to_flow_model
+        ::Io::Flow::V0::Models::FulfillmentCancellationForm.new(
+          reason: "consumer_requested",
+          lines: lines
+        )
+      end
+
+      private
+
+        def lines
+          @lines ||= quantities.map do |order_item_id, quantity|
+            order_item = order.items.detect { |item| item.id.to_s == order_item_id.to_s }
+            next unless order_item.present?
+
+            {
+              item_number: order_item.sku,
+              quantity: quantity.to_i
+            }
+          end.compact
+        end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+module Workarea
+  module FlowIo
+    class Item
+      include ActionView::Helpers::AssetUrlHelper
+      include Core::Engine.routes.url_helpers
+      include Workarea::ApplicationHelper
+
+      attr_reader :product, :sku
+      delegate :name, :description, to: :product
+
+      def initialize(product, sku)
+        @product = product
+        @sku = sku
+      end
+
+      def form
+        ::Io::Flow::V0::Models::ItemForm.new(self.to_h)
+      end
+
+      def to_h
+        {
+          number:     sku,
+          locale:     FlowIo.config.original_locale,
+          name:       name,
+          currency:   pricing_sku.sell_price.currency.iso_code,
+          price:      price,
+          categories: categories,
+          attributes: attributes,
+          dimensions: dimensions,
+          images:     images
+        }
+      end
+
+      private
+
+      def variant
+        @variant ||= product.variants.find_by(sku: sku)
+      end
+
+      def shipping_sku
+        @shipping_sku ||= Shipping::Sku.find(sku) rescue nil
+      end
+
+      def pricing_sku
+        @pricing_sku ||= Pricing::Sku.find(sku) rescue Pricing::Sku.new(id: sku)
+      end
+
+      def price
+        pricing_sku.sell_price.dollars.to_f
+      end
+
+      def categories
+        @categories ||= Categorization.new(product).to_models.map(&:name)
+      end
+
+      def attributes
+        variant_attributes.merge(
+          "product_id" => product.id,
+          "msrp" => pricing_sku.msrp&.dollars&.to_f,
+          "regular_price" => sku_price.regular.dollars.to_f,
+          "sale_price" => sku_price.sale&.dollars&.to_f,
+          "fulfillment_method" => product.digital ? "digital" : "physical"
+        ).compact.map { |k, v| [k, v.to_s] }.to_h
+      end
+
+      def dimensions
+        return unless shipping_sku.present?
+
+        spatial_dimensions =
+          if shipping_sku.dimensions.present?
+            {
+              depth:  { value: shipping_sku.height, units: shipping_sku.length_units },
+              length: { value: shipping_sku.length, units: shipping_sku.length_units },
+              width:  { value: shipping_sku.width,  units: shipping_sku.length_units },
+            }
+          else
+            {}
+          end
+
+        weight =
+          if shipping_sku.weight.present?
+            { weight: { value: shipping_sku.weight, units: shipping_sku.weight_units } }
+          else
+            {}
+          end
+
+        { packing: spatial_dimensions.merge(weight) }
+      end
+
+      def variant_specific_images
+        @variant_specific_images ||=
+          begin
+            sku_options = variant.details.values.flat_map { |options| options.map(&:optionize) }
+
+            product.images.select do |image|
+              sku_options.include?(image.option.optionize)
+            end
+          end
+      end
+
+      def images
+        @images ||= (variant_specific_images || [product.images.first]).flat_map do |image|
+          FlowIo.image_sizes.map do |processor, tags|
+            { url: product_image_url(image, processor), tags: tags }
+          end
+        end
+      end
+
+      def sku_price
+        @sku_price ||= pricing_sku.find_price(quantity: 1)
+      end
+
+      def variant_attributes
+        variant.details.map { |k, v| [k, v.join(', ')] }.to_h
+      end
+
+      def mounted_core
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Workarea
+  module FlowIo
+    class ItemImporter
+      def self.perform!(item)
+        new(item).perform!
+      end
+
+      attr_reader :item
+
+      def initialize(item)
+        @item = item
+      end
+
+      def perform!
+        if local_item.present?
+          local_item.update_attributes local_item_attributes
+        else
+          pricing_sku.flow_io_local_items.create!(local_item_attributes)
+        end
+        Sidekiq::Callbacks.disable(Workarea::FlowIo::ItemExporter) do
+          pricing_sku.save
+        end
+      end
+
+      private
+        delegate :local, to: :item
+        delegate :experience, to: :local
+
+        def sku
+          item.number
+        end
+
+        def pricing_sku
+          @pricing_sku ||= Pricing::Sku.find sku
+        end
+
+        def local_item
+          @local_item ||= pricing_sku
+            .flow_io_local_items
+            .detect { |li| li.experience.key == experience.key }
+        end
+
+        def pricing_attributes
+          @pricing_attributes || local.price_attributes.symbolize_keys
+        end
+
+        def msrp_attributes
+          @msrp_attributes ||= pricing_attributes[:msrp]
+        end
+
+        def msrp
+          return {} unless msrp_attributes.present?
+
+          {
+            msrp: {
+              price: msrp_attributes.to_m,
+              label: msrp_attributes.label,
+              base_currency: { price: msrp_attributes.base.to_m, label: msrp_attributes.base.label }
+            }
+          }
+        end
+
+        def local_item_attributes
+          {
+            experience: {
+              id:       experience.id,
+              key:      experience.key,
+              name:     experience.name,
+              country:  Country.find_country_by_alpha3(experience.country),
+              currency: experience.currency,
+              language: experience.language
+            },
+            prices: prices
+          }.merge(msrp)
+        end
+
+        def prices
+          regular = pricing_attributes[:regular_price]
+          sale    = pricing_attributes[:sale_price]
+
+          price = {
+            min_quantity: 1,
+            regular: {
+              price: regular.to_m,
+              label: regular.label,
+              base_currency: {
+                price: regular.base.to_m,
+                label: regular.base.label
+              }
+            }
+          }
+
+          if sale.present?
+            price[:sale] = {
+              price: sale.to_m,
+              label: sale.label,
+              base_currency: {
+                price: sale.base.to_m,
+                label: sale.base.label
+              }
+            }
+          end
+
+          [price]
+        end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Workarea
+  module FlowIo
+    class LineItemForm
+      def self.from(order_item:, discounts:)
+        new(order_item: order_item, discounts: discounts).to_flow_model
+      end
+
+      attr_reader :order_item, :discounts
+
+      def initialize(order_item:, discounts:)
+        @order_item = order_item
+        @discounts = discounts
+      end
+
+      def price
+        ::Io::Flow::V0::Models::Money.new(
+          amount: base_item_price.cents,
+          currency: base_item_price.currency.to_s
+        )
+      end
+
+      def to_h
+        {
+          number: order_item.sku,
+          quantity: order_item.quantity,
+          price: price,
+          discounts: discounts_form
+        }
+      end
+
+      def to_flow_model
+        ::Io::Flow::V0::Models::LineItemForm.new(to_h)
+      end
+
+      private
+
+        # Discount price adjustments for the order_item
+        #
+        # @return [Array<Workarea::PriceAdjustment>]
+        #
+        def discount_price_adjustments
+          order_item.price_adjustments.discounts
+        end
+
+        def base_item_price
+          order_item
+            .flow_price_adjustments
+            .adjusting('item')
+            .reject(&:discount?)
+            .sum
+        end
+
+        def discounts_form
+          ::Io::Flow::V0::Models::DiscountsForm.new(
+            discounts: discount_price_adjustments.map do |discount_price_adjustment|
+              {
+                offer: {
+                  money: {
+                    amount: discount_price_adjustment.amount.abs.to_f,
+                    currency: discount_price_adjustment.amount.currency.iso_code
+                  },
+                  discriminator: ::Io::Flow::V0::Models::DiscountOffer::Types::DISCOUNT_OFFER_FIXED
+                },
+                target: "item",
+                label: discount_price_adjustment.description
+              }
+            end
+          )
+        end
+    end
+  end
+end