workarea-magento_data_importer 1.0.0

data/bin/rails

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/workarea/magento_data_importer/engine', __dir__)
+APP_PATH = File.expand_path('../test/dummy/config/application', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require "rails"
+# Pick the frameworks you want:
+require "active_model/railtie"
+require "active_job/railtie"
+# require "active_record/railtie"
+# require "active_storage/engine"
+require "action_controller/railtie"
+require "action_mailer/railtie"
+require "action_view/railtie"
+# require "action_cable/engine"
+require "sprockets/railtie"
+require "rails/test_unit/railtie"
+require 'rails/engine/commands'

data/config/initializers/workarea.rb

@@ -0,0 +1,3 @@
+Workarea.configure do |config|
+  # Add custom configuration here
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/tasks/magento_import.rake

@@ -0,0 +1,19 @@
+namespace :workarea do
+  namespace :magento do
+    desc 'Import Magento Catalog Data'
+    task import_products: :environment do
+      require 'workarea/seeds'
+
+      Workarea::Seeds.puts_with_color "== Starting Magento Products Migration", :yellow
+
+      raise 'No File provided' if ARGV.length < 2
+
+      file_path = ARGV.second
+
+      Workarea::MagentoDataImporter::ImportProducts.import!(file_path)
+
+      Workarea::Seeds.puts_with_color "\n== Updating Elasticsearch data", :yellow
+      Rake::Task['workarea:search_index:all'].invoke
+    end
+  end
+end

data/lib/workarea/magento_data_importer.rb

@@ -0,0 +1,17 @@
+require 'workarea'
+require 'workarea/storefront'
+require 'workarea/admin'
+
+require 'workarea/magento_data_importer/engine'
+require 'workarea/magento_data_importer/version'
+
+require 'workarea/magento_data_importer/import_products'
+require 'workarea/magento_data_importer/base_product'
+require 'workarea/magento_data_importer/simple_product'
+require 'workarea/magento_data_importer/configurable_product'
+require 'workarea/magento_data_importer/taxonomy'
+
+module Workarea
+  module MagentoDataImporter
+  end
+end

data/lib/workarea/magento_data_importer/base_product.rb

@@ -0,0 +1,192 @@
+module Workarea
+  module MagentoDataImporter
+    class BaseProduct
+      module ProductUrl
+        include Workarea::I18n::DefaultUrlOptions
+        include Storefront::Engine.routes.url_helpers
+        extend self
+      end
+
+      attr_reader :magento_product, :product_data, :product
+
+      def initialize(magento_product)
+        @magento_product = magento_product
+        @product_data = magento_product.product_data.deep_symbolize_keys
+        @product = Workarea::Catalog::Product.find_or_initialize_by(id: magento_product.magento_product_id)
+      end
+
+      private
+
+      # Converts the row's product data into a hash of data to be used in creating
+      # and updating the product information.
+      #
+      # @return [Hash]
+      def product_attributes
+        {
+          name: product_data[:name],
+          description:  product_data[:description],
+          meta_description: product_data[:meta_description],
+        }
+      end
+
+      # Converts the row's product data into a hash of filters.
+      #
+      # @param attrs [Hash] the rows product data
+      # @return [Hash]
+      def row_filters(attrs)
+        return if ENV["product_filter_columns"].blank?
+        filter_columns = ENV["product_filter_columns"]
+        headers = filter_columns.split(",")
+
+        filters = {}
+
+        headers.each do |header|
+          k = header.to_sym
+          v = attrs[k]
+          if v.present?
+            filters[k] = v
+          end
+        end
+        filters
+      end
+
+      # Adds a hash to an existing set of product filters
+      #
+      # @param existing_filters [Hash] the set of existing product filters
+      # @param new_filters [Hash] new filters to add
+      # @return [Hash]
+      def add_filter_values(existing_filters, new_filters)
+        return existing_filters unless new_filters.present?
+
+        new_filters.each do |k, v|
+          if existing_filters.key?(k)
+            existing_filters[k] << v
+            existing_filters[k].uniq!
+          else
+            existing_filters[k] = [v]
+          end
+        end
+        existing_filters
+      end
+
+      # Creates a hash based on the product data's category value, data is split
+      # on "/" which is the default seperator in the magento export
+      #
+      # @return [Hash]
+      def category_filters(attrs)
+        if attrs[:_category].present?
+          { import_category: attrs[:_category].split('/') }
+        else
+          {}
+        end
+      end
+
+      # Creates a hash based on the configured product attributes columns
+      #
+      # @param attrs [Hash] a hash of magento product data
+      # @return [Hash]
+      def build_product_details(attrs)
+        return if ENV["product_attributes_columns"].blank?
+        details_columns = ENV["product_attributes_columns"]
+
+        headers = details_columns.split(",")
+
+        details = {}
+
+        headers.each do |header|
+          k = header.to_sym
+          v = attrs[k]
+          if v.present?
+            details[k] = v
+          end
+        end
+        details
+      end
+
+      # Creates a hash based on the configured product attributes columns
+      #
+      # @param attrs [Hash] a hash of magento product data
+      # @return [Hash]
+      def create_categories(attrs)
+        return unless attrs[:_category].present?
+        categories = attrs[:_category].split('/')
+
+        count = 0
+        max_size = categories.size - 1
+
+        while count <= max_size do
+          client_id =  categories[0..count].join("/")
+          category = Workarea::Catalog::Category.find_or_initialize_by(client_id: client_id)
+
+          category_name = client_id.split("/").last
+          category.name = category_name.titleize
+
+          existing_rules = category.product_rules.map(&:value)
+          category.product_rules.build(name: "import_category", operator: "equals", value: category_name) unless existing_rules.include?(category_name)
+          category.save!
+
+          count = count + 1
+        end
+      end
+
+      # Creates a Workarea::Catalog::ProductImage based on a magento export row
+      #
+      # @param attrs [Hash] a hash of magento product data
+      # @return [Bool]
+      def build_image(attrs)
+        return unless ENV["product_image_base_url"].present? && attrs[:image].present?
+
+        return if attrs[:image] == "no_selection"
+
+        product_image_base_url = ENV["product_image_base_url"]
+        option_column = ENV["image_option_column"]
+
+        image_path = product_image_base_url + attrs[:image]
+
+        option = option_column.present? ? attrs[option_column.to_sym] : nil
+
+        image_attributes = {
+          position: attrs[:_media_position],
+          image_url: image_path,
+          option: option
+        }
+
+        existing_image = product.images.detect { |i| i.image_name == attrs[:image].split('/').last }
+
+        begin
+          if existing_image.present?
+            existing_image.update_attributes!(
+              image_attributes
+            )
+            return
+          else
+            image = product.images.build(image_attributes)
+            image.save!
+          end
+        rescue
+          puts "Error creating image #{attrs[:image]}"
+        end
+      end
+
+      # Creates a redirect based on the attributes url_path
+      #
+      # @param attrs [Hash] a hash of magento product data
+      # @return [Workarea::Navigation::Redirect]
+      def create_redirect(attrs)
+        return unless attrs[:url_path].present?
+        path = attrs[:url_path]
+        destination = ProductUrl.product_path(product)
+
+        Workarea::Navigation::Redirect.create(path: path, destination: destination)
+      end
+
+      def inventory_policy(attrs)
+        if attrs[:backorders] == 1
+          "allow_backorder"
+        else
+          "standard"
+        end
+      end
+    end
+  end
+end

data/lib/workarea/magento_data_importer/configurable_product.rb

@@ -0,0 +1,110 @@
+module Workarea
+  module MagentoDataImporter
+    class ConfigurableProduct < BaseProduct
+      attr_reader :magento_product, :product_data
+
+      def process
+        product.assign_attributes(product_attributes)
+        product.filters = category_filters(product_data)
+
+        product_details = build_product_details(product_data)
+        product.update_details(product_details)
+
+        product.save! rescue puts "Error saving #{magento_product.magento_product_id}"
+
+        create_variants
+
+        create_categories(product_data)
+
+        create_redirect(product_data)
+
+        magento_product.update_attributes!(imported: true)
+      end
+
+      private
+
+      def variant_details_row(products)
+        products.detect { |p| p.product_data[:price].present? }
+      end
+
+      def variant_products
+        @variant_products ||= Workarea::Import::MagentoProduct.where(magento_product_id: magento_product.magento_product_id)
+      end
+
+      def create_variants
+        variant_products.each_with_index do |variant_product, variant_position = 1|
+          variant_product_data = variant_product.product_data.deep_symbolize_keys
+
+          next unless variant_product_data[:_super_products_sku].present?
+
+          sku = variant_product_data[:_super_products_sku].parameterize
+
+          # the "super_products_sku" field points to a record with the required details
+          detail_products = associated_products(variant_product_data[:_super_products_sku])
+
+          # get the record with the pricing and inventory
+          details_row = variant_details_row(detail_products)
+
+          # create the variant sku
+          variant = product.variants.find_or_initialize_by(sku: sku)
+          variant.name = variant_product_data[:sku]
+
+          options = row_filters(variant_product_data)
+          variant.update_details(options)
+
+          variant.save! rescue (puts "#{sku} variant could not be saved" && next)
+
+          pricing_sku = Workarea::Pricing::Sku.find_or_initialize_by(id: sku)
+
+          msrp = details_row.product_data[:msrp].to_m
+          pricing_sku.msrp = msrp if msrp > 0.to_m
+          pricing_sku.prices = [{ regular: details_row.product_data[:price].to_m }]
+          pricing_sku.save! rescue (puts "pricing #{sku} variant could not be saved" && next)
+
+          # create the inventory sku
+          inventory_sku = Workarea::Inventory::Sku.find_or_initialize_by(id: sku)
+          inventory_sku.available = details_row.product_data[:qty] || 0
+          inventory_sku.policy = inventory_policy(details_row.product_data)
+          inventory_sku.save! rescue (puts "inventory #{sku} variant could not be saved" && next)
+
+          detail_product_filters = product.filters
+
+          detail_products.each do |detail_product|
+            detail_product_data = detail_product.product_data.deep_symbolize_keys
+            build_image(detail_product_data)
+
+            create_categories(detail_product_data)
+
+            detail_product_category_filters = category_filters(detail_product_data)
+            detail_product_filters = add_filter_values(detail_product_filters, detail_product_category_filters)
+
+            new_filters = row_filters(detail_product_data)
+            detail_product_filters = add_filter_values(detail_product_filters, new_filters)
+
+            detail_product.imported = true
+            detail_product.save!
+
+            create_redirect(detail_product_data)
+          end
+
+          # Create the categories for variants that are categorized differently than their
+          # parent products.
+          create_categories(variant_product_data)
+          variant_product_category_filters = category_filters(variant_product_data)
+          detail_product_filters = add_filter_values(detail_product_filters, variant_product_category_filters)
+
+          product.filters = detail_product_filters
+          product.save!
+
+          create_redirect(variant_product_data)
+
+          variant_product.update_attributes!(imported: true)
+        end
+      end
+
+      def associated_products(sku)
+        Workarea::Import::MagentoProduct.where(magento_product_id: sku)
+      end
+    end
+  end
+end

data/lib/workarea/magento_data_importer/engine.rb

@@ -0,0 +1,10 @@
+require 'workarea/magento_data_importer'
+
+module Workarea
+  module MagentoDataImporter
+    class Engine < ::Rails::Engine
+      include Workarea::Plugin
+      isolate_namespace Workarea::MagentoDataImporter
+    end
+  end
+end

data/lib/workarea/magento_data_importer/import_products.rb

@@ -0,0 +1,86 @@
+module Workarea
+  module MagentoDataImporter
+    class ImportProducts
+      def self.import!(file_path)
+        # purge existing data
+        Workarea::Import::MagentoProduct.delete_all
+
+        current_id = nil
+
+        CSV.foreach(file_path, csv_options) do |row|
+          current_id = row[:sku] if row[:sku].present?
+
+          Workarea::Import::MagentoProduct.create!(
+            product_data: row.to_hash,
+            magento_product_id: current_id,
+            product_type: row[:_type]
+          )
+        end
+
+        # get distinct values for creating the taxonomy, get this list before import because the
+        # import collection is deleted after import.
+        import_categories = Workarea::Import::MagentoProduct.distinct("product_data._category").compact!.sort!
+        Sidekiq::Callbacks.disable do
+          puts "Creating Configurable Products"
+          process_configurable_products
+
+          puts "Creating Simple Products"
+          process_simple_products
+
+          puts "Creating Taxonomy"
+          process_taxonomy(import_categories)
+
+          puts "Creating Navigation Menu"
+          process_navigation_menu
+        end
+      end
+
+      private
+
+      def self.process_configurable_products
+        Workarea::Import::MagentoProduct.parent_products.each do |parent_product|
+          begin
+            MagentoDataImporter::ConfigurableProduct.new(parent_product).process
+          rescue
+            puts "Error importing product #{parent_product.magento_product_id}"
+            parent_product.update_attributes!(import_failed: true)
+          end
+        end
+        Workarea::Import::MagentoProduct.where(imported: true).delete_all
+      end
+
+      def self.process_simple_products
+        Workarea::Import::MagentoProduct.simple_products.each do |simple_product|
+          begin
+            MagentoDataImporter::SimpleProduct.new(simple_product).process
+          rescue
+            puts "Error importing product #{simple_product.magento_product_id}"
+            simple_product.update_attributes!(import_failed: true)
+          end
+        end
+        Workarea::Import::MagentoProduct.where(imported: true).delete_all
+      end
+
+      def self.process_taxonomy(import_categories)
+        import_categories.each do |import_category|
+          Workarea::MagentoDataImporter::Taxonomy.new(import_category).process
+        end
+      end
+
+      def self.process_navigation_menu
+        taxons = Workarea::Navigation::Taxon.where(depth: 1)
+        taxons.each do |taxon|
+          Workarea::Navigation::Menu.create!(taxon: taxon)
+        end
+      end
+
+      def self.csv_options
+        {
+          headers: true,
+          return_headers: false,
+          header_converters: -> (h) { h.underscore.optionize.to_sym }
+        }
+      end
+    end
+  end
+end