spree_gladly 1.0.0

data/Rakefile

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir['spec/dummy'].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir('../../')
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_gladly'
+  Rake::Task['extension:test_app'].invoke
+end

data/app/concerns/customer/database_adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Customer
+  module DatabaseAdapter
+    def concat(*args)
+      if adapter =~ /mysql/i
+        "CONCAT(#{args.join(',')})"
+      else
+        args.join('||')
+      end
+    end
+
+    def adapter
+      if ActiveRecord::Base.respond_to?(:connection_db_config)
+        ActiveRecord::Base.connection_db_config.configuration_hash[:adapter]
+      else
+        ActiveRecord::Base.connection_config[:adapter]
+      end
+    end
+  end
+end

data/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/app/controllers/spree/admin/gladly_settings_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class GladlySettingsController < ::Spree::Admin::BaseController
+      NONNEGATIVE_INT_REGEX = /\A[0-9]+\Z/.freeze
+
+      def edit
+        @signing_key = SpreeGladly::Config.signing_key
+        @signing_threshold = SpreeGladly::Config.signing_threshold
+      end
+
+      def update
+        if params[:signing_threshold].present? && params[:signing_threshold] !~ NONNEGATIVE_INT_REGEX
+          flash[:error] = Spree.t('spree_gladly.signing_threshold_error')
+        else
+          set_signing_key
+          set_signing_threshold
+          flash[:success] = Spree.t('spree_gladly.save_success')
+        end
+
+        redirect_to edit_admin_gladly_settings_path
+      end
+
+      private
+
+      def set_signing_key
+        SpreeGladly::Config.signing_key = params[:signing_key] if params.key?('signing_key')
+      end
+
+      def set_signing_threshold
+        return unless params.key?(:signing_threshold)
+
+        SpreeGladly::Config.signing_threshold = [0, params[:signing_threshold].to_i].max
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v1/customers_controller.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Spree
+  module Api
+    module V1
+      class CustomersController < ::ApplicationController
+        skip_before_action :verify_authenticity_token, only: :lookup
+        before_action :validate_signature, only: :lookup
+        before_action :validate_params, only: :lookup
+
+        rescue_from ::Auth::InvalidSignatureError, with: :authorization_error
+        rescue_from ::Auth::MissingKeyError, with: :authorization_error
+        rescue_from ::Auth::HeaderParseError, with: :authorization_error
+
+        def lookup
+          lookup_level = params['lookupLevel'].downcase.to_sym
+          collection = customer_lookup(type: lookup_level).execute
+
+          render json: serialize_collection(
+            type: lookup_level,
+            collection: collection
+          ), status: 200
+        end
+
+        private
+
+        def serialize_collection(type:, collection:)
+          presenter = {
+            detailed: SpreeGladly::Config.detailed_lookup_presenter.new(resource: collection),
+            basic: SpreeGladly::Config.basic_lookup_presenter.new(resource: collection)
+          }[type]
+
+          { results: presenter.to_h }
+        end
+
+        def customer_lookup(type:)
+          {
+            detailed: Customer::DetailedLookup.new(params: params),
+            basic: Customer::BasicLookup.new(params: params)
+          }[type]
+        end
+
+        def validate_signature
+          ::Auth::SignatureValidator.new(SpreeGladly::Config.signing_key,
+                                         SpreeGladly::Config.signing_threshold).validate(request)
+        end
+
+        def authorization_error(error)
+          errors = [{ attr: 'Gladly-Authorization', code: error.class.to_s, detail: error.to_s }]
+          render json: { errors: errors }, status: 401
+        end
+
+        def validate_params
+          result = LookupValidator.new.call(params.permit!.to_h.deep_symbolize_keys)
+          render json: { errors: result.format_errors }, status: 422 unless result.success?
+        end
+      end
+    end
+  end
+end

data/app/finders/customer/base_lookup.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Customer
+  class BaseLookup
+    include Customer::DatabaseAdapter
+
+    def initialize(params:)
+      @params = params
+      @query = params.include?(:query) ? params.fetch(:query) : {}
+
+      @emails = normalize_param(param: query[:emails])
+      @phones = normalize_param(param: query[:phones])
+      @name = query[:name]
+      @external_customer_id = query[:externalCustomerId]
+      @spree_id = query[:spreeId]
+    end
+
+    private
+
+    attr_reader :params, :query, :emails, :phones, :name, :external_customer_id, :spree_id
+
+    def customer
+      @customer ||= Spree.user_class.where('id = ? OR email = ?', spree_id.to_i, external_customer_id).take
+    end
+
+    def guest_customer?
+      !customer.present?
+    end
+
+    def normalize_param(param:)
+      return [] if param.nil?
+      return param if param.is_a?(Array)
+
+      param.split(',').map(&:strip)
+    end
+  end
+end

data/app/finders/customer/basic_lookup.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Customer
+  class BasicLookup < Customer::BaseLookup
+    def execute
+      OpenStruct.new(
+        guest_customers: guest_customers(registered_customers.pluck(:email)),
+        registered_customers: registered_customers.uniq.sort
+      )
+    end
+
+    private
+
+    def guest_customers(excluded_emails)
+      Customer::Guest::BasicFinder.new(emails: emails, options: { excluded_emails: excluded_emails }).execute
+    end
+
+    def registered_customers
+      @registered_customers ||= Customer::Registered::BasicFinder.new(
+        name: name,
+        emails: emails,
+        phones: phones
+      ).execute
+    end
+  end
+end

data/app/finders/customer/detailed_lookup.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Customer
+  class DetailedLookup < Customer::BaseLookup
+    def execute
+      guest_customer? ? guest_customer : registered_customer
+    end
+
+    private
+
+    def guest_customer
+      Customer::Guest::DetailedFinder.new(email: external_customer_id).execute
+    end
+
+    def registered_customer
+      Customer::Registered::DetailedFinder.new(customer: customer).execute
+    end
+  end
+end

data/app/finders/customer/guest/basic_finder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Customer
+  module Guest
+    class BasicFinder
+      def initialize(emails:, options: {})
+        @emails = emails
+        @options = options
+      end
+
+      def execute
+        return [] if emails.empty?
+
+        guest_customers
+      end
+
+      private
+
+      attr_reader :emails, :options
+
+      def guest_customers
+        Spree::Order
+          .where(user_id: nil)
+          .where(email: search_emails)
+          .order(created_at: :desc)
+          .to_a
+          .uniq(&:email)
+      end
+
+      def search_emails
+        return emails - options[:excluded_emails] if options[:excluded_emails].present?
+
+        emails
+      end
+    end
+  end
+end

data/app/finders/customer/guest/detailed_finder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Customer
+  module Guest
+    class DetailedFinder
+      def initialize(email:)
+        @email = email
+      end
+
+      def execute
+        OpenStruct.new(customer: customer, transactions: transactions, guest: true)
+      end
+
+      private
+
+      attr_reader :email
+
+      def customer
+        transactions.first || []
+      end
+
+      def transactions
+        @transactions ||= find_transactions
+      end
+
+      def find_transactions
+        scope = Spree::Order
+                .includes(SpreeGladly::Config.order_includes)
+                .where(state: SpreeGladly::Config.order_states)
+                .order(SpreeGladly::Config.order_sorting)
+                .where("(#{order_table}.user_id IS NULL AND #{order_table}.email = ?)", email)
+
+        scope = scope.limit(SpreeGladly::Config.order_limit) if SpreeGladly::Config.order_limit
+        scope.to_a
+      end
+
+      def order_table
+        Spree::Order.table_name
+      end
+    end
+  end
+end

data/app/finders/customer/registered/basic_finder.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Customer
+  module Registered
+    class BasicFinder
+      include Customer::DatabaseAdapter
+
+      def initialize(name:, emails:, phones:)
+        @name = name
+        @emails = emails
+        @phones = phones
+      end
+
+      def execute
+        registered_customers
+      end
+
+      private
+
+      attr_reader :name, :emails, :phones
+
+      def registered_customers
+        conditions = search_conditions
+        return empty_scope unless conditions.present?
+
+        template = conditions.map(&:first).join(' OR ')
+        args = conditions.map(&:last)
+
+        scope.where(template, *args)
+      end
+
+      def search_conditions
+        [by_email, by_name, by_phone].compact
+      end
+
+      def by_email
+        return nil unless emails.present?
+
+        where = "#{Spree.user_class.table_name}.email IN (?)"
+        [where, emails]
+      end
+
+      def by_name
+        return nil unless name.present?
+
+        sql_name = concat("#{Spree::Address.table_name}.firstname", "' '", "#{Spree::Address.table_name}.lastname")
+        where = "(LOWER(#{sql_name}) LIKE ?)"
+        args = "%#{name.downcase}%"
+        [where, args]
+      end
+
+      def by_phone
+        return nil unless phones.present?
+
+        where = "#{Spree::Address.table_name}.phone IN (?)"
+        [where, phones]
+      end
+
+      def empty_scope
+        Spree.user_class.none
+      end
+
+      def scope
+        Spree.user_class.eager_load(:bill_address, :orders)
+      end
+    end
+  end
+end

data/app/finders/customer/registered/detailed_finder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Customer
+  module Registered
+    class DetailedFinder
+      def initialize(customer:)
+        @customer = customer
+      end
+
+      def execute
+        return empty_result if customer.nil?
+
+        OpenStruct.new(customer: customer, transactions: transactions, guest: false)
+      end
+
+      private
+
+      attr_reader :customer
+
+      def transactions
+        customer_orders = "(#{order_table}.user_id = ?)"
+        guest_orders = "(#{order_table}.user_id IS NULL AND #{order_table}.email = ?)"
+
+        scope = Spree::Order
+                .includes(SpreeGladly::Config.order_includes)
+                .where(state: SpreeGladly::Config.order_states)
+                .order(SpreeGladly::Config.order_sorting)
+                .where("#{customer_orders} OR #{guest_orders}", customer.id, customer.email)
+
+        scope = scope.limit(SpreeGladly::Config.order_limit) if SpreeGladly::Config.order_limit
+        scope.to_a
+      end
+
+      def empty_result
+        OpenStruct.new(customer: [], transactions: [], guest: false)
+      end
+
+      def order_table
+        Spree::Order.table_name
+      end
+    end
+  end
+end

data/app/models/spree_gladly/configuration.rb

@@ -0,0 +1,25 @@
+module SpreeGladly
+  class Configuration < ::Spree::Preferences::Configuration
+    preference :signing_key, :string, default: ''
+    preference :signing_threshold, :integer, default: 0
+
+    attr_accessor :basic_lookup_presenter,
+                  :detailed_lookup_presenter,
+                  :order_limit,
+                  :order_includes,
+                  :order_sorting,
+                  :order_states
+
+    @basic_lookup_presenter = nil
+
+    @detailed_lookup_presenter = nil
+
+    @order_limit = nil
+
+    @order_includes = nil
+
+    @order_sorting = nil
+
+    @order_states = nil
+  end
+end