solidus_importer 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+gem install bundler --conservative
+bundle update
+bin/rake clobber

data/config/initializers/spree.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+Spree::Backend::Config.configure do |config|
+  config.menu_items << config.class::MenuItem.new(
+    :imports,
+    'download',
+    condition: -> { can?(:admin, Spree::Product) },
+    label: :importer,
+    url: :admin_solidus_importer_imports_path
+  )
+end

data/config/locales/en.yml

@@ -0,0 +1,28 @@
+en:
+  spree:
+    solidus_importer:
+      created_at: Created at
+      data: Data
+      import: Import
+      imports: Imports
+      import_rows: Import rows
+      log_entry: Log information
+      messages: Messages
+      target_entity: Target entity
+      title: &solidus_importer_title
+        Importer
+      updated_at: Updated at
+      updated_at_from: 'Updated at: start date'
+      updated_at_to: 'Updated at: end date'
+      import_type: Import Type
+      import_types:
+        customers: Customers
+        orders: Orders
+        products: Products
+
+    admin:
+      tab:
+        importer: *solidus_importer_title
+      solidus_importer:
+        create: Import!
+        new: New import

data/config/routes.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+Spree::Core::Engine.routes.draw do
+  namespace :admin do
+    namespace :solidus_importer do
+      resources :imports, only: [:create, :index, :new, :show] do
+        resources :import_rows, only: [:show]
+      end
+    end
+  end
+end

data/db/migrate/20191216101011_create_solidus_importer_imports.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateSolidusImporterImports < ActiveRecord::Migration[5.2]
+  def change
+    create_table :solidus_importer_imports do |t|
+      t.string :import_type
+      t.string :state, null: false, default: 'created', limit: 32
+      t.string :file, null: false, default: '', limit: 1024
+      t.text :messages
+
+      t.timestamps null: false
+    end
+
+    reversible do |dir|
+      dir.up { add_attachment :solidus_importer_imports, :file }
+      dir.down { remove_attachment :solidus_importer_imports, :file }
+    end
+  end
+end

data/db/migrate/20191216101012_create_solidus_importer_rows.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreateSolidusImporterRows < ActiveRecord::Migration[5.2]
+  def change
+    create_table :solidus_importer_rows do |t|
+      t.belongs_to :import
+      t.string :state, null: false, default: 'created', limit: 32
+      t.text :data
+      t.text :messages
+
+      t.timestamps null: false
+    end
+  end
+end

data/examples/importers/custom_importer.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Importers
+    ##
+    # This importer sends an email when the import process is finished.
+    #
+    # Install: set the class as importer in solidus_importer configuration
+    class CustomImporter < ::SolidusImporter::BaseImporter
+      def after_import(context)
+        ActionMailer::Base.mail(
+          from: 'some_email',
+          to: 'some_email_2',
+          subject: 'Import finished',
+          body: "Ending context:\n#{context.to_json}"
+        ).deliver_now
+      end
+    end
+  end
+end

data/examples/processors/notify_on_failure.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    ##
+    # This processor sends an email if the process of a single row is failing.
+    #
+    # Install: add the class to processors in solidus_importer configuration
+    class NotifyOnFailure < Base
+      def call(context)
+        return if context[:success]
+
+        ActionMailer::Base.mail(
+          from: 'some_email',
+          to: 'some_email_2',
+          subject: 'Row process error',
+          body: "Row context:\n#{context.to_json}"
+        ).deliver_now
+      end
+    end
+  end
+end

data/lib/generators/solidus_importer/install/install_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      class_option :auto_run_migrations, type: :boolean, default: false
+
+      def add_migrations
+        run 'bin/rails railties:install:migrations FROM=solidus_importer'
+      end
+
+      def run_migrations
+        run_migrations = options[:auto_run_migrations] || ['', 'y', 'Y'].include?(ask('Would you like to run the migrations now? [Y/n]')) # rubocop:disable Metrics/LineLength
+        if run_migrations
+          run 'bin/rails db:migrate'
+        else
+          puts 'Skipping bin/rails db:migrate, don\'t forget to run it!' # rubocop:disable Rails/Output
+        end
+      end
+    end
+  end
+end

data/lib/solidus_importer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'solidus_core'
+require 'solidus_support'
+
+require 'solidus_importer/version'
+require 'solidus_importer/exception'
+require 'solidus_importer/base_importer'
+
+require 'solidus_importer/processors/base'
+processors = File.join(__dir__, 'solidus_importer/processors/*.rb')
+Dir[processors].each { |file| require file }
+
+require 'solidus_importer/configuration'
+require 'solidus_importer/engine'
+require 'solidus_importer/process_import'
+require 'solidus_importer/process_row'
+
+module SolidusImporter
+  class << self
+    def import!(import_path, type:)
+      ProcessImport.import_from_file(import_path, type.to_sym)
+    end
+  end
+end

data/lib/solidus_importer/base_importer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  class BaseImporter
+    def initialize(options)
+      @options = options
+    end
+
+    def processors
+      @options[:processors] || []
+    end
+
+    ##
+    # Defines a method called before the import process is started.
+    # Remember to always return a context with `success` key.
+    #
+    # - initial_context: context used process the rows, example: `{ success: true }`
+    def before_import(initial_context)
+      initial_context
+    end
+
+    ##
+    # Defines a method called after the import process is started
+    def after_import(_ending_context); end
+  end
+end

data/lib/solidus_importer/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  class Configuration < Spree::Preferences::Configuration
+    preference :solidus_importer, :hash, default: {
+      customers: {
+        importer: SolidusImporter::BaseImporter,
+        processors: [
+          SolidusImporter::Processors::Address,
+          SolidusImporter::Processors::Customer,
+          SolidusImporter::Processors::Log
+        ]
+      },
+      orders: {
+        importer: SolidusImporter::BaseImporter,
+        processors: [
+          SolidusImporter::Processors::Order,
+          SolidusImporter::Processors::Log
+        ]
+      },
+      products: {
+        importer: SolidusImporter::BaseImporter,
+        processors: [
+          SolidusImporter::Processors::Product,
+          SolidusImporter::Processors::Variant,
+          SolidusImporter::Processors::OptionTypes,
+          SolidusImporter::Processors::OptionValues,
+          SolidusImporter::Processors::ProductImages,
+          SolidusImporter::Processors::VariantImages,
+          SolidusImporter::Processors::Log
+        ]
+      }
+    }
+
+    def available_types
+      solidus_importer.keys
+    end
+  end
+end

data/lib/solidus_importer/engine.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spree/core'
+require 'solidus_importer'
+
+module SolidusImporter
+  class Engine < Rails::Engine
+    include SolidusSupport::EngineExtensions
+
+    isolate_namespace ::Spree
+
+    engine_name 'solidus_importer'
+
+    initializer 'solidus_importer.environment', before: :load_config_initializers do |_app|
+      SolidusImporter::Config = SolidusImporter::Configuration.new
+    end
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+  end
+end

data/lib/solidus_importer/exception.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  class Exception < StandardError; end
+end

data/lib/solidus_importer/factories.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+end

data/lib/solidus_importer/process_import.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module SolidusImporter
+  ##
+  # This class parse the source file and create the rows (scan). Then it asks to
+  # Process Row to process each one.
+  class ProcessImport
+    attr_reader :importer
+
+    def initialize(import, importer_options: nil)
+      @import = import
+      options = importer_options || ::SolidusImporter::Config.solidus_importer[@import.import_type.to_sym]
+      @importer = options[:importer].new(options)
+      @import.importer = @importer
+      validate!
+    end
+
+    def process(force_scan: nil)
+      return @import unless @import.created_or_failed?
+
+      scan_required = force_scan.nil? ? @import.created? : force_scan
+      @import.update(state: :processing)
+      initial_context = scan_required ? scan : { success: true }
+      initial_context = @importer.before_import(initial_context)
+      unless @import.failed?
+        rows = process_rows(initial_context)
+        @import.update(state: :completed) if rows.zero?
+      end
+      @import
+    end
+
+    class << self
+      def import_from_file(import_path, import_type)
+        import = ::SolidusImporter::Import.new(import_type: import_type)
+        import.import_file = import_path
+        import.save!
+        new(import).process
+      end
+    end
+
+    private
+
+    def scan
+      data = CSV.parse(
+        File.read(@import.file.path),
+        headers: true,
+        encoding: 'UTF-8',
+        header_converters: ->(h) { h.strip }
+      )
+      prepare_rows(data)
+    end
+
+    def check_data(data)
+      messages = []
+      headers = data.headers
+      messages << 'Invalid headers' if headers.blank? || !headers.exclude?(nil)
+      messages
+    end
+
+    def prepare_rows(data)
+      messages = check_data(data)
+      if messages.empty?
+        data.each do |row|
+          @import.rows << ::SolidusImporter::Row.new(data: row.to_h)
+        end
+        { success: true }
+      else
+        @import.update(state: :failed, messages: messages.join(', '))
+        { success: false, messages: messages.join(', ') }
+      end
+    end
+
+    def process_rows(initial_context)
+      rows = @import.rows.created_or_failed.order(id: :asc)
+      rows.each do |row|
+        ::SolidusImporter::ProcessRow.new(@importer, row).process(initial_context)
+      end
+      rows.size
+    end
+
+    def validate!
+      raise ::SolidusImporter::Exception, 'Valid import entity required' if !@import || !@import.valid?
+      raise ::SolidusImporter::Exception, "No importer found for #{@import.import_type} type" if !@importer
+    end
+  end
+end

data/lib/solidus_importer/process_row.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  ##
+  # This class process a single row of an import running the configured
+  # processor in chain.
+  class ProcessRow
+    def initialize(importer, row)
+      @importer = importer
+      @row = row
+      validate!
+    end
+
+    def process(initial_context)
+      context = initial_context.dup.merge!(row_id: @row.id, importer: @importer, data: @row.data)
+      @importer.processors.each do |processor|
+        begin
+          processor.call(context)
+        rescue StandardError => e
+          context.merge!(success: false, messages: e.message) # rubocop:disable Performance/RedundantMerge
+          break
+        end
+      end
+      @row.update!(
+        state: context[:success] ? :completed : :failed,
+        messages: context[:messages]
+      )
+      check_import_finished(context)
+      context
+    end
+
+    private
+
+    def check_import_finished(context)
+      return unless @row.import.finished?
+
+      @importer.after_import(context)
+      @row.import.update!(state: (@row.import.rows.failed.any? ? :failed : :completed))
+    end
+
+    def validate!
+      raise SolidusImporter::Exception, 'No importer defined' if !@importer
+      raise SolidusImporter::Exception, 'Invalid row type' if !@row || !@row.is_a?(SolidusImporter::Row)
+    end
+  end
+end

data/lib/solidus_importer/processors/address.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Address < Base
+      def call(context)
+        @data = context.fetch(:data)
+
+        return unless address?
+
+        context.merge!(address: process_address)
+      end
+
+      private
+
+      def process_address
+        prepare_address.tap(&:save)
+      end
+
+      def prepare_address
+        Spree::Address.new(
+          firstname: @data['First Name'],
+          lastname: @data['Last Name'],
+          address1: @data['Address1'],
+          address2: @data['Address2'],
+          city: @data['City'],
+          zipcode: @data['Zip'],
+          phone: @data['Phone'],
+          country: extract_country(@data['Country Code']),
+          state: extract_state(@data['Province Code'])
+        )
+      end
+
+      def extract_country(iso)
+        Spree::Country.find_by(iso: iso)
+      end
+
+      def extract_state(iso)
+        Spree::State.find_by(abbr: iso) || Spree::State.find_by(name: iso)
+      end
+
+      def address?
+        @data['Address1'].present?
+      end
+    end
+  end
+end