solidus_importer 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c368dcdb23d45c02c54cd01f247debce0e9083119bda2dc1f358a0718e3b7d8
-  data.tar.gz: 4336a3ad45dc07ba7e6aa5d0e12a953242439a8698c3b8c6a0b36a175e38384d
+  metadata.gz: 06ff1cdd3f709eebef5325d77c7c4b43d4ea41de11c11365e0490f6f52214d2f
+  data.tar.gz: a5f0868efe1a6c62b7f048eba8aa81af91dd98364af367b8a44811acbed9440f
 SHA512:
-  metadata.gz: 0a3de867687407c132ffe9444a4a1e3b5913dcde1cedabc3b28353bac061f9822bd87ce66fba277904ca20a9c63cfeb8854edadcc37cbff3a9852b80092066c2
-  data.tar.gz: e32d1dc88ccc3db3a234223d0149514aa8173b163f940ada667e43e128a74802d4e2331ec41a7773694ba0cc744051390756c76f22eb2cad7c09504e3fc9c4cd
+  metadata.gz: a344000551b4f69f1795d7b9c114621a523a40b50a0fa5ca2ec0a3122b61fd69642f5ee6aa3a716f6e6cd2a7198e1a426f58012ab87f99118f843bb7c1c839e3
+  data.tar.gz: a181da584ecc1fc043a9ad5c877fe8ca6e7369a5c3a9f5cfd28e8fb71d70a0c4a9702f00b2172c92f2b6c1630104af1943c864ae21747b3607e752192c284727

data/README.md

@@ -20,6 +20,14 @@ bundle exec rails g solidus_importer:install
 
 ## Usage
 
+The imports can be fully managed from the backend UI, following progress (image processing can take a few seconds for each image).
+
+![Import products CSV from the backend](.readme/import-products-1.gif)
+
+![Look at the newly imported products](.readme/import-products-2.gif)
+
+### From the console
+
 Sample code to import some products:
 
 ```ruby
@@ -84,7 +92,7 @@ SolidusImporter::Config.solidus_importer[:customers][:processors].map! do |proce
   if processor == 'SolidusImporter::Processors::Log'
     'CustomLoggerProcessor'
   else
-    processors
+    processor
   end
 end
 ```

data/Rakefile

@@ -4,3 +4,7 @@ require 'solidus_dev_support/rake_tasks'
 SolidusDevSupport::RakeTasks.install
 
 task default: 'extension:specs'
+
+require 'bundler'
+Bundler.require
+Bundler::GemHelper.install_tasks

data/app/models/solidus_importer/order_updater.rb

@@ -0,0 +1,6 @@
+module SolidusImporter
+  class OrderUpdater < Spree::OrderUpdater
+    # Override this method to avoid tax calculation
+    def update_taxes; end
+  end
+end

data/app/models/solidus_importer/spree_core_importer_order.rb

@@ -0,0 +1,50 @@
+module SolidusImporter
+  class SpreeCoreImporterOrder < Spree::Core::Importer::Order
+    def self.import(user, params)
+      params = params.to_h
+      ActiveRecord::Base.transaction do
+        ensure_country_id_from_params params[:ship_address_attributes]
+        ensure_state_id_from_params params[:ship_address_attributes]
+        ensure_country_id_from_params params[:bill_address_attributes]
+        ensure_state_id_from_params params[:bill_address_attributes]
+
+        create_params = params.slice :currency
+        order = Spree::Order.create! create_params
+        order.store ||= Spree::Store.default
+        order.associate_user!(user)
+        order.save!
+
+        shipments_attrs = params.delete(:shipments_attributes)
+
+        create_line_items_from_params(params.delete(:line_items_attributes), order)
+        create_shipments_from_params(shipments_attrs, order)
+        create_adjustments_from_params(params.delete(:adjustments_attributes), order)
+        create_payments_from_params(params.delete(:payments_attributes), order)
+
+        params.delete(:user_id) unless user.try(:has_spree_role?, "admin") && params.key?(:user_id)
+
+        completed_at = params.delete(:completed_at)
+
+        order.update!(params)
+
+        order.create_proposed_shipments unless shipments_attrs.present?
+
+        if completed_at
+          order.completed_at = completed_at
+          order.state = 'complete'
+          order.save!
+        end
+
+        # Really ensure that the order totals & states are correct
+        updater = SolidusImporter::OrderUpdater.new(order)
+        updater.update
+        if shipments_attrs.present?
+          order.shipments.each_with_index do |shipment, index|
+            shipment.update_columns(cost: shipments_attrs[index][:cost].to_f) if shipments_attrs[index][:cost].present?
+          end
+        end
+        order.reload
+      end
+    end
+  end
+end

data/bin/rails-sandbox

@@ -5,7 +5,7 @@ app_root = 'sandbox'
 unless File.exist? "#{app_root}/bin/rails"
   warn 'Creating the sandbox app...'
   Dir.chdir "#{__dir__}/.." do
-    system "#{__dir__}/sandbox" or begin # rubocop:disable Style/AndOr
+    system "#{__dir__}/sandbox" or begin
       warn 'Automatic creation of the sandbox app failed'
       exit 1
     end

data/bin/sandbox

@@ -72,9 +72,11 @@ unbundled bundle exec rails generate spree:install \
   --user_class=Spree::User \
   --enforce_available_locales=true \
   --with-authentication=false \
+  --payment-method=none
   $@
 
 unbundled bundle exec rails generate solidus:auth:install
+unbundled bundle exec rails generate ${extension_name}:install
 
 echo
 echo "🚀 Sandbox app successfully created for $extension_name!"

data/lib/solidus_importer.rb

@@ -6,6 +6,7 @@ require 'solidus_support'
 require 'solidus_importer/version'
 require 'solidus_importer/exception'
 require 'solidus_importer/base_importer'
+require 'solidus_importer/order_importer'
 
 require 'solidus_importer/processors/base'
 processors = File.join(__dir__, 'solidus_importer/processors/*.rb')

data/lib/solidus_importer/base_importer.rb

@@ -20,7 +20,14 @@ module SolidusImporter
     end
 
     ##
-    # Defines a method called after the import process is started
-    def after_import(_ending_context); end
+    # Defines a method called after the import process is finished
+    def after_import(context)
+      context
+    end
+
+    ##
+    # Defines a method called after the import of each row
+    def handle_row_import(_ending_row_context)
+    end
   end
 end

data/lib/solidus_importer/configuration.rb

@@ -6,15 +6,20 @@ module SolidusImporter
       customers: {
         importer: SolidusImporter::BaseImporter,
         processors: [
-          SolidusImporter::Processors::Address,
           SolidusImporter::Processors::Customer,
+          SolidusImporter::Processors::CustomerAddress,
           SolidusImporter::Processors::Log
         ]
       },
       orders: {
-        importer: SolidusImporter::BaseImporter,
+        importer: SolidusImporter::OrderImporter,
         processors: [
           SolidusImporter::Processors::Order,
+          SolidusImporter::Processors::BillAddress,
+          SolidusImporter::Processors::ShipAddress,
+          SolidusImporter::Processors::LineItem,
+          SolidusImporter::Processors::Shipment,
+          SolidusImporter::Processors::Payment,
           SolidusImporter::Processors::Log
         ]
       },

data/lib/solidus_importer/order_importer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module SolidusImporter
+  class OrderImporter < BaseImporter
+    attr_accessor :orders
+
+    def initialize(options)
+      super
+      self.orders = {}
+    end
+
+    def handle_row_import(context)
+      number = context.dig(:order, :number)
+
+      return unless number
+
+      orders[number] ||= {}
+
+      order_params = context[:order].to_h.reject { |_k, v| v.blank? }
+      payments_attributes = order_params[:payments_attributes]
+      orders[number][:payments_attributes] ||= []
+      orders[number][:payments_attributes] << payments_attributes if payments_attributes.present?
+      orders[number].merge!(order_params)
+    end
+
+    def after_import(context)
+      orders.each do |_, params|
+        user = params.delete(:user)
+        SolidusImporter::SpreeCoreImporterOrder.import(user, params)
+      rescue StandardError
+        context[:success] = false
+      end
+
+      context
+    end
+  end
+end

data/lib/solidus_importer/process_import.rb

@@ -26,7 +26,11 @@ module SolidusImporter
       initial_context = @importer.before_import(initial_context)
       unless @import.failed?
         rows = process_rows(initial_context)
-        @import.update(state: :completed) if rows.zero?
+        ending_context = @importer.after_import(initial_context)
+        state = @import.state
+        state = :completed if rows.zero?
+        state = :failed if ending_context[:success] == false
+        @import.update(state: state)
       end
       @import
     end

data/lib/solidus_importer/process_row.rb

@@ -21,6 +21,9 @@ module SolidusImporter
           break
         end
       end
+
+      @importer.handle_row_import(context)
+
       @row.update!(
         state: context[:success] ? :completed : :failed,
         messages: context[:messages]
@@ -34,7 +37,6 @@ module SolidusImporter
     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
 

data/lib/solidus_importer/processors/bill_address.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class BillAddress < Base
+      def call(context)
+        @data = context[:data]
+
+        return if @data['Billing Address1'].blank?
+
+        order = context.fetch(:order, {})
+
+        order[:bill_address_attributes] = bill_address_attributes
+
+        context.merge!(order: order)
+      end
+
+      private
+
+      def country_code
+        @data['Billing Country Code']
+      end
+
+      def province_code
+        @data['Billing Province Code']
+      end
+
+      def bill_address_attributes
+        {
+          firstname: @data['Billing First Name'],
+          lastname: @data['Billing Last Name'],
+          address1: @data['Billing Address1'],
+          address2: @data['Billing Address2'],
+          city: @data['Billing City'],
+          company: @data['Billing Company'],
+          zipcode: @data['Billing Zip'],
+          phone: @data['Billing Phone'],
+          country: country,
+          state: state
+        }
+      end
+
+      def country
+        @country ||= Spree::Country.find_by(iso: country_code) if country_code
+      end
+
+      def state
+        @state ||= country&.states&.find_by(abbr: province_code) if province_code
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/customer.rb

@@ -3,15 +3,11 @@
 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)
+        context.merge!(user: process_user && persist_user)
       end
 
       def options
@@ -26,15 +22,22 @@ module SolidusImporter
         raise SolidusImporter::Exception, 'Missing required key: "Email"' if @data['Email'].blank?
       end
 
+      def user
+        @user ||= prepare_user
+      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!)
+        user
+      end
+
+      def persist_user
+        user.tap(&:save!)
       end
     end
   end

data/lib/solidus_importer/processors/customer_address.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class CustomerAddress < Base
+      def call(context)
+        @data = context.fetch(:data)
+
+        address = Spree::Address.find_or_create_by(address_attributes)
+        return unless address.valid?
+
+        user = context.fetch(:user)
+        user.addresses << address
+        user.bill_address ||= address
+        user.ship_address ||= address
+        user.save!
+      end
+
+      private
+
+      def country
+        @country ||= Spree::Country.find_by(iso: @data['Country Code']) if @data['Country Code']
+      end
+
+      def state
+        @state ||= country&.states&.find_by(abbr: @data['Province Code']) if @data['Province Code']
+      end
+
+      def address_attributes
+        @address_attributes ||= {
+          firstname: @data['First Name'],
+          lastname: @data['Last Name'],
+          address1: @data['Address1'],
+          address2: @data['Address2'],
+          city: @data['City'],
+          zipcode: @data['Zip'],
+          phone: @data['Phone'],
+          country: country,
+          state: state,
+        }
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/line_item.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class LineItem < Base
+      def call(context)
+        @data = context[:data]
+
+        return if @data['Lineitem sku'].blank?
+
+        order = context.fetch(:order, {})
+
+        order[:line_items_attributes] ||= {}
+
+        index = order[:line_items_attributes].size
+
+        order[:line_items_attributes][index] = line_items_attributes
+
+        context.merge!(order: order)
+      end
+
+      private
+
+      def line_items_attributes
+        {
+          sku: @data['Lineitem sku'],
+          quantity: @data['Lineitem quantity'],
+          price: @data['Lineitem price']
+        }
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/order.rb

@@ -6,7 +6,7 @@ module SolidusImporter
       def call(context)
         @data = context.fetch(:data)
         check_data
-        context.merge!(order: process_order)
+        context.merge!(order: order_attributes)
       end
 
       def options
@@ -21,19 +21,48 @@ module SolidusImporter
         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
+      def completed_at
+        processed_at = @data['Processed At']
+        processed_at ? Time.parse(processed_at).in_time_zone : Time.current
+      rescue ArgumentError
+        Time.current
       end
 
-      def process_order
-        prepare_order.tap(&:save!)
+      def currency
+        @data['Currency']
+      end
+
+      def email
+        @data['Email']
+      end
+
+      def order_attributes
+        {
+          number: number,
+          completed_at: completed_at,
+          store: options[:store],
+          currency: currency,
+          email: email,
+          user: user,
+          special_instructions: special_instruction,
+          line_items_attributes: {},
+          bill_address_attributes: {},
+          ship_address_attributes: {},
+          shipments_attributes: [],
+          payments_attributes: []
+        }
+      end
+
+      def number
+        @data['Name']
+      end
+
+      def special_instruction
+        @data['Note']
+      end
+
+      def user
+        @user ||= Spree::User.find_by(email: email)
       end
     end
   end