shopify_transporter 1.0.0 → 2.0.0

data/lib/shopify_transporter/exporters/magento/magento_exporter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative './customer_exporter.rb'
+require_relative './order_exporter.rb'
+require_relative './product_exporter.rb'
+
+module ShopifyTransporter
+  module Exporters
+    module Magento
+      class MissingExporterError < ExportError; end
+
+      class MagentoExporter
+        def self.for(type: nil)
+          case type
+          when 'customer'
+            CustomerExporter
+          when 'order'
+            OrderExporter
+          when 'product'
+            ProductExporter
+          else
+            raise MissingExporterError
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/exporters/magento/order_exporter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ShopifyTransporter
+  module Exporters
+    module Magento
+      class OrderExporter
+        def initialize(soap_client: nil, database_adapter: nil)
+          @client = soap_client
+          @database_adapter = database_adapter
+        end
+
+        def key
+          :order_id
+        end
+
+        def export
+          base_orders.each do |order|
+            yield with_attributes(order)
+          end
+        end
+
+        private
+
+        def with_attributes(base_order)
+          base_order.merge(items: info_for(base_order[:increment_id]))
+        end
+
+        def base_orders
+          Enumerator.new do |enumerator|
+            @client.call_in_batches(method: :sales_order_list, batch_index_column: 'order_id').each do |batch|
+              result = batch.body[:sales_order_list_response][:result][:item] || []
+              result = [result] unless result.is_a? Array
+              result.each { |order| enumerator << order }
+            end
+          end
+        end
+
+        def info_for(order_increment_id)
+          @client
+            .call(:sales_order_info, order_increment_id: order_increment_id)
+            .body[:sales_order_info_response]
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/exporters/magento/product_exporter.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative './database_table_exporter.rb'
+require_relative './database_cache.rb'
+require_relative './product_options.rb'
+
+module ShopifyTransporter
+  module Exporters
+    module Magento
+      class ProductExporter
+        def initialize(soap_client: nil, database_adapter: nil)
+          @client = soap_client
+          @database_table_exporter = DatabaseTableExporter.new(database_adapter)
+          @database_cache = DatabaseCache.new
+          @product_options = ProductOptions.new(@database_table_exporter, @database_cache)
+        end
+
+        def key
+          :product_id
+        end
+
+        def export
+          base_products.each do |product|
+            yield with_attributes(product)
+          end
+        end
+
+        private
+
+        def base_products
+          Enumerator.new do |enumerator|
+            @client.call_in_batches(method: :catalog_product_list, batch_index_column: 'product_id').each do |batch|
+              result = batch.body[:catalog_product_list_response][:store_view][:item] || []
+              result = [result] unless result.is_a? Array
+              with_parent_mappings(result).each { |product| enumerator << product }
+            end
+          end
+        end
+
+        def product_mappings
+          @product_mappings ||= begin
+            @database_table_exporter.export_table('catalog_product_relation', 'parent_id')
+
+            {}.tap do |product_mapping_table|
+              @database_cache.table('catalog_product_relation').each do |row|
+                product_mapping_table[row['child_id']] = row['parent_id']
+              end
+            end
+          end
+        end
+
+        def with_parent_mappings(product_list)
+          product_list.map do |product|
+            case product[:type]
+            when 'simple'
+              merge_simple_product_with_parent(product, product_mappings)
+            else
+              product
+            end
+          end
+        end
+
+        def merge_simple_product_with_parent(product, product_mappings)
+          return product unless product_mappings[product[:product_id]].present?
+
+          product.merge(parent_id: product_mappings[product[:product_id]])
+        end
+
+        def with_attributes(product)
+          product_with_base_attributes = product
+            .merge(images: images_attribute(product[:product_id]))
+            .merge(info_for(product))
+            .merge(tags: product_tags(product[:product_id]))
+
+          case product[:type]
+          when 'simple'
+            product_with_base_attributes
+              .merge(inventory_quantity: inventory_quantity_for(product[:product_id]))
+              .merge(variant_option_values(product_with_base_attributes))
+          when 'configurable'
+            product_with_base_attributes
+              .merge(configurable_product_options(product_with_base_attributes))
+          else
+            product_with_base_attributes
+          end
+        end
+
+        def variant_option_values(simple_product)
+          @product_options.shopify_variant_options(simple_product)
+        end
+
+        def configurable_product_options(product)
+          @product_options.shopify_option_names(product[:product_id])
+        end
+
+        def info_for(product)
+          additional_attributes = @product_options.lowercase_option_names(product[:parent_id]) if product[:parent_id]
+          attributes = { 'additional_attributes' => { item: additional_attributes } } if additional_attributes
+
+          @client
+            .call(
+              :catalog_product_info,
+              product_id: product[:product_id],
+              attributes: attributes
+            )
+            .body[:catalog_product_info_response][:info]
+        end
+
+        def inventory_quantity_for(product_id)
+          @client
+            .call(:catalog_inventory_stock_item_list, products: { product_id: product_id })
+            .body[:catalog_inventory_stock_item_list_response][:result][:item][:qty].to_i
+        end
+
+        def images_attribute(product_id)
+          @client
+            .call(:catalog_product_attribute_media_list, product: product_id.to_i)
+            .body[:catalog_product_attribute_media_list_response][:result][:item]
+        end
+
+        def product_tags(product_id)
+          @client
+            .call(:catalog_product_tag_list, product_id: product_id.to_i)
+            .body[:catalog_product_tag_list_response][:result][:item]
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/exporters/magento/product_options.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ShopifyTransporter
+  module Exporters
+    module Magento
+      class ProductOptions
+        def initialize(database_table_exporter, database_cache)
+          @database_table_exporter = database_table_exporter
+          @database_cache = database_cache
+
+          export_required_tables
+        end
+
+        def shopify_option_names(parent_product_id)
+          option_names(parent_product_id).each_with_index.with_object({}) do |(option_name, index), obj|
+            obj["option#{index + 1}_name".to_sym] = option_name
+          end
+        end
+
+        def lowercase_option_names(parent_product_id)
+          option_names(parent_product_id).map(&:downcase)
+        end
+
+        def shopify_variant_options(simple_product)
+          return {} unless simple_product_has_required_option_keys(simple_product)
+
+          parent_product_options = lowercase_option_names(simple_product[:parent_id])
+          variant_attributes = simple_product[:additional_attributes][:item]
+          variant_attributes = [variant_attributes] unless variant_attributes.is_a?(Array)
+          parent_product_options.each_with_index.with_object({}) do |(option_name, index), obj|
+            option_value_id = fetch_option_value_id(option_name, variant_attributes)
+
+            obj["option#{index + 1}_name".to_sym] = option_name.capitalize
+            obj["option#{index + 1}_value".to_sym] = option_value(option_value_id)
+          end
+        end
+
+        private
+
+        def option_names(product_id)
+          option_lookup[product_id] || []
+        end
+
+        def option_value(soap_value_id)
+          option_value_lookup[soap_value_id] || nil
+        end
+
+        def fetch_option_value_id(option_name, variant_attributes)
+          option_attribute_hash = variant_attributes.select do |attribute|
+            attribute[:key] == option_name
+          end.first
+
+          return nil if option_attribute_hash.nil?
+          option_attribute_hash[:value]
+        end
+
+        def simple_product_has_required_option_keys(simple_product)
+          simple_product.key?(:parent_id) && simple_product.key?(:additional_attributes)
+        end
+
+        def export_required_tables
+          @database_table_exporter.export_table('catalog_product_super_attribute', 'product_super_attribute_id')
+          @database_table_exporter.export_table('catalog_product_super_attribute_label', 'value_id')
+          @database_table_exporter.export_table('eav_attribute_option_value', 'value_id')
+        end
+
+        def option_lookup
+          @option_lookup ||= @database_cache
+            .table('catalog_product_super_attribute')
+            .each_with_object({}) do |attribute, option_hash|
+            option_hash[attribute['product_id']] ||= []
+            option_hash[attribute['product_id']] << option_label_lookup[attribute['product_super_attribute_id']]
+          end
+        end
+
+        def option_label_lookup
+          @option_label_lookup ||= @database_cache
+            .table('catalog_product_super_attribute_label')
+            .each_with_object({}) do |label, label_lookup|
+            label_lookup[label['product_super_attribute_id']] = label['value']
+          end
+        end
+
+        def option_value_lookup
+          @option_value_lookup ||= begin
+            soap_value_id_column_key = 'option_id'
+
+            @database_cache
+              .table('eav_attribute_option_value')
+              .each_with_object({}) do |option_value, value_lookup|
+              value_lookup[option_value[soap_value_id_column_key]] = option_value['value']
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/exporters/magento/soap.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'savon'
+
+module ShopifyTransporter
+  module Exporters
+    module Magento
+      class Soap
+        RETRY_SLEEP_TIME = 0.1
+        MAX_RETRIES = 4
+
+        def initialize(hostname: '', username: '', api_key: '', batch_config:)
+          @hostname = hostname
+          @username = username
+          @api_key = api_key
+          @batch_config = batch_config
+        end
+
+        def call(method, params)
+          call_with_retries(method, params)
+        end
+
+        def call_in_batches(method:, params: {}, batch_index_column:)
+          current_id = @batch_config['first_id']
+          max_id = @batch_config['last_id']
+          batch_size = @batch_config['batch_size']
+
+          Enumerator.new do |enumerator|
+            while current_id <= max_id
+              end_of_range = current_id + batch_size - 1
+              end_of_range = max_id if end_of_range >= max_id
+
+              $stderr.puts "Processing batch: #{current_id}..#{end_of_range}"
+
+              enumerator << call(
+                method,
+                params.merge(batching_filter(current_id, end_of_range, batch_index_column)),
+              )
+
+              current_id += batch_size
+            end
+          end
+        end
+
+        private
+
+        def call_with_retries(method, params, retry_count = 0)
+          soap_client.call(
+            method,
+            message: { session_id: soap_session_id }.merge(params)
+          )
+        rescue Savon::Error
+          raise if retry_count >= MAX_RETRIES
+          sleep(RETRY_SLEEP_TIME * (retry_count + 1))
+          call_with_retries(method, params, retry_count + 1)
+        end
+
+        def soap_client
+          @soap_client ||= Savon.client(
+            wsdl: "https://#{@hostname}/api/v2_soap?wsdl",
+            open_timeout: 500,
+            read_timeout: 500,
+          )
+        end
+
+        def soap_session_id
+          @soap_session_id ||= soap_client.call(
+            :login,
+            message: {
+              username: @username,
+              api_key: @api_key,
+            }
+          ).body[:login_response][:login_return]
+        end
+
+        def batching_filter(starting_id, ending_id, batch_index_column)
+          {
+            filters: {
+              'complex_filter' => [
+                item: [
+                  {
+                    key: batch_index_column,
+                    value: {
+                      key: 'in',
+                      value: range_id_string(starting_id, ending_id),
+                    },
+                  },
+                ],
+              ],
+            },
+          }
+        end
+
+        def range_id_string(starting_id, ending_id)
+          (starting_id..ending_id).to_a.join(',')
+        end
+      end
+    end
+  end
+end

data/lib/shopify_transporter/exporters/magento/sql.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'sequel'
+
+module ShopifyTransporter
+  module Exporters
+    module Magento
+      class SQL
+        def initialize(
+          database: '',
+          host: '',
+          port: 3306,
+          user: '',
+          password: ''
+        )
+
+          @database = database
+          @host = host
+          @port = port
+          @user = user
+          @password = password
+        end
+
+        def connect
+          Sequel.connect(
+            adapter: :mysql2,
+            user: @user,
+            password: @password,
+            host: @host,
+            port: @port,
+            database: @database
+          ) do |connection|
+            yield connection
+          end
+        end
+      end
+    end
+  end
+end