shopify_transporter 1.0.0

data/lib/shopify_transporter/pipeline/magento/customer/top_level_attributes.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'shopify_transporter/pipeline/stage'
+require 'shopify_transporter/shopify'
+
+module ShopifyTransporter
+  module Pipeline
+    module Magento
+      module Customer
+        class TopLevelAttributes < Pipeline::Stage
+          def convert(hash, record)
+            accumulator = TopLevelAttributesAccumulator.new(record)
+            accumulator.accumulate(hash)
+            record.merge!(accumulator.output)
+          end
+
+          class TopLevelAttributesAccumulator < Shopify::AttributesAccumulator
+            COLUMN_MAPPING = {
+              'firstname' => 'first_name',
+              'lastname' => 'last_name',
+              'email' => 'email',
+            }
+
+            private
+
+            def input_applies?(_input)
+              true
+            end
+
+            def attributes_from(input)
+              attributes = COLUMN_MAPPING.each_with_object({}) do |(key, value), obj|
+                obj[value] = input[key] if input[key]
+              end
+              attributes['accepts_marketing'] = accepts_marketing(input)
+              attributes
+            end
+
+            def accepts_marketing(input)
+              value = input['is_subscribed']
+              return unless value.present?
+              (value == '1').to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/pipeline/magento/order/addresses_attribute.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'shopify_transporter/pipeline/stage'
+require 'shopify_transporter/shopify'
+module ShopifyTransporter
+  module Pipeline
+    module Magento
+      module Order
+        class AddressesAttribute < Pipeline::Stage
+          BILLING_PREFIX = 'billing_'
+          SHIPPING_PREFIX = 'shipping_'
+
+          def convert(input, record)
+            record['billing_address'] = address_attributes(input, BILLING_PREFIX)
+            record['shipping_address'] = address_attributes(input, SHIPPING_PREFIX)
+            record
+          end
+
+          private
+
+          def get_nested_address(input, prefix)
+            items = input['items']
+            result = items && items['result']
+            address = result && result["#{prefix}address"]
+            address || []
+          end
+
+          def address_attributes(input, prefix)
+            address_attrs = get_nested_address(input, prefix)
+            return address_attrs unless address_attrs.present?
+
+            {
+              first_name: address_attrs['firstname'],
+              last_name: address_attrs['lastname'],
+              phone: address_attrs['telephone'],
+              address1: address_attrs['street'],
+              city: address_attrs['city'],
+              province_code: address_attrs['region'],
+              zip: address_attrs['postcode'],
+              country_code: address_attrs['country_id'],
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/pipeline/magento/order/line_items.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require 'shopify_transporter/pipeline/stage'
+require 'shopify_transporter/shopify'
+
+module ShopifyTransporter
+  module Pipeline
+    module Magento
+      module Order
+        class LineItems < Pipeline::Stage
+          def convert(input, record)
+            record.merge!(
+              {
+                line_items: line_items(input),
+              }.stringify_keys
+            )
+          end
+
+          private
+
+          def line_items(input)
+            line_items = line_items_array(input)
+            line_items.map { |item| line_item(item) }
+          end
+
+          def line_items_array(input)
+            items_1 = input['items']
+            result = items_1 && items_1['result']
+            items_2 = result && result['items']
+            item = items_2 && items_2['item']
+            return [] unless item
+            item.is_a?(Array) ? item : [item]
+          end
+
+          def line_item(item)
+            {
+              quantity: item['qty_ordered'],
+              sku: item['sku'],
+              name: item['name'],
+              price: item['price'],
+              tax_lines: tax_lines(item),
+            }.stringify_keys
+          end
+
+          def tax_lines(item)
+            {
+              title: 'Tax',
+              price: item['tax_amount'],
+              rate: item['tax_percent'],
+            }.stringify_keys
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/pipeline/magento/order/top_level_attributes.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require 'shopify_transporter/pipeline/stage'
+require 'shopify_transporter/shopify'
+
+module ShopifyTransporter
+  module Pipeline
+    module Magento
+      module Order
+        class TopLevelAttributes < Pipeline::Stage
+          def convert(hash, record)
+            record.merge!(
+              {
+                name: hash['increment_id'],
+                email: hash['customer_email'],
+                processed_at: hash['created_at'],
+                subtotal_price: hash['subtotal'],
+                total_tax: hash['tax_amount'],
+                total_price: hash['grand_total'],
+              }.stringify_keys
+            )
+            customer = build_customer(hash)
+            record['customer'] = customer unless customer.empty?
+            record
+          end
+
+          private
+
+          def build_customer(hash)
+            {
+              email: hash['customer_email'],
+              first_name: hash['customer_firstname'],
+              last_name: hash['customer_lastname'],
+            }.stringify_keys
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/pipeline/magento/product/top_level_attributes.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'shopify_transporter/pipeline/stage'
+require 'shopify_transporter/shopify'
+
+module ShopifyTransporter
+  module Pipeline
+    module Magento
+      module Product
+        class TopLevelAttributes < Pipeline::Stage
+          def convert(hash, record)
+            accumulator = TopLevelAttributesAccumulator.new(record)
+            accumulator.accumulate(hash)
+          end
+
+          class TopLevelAttributesAccumulator < Shopify::AttributesAccumulator
+            COLUMN_MAPPING = {
+              'sku' => 'sku',
+              'name' => 'title',
+              'description' => 'body_html',
+            }
+
+            private
+
+            def input_applies?(_input)
+              true
+            end
+
+            def attributes_from(input)
+              map_from_key_to_val(COLUMN_MAPPING, input)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/pipeline/stage.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module ShopifyTransporter
+  module Pipeline
+    class Stage
+      attr_reader :params
+
+      def initialize(params = nil)
+        @params = params
+      end
+
+      def convert(_hash, _record)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/shopify_transporter/pipeline.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+require_relative 'pipeline/stage.rb'
+Dir["#{File.dirname(__FILE__)}/pipeline/all_platforms/*.rb"].each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/pipeline/magento/**/*.rb"].each { |f| require f }

data/lib/shopify_transporter/record_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ShopifyTransporter
+  class KeyMissing < StandardError
+    def initialize(key_name)
+      super("cannot process entry. Required field not found: '#{key_name}'")
+    end
+  end
+
+  class RequiredKeyMissing < KeyMissing; end
+
+  class MissingParentObject < KeyMissing; end
+
+  class RecordBuilder
+    attr_accessor :instances
+
+    def initialize(key_name, key_required)
+      @instances = {}
+      @key_name = key_name
+      @key_required = key_required
+    end
+
+    def build(input)
+      validate_related(input)
+
+      if key_of(input).nil?
+        yield @last_record
+        return
+      end
+
+      yield record_from(input)
+    end
+
+    private
+
+    def validate_related(input)
+      raise MissingParentObject, @key_name if key_of(input).nil? && @last_record.nil?
+    end
+
+    def record_from(input)
+      record = @instances[key_of(input)] ||= {}
+      @last_record = record
+    end
+
+    def key_of(input)
+      record_key = input[@key_name]
+      raise RequiredKeyMissing, @key_name if @key_required && record_key.nil?
+      record_key
+    end
+  end
+end

data/lib/shopify_transporter/shopify/attributes_accumulator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative 'attributes_helpers'
+
+module ShopifyTransporter
+  module Shopify
+    class AttributesAccumulator
+      include AttributesHelpers
+
+      attr_reader :output
+
+      def initialize(initial_value)
+        @output = initial_value
+      end
+
+      def accumulate(input)
+        return @output unless input_applies?(input)
+        attributes = attributes_from(input)
+        accumulate_attributes(attributes)
+      end
+
+      private
+
+      def input_applies?(_input)
+        raise NotImplementedError
+      end
+
+      def attributes_from(_input)
+        raise NotImplementedError
+      end
+
+      def accumulate_attributes(attributes)
+        case @output
+        when Array
+          @output << attributes
+        when Hash
+          @output.merge!(attributes)
+        else
+          raise 'Unexpected initial value. Initial value must be an array or a hash.'
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/shopify/attributes_helpers.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require "active_support/core_ext/string"
+module ShopifyTransporter
+  module Shopify
+    module AttributesHelpers
+      def attributes_present?(row, *attributes)
+        row.slice(*attributes).any? { |_, v| v.present? }
+      end
+
+      def add_prefix(prefix, *attributes)
+        [*attributes].map { |attribute| "#{prefix}#{attribute}".to_sym }
+      end
+
+      def drop_prefix(row, prefix)
+        row.transform_keys { |key| key.to_s.remove(prefix).to_sym }
+      end
+
+      def delete_empty_attributes(row)
+        row.delete_if { |_, v| v.respond_to?(:empty?) && v.empty? }
+      end
+
+      def normalize_keys(row)
+        row.compact.transform_keys { |key| normalize_string(key).to_sym }
+      end
+
+      def normalize_string(str)
+        str.to_s.parameterize.underscore
+      end
+
+      def rename_fields(row, field_map)
+        return row unless field_map.present?
+        row = row.dup
+        field_map.each { |from, to| row[to] = row.delete from if row[from].present? }
+        row
+      end
+
+      def map_from_key_to_val(mapper, input)
+        mapper.each_with_object({}) do |(key, value), attributes|
+          attributes[value] = input[key] if input[key]
+        end
+      end
+
+      def shopify_metafield_hash(key:, value:, value_type: 'string', namespace:)
+        {
+          'key' => key,
+          'value' => value,
+          'value_type' => value_type,
+          'namespace' => namespace,
+        }
+      end
+    end
+  end
+end

data/lib/shopify_transporter/shopify/customer.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require_relative 'record'
+require 'active_support/inflector'
+require 'csv'
+
+module ShopifyTransporter
+  module Shopify
+    class Customer < Record
+      class << self
+        def header
+          columns.map(&:titleize).to_csv
+        end
+
+        def keys
+          %w(email phone).freeze
+        end
+
+        def columns
+          %w(
+            first_name last_name email phone accepts_marketing tags
+            note tax_exempt company address1 address2 city province
+            province_code zip country country_code metafield_namespace
+            metafield_key metafield_value metafield_value_type
+          ).freeze
+        end
+      end
+
+      def to_csv
+        CSV.generate do |csv|
+          csv << top_level_row_values
+          address_row_values.each { |row| csv << row }
+          metafield_row_values.each { |row| csv << row }
+        end
+      end
+
+      private
+
+      TOP_LEVEL_ATTRIBUTES = %w(
+        first_name last_name email phone
+        accepts_marketing
+        tags
+        note
+        tax_exempt
+      ).freeze
+
+      ADDRESS_ATTRIBUTES = %w(
+        first_name last_name phone
+        company
+        address1 address2
+        city
+        province province_code zip
+        country country_code
+      ).freeze
+
+      SHARED_ADDRESS_ATTRIBUTES = %w(
+        first_name last_name phone
+      ).freeze
+
+      def top_level_row_values
+        base_hash.merge(record_hash.slice(*TOP_LEVEL_ATTRIBUTES)).values
+      end
+
+      def address_row_values
+        return [] unless record_hash['addresses']
+        record_hash['addresses'].map do |address_hash|
+          address = address_hash.slice(*ADDRESS_ATTRIBUTES)
+          populate_missing_address_attributes!(address)
+          row_values_from(address) if self.class.has_values?(address)
+        end.compact
+      end
+
+      def populate_missing_address_attributes!(address)
+        SHARED_ADDRESS_ATTRIBUTES.each do |shared_attribute|
+          address[shared_attribute] = record_hash[shared_attribute] if address[shared_attribute].nil?
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/shopify/order.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+require 'active_support/inflector'
+require 'csv'
+require_relative 'attributes_helpers'
+require_relative 'record'
+
+module ShopifyTransporter
+  module Shopify
+    class Order < Record
+      class << self
+        include AttributesHelpers
+
+        def header
+          [
+            'Name', 'Email', 'Financial Status', 'Fulfillment Status', 'Currency',
+            'Buyer Accepts Marketing', 'Cancel Reason', 'Cancelled At', 'Closed At', 'Tags', 'Note',
+            'Phone', 'Referring Site', 'Processed At', 'Source name', 'Total discounts', 'Total weight',
+            'Total Tax', 'Shipping Company', 'Shipping Name', 'Shipping Phone', 'Shipping First Name',
+            'Shipping Last Name', 'Shipping Address1', 'Shipping Address2', 'Shipping City',
+            'Shipping Province', 'Shipping Province Code', 'Shipping Zip', 'Shipping Country',
+            'Shipping Country Code', 'Billing Company', 'Billing Name', 'Billing Phone',
+            'Billing First Name', 'Billing Last Name', 'Billing Address1', 'Billing Address2',
+            'Billing City', 'Billing Province', 'Billing Province Code', 'Billing Zip',
+            'Billing Country', 'Billing Country Code', 'Lineitem name', 'Lineitem quantity',
+            'Lineitem price', 'Lineitem discount', 'Lineitem compare at price', 'Lineitem sku',
+            'Lineitem requires shipping', 'Lineitem taxable', 'Lineitem fulfillment status',
+            'Tax 1 Title', 'Tax 1 Price', 'Tax 1 Rate', 'Tax 2 Title', 'Tax 2 Price', 'Tax 2 Rate',
+            'Tax 3 Title', 'Tax 3 Price', 'Tax 3 Rate', 'Metafield Namespace', 'Metafield Key',
+            'Metafield Value', 'Metafield Value Type'
+          ].to_csv
+        end
+
+        def keys
+          %w(name).freeze
+        end
+
+        def columns
+          @columns ||= header.split(',').map do |header_column|
+            normalize_string(header_column)
+          end
+        end
+      end
+
+      def to_csv
+        CSV.generate do |csv|
+          csv << top_level_row_values
+          line_item_row_values.each { |row| csv << row }
+          metafield_row_values.each { |row| csv << row }
+        end
+      end
+
+      private
+
+      TOP_LEVEL_ATTRIBUTES = %w(
+        name email financial_status fulfillment_status currency
+        buyer_accepts_marketing cancel_reason cancelled_at closed_at tags note
+        phone referring_site processed_at source_name total_discounts total_weight total_tax
+      )
+
+      ADDRESS_ATTRIBUTES = %w(
+        company name phone first_name last_name address1 address2 city province province_code zip country country_code
+      )
+
+      LINE_ITEM_PREFIX = "lineitem_"
+
+      LINE_ITEM_ATTRIBUTES = %w(
+        name quantity price discount compare_at_price sku requires_shipping taxable fulfillment_status
+      )
+
+      def address_hash_for(address_hash, prefix)
+        return {} if address_hash.blank?
+
+        address_hash.transform_keys { |k| "#{prefix}#{k}" }
+      end
+
+      def top_level_row_values
+        top_level_hash = record_hash
+          .slice(*TOP_LEVEL_ATTRIBUTES)
+          .merge(address_hash_for(record_hash['billing_address'], 'billing_'))
+          .merge(address_hash_for(record_hash['shipping_address'], 'shipping_'))
+        self.class.has_values?(top_level_hash) ? row_values_from(top_level_hash) : nil
+      end
+
+      def tax_line_hash(line_item_hash)
+        return {} if line_item_hash['tax_lines'].blank?
+
+        line_item_hash['tax_lines'].each_with_index.map do |tax_line, index|
+          tax_line.each_with_object({}) do |(key, val), hash|
+            hash["tax_#{index + 1}_#{key}"] = val
+          end
+        end.reduce({}, :merge)
+      end
+
+      def line_item_row_values
+        return [] unless record_hash['line_items']
+
+        record_hash['line_items'].map do |line_item_hash|
+          line_item = line_item_hash.slice(*LINE_ITEM_ATTRIBUTES)
+            .transform_keys! { |k| "#{LINE_ITEM_PREFIX}#{k}" }
+            .merge(tax_line_hash(line_item_hash))
+
+          row_values_from(line_item) if self.class.has_values?(line_item)
+        end.compact
+      end
+    end
+  end
+end