solidus_backend_devise_token_auth 2.8.0.alpha.2

data/app/assets/stylesheets/spree/backend.css

@@ -0,0 +1,11 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+
+ *= require solidus_admin/select2
+ *= require solidus_admin/flatpickr/flatpickr
+ *= require prism
+
+ *= require spree/backend/spree_admin
+*/

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class AdjustmentReasonsController < ResourceController
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class AdjustmentsController < ResourceController
+      belongs_to 'spree/order', find_by: :number
+
+      create.after :update_totals
+      destroy.after :update_totals
+      update.after :update_totals
+
+      skip_before_action :load_resource, only: [:toggle_state, :edit, :update, :destroy]
+
+      before_action :find_adjustment, only: [:destroy, :edit, :update]
+
+      helper_method :reasons_for
+
+      def index
+        @adjustments = @order.all_adjustments.order("created_at ASC")
+      end
+
+      private
+
+      def find_adjustment
+        # Need to assign to @object here to keep ResourceController happy
+        @adjustment = @object = parent.all_adjustments.find(params[:id])
+      end
+
+      def update_totals
+        @order.reload.recalculate
+      end
+
+      # Override method used to create a new instance to correctly
+      # associate adjustment with order
+      def build_resource
+        parent.adjustments.build(order: parent)
+      end
+
+      def reasons_for(_adjustment)
+        [
+          Spree::AdjustmentReason.active.to_a,
+          @adjustment.adjustment_reason
+        ].flatten.compact.uniq.sort_by { |r| r.name.downcase }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class BaseController < Spree::BaseController
+      helper 'spree/admin/navigation'
+      layout '/spree/layouts/admin'
+
+      before_action :authorize_admin
+
+      private
+
+      # Overrides ControllerHelpers::Common
+      # We want the admin's locale selection to be different than that on the frontend
+      def set_user_language_locale_key
+        :admin_locale
+      end
+
+      def action
+        params[:action].to_sym
+      end
+
+      def authorize_admin
+        if respond_to?(:model_class, true) && model_class
+          record = model_class
+        else
+          record = controller_name.to_sym
+        end
+        authorize! :admin, record
+        authorize! action, record
+      end
+
+      def flash_message_for(object, event_sym)
+        resource_desc  = object.class.model_name.human
+        resource_desc += " \"#{object.name}\"" if object.respond_to?(:name) && object.name.present?
+        t(event_sym, resource: resource_desc, scope: 'spree')
+      end
+
+      def render_js_for_destroy
+        render partial: '/spree/admin/shared/destroy'
+      end
+
+      def config_locale
+        Spree::Backend::Config[:locale]
+      end
+
+      def lock_order
+        Spree::OrderMutex.with_lock!(@order) { yield }
+      rescue Spree::OrderMutex::LockFailed
+        flash[:error] = t('spree.order_mutex_admin_error')
+        redirect_to order_mutex_redirect_path
+      end
+
+      def order_mutex_redirect_path
+        edit_admin_order_path(@order)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class CancellationsController < Spree::Admin::BaseController
+      before_action :load_order, only: [:index, :short_ship]
+
+      def index
+        @inventory_units = @order.inventory_units.cancelable
+      end
+
+      def short_ship
+        inventory_unit_ids = params[:inventory_unit_ids] || []
+        inventory_units = Spree::InventoryUnit.where(id: inventory_unit_ids)
+
+        if inventory_units.size != inventory_unit_ids.size
+          flash[:error] = t('spree.unable_to_find_all_inventory_units')
+          redirect_to admin_order_cancellations_path(@order)
+        elsif inventory_units.empty?
+          flash[:error] = t('spree.no_inventory_selected')
+          redirect_to admin_order_cancellations_path(@order)
+        else
+          @order.cancellations.short_ship(inventory_units, whodunnit: whodunnit)
+
+          flash[:success] = t('spree.inventory_canceled')
+          redirect_to edit_admin_order_url(@order)
+        end
+      end
+
+      private
+
+      def whodunnit
+        try_spree_current_user.try(:email)
+      end
+
+      def load_order
+        @order = Spree::Order.find_by!(number: params[:order_id])
+        authorize! action, @order
+      end
+
+      def model_class
+        Spree::OrderCancellations
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class CustomerReturnsController < ResourceController
+      helper 'spree/admin/reimbursement_type'
+      belongs_to 'spree/order', find_by: :number
+
+      before_action :parent # ensure order gets loaded to support our pseudo parent-child relationship
+      before_action :load_form_data, only: [:new, :edit]
+      before_action :build_return_items_from_params, only: [:create]
+      create.fails  :load_form_data
+
+      def edit
+        @pending_return_items = @customer_return.return_items.select(&:pending?)
+        @accepted_return_items = @customer_return.return_items.select(&:accepted?)
+        @rejected_return_items = @customer_return.return_items.select(&:rejected?)
+        @manual_intervention_return_items = @customer_return.return_items.select(&:manual_intervention_required?)
+        @pending_reimbursements = @customer_return.reimbursements.select(&:pending?)
+
+        super
+      end
+
+      private
+
+      def location_after_save
+        url_for([:edit, :admin, @order, @customer_return])
+      end
+
+      def build_resource
+        Spree::CustomerReturn.new
+      end
+
+      def find_resource
+        Spree::CustomerReturn.accessible_by(current_ability, :read).find(params[:id])
+      end
+
+      def collection
+        parent # trigger loading the order
+        @collection ||= Spree::ReturnItem
+          .accessible_by(current_ability, :read)
+          .where(inventory_unit_id: @order.inventory_units.pluck(:id))
+          .map(&:customer_return).uniq.compact
+        @customer_returns = @collection
+      end
+
+      def load_form_data
+        return_items = @order.inventory_units.map(&:current_or_new_return_item).reject(&:customer_return_id)
+        @rma_return_items, @new_return_items = return_items.partition(&:return_authorization_id)
+        load_return_reasons
+      end
+
+      def load_return_reasons
+        @reasons = Spree::ReturnReason.reasons_for_return_items(@customer_return.return_items)
+      end
+
+      def permitted_resource_params
+        @permitted_resource_params ||= params.require('customer_return').permit(permitted_customer_return_attributes)
+      end
+
+      def build_return_items_from_params
+        return_items_params = permitted_resource_params.delete(:return_items_attributes).values
+
+        @customer_return.return_items = return_items_params.map do |item_params|
+          next unless item_params.delete('returned') == '1'
+          return_item = item_params[:id] ? Spree::ReturnItem.find(item_params[:id]) : Spree::ReturnItem.new
+          return_item.assign_attributes(item_params)
+          if item_params[:reception_status_event].blank?
+            return redirect_to(new_object_url, flash: { error: 'Reception status choice required' })
+          end
+          return_item
+        end.compact
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class DashboardsController < BaseController
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class GeneralSettingsController < Spree::Admin::BaseController
+      def edit
+        redirect_to admin_stores_path
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class ImagesController < ResourceController
+      before_action :load_data
+
+      create.before :set_viewable
+      update.before :set_viewable
+
+      private
+
+      def location_after_destroy
+        admin_product_images_url(@product)
+      end
+
+      def location_after_save
+        admin_product_images_url(@product)
+      end
+
+      def load_data
+        @product = Spree::Product.friendly.find(params[:product_id])
+        @variants = @product.variants.collect do |variant|
+          [variant.sku_and_options_text, variant.id]
+        end
+        @variants.insert(0, [t('spree.all'), @product.master.id])
+      end
+
+      def set_viewable
+        @image.viewable_type = 'Spree::Variant'
+        @image.viewable_id = params[:image][:viewable_id]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class LocaleController < Spree::Admin::BaseController
+      def set
+        locale = params[:switch_to_locale].to_s.presence
+
+        if locale && I18n.available_locales.include?(locale.to_sym)
+          I18n.locale = locale
+          session[:locale] = locale
+
+          respond_to do |format|
+            format.json { render json: { locale: locale, location: spree.admin_url } }
+          end
+        else
+          respond_to do |format|
+            format.json { render json: { locale: I18n.locale }, status: 404 }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class LogEntriesController < Spree::Admin::BaseController
+      before_action :find_order_and_payment
+
+      def index
+        @log_entries = @payment.log_entries
+      end
+
+      private
+
+      def find_order_and_payment
+        @order = Spree::Order.where(number: params[:order_id]).first!
+        @payment = @order.payments.find(params[:payment_id])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class OptionTypesController < ResourceController
+      before_action :setup_new_option_value, only: :edit
+
+      def update_values_positions
+        params[:positions].each do |id, index|
+          Spree::OptionValue.where(id: id).update_all(position: index)
+        end
+
+        respond_to do |format|
+          format.js { head :no_content }
+        end
+      end
+
+      private
+
+      def location_after_save
+        edit_admin_option_type_url(@option_type)
+      end
+
+      def load_product
+        @product = Spree::Product.find_by_param!(params[:product_id])
+      end
+
+      def setup_new_option_value
+        @option_type.option_values.build if @option_type.option_values.empty?
+      end
+
+      def set_available_option_types
+        @available_option_types = if @product.option_type_ids.any?
+          Spree::OptionType.where('id NOT IN (?)', @product.option_type_ids)
+        else
+          Spree::OptionType.all
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class OptionValuesController < Spree::Admin::BaseController
+      def destroy
+        option_value = Spree::OptionValue.find(params[:id])
+        option_value.destroy
+        render plain: nil
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/orders/customer_details_controller.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module Orders
+      class CustomerDetailsController < Spree::Admin::BaseController
+        rescue_from Spree::Order::InsufficientStock, with: :insufficient_stock_error
+
+        before_action :load_order
+
+        def show
+          edit
+        end
+
+        def edit
+          country_id = Spree::Country.default.id
+          @order.build_bill_address(country_id: country_id) if @order.bill_address.nil?
+          @order.build_ship_address(country_id: country_id) if @order.ship_address.nil?
+
+          @order.bill_address.country_id = country_id if @order.bill_address.country.nil?
+          @order.ship_address.country_id = country_id if @order.ship_address.country.nil?
+        end
+
+        def update
+          if @order.contents.update_cart(order_params)
+
+            if should_associate_user?
+              requested_user = Spree.user_class.find(params[:user_id])
+              @order.associate_user!(requested_user, @order.email.blank?)
+            end
+
+            unless @order.completed?
+              @order.next
+              @order.refresh_shipment_rates
+            end
+
+            flash[:success] = t('spree.customer_details_updated')
+            redirect_to edit_admin_order_url(@order)
+          else
+            render action: :edit
+          end
+        end
+
+        private
+
+        def order_params
+          params.require(:order).permit(
+            :email,
+            :use_billing,
+            bill_address_attributes: permitted_address_attributes,
+            ship_address_attributes: permitted_address_attributes
+          )
+        end
+
+        def load_order
+          @order = Spree::Order.includes(:adjustments).find_by!(number: params[:order_id])
+        end
+
+        def model_class
+          Spree::Order
+        end
+
+        def should_associate_user?
+          params[:guest_checkout] == "false" && params[:user_id] && params[:user_id].to_i != @order.user_id
+        end
+
+        def insufficient_stock_error
+          flash[:error] = t('spree.insufficient_stock_for_order')
+          redirect_to edit_admin_order_customer_url(@order)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class OrdersController < Spree::Admin::BaseController
+      helper 'spree/admin/payments'
+
+      before_action :initialize_order_events
+      before_action :load_order, only: [:edit, :update, :complete, :advance, :cancel, :resume, :approve, :resend, :unfinalize_adjustments, :finalize_adjustments, :cart, :confirm]
+      around_action :lock_order, only: [:update, :advance, :complete, :confirm, :cancel, :resume, :approve, :resend]
+
+      rescue_from Spree::Order::InsufficientStock, with: :insufficient_stock_error
+
+      respond_to :html
+
+      def index
+        query_present = params[:q]
+        params[:q] ||= {}
+        params[:q][:completed_at_not_null] ||= '1' if Spree::Config[:show_only_complete_orders_by_default]
+        @show_only_completed = params[:q][:completed_at_not_null] == '1'
+        params[:q][:s] ||= @show_only_completed ? 'completed_at desc' : 'created_at desc'
+        params[:q][:completed_at_not_null] = '' unless @show_only_completed
+
+        # As date params are deleted if @show_only_completed, store
+        # the original date so we can restore them into the params
+        # after the search
+        created_at_gt = params[:q][:created_at_gt]
+        created_at_lt = params[:q][:created_at_lt]
+
+        params[:q].delete(:inventory_units_shipment_id_null) if params[:q][:inventory_units_shipment_id_null] == "0"
+
+        if params[:q][:created_at_gt].present?
+          params[:q][:created_at_gt] = begin
+                                         Time.zone.parse(params[:q][:created_at_gt]).beginning_of_day
+                                       rescue StandardError
+                                         ""
+                                       end
+        end
+
+        if params[:q][:created_at_lt].present?
+          params[:q][:created_at_lt] = begin
+                                         Time.zone.parse(params[:q][:created_at_lt]).end_of_day
+                                       rescue StandardError
+                                         ""
+                                       end
+        end
+
+        if @show_only_completed
+          params[:q][:completed_at_gt] = params[:q].delete(:created_at_gt)
+          params[:q][:completed_at_lt] = params[:q].delete(:created_at_lt)
+        end
+
+        @search = Spree::Order.accessible_by(current_ability, :index).ransack(params[:q])
+        @orders = @search.result.includes([:user]).
+          page(params[:page]).
+          per(params[:per_page] || Spree::Config[:orders_per_page])
+
+        # Restore dates
+        params[:q][:created_at_gt] = created_at_gt
+        params[:q][:created_at_lt] = created_at_lt
+      end
+
+      def new
+        user = Spree.user_class.find_by(id: params[:user_id]) if params[:user_id]
+        @order = Spree::Core::Importer::Order.import(user, order_params)
+        redirect_to cart_admin_order_url(@order)
+      end
+
+      def edit
+        require_ship_address
+      end
+
+      def cart
+        if @order.shipped_shipments.count > 0
+          redirect_to edit_admin_order_url(@order)
+        end
+      end
+
+      def advance
+        if @order.completed?
+          flash[:notice] = t('spree.order_already_completed')
+          redirect_to edit_admin_order_url(@order)
+        else
+          @order.contents.advance
+
+          if @order.can_complete?
+            flash[:success] = t('spree.order_ready_for_confirm')
+          else
+            flash[:error] = @order.errors.full_messages
+          end
+          redirect_to confirm_admin_order_url(@order)
+        end
+      end
+
+      # GET
+      def confirm
+        if @order.completed?
+          redirect_to edit_admin_order_url(@order)
+        elsif !@order.can_complete?
+          render template: 'spree/admin/orders/confirm_advance'
+        end
+      end
+
+      # PUT
+      def complete
+        @order.complete!
+        flash[:success] = t('spree.order_completed')
+        redirect_to edit_admin_order_url(@order)
+      rescue StateMachines::InvalidTransition => e
+        flash[:error] = e.message
+        redirect_to confirm_admin_order_url(@order)
+      end
+
+      def cancel
+        @order.canceled_by(try_spree_current_user)
+        flash[:success] = t('spree.order_canceled')
+        redirect_to(spree.edit_admin_order_path(@order))
+      end
+
+      def resume
+        @order.resume!
+        flash[:success] = t('spree.order_resumed')
+        redirect_to(spree.edit_admin_order_path(@order))
+      end
+
+      def approve
+        @order.contents.approve(user: try_spree_current_user)
+        flash[:success] = t('spree.order_approved')
+        redirect_to(spree.edit_admin_order_path(@order))
+      end
+
+      def resend
+        Spree::Config.order_mailer_class.confirm_email(@order, true).deliver_later
+        flash[:success] = t('spree.order_email_resent')
+
+        redirect_to(spree.edit_admin_order_path(@order))
+      end
+
+      def unfinalize_adjustments
+        adjustments = @order.all_adjustments.finalized
+        adjustments.each(&:unfinalize!)
+        flash[:success] = t('spree.all_adjustments_unfinalized')
+
+        respond_with(@order) { |format| format.html { redirect_to(spree.admin_order_adjustments_path(@order)) } }
+      end
+
+      def finalize_adjustments
+        adjustments = @order.all_adjustments.not_finalized
+        adjustments.each(&:finalize!)
+        flash[:success] = t('spree.all_adjustments_finalized')
+
+        respond_with(@order) { |format| format.html { redirect_to(spree.admin_order_adjustments_path(@order)) } }
+      end
+
+      private
+
+      def order_params
+        {
+          created_by_id: try_spree_current_user.try(:id),
+          frontend_viewable: false,
+          store_id: current_store.try(:id)
+        }.with_indifferent_access
+      end
+
+      def load_order
+        @order = Spree::Order.includes(:adjustments).find_by!(number: params[:id])
+        authorize! action, @order
+      end
+
+      # Used for extensions which need to provide their own custom event links on the order details view.
+      def initialize_order_events
+        @order_events = %w{approve cancel resume}
+      end
+
+      def model_class
+        Spree::Order
+      end
+
+      def insufficient_stock_error
+        flash[:error] = t('spree.insufficient_stock_for_order')
+        redirect_to cart_admin_order_url(@order)
+      end
+
+      def require_ship_address
+        if @order.ship_address.nil?
+          flash[:notice] = t('spree.fill_in_customer_info')
+          redirect_to edit_admin_order_customer_url(@order)
+        end
+      end
+    end
+  end
+end