solidus_importer 0.1.0 → 0.2.0

data/lib/solidus_importer/processors/payment.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'line_item'
+
+module SolidusImporter
+  module Processors
+    class Payment < Base
+      attr_accessor :order
+
+      def call(context)
+        @data = context.fetch(:data)
+
+        return unless amount > 0
+
+        self.order = context.fetch(:order, {})
+
+        order[:payments_attributes] ||= []
+        order[:payments_attributes] << payment_attributes
+
+        context.merge!(order: order)
+      end
+
+      private
+
+      def amount
+        price * quantity
+      end
+
+      def price
+        @data['Lineitem price'].to_f
+      end
+
+      def quantity
+        @data['Lineitem quantity'].to_i
+      end
+
+      def financial_status
+        @data['Financial Status'].to_s.inquiry
+      end
+
+      def payment_attributes
+        {
+          payment_method: payment_method.name,
+          amount: amount
+        }
+      end
+
+      def payment_method
+        @payment_method ||= Spree::PaymentMethod.find_or_initialize_by(
+          name: 'SolidusImporter PaymentMethod',
+          type: 'Spree::PaymentMethod::Check'
+        ).tap(&:save)
+      end
+    end
+  end
+end

data/lib/solidus_importer/processors/ship_address.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class ShipAddress < Base
+      def call(context)
+        @data = context[:data]
+
+        return if @data['Shipping Address1'].blank?
+
+        order = context.fetch(:order, {})
+
+        order[:ship_address_attributes] = ship_address_attributes
+
+        context.merge!(order: order)
+      end
+
+      private
+
+      def country_code
+        @data['Shipping Country Code']
+      end
+
+      def province_code
+        @data['Shipping Province Code']
+      end
+
+      def ship_address_attributes
+        {
+          firstname: @data['Shipping First Name'],
+          lastname: @data['Shipping Last Name'],
+          address1: @data['Shipping Address1'],
+          address2: @data['Shipping Address2'],
+          city: @data['Shipping City'],
+          company: @data['Shipping Company'],
+          zipcode: @data['Shipping Zip'],
+          phone: @data['Shipping 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/shipment.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module SolidusImporter
+  module Processors
+    class Shipment < Base
+      attr_accessor :order
+
+      def call(context)
+        @data = context.fetch(:data)
+
+        self.order = context.fetch(:order, {})
+        order[:shipments_attributes] ||= []
+        order[:shipments_attributes] << shipments_attributes
+
+        context.merge!(order: order)
+      end
+
+      private
+
+      def cost
+        @data['Shipping Line Price'].to_f
+      end
+
+      def inventory_units
+        line_items_attributes.map do |_, line_item|
+          { sku: line_item[:sku] }
+        end
+      end
+
+      def line_items_attributes
+        order.fetch(:line_items_attributes, [])
+      end
+
+      def shipments_attributes
+        {
+          shipped_at: shipped_at,
+          shipping_method: shipping_method.name,
+          stock_location: stock_location.name,
+          inventory_units: inventory_units,
+          cost: cost
+        }
+      end
+
+      def shipped_at
+        Time.zone.now if fulfillment_status == 'fulfilled'
+      end
+
+      def fulfillment_status
+        @data['Lineitem fulfillment status']
+      end
+
+      def shipping_method_name
+        @data['Shipping Line Title'] || 'SolidusImporter ShippingMethod'
+      end
+
+      def shipping_method
+        Spree::ShippingMethod.find_by(name: shipping_method_name) || create_shipping_method
+      end
+
+      def create_shipping_method
+        shipping_method = Spree::ShippingMethod.new(name: shipping_method_name, calculator: calculator)
+        shipping_method.shipping_categories << shipping_category
+        shipping_method.save!
+        shipping_method
+      end
+
+      def calculator
+        @calculator ||= Spree::Calculator::FlatRate.find_or_create_by(
+          preferences: { amount: 0 }
+        )
+      end
+
+      def shipping_category
+        Spree::ShippingCategory.find_or_create_by(
+          name: 'SolidusImporter ShippingCategory'
+        )
+      end
+
+      def stock_location
+        @stock_location ||= Spree::StockLocation.find_or_create_by(
+          name: 'SolidusImporter StockLocation'
+        )
+      end
+    end
+  end
+end

data/lib/solidus_importer/version.rb

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

data/spec/features/solidus_importer/import_spec.rb

@@ -13,8 +13,10 @@ RSpec.describe 'Import from CSV files' do # rubocop:disable RSpec/DescribeClass
   context 'with a customers source file' do
     let(:import_file) { solidus_importer_fixture_path('customers.csv') }
     let(:import_type) { :customers }
-    let(:csv_file_rows) { 2 }
-    let(:user_emails) { ['jane.doe01520022060@example.com', 'jane.doe11520022060@example.com'] }
+    let(:csv_file_rows) { 4 }
+    let(:user_emails) { ['jane.doe@acme.com', 'john.doe@acme.com'] }
+    let(:imported_customer) { Spree::User.last }
+    let!(:state) { create(:state, abbr: 'ON', country_iso: 'CA') }
 
     it 'imports some customers' do
       expect { import }.to change(Spree::User, :count).by(2)
@@ -22,6 +24,11 @@ RSpec.describe 'Import from CSV files' do # rubocop:disable RSpec/DescribeClass
       expect(import.state).to eq('completed')
       expect(Spree::LogEntry).to have_received(:create!).exactly(csv_file_rows).times
     end
+
+    it 'import customer with addresses' do
+      import
+      expect(imported_customer.addresses.reload).not_to be_empty
+    end
   end
 
   context 'with a products file' do
@@ -126,13 +133,70 @@ RSpec.describe 'Import from CSV files' do # rubocop:disable RSpec/DescribeClass
     let(:import_type) { :orders }
     let(:csv_file_rows) { 4 }
     let(:order_numbers) { ['#MA-1097', '#MA-1098'] }
-    let!(:store) { create(:store) }
+    let(:product) { create(:product) }
+    let!(:state) { create(:state, abbr: 'ON', country_iso: 'CA') }
+    let(:imported_order) { Spree::Order.first }
+    let(:tax_category) { product.tax_category }
+
+    before do
+      create(:store)
+      create(:shipping_method, name: 'Acme Shipping')
+      create(:variant, sku: 'a-123', product: product)
+      create(:variant, sku: 'a-456', product: product)
+      create(:variant, sku: 'b-001', product: product)
+    end
 
     it 'imports some orders' do
-      expect { import }.to change(Spree::Order, :count).by(2)
+      expect { import }.to change(Spree::Order, :count).from(0).to(2)
       expect(Spree::Order.where(number: order_numbers).count).to eq(2)
       expect(import.state).to eq('completed')
       expect(Spree::LogEntry).to have_received(:create!).exactly(csv_file_rows).times
     end
+
+    it 'imports order with line items' do
+      import
+      expect(imported_order.line_items).not_to be_blank
+    end
+
+    it 'imports an order with bill address' do
+      import
+      expect(imported_order.bill_address).not_to be_blank
+      expect(imported_order.bill_address.state).to eq state
+      expect(imported_order.bill_address.country).to eq state.country
+    end
+
+    it 'imports order with ship address' do
+      import
+      expect(imported_order.ship_address).not_to be_blank
+      expect(imported_order.ship_address.state).to eq state
+      expect(imported_order.ship_address.country).to eq state.country
+    end
+
+    it 'imports order with shipments' do
+      import
+      expect(imported_order.shipments).not_to be_blank
+    end
+
+    it 'imports the order with payments' do
+      import
+      expect(imported_order.payments).not_to be_empty
+      expect(imported_order.payment_state).to eq 'paid'
+      expect(imported_order.payments.first.state).to eq 'completed'
+      expect(imported_order.payment_total).to eq imported_order.payments.first.amount
+    end
+
+    context 'when there is a promotion applicable to the order' do
+      let(:zone) { create(:zone, countries: [country]) }
+      let(:country) { state.country }
+
+      before do
+        create(:tax_rate, tax_categories: [tax_category], zone: zone)
+      end
+
+      it 'has no taxes by default' do
+        import
+        expect(imported_order.tax_total).to eq 0
+      end
+    end
   end
 end

data/spec/features/solidus_importer/processors_spec.rb

@@ -20,34 +20,37 @@ RSpec.describe 'Set up a some processors' do # rubocop:disable RSpec/DescribeCla
   let(:processor_check_domain) do
     ->(context) {
       user = context[:user].reload
-      (context[:importer].checks ||= []) << user.email.end_with?('@example.com')
+      context[:valid] = user.email.end_with?('@acme.com')
     }
   end
   let(:import_source) { create(:solidus_importer_import_customers) }
   let(:importer_options) do
     {
-      importer: CustomImporter,
+      importer: importer_class,
       processors: [processor_create_user, processor_check_domain]
     }
   end
-  let(:importer) { CustomImporter.new(importer_options) }
-
-  before do
-    stub_const('CustomImporter', SolidusImporter::BaseImporter)
-    CustomImporter.class_eval do
+  let(:importer) { importer_class.new(importer_options) }
+  let(:importer_class) do
+    Class.new(SolidusImporter::BaseImporter) do
       attr_accessor :checks
 
-      def after_import(ending_context)
-        ending_context[:importer].checks
+      def handle_row_import(ending_context)
+        self.checks ||= []
+        checks << ending_context[:valid]
       end
     end
+  end
+
+  before do
     importer
-    allow(CustomImporter).to receive(:new).and_return(importer)
+    allow(importer_class).to receive(:new).and_return(importer)
     allow(importer).to receive(:after_import).and_call_original
   end
 
   it 'creates 2 users and check the result' do
     expect { process_import }.to change(Spree::User, :count).from(0).to(2)
-    expect(importer).to have_received(:after_import)
+    expect(importer).to have_received(:after_import).once
+    expect(importer.checks).to eq [true, nil, nil, true]
   end
 end

data/spec/fixtures/solidus_importer/customers.csv

@@ -1,3 +1,5 @@
-First Name,Last Name,Email
-Jane,Doe,jane.doe01520022060@example.com
-Jane,Doe,jane.doe11520022060@example.com
+First Name,Last Name,Email,Company,Address1,Address2,City,Province,Province Code,Country,Country Code,Zip,Phone,Accepts Marketing,Tags,Note,Tax Exempt,Metafield Namespace,Metafield Key,Metafield Value,Metafield Value Type
+John,Doe,john.doe@acme.com,Acme Warehouse,57 Erb St W,,Waterloo,Ontario,ON,Canada,CA,N2L 6C2,519-555-5555,true,"repeat_customer,member_since_2017",John wrote a very positive review of our product on his blog.,false,global,vip_status,TRUE,string
+,,john.doe@acme.com,Acme Ltd.,150 Elgin St,Unit 56,Ottawa,Ontario,ON,Canada,CA,K2P 1L4,,,,,,global,email_list,weekly,string
+,,john.doe@acme.com,,,,,,,,,,,,,,,global,corporate,true,string
+Jane,Doe,jane.doe@acme.com,Acme Inc.,490 Rue de la Gauchetière O,,Montreal,Quebec,QC,Canada,CA,H2Z 0B2,613-555-6666,false,,Tendency to return clothing in size 0.,true,global,frequent_returner,TRUE,string

data/spec/fixtures/solidus_importer/orders.csv

@@ -1,5 +1,5 @@
 Name,Email,Financial Status,Fulfillment Status,Currency,Buyer Accepts Marketing,Cancel Reason,Cancelled At,Closed At,Tags,Note,Phone,Referring Site,Processed At,Source name,Total weight,Total Tax,Shipping Company,Shipping Name,Shipping Phone,Shipping First Name,Shipping Last Name,Shipping Address1,Shipping Address2,Shipping City,Shipping Province,Shipping Province Code,Shipping Zip,Shipping Country,Shipping Country Code,Billing Company,Billing Name,Billing Phone,Billing First Name,Billing Last Name,Billing Address1,Billing Address2,Billing City,Billing Province,Billing Province Code,Billing Zip,Billing Country,Billing Country Code,Lineitem name,Lineitem quantity,Lineitem price,Lineitem sku,Lineitem requires shipping,Lineitem taxable,Lineitem fulfillment status,Tax 1 Title,Tax 1 Price,Tax 1 Rate,Tax 2 Title,Tax 2 Price,Tax 2 Rate,Tax 3 Title,Tax 3 Price,Tax 3 Rate,Transaction amount,Transaction kind,Transaction status,Shipping line code,Shipping line price,Shipping line title,Shipping line carrier identifier,Shipping Tax Price,Discount code,Discount amount,Discount type,Metafield Namespace,Metafield Key,Metafield Value,Metafield Value Type
 #MA-1097,john.doe@acme.com,paid,unfulfilled,USD,true,,,,,"Review verified, discount code e-mailed",555 555-5555,http://acme-influencers.com,2018-01-04 15:51:23 -0800,,,,Acme Warehouse,Receiver Joe,555.555.5556,Receiver,Joe,57 Erb St W,,Waterloo,Ontario,ON,N2L 6C2,Canada,CA,Acme Ltd.,Ami Shaperi,555.555.5557,Ami,Shaperi,150 Elgin St,Unit 56,Ottawa,Ontario,ON,K2P 1L4,Canaada,CA,Garden Trowel - Composite / Small,2,10,a-123,true,true,fulfilled,HST,2.60,0.13,,,,,,,1000,sale,success,,,,,,25OFF,10,fixed_amount,instructions,wash,cold_water,string
-#MA-1097,john.doe@acme.com,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,Acme Ltd.,,,,,,,,,,,,,Mini Handle Shovel,3,20,a-456,true,true,fulfilled,HST,7.80,0.13,,,,,,500,refund,success,,,,,,,,,instructions,dry,tumble_dry,string
+#MA-1097,john.doe@acme.com,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,Acme Ltd.,,,,,,,,,,,,Mini Handle Shovel,3,20,a-456,true,true,fulfilled,HST,7.80,0.13,,,,,,,500,refund,success,,,,,,,,,instructions,dry,tumble_dry,string
 #MA-1097,john.doe@acme.com,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,United Parcel Service - 2nd Day Air,0,United Parcel Service - 2nd Day Air,ups_2DA,,,,,instructions,dry,tumble_dry,string
-#MA-1098,jane.doe@acme.com,refunded,unfulfilled,USD,false,customer changed/cancelled order,2018-01-19 12:54:42 -0800,,,,,,2018-01-19 12:54:41 -0800,,,,,,,,,,,,,,,,,Acme Inc.,,,,,,,,,,,,,Big Brown Bear Boots,1,30,b-001,true,true,null,,,,,,,,,,,,,,,,,,,,,origin,country,China,string
+#MA-1098,jane.doe@acme.com,refunded,unfulfilled,USD,false,customer changed/cancelled order,2018-01-19 12:54:42 -0800,,,,,,2018-01-19 12:54:41 -0800,,,,,,,,,,,,,,,,,Acme Inc.,,,,,,,,,,,,,Big Brown Bear Boots,1,30,b-001,true,true,null,,,,,,,,,,,,,,,,,,,,,origin,country,China,string

data/spec/lib/solidus_importer/base_importer_spec.rb

@@ -9,6 +9,16 @@ RSpec.describe SolidusImporter::BaseImporter do
 
   describe '#after_import' do
     it { is_expected.to respond_to(:after_import) }
+
+    context 'when ending contexts of rows is a success' do
+      subject { described_instance.after_import(context) }
+
+      let(:context) { { success: true } }
+
+      it 'returns a successful context' do
+        is_expected.to match(hash_including(success: true))
+      end
+    end
   end
 
   describe '#before_import' do

data/spec/lib/solidus_importer/order_importer_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SolidusImporter::OrderImporter do
+  subject(:described_instance) { described_class.new(options) }
+
+  let(:options) { {} }
+
+  describe '#after_import' do
+    subject(:ending_context) { described_instance.after_import(context) }
+
+    let(:context) { { success: true } }
+
+    context 'when there are orders attributes' do
+      let(:orders) do
+        {
+          '#001' => {
+            number: '#001',
+            email: 'email@example.com'
+          },
+          '#002' => {
+            number: '#002',
+            email: 'email@example.com'
+          }
+        }
+      end
+
+      before do
+        described_instance.orders = orders
+        allow(SolidusImporter::SpreeCoreImporterOrder).to receive(:import)
+      end
+
+      it 'calls Solidus order importer with those params' do
+        expect(ending_context).to be_an_instance_of(Hash)
+        expect(SolidusImporter::SpreeCoreImporterOrder).to have_received(:import)
+          .with(nil, hash_including(email: 'email@example.com'))
+          .exactly(orders.size).times
+      end
+
+      context 'when something went wrong during import' do
+        before do
+          allow(SolidusImporter::SpreeCoreImporterOrder).to receive(:import).and_raise(StandardError)
+        end
+
+        it 'finish #after_import regardless of the error' do
+          expect { subject }.not_to raise_error
+          expect(ending_context).to match(hash_including(success: false))
+        end
+      end
+    end
+  end
+
+  describe '#before_import' do
+    it { is_expected.to respond_to(:before_import) }
+  end
+
+  describe '#processors' do
+    subject(:described_method) { described_instance.processors }
+
+    it { is_expected.to be_empty }
+  end
+end