spree_admin 5.0.0.rc1

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

@@ -0,0 +1,52 @@
+module Spree
+  module Admin
+    class ReportsController < ResourceController
+      include ActiveStorage::SetCurrent
+
+      before_action :set_user, only: [:new, :create]
+
+      def show
+        redirect_to @object.attachment.url, status: :see_other, allow_other_host: true
+      end
+
+      private
+
+      def set_user
+        @object.user = try_spree_current_user
+      end
+
+      def create_turbo_stream_enabled?
+        true
+      end
+
+      def message_after_create
+        Spree.t('admin.report_created')
+      end
+
+      def location_after_save
+        spree.admin_reports_path
+      end
+
+      def build_resource
+        model_class.new(store: current_store, date_from: params[:date_from], date_to: params[:date_to], currency: params[:currency])
+      end
+
+      def model_class
+        @model_class = if params[:type].present?
+                         report_type = "Spree::Reports::#{params[:type].classify}"
+                         if allowed_report_types.include?(report_type)
+                           report_type.constantize
+                         else
+                           raise 'Unknown report type'
+                         end
+                       else
+                         Spree::Report
+                       end
+      end
+
+      def allowed_report_types
+        Rails.application.config.spree.reports.map(&:to_s)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,325 @@
+class Spree::Admin::ResourceController < Spree::Admin::BaseController
+  include Spree::Admin::Callbacks
+
+  helper_method :new_object_url, :edit_object_url, :object_url, :collection_url, :model_class
+  before_action :load_resource
+  before_action :set_currency, :set_current_store, only: [:new, :create]
+  after_action :set_return_to, only: [:index]
+
+  rescue_from ActiveRecord::RecordNotFound, with: :resource_not_found
+
+  def new
+    invoke_callbacks(:new_action, :before)
+  end
+
+  def edit
+    invoke_callbacks(:edit_action, :before)
+  end
+
+  def update
+    invoke_callbacks(:update, :before)
+    if @object.update(permitted_resource_params)
+      set_current_store
+      remove_assets(%w[asset image square_image])
+
+      invoke_callbacks(:update, :after)
+      respond_to do |format|
+        if update_turbo_stream_enabled?
+          format.turbo_stream do
+            flash.now[:success] = message_after_update
+          end
+        end
+        format.html do
+          flash[:success] = message_after_update
+          redirect_to location_after_save, status: :see_other
+        end
+      end
+    else
+      invoke_callbacks(:update, :fails)
+      respond_to do |format|
+        if update_turbo_stream_enabled?
+          format.turbo_stream do
+            flash.now[:error] = @object.errors.full_messages.join(', ')
+          end
+        end
+        format.html { render action: :edit, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def create
+    invoke_callbacks(:create, :before)
+    @object.attributes = permitted_resource_params
+    if @object.save
+      invoke_callbacks(:create, :after)
+      respond_to do |format|
+        if create_turbo_stream_enabled?
+          format.turbo_stream do
+            flash.now[:success] = message_after_create
+          end
+        end
+        format.html do
+          flash[:success] = message_after_create
+          redirect_to location_after_save, status: :see_other
+        end
+      end
+    else
+      invoke_callbacks(:create, :fails)
+      respond_to do |format|
+        if create_turbo_stream_enabled?
+          format.turbo_stream do
+            flash.now[:error] = @object.errors.full_messages.join(', ')
+          end
+        end
+        format.html { render action: :new, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    invoke_callbacks(:destroy, :before)
+    if @object.destroy
+      invoke_callbacks(:destroy, :after)
+
+      respond_to do |format|
+        if destroy_turbo_stream_enabled?
+          format.turbo_stream do
+            flash.now[:success] = flash_message_for(@object, :successfully_removed)
+          end
+        end
+        format.html do
+          flash[:success] = flash_message_for(@object, :successfully_removed)
+          redirect_to location_after_destroy, status: :see_other
+        end
+      end
+    else
+      invoke_callbacks(:destroy, :fails)
+
+      respond_to do |format|
+        if destroy_turbo_stream_enabled?
+          format.turbo_stream do
+            flash.now[:error] = @object.errors.full_messages.to_sentence
+          end
+        end
+        format.html do
+          flash[:error] = @object.errors.full_messages.to_sentence
+        end
+      end
+    end
+  end
+
+  protected
+
+  class << self
+    attr_accessor :parent_data
+
+    def belongs_to(model_name, options = {})
+      @parent_data ||= {}
+      @parent_data[:model_name] = model_name
+      @parent_data[:model_class] = model_name.to_s.classify.constantize
+      @parent_data[:find_by] = options[:find_by] || :id
+    end
+  end
+
+  def model_class
+    @model_class ||= resource.model_class
+  end
+
+  def resource_not_found
+    flash[:error] = flash_message_for(model_class.new, :not_found)
+    redirect_to collection_url, status: :see_other
+  end
+
+  def resource
+    return @resource if @resource
+
+    parent_model_name = parent_data[:model_name] if parent_data
+    @resource = Spree::Admin::Resource.new controller_path, controller_name, parent_model_name, object_name
+  end
+
+  def load_resource
+    if member_action?
+      @object ||= load_resource_instance
+
+      # call authorize! a third time (called twice already in Admin::BaseController)
+      # this time we pass the actual instance so fine-grained abilities can control
+      # access to individual records, not just entire models.
+      authorize! action, @object
+
+      instance_variable_set("@#{resource.object_name}", @object)
+    else
+      @collection ||= collection
+
+      # note: we don't call authorize here as the collection method should use
+      # CanCan's accessible_by method to restrict the actual records returned
+
+      instance_variable_set("@#{controller_name}", @collection)
+    end
+  end
+
+  def load_resource_instance
+    if new_actions.include?(action)
+      build_resource
+    elsif params[:id]
+      find_resource
+    end
+  end
+
+  def parent_data
+    self.class.parent_data
+  end
+
+  def parent
+    if parent_data.present?
+      base_scope = parent_data[:model_class].try(:for_store, current_store) || parent_data[:model_class]
+
+      @parent ||= base_scope.
+                  # Don't use `find_by_attribute_name` to workaround globalize/globalize#423 bug
+                  send(:find_by, parent_data[:find_by].to_s => params["#{resource.model_name}_id"])
+      instance_variable_set("@#{resource.model_name}", @parent)
+
+      raise ActiveRecord::RecordNotFound if @parent.nil?
+
+      @parent
+    end
+  end
+
+  def find_resource
+    base_scope = if parent_data.present?
+                   parent.send(controller_name)
+                 else
+                   model_class.try(:for_store, current_store) || model_class
+                end
+
+    if model_class.try(:friendly)
+      base_scope.friendly.find(params[:id])
+    else
+      base_scope.find(params[:id])
+    end
+  end
+
+  def build_resource
+    if parent_data.present?
+      parent.send(controller_name).build
+    else
+      model_class.new
+    end
+  end
+
+  def collection
+    return parent.send(controller_name) if parent_data.present?
+
+    base_scope = model_class.try(:for_store, current_store) || model_class
+    if defined?(current_vendor) && current_vendor.present? && model_class.respond_to?(:with_vendor)
+      base_scope = base_scope.with_vendor(current_vendor)
+    end
+
+    if model_class.respond_to?(:accessible_by) &&
+        !current_ability.has_block?(params[:action], model_class)
+      base_scope.accessible_by(current_ability, action)
+    else
+      base_scope
+    end
+  end
+
+  def location_after_destroy
+    collection_url
+  end
+
+  def location_after_save
+    edit_object_url(@object)
+  end
+
+  def message_after_create
+    flash_message_for(@object, :successfully_created)
+  end
+
+  def message_after_update
+    flash_message_for(@object, :successfully_updated)
+  end
+
+  def set_current_store
+    return if @object.nil?
+
+    ensure_current_store(@object)
+  end
+
+  def set_currency
+    return if @object.nil?
+
+    @object.currency = current_currency if model_class.method_defined?(:currency=)
+    @object.cost_currency = current_currency if model_class.method_defined?(:cost_currency=)
+  end
+
+  # URL helpers
+
+  def new_object_url(options = {})
+    if parent_data.present?
+      spree.new_polymorphic_url([:admin, parent, model_class], options)
+    else
+      spree.new_polymorphic_url([:admin, model_class], options)
+    end
+  end
+
+  def edit_object_url(object, options = {})
+    if parent_data.present?
+      spree.send "edit_admin_#{resource.model_name}_#{resource.object_name}_url",
+                 parent, object, options
+    else
+      spree.send "edit_admin_#{resource.object_name}_url", object, options
+    end
+  end
+
+  def object_url(object = nil, options = {})
+    target = object || @object
+    if parent_data.present?
+      spree.send "admin_#{resource.model_name}_#{resource.object_name}_url", parent, target, options
+    else
+      spree.send "admin_#{resource.object_name}_url", target, options
+    end
+  end
+
+  def collection_url(options = {})
+    if parent_data.present?
+      spree.polymorphic_url([:admin, parent, model_class], options)
+    else
+      spree.polymorphic_url([:admin, model_class], options)
+    end
+  end
+
+  # This method should be overridden when object_name does not match the controller name
+  def object_name; end
+
+  # Allow all attributes to be updatable.
+  #
+  # Other controllers can, should, override it to set custom logic
+  def permitted_resource_params
+    params[resource.object_name].present? ? params.require(resource.object_name).permit! : ActionController::Parameters.new
+  end
+
+  def collection_actions
+    [:index, :select_options, :bulk_modal, :bulk_status_update,
+     :bulk_add_to_taxons, :bulk_remove_from_taxons,
+     :bulk_add_tags, :bulk_remove_tags, :bulk_destroy]
+  end
+
+  def member_action?
+    !collection_actions.include? action
+  end
+
+  def new_actions
+    [:new, :create]
+  end
+
+  def create_turbo_stream_enabled?
+    false
+  end
+
+  def update_turbo_stream_enabled?
+    false
+  end
+
+  def destroy_turbo_stream_enabled?
+    false
+  end
+end

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

@@ -0,0 +1,6 @@
+module Spree
+  module Admin
+    class ReturnAuthorizationReasonsController < ResourceController
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Spree
+  module Admin
+    class ReturnAuthorizationsController < ResourceController
+      def index; end
+
+      def cancel
+        @return_authorization.cancel!
+        flash[:success] = Spree.t(:return_authorization_canceled)
+        redirect_back fallback_location: spree.edit_admin_order_path(@return_authorization.order)
+      end
+
+      private
+
+      def location_after_destroy
+        spree.edit_admin_order_path(@return_authorization.order)
+      end
+
+      def collection
+        return @collection if @collection.present?
+
+        params[:q] ||= {}
+
+        # @search needs to be defined as this is passed to search_form_for
+        @search = current_store.return_authorizations.accessible_by(current_ability, :index).ransack(params[:q])
+        @collection = @search.result.order(created_at: :desc).page(params[:page]).per(params[:per_page])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Spree
+  module Admin
+    class ReturnItemsController < ResourceController
+      def location_after_save
+        spree.edit_admin_order_customer_return_path(@return_item.customer_return.order, @return_item.customer_return)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Spree
+  module Admin
+    class RolesController < ResourceController
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+module Spree
+  module Admin
+    class ShipmentsController < Spree::Admin::ResourceController
+      include Spree::Admin::StockLocationsHelper
+
+      layout 'turbo_rails/frame'
+
+      belongs_to 'spree/order', find_by: :number
+
+      before_action :load_variant, only: [:split, :transfer]
+      before_action :refresh_shipping_rates, only: :edit
+
+      def update
+        @result = Spree::Dependencies.shipment_update_service.constantize.call(shipment: @shipment, shipment_attributes: shipment_params)
+        flash[:success] = Spree.t(:successfully_updated, resource: Spree.t(:shipment)) if @result.success?
+
+        redirect_back fallback_location: spree.edit_admin_order_path(@order)
+      end
+
+      def ship
+        if @shipment.shippable? && @shipment.ship
+          flash[:success] = Spree.t(:shipment_successfully_shipped)
+        else
+          flash[:error] = Spree.t(:cannot_ship)
+        end
+
+        redirect_back fallback_location: spree.edit_admin_order_path(@order)
+      end
+
+      def split
+        @max_quantity = @shipment.inventory_units.where(variant_id: @variant.id).sum(:quantity)
+      end
+
+      def transfer
+        destination_name, destination_id = params[:destination].split('_')
+        quantity = params[:quantity]&.to_i || 1
+
+        errors = []
+        errors << "#{Spree.t(:quantity)} #{Spree.t('validation.is_too_large')}" if quantity <= 0
+
+        transfer = nil
+
+        case destination_name
+        when 'stock-location'
+          destination = available_stock_locations.find(destination_id)
+          transfer = @shipment.transfer_to_location(@variant, quantity, destination)
+        when 'shipment'
+          destination = parent.shipments.
+                        where(stock_location: available_stock_locations).
+                        find(destination_id)
+          transfer = @shipment.transfer_to_shipment(@variant, quantity, destination)
+        end
+
+        errors << Spree.t('admin.shipment_transfer.wrong_destination') if transfer.nil?
+
+        if errors.any?
+          flash[:error] = errors.to_sentence
+          return redirect_back_or_default(spree.edit_admin_order_path(@order))
+        end
+
+        if transfer.valid? && transfer.run!
+          flash[:success] = Spree.t(:shipment_transfer_success)
+        else
+          flash[:error] = transfer.errors.full_messages.to_sentence
+        end
+
+        redirect_back_or_default(spree.edit_admin_order_path(@order))
+      end
+
+      private
+
+      def refresh_shipping_rates
+        unless @order.completed?
+          ActiveRecord::Base.connected_to(role: :writing) do
+            @order.refresh_shipment_rates(ShippingMethod::DISPLAY_ON_BACK_END)
+          end
+        end
+      end
+
+      def model_class
+        Spree::Shipment
+      end
+
+      def find_resource
+        record = parent.shipments.find_by!(number: params[:id])
+        authorize! action, record
+      end
+
+      def collection_url
+        spree.edit_admin_order_path(@order)
+      end
+
+      def load_variant
+        @variant = current_store.variants.accessible_by(current_ability, :manage).find(params[:variant_id])
+      end
+
+      def shipment_params
+        params.require(:shipment).permit(permitted_shipment_attributes)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Spree
+  module Admin
+    class ShippingCategoriesController < ResourceController
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Spree
+  module Admin
+    class ShippingMethodsController < ResourceController
+      before_action :load_data, except: :index
+      before_action :set_default_values, only: :new
+
+      private
+
+      def set_default_values
+        @shipping_method.display_on = 'both'
+        @shipping_method.shipping_categories = [Spree::ShippingCategory.first]
+        @shipping_method.zone_ids = @available_zones.map(&:id)
+        @shipping_method.calculator_type = @calculators.first.name
+      end
+
+      def load_data
+        @available_zones = current_store.supported_shipping_zones
+        @tax_categories = Spree::TaxCategory.order(:name)
+        @calculators = Spree::ShippingMethod.calculators
+        @shipping_categories = Spree::ShippingCategory.all
+      end
+
+      # needed for the inline edit of display on on the index page
+      def update_turbo_stream_enabled?
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Spree
+  module Admin
+    class StockItemsController < ResourceController
+      private
+
+      def update_turbo_stream_enabled?
+        true
+      end
+
+      def collection
+        params[:q] ||= {}
+        params[:q][:s] ||= 'created_at desc'
+
+        @search = super.accessible_by(current_ability, :update).ransack(params[:q])
+        @stock_items = @search.result.
+                       joins(:variant).
+                       where(spree_variants: { track_inventory: true }).
+                       merge(current_store.variants.eligible).
+                       includes(:stock_location, [variant: [product: [variants: [:images], master: [:images]], images: []]]).
+                       page(params[:page]).
+                       per(params[:per_page])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Spree
+  module Admin
+    class StockLocationsController < ResourceController
+      before_action :set_country, only: :new
+
+      def mark_as_default
+        @stock_location.update(default: true)
+
+        flash[:success] = flash_message_for(@stock_location, :marked_as_default)
+        redirect_to spree.admin_stock_locations_path
+      end
+
+      private
+
+      def collection
+        super.order_default
+      end
+
+      def set_country
+        @stock_location.country = current_store.default_country
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Spree
+  module Admin
+    class StockTransfersController < ResourceController
+      before_action :prepare_params, only: :create
+
+      create.fails :load_variant_omit_ids
+
+      private
+
+      def location_after_save
+        spree.admin_stock_transfer_path(@object)
+      end
+
+      def collection
+        params[:q] ||= {}
+        params[:q][:s] ||= 'created_at desc'
+
+        @search = super.accessible_by(current_ability, :index).ransack(params[:q])
+        @stock_transfers = @search.result.
+                           page(params[:page]).
+                           per(params[:per_page])
+      end
+
+      def permitted_resource_params
+        params.require(:stock_transfer).permit(:source_location_id, :destination_location_id, :reference,
+                                               stock_movements_attributes: [:variant_id, :quantity, :originator_id, :stock_item_id])
+      end
+
+      def prepare_params
+        stock_movements_attributes = params.dig(:stock_transfer, :stock_movements_attributes) || []
+        stock_movements_attributes.each do |_key, sm_params|
+          if sm_params[:stock_item_id].blank? && sm_params[:location_id].present?
+            sm_params[:stock_item_id] = Spree::StockLocation.
+                                        accessible_by(current_ability).
+                                        find(sm_params[:location_id]).
+                                        stock_item_or_create(sm_params[:variant_id]).id
+          end
+
+          sm_params.delete(:variant_id)
+        end
+      end
+
+      def load_variant_omit_ids
+        @variant_omit_ids = @stock_transfer.stock_movements.map(&:variant_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+module Spree
+  module Admin
+    class StoreCreditCategoriesController < ResourceController
+    end
+  end
+end