solidus_importer 0.1.0

data/lib/solidus_importer/processors/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Base
+      def options
+        {}
+      end
+
+      class << self
+        delegate :call, to: :new
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/customer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Customer < Base
+      attr_accessor :address
+
+      def call(context)
+        @data = context.fetch(:data)
+        check_data
+
+        self.address = context[:address]
+
+        context.merge!(user: process_user)
+      end
+
+      def options
+        @options ||= {
+          password_method: ->(_user) { SecureRandom.alphanumeric(8) }
+        }
+      end
+
+      private
+
+      def check_data
+        raise SolidusImporter::Exception, 'Missing required key: "Email"' if @data['Email'].blank?
+      end
+
+      def prepare_user
+        Spree::User.find_or_initialize_by(email: @data['Email']) do |u|
+          u.password = options[:password_method].call(u)
+          u.bill_address = address if address.present?
+        end
+      end
+
+      def process_user
+        prepare_user.tap(&:save!)
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/log.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Log < Base
+      def call(context)
+        Spree::LogEntry.create!(
+          source_id: context[:row_id],
+          source_type: 'SolidusImporter::Row',
+          details: context.except(:importer, :data).to_json
+        )
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/option_types.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class OptionTypes < Base
+      def call(context)
+        @data = context.fetch(:data)
+        return unless option_types?
+
+        product = context.fetch(:product)
+        context.merge!(option_types: process_option_types(product))
+      end
+
+      private
+
+      def process_option_types(product)
+        option_type_names.each_with_index.map do |name, i|
+          option_type = product.option_types.find_or_initialize_by(
+            name: name
+          )
+          option_type.presentation = name
+          option_type.name = name.downcase
+          option_type.position = i + 1
+          option_type.save
+        end
+      end
+
+      def option_type_names
+        @option_type_names ||= @data.values_at(
+          'Option1 Name',
+          'Option2 Name',
+          'Option3 Name'
+        ).compact
+      end
+
+      def option_types?
+        # NOTE: according to https://help.shopify.com/en/manual/products/import-export
+        # when `Option Name1` is equal to 'Title`, means that product has no variants.
+        (@data['Option1 Name'] != 'Title') && option_type_names.any?
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/option_values.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class OptionValues < Base
+      attr_accessor :option_types, :variant
+
+      def call(context)
+        @data = context.fetch(:data)
+        return unless option_values?
+
+        self.variant = context.fetch(:variant)
+        process_option_values
+      end
+
+      private
+
+      def process_option_values
+        option_value_names.each_with_index do |name, i|
+          option_value = Spree::OptionValue.find_or_initialize_by(
+            option_type: option_type(i),
+            name: name
+          )
+          option_value.presentation = name
+          variant.option_values << option_value
+        end
+      end
+
+      def option_type(index)
+        variant.product.option_types.find { |ot| ot.position == index + 1 }
+      end
+
+      def option_value_names
+        @option_value_names ||= @data.values_at(
+          'Option1 Value',
+          'Option2 Value',
+          'Option3 Value'
+        ).compact
+      end
+
+      def option_values?
+        # NOTE: according to https://help.shopify.com/en/manual/products/import-export
+        # when `Option Value1` is equal to 'Default Title`, means that product has no
+        # variants.
+        (@data['Option1 Value'] != 'Default Title') && option_value_names.any?
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/order.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Order < Base
+      def call(context)
+        @data = context.fetch(:data)
+        check_data
+        context.merge!(order: process_order)
+      end
+
+      def options
+        @options ||= {
+          store: Spree::Store.default
+        }
+      end
+
+      private
+
+      def check_data
+        raise SolidusImporter::Exception, 'Missing required key: "Name"' if @data['Name'].blank?
+      end
+
+      def prepare_order
+        Spree::Order.find_or_initialize_by(number: @data['Name']) do |order|
+          order.store = options[:store]
+        end.tap do |order|
+          # Apply the row attributes
+          order.currency = @data['Currency'] unless @data['Currency'].nil?
+          order.email = @data['Email'] unless @data['Email'].nil?
+          order.special_instructions = @data['Note'] unless @data['Note'].nil?
+        end
+      end
+
+      def process_order
+        prepare_order.tap(&:save!)
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/product.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Product < Base
+      def call(context)
+        @data = context.fetch(:data)
+        check_data
+        context.merge!(product: process_product)
+      end
+
+      def options
+        @options ||= {
+          available_on: Date.current.yesterday,
+          not_available: nil,
+          price: 0,
+          shipping_category: Spree::ShippingCategory.find_by(name: 'Default') || Spree::ShippingCategory.first
+        }
+      end
+
+      private
+
+      def check_data
+        raise SolidusImporter::Exception, 'Missing required key: "Handle"' if @data['Handle'].blank?
+      end
+
+      def prepare_product
+        Spree::Product.find_or_initialize_by(slug: @data['Handle'])
+      end
+
+      def process_product
+        prepare_product.tap do |product|
+          product.slug = @data['Handle']
+          product.price = options[:price]
+          product.available_on = available? ? options[:available_on] : options[:not_available]
+          product.shipping_category = options[:shipping_category]
+
+          # Apply the row attributes
+          product.name = @data['Title'] unless @data['Title'].nil?
+
+          # Save the product
+          product.save!
+        end
+      end
+
+      def available?
+        @data['Published'] == 'true'
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/product_images.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class ProductImages < Base
+      def call(context)
+        @data = context.fetch(:data)
+        return unless product_image?
+
+        product = context.fetch(:product)
+        process_images(product)
+      end
+
+      private
+
+      def prepare_image
+        attachment = URI.open(@data['Image Src'])
+        Spree::Image.new(attachment: attachment, alt: @data['Alt Text'])
+      end
+
+      def process_images(product)
+        product.images << prepare_image
+      end
+
+      def product_image?
+        @product_image ||= @data['Image Src'].present?
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/taxon.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Taxon < Base
+      attr_accessor :product, :taxonomy
+
+      def call(context)
+        @data = context.fetch(:data)
+
+        self.product = context.fetch(:product)
+
+        process_taxons_type
+        process_taxons_tags
+      end
+
+      private
+
+      def options
+        @options ||= {
+          type_taxonomy: Spree::Taxonomy.find_or_create_by(name: 'Type'),
+          tags_taxonomy: Spree::Taxonomy.find_or_create_by(name: 'Tags')
+        }
+      end
+
+      def process_taxons_type
+        product.taxons << prepare_taxon(type, options[:type_taxonomy])
+      end
+
+      def process_taxons_tags
+        tags.map do |tag|
+          product.taxons << prepare_taxon(tag, options[:tags_taxonomy])
+        end
+      end
+
+      def prepare_taxon(name, taxonomy)
+        Spree::Taxon.find_or_initialize_by(
+          name: name,
+          taxonomy_id: taxonomy.id
+        )
+      end
+
+      def tags
+        @data['Tags'].split(',').map(&:strip)
+      end
+
+      def type
+        @data['Type']
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/variant.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Variant < Base
+      attr_accessor :product
+
+      def call(context)
+        @data = context.fetch(:data)
+        self.product = context.fetch(:product) || raise(ArgumentError, 'missing :product in context')
+
+        context.merge!(variant: process_variant)
+      end
+
+      private
+
+      def prepare_variant
+        return product.master if master_variant?
+
+        @prepare_variant ||= Spree::Variant.find_or_initialize_by(sku: sku) do |variant|
+          variant.product = product
+        end
+      end
+
+      def process_variant
+        prepare_variant.tap do |variant|
+          # Apply the row attributes
+          variant.weight = @data['Variant Weight'] unless @data['Variant Weight'].nil?
+          variant.price = @data['Variant Price'] if @data['Variant Price'].present?
+
+          # Save the product
+          variant.save!
+        end
+      end
+
+      def master_variant?
+        ov1 = @data['Option1 Value']
+        ov1.blank? || ov1 == 'Default Title'
+      end
+
+      def sku
+        @data['Variant SKU'] || generate_sku
+      end
+
+      def generate_sku
+        variant_part = @data['Option1 Value'].parameterize
+        "#{product.slug}-#{variant_part}"
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/variant_images.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class VariantImages < Base
+      def call(context)
+        @data = context.fetch(:data)
+        return unless variant_image?
+
+        variant = context.fetch(:variant)
+        process_images(variant)
+      end
+
+      private
+
+      def prepare_image
+        attachment = URI.open(@data['Variant Image'])
+        Spree::Image.new(attachment: attachment)
+      end
+
+      def process_images(variant)
+        variant.images << prepare_image
+      end
+
+      def variant_image?
+        @variant_image ||= @data['Variant Image'].present?
+      end
+    end
+  end
+end

data/lib/solidus_importer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  VERSION = '0.1.0'
+end

data/solidus_importer.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'lib/solidus_importer/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'solidus_importer'
+  spec.version = SolidusImporter::VERSION
+  spec.authors = ['Mattia Roccoberton']
+  spec.email = 'contact@solidus.io'
+
+  spec.summary = 'Solidus Importer extension'
+  spec.description = 'Solidus Importer extension to migrate data from other eCommerce systems'
+  spec.homepage = 'https://github.com/nebulab/solidus_importer#readme'
+  spec.license = 'BSD-3-Clause'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/nebulab/solidus_importer#readme'
+  spec.metadata['changelog_uri'] = 'https://github.com/nebulab/solidus_importer/releases'
+
+  spec.required_ruby_version = Gem::Requirement.new('~> 2.5')
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+
+  spec.files = files.grep_v(%r{^(test|spec|features)/})
+  spec.test_files = files.grep(%r{^(test|spec|features)/})
+  spec.bindir = "exe"
+  spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'solidus_core', ['>= 2.0.0', '< 3']
+  spec.add_dependency 'solidus_support', '~> 0.5'
+
+  spec.add_development_dependency 'solidus_dev_support'
+end