spree_admin 5.0.0.rc1

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

@@ -0,0 +1,366 @@
+module Spree
+  module Admin
+    class ProductsController < ResourceController
+      include Spree::Admin::StockLocationsHelper
+      include Spree::Admin::BulkOperationsConcern
+      include Spree::Admin::SessionAssetsHelper
+
+      helper 'spree/admin/products'
+      helper 'spree/admin/taxons'
+
+      before_action :load_data, except: :index
+      before_action :load_variants_data, only: %i[edit update]
+      before_action :set_product_defaults, only: :new
+
+      before_action :prepare_product_params, only: [:create, :update]
+      before_action :strip_stock_items_param, only: [:create, :update]
+      before_action :ensure_session_uploaded_assets_uuid, only: :new
+
+      new_action.before :build_master_prices
+      new_action.before :build_master_stock_items
+      new_action.before :build_product_properties
+      edit_action.before :build_master_prices
+      edit_action.before :build_master_stock_items
+      edit_action.before :build_product_properties
+      create.after :assign_master_images
+      update.before :skip_updating_status
+      update.before :update_status
+      update.before :remove_empty_params
+      helper_method :clone_object_url
+
+      # https://blog.corsego.com/hotwire-turbo-streams-autocomplete-search
+      def search
+        query = params[:q]&.strip
+
+        head :ok and return if query.blank? || query.length < 3
+
+        scope = current_store.products.not_archived.accessible_by(current_ability, :index)
+        scope = scope.where.not(id: params[:omit_ids].split(',')) if params[:omit_ids].present?
+        @products = scope.includes(master: :images, variants: :images).multi_search(query).limit(params[:limit] || 10)
+
+        respond_to do |format|
+          format.turbo_stream do
+            render turbo_stream: [
+              turbo_stream.replace(
+                'products_search_results',
+                partial: 'spree/admin/products/search_results',
+                locals: { products: @products }
+              )
+            ]
+          end
+        end
+      end
+
+      def show
+        redirect_to action: :edit
+      end
+
+      def update
+        invoke_callbacks(:update, :before)
+
+        if @product.update(permitted_resource_params)
+          set_current_store
+          invoke_callbacks(:update, :after)
+          flash[:success] = flash_message_for(@product, :successfully_updated)
+          redirect_to location_after_save
+        else
+          # Stops people submitting blank slugs, causing errors when they try to
+          # update the product again
+          @product.slug = @product.slug_was if @product.slug.blank?
+          invoke_callbacks(:update, :fails)
+          respond_to do |format|
+            format.html { render :edit, status: :unprocessable_entity }
+            format.turbo_stream
+          end
+        end
+      end
+
+      def clone
+        clone_result = @product.duplicate
+
+        if clone_result.success?
+          flash[:success] = Spree.t('notice_messages.product_cloned')
+          redirect_to spree.edit_admin_product_path(clone_result.value)
+        else
+          flash[:error] = Spree.t('notice_messages.product_not_cloned', error: clone_result.error.value)
+          redirect_to spree.edit_admin_product_path(@product)
+        end
+      end
+
+      def bulk_modal
+        if params[:kind] == 'set_status'
+          @title = Spree.t('admin.bulk_ops.products.title.set_status', status: params[:status].titleize)
+          @body = Spree.t("admin.bulk_ops.products.body.set_status.#{params[:status]}")
+        else
+          @title = Spree.t("admin.bulk_ops.products.title.#{params[:kind]}")
+          @body = Spree.t("admin.bulk_ops.products.body.#{params[:kind]}")
+        end
+      end
+
+      def bulk_status_update
+        if bulk_collection.update_all(status: params[:status], updated_at: Time.current)
+          product_ids = bulk_collection.ids
+
+          if Spree::Webhooks::Subscriber.any?
+            ::Spree::Products::QueueStatusChangedWebhook.call(
+              ids: product_ids,
+              event: Spree::Product::STATUS_TO_WEBHOOK_EVENT[params[:status]]
+            )
+          end
+
+          invoke_callbacks(:bulk_status_update, :after)
+
+          flash.now[:success] = Spree.t('admin.bulk_ops.products.status_updated', status: params[:status].titleize)
+        else
+          flash.now[:error] = Spree.t('something_went_wrong')
+        end
+      end
+
+      def bulk_add_tags
+        Spree::Tags::BulkAdd.call(tag_names: params[:tags], records: bulk_collection)
+        Spree::Product.bulk_auto_match_taxons(current_store, bulk_collection.ids)
+
+        handle_bulk_operation_response
+      end
+
+      def bulk_remove_tags
+        Spree::Tags::BulkRemove.call(tag_names: params[:tags], records: bulk_collection)
+        Spree::Product.bulk_auto_match_taxons(current_store, bulk_collection.ids)
+
+        handle_bulk_operation_response
+      end
+
+      def bulk_remove_from_taxons
+        taxons = current_store.taxons.accessible_by(current_ability, :manage).where(id: params[:taxon_ids])
+        Spree::Taxons::RemoveProducts.call(taxons: taxons, products: bulk_collection)
+        Spree::Product.bulk_auto_match_taxons(current_store, bulk_collection.ids)
+
+        handle_bulk_operation_response
+      end
+
+      def bulk_add_to_taxons
+        taxons = current_store.taxons.accessible_by(current_ability, :manage).where(id: params[:taxon_ids])
+        Spree::Taxons::AddProducts.call(taxons: taxons, products: bulk_collection)
+        Spree::Product.bulk_auto_match_taxons(current_store, bulk_collection.ids)
+
+        handle_bulk_operation_response
+      end
+
+      def select_options
+        render json: current_store.products.not_archived.accessible_by(current_ability, :index).to_tom_select_json
+      end
+
+      protected
+
+      def find_resource
+        current_store.products.accessible_by(current_ability, :manage).with_deleted.friendly.find(params[:id])
+      end
+
+      def load_data
+        @taxons = Taxon.order(:name)
+        @option_types = OptionType.order(:name)
+        @tax_categories = TaxCategory.order(:name)
+        @shipping_categories = ShippingCategory.order(:name)
+      end
+
+      def load_variants_data
+        return unless @product.has_variants?
+
+        @product_options = {}
+        @product_available_options = {}
+
+        @product.
+          option_values.
+          joins(option_type: :product_option_types).
+          includes(option_type: :option_values).
+          merge(@product.product_option_types).
+          reorder('spree_product_option_types.position').
+          uniq.group_by(&:option_type).each_with_index do |option, index|
+            option_type, option_values = option
+
+            @product_options[option_type.id.to_s] = {
+              name: option_type.presentation,
+              position: index + 1,
+              values: option_values.pluck(:presentation).uniq
+            }
+
+            @product_available_options[option_type.id.to_s] = option_type.option_values.to_tom_select_json
+          end
+
+        @product_stock = {}
+        @product.stock_items.includes(:variant).each do |stock_item|
+          @product_stock[stock_item.variant.human_name] ||= {}
+          @product_stock[stock_item.variant.human_name][stock_item.stock_location_id.to_s] = {
+            count_on_hand: stock_item.count_on_hand,
+            backorderable: stock_item.backorderable,
+            id: stock_item.id.to_s
+          }
+        end
+
+        @product_prices = {}
+        @product.prices.includes(:variant).each do |price|
+          @product_prices[price.variant.human_name] ||= {}
+          @product_prices[price.variant.human_name][price.currency.downcase] = {
+            id: price.id.to_s,
+            amount: price.amount
+          }
+        end
+
+        @product_variant_ids = {}
+
+        @product.variants.includes(:option_values).each do |variant|
+          @product_variant_ids[variant.human_name] = variant.id.to_s
+        end
+      end
+
+      def set_product_defaults
+        @product.shipping_category ||= @shipping_categories&.first
+      end
+
+      def skip_updating_status
+        @new_status = params[:product].delete(:status)
+      end
+
+      def update_status
+        return if @new_status == @product.status
+        return if cannot?(:activate, @product) && @new_status&.to_sym == :active
+
+        event_to_fire = @product.status_transitions.find { |transition| transition.from == @product.status && transition.to == @new_status }&.event
+        @product.status_event = event_to_fire if event_to_fire
+      end
+
+      def remove_empty_params
+        reject_empty_params(:tag_list) if can?(:manage_tags, @product)
+        reject_empty_params(:taxon_ids)
+        reject_empty_params(:label_list) if can?(:manage_labels, @product)
+      end
+
+      def reject_empty_params(key)
+        params[:product][key] = params[:product][key].present? ? params[:product][key].reject(&:empty?) : []
+      end
+
+      def prepare_product_params
+        params_service = Spree::Products::PrepareNestedAttributes.new(@product, current_store, permitted_resource_params, current_ability)
+        params[:product] = params_service.call
+      end
+
+      def collection
+        return @collection if @collection.present?
+
+        params[:q] ||= {}
+        params[:q][:deleted_at_null] ||= '1'
+
+        params[:q][:s] ||= 'name asc'
+        params[:q][:status_eq] == 'archived' ? params[:q].delete(:status_not_eq) : params[:q][:status_not_eq] = 'archived'
+
+        params[:q][:taxons_id_null] = '1' if params.dig(:q, :taxons_id_in)&.include?(' ')
+
+        assign_extra_collection_params if respond_to?(:assign_extra_collection_params)
+
+        @collection = super
+
+        # Don't delete params[:q][:deleted_at_null] here because it is used in view to check the
+        # checkbox for 'q[deleted_at_null]'. This also messed with pagination when deleted_at_null is checked.
+        @collection = @collection.with_deleted if params[:q][:deleted_at_null] == '0'
+
+        # The out_of_stock scope groups products - we also need to group it by name coming from product translations
+        # That's because we sort products by name
+        @collection = @collection.group(:name) if params.dig(:q, :out_of_stock_items) == '1'
+
+        # @search needs to be defined as this is passed to search_form_for
+        # Temporarily remove params[:q][:deleted_at_null] from params[:q] to ransack products.
+        # This is to include all products and not just deleted products.
+        @search = @collection.ransack(params[:q].except(:deleted_at_null))
+        @collection = @search.result(distinct: true).
+                      for_ordering_with_translations(model_class, :name).
+                      includes(product_includes).
+                      page(params[:page]).
+                      per(params[:per_page] || ENV.fetch('ADMIN_PRODUCTS_PER_PAGE', 25))
+
+        @collection
+      end
+
+      def clone_object_url(resource)
+        clone_admin_product_url resource
+      end
+
+      def permitted_resource_params
+        if cannot?(:activate, @product) && @new_status&.to_sym == :active
+          super.except(:status, :make_active_at).permit!
+        else
+          super
+        end
+      end
+
+      private
+
+      def update_turbo_stream_enabled?
+        true
+      end
+
+      def variant_stock_includes
+        [:images, { stock_items: :stock_location, option_values: :option_type }]
+      end
+
+      def strip_stock_items_param
+        if params.dig(:product, :track_inventory) == '0'
+          if params.dig(:product, :master_attributes, :stock_items_attributes).present?
+            params[:product][:master_attributes][:stock_items_attributes] = {}
+          end
+          if params.dig(:product, :variants_attributes)
+            params[:product][:variants_attributes].each do |_key, variant|
+              variant[:stock_items_attributes] = {}
+            end
+          end
+        end
+      end
+
+      def build_master_prices
+        return if @product.has_variants?
+
+        current_store.supported_currencies_list.each do |currency|
+          @product.master.prices.build(currency: currency) unless @product.master.prices.find { |price| price.currency == currency }
+        end
+      end
+
+      def build_master_stock_items
+        return if @product.has_variants?
+
+        available_stock_locations_list(master_stock_items_locations_opts).each do |_name, id|
+          @product.master.stock_items.build(stock_location_id: id, count_on_hand: 0) unless @product.master.stock_items.find { |stock_item| stock_item.stock_location_id == id }
+        end
+      end
+
+      def master_stock_items_locations_opts
+        {}
+      end
+
+      def build_product_properties
+        Spree::Property.all.each do |property|
+          @product.product_properties.build(property: property) unless @product.product_properties.find { |product_property| product_property.property_id == property.id }
+        end
+      end
+
+      def assign_master_images
+        return unless @product.master.persisted?
+
+        return if session_uploaded_assets.empty?
+
+        session_uploaded_assets.update_all(viewable_id: @product.master.id, viewable_type: 'Spree::Variant', updated_at: Time.current)
+        clear_session_for_uploaded_assets
+      end
+
+      def product_includes
+        {
+          tax_category: [],
+          stock_items: [:stock_location],
+          variants_including_master: [],
+          shipping_category: [],
+          master: [:prices, :images, :stock_items, :stock_locations],
+          variants: [:prices, :images, :stock_items, :stock_locations],
+          variant_images: [],
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Spree
+  module Admin
+    class ProfileController < BaseController
+      def edit
+        @user = try_spree_current_user
+      end
+
+      def update
+        @user = try_spree_current_user
+
+        if @user.update(user_params)
+          if params[:remove_avatar] == '1' && @user.avatar.attached?
+            @user.avatar.detach
+            @user.avatar.purge_later
+          end
+
+          flash[:success] = flash_message_for(@user, :successfully_updated)
+          redirect_to spree.edit_admin_profile_path
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      private
+
+      def user_params
+        params.require(:user).permit(permitted_user_attributes)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Spree
+  module Admin
+    class PromotionActionsController < ResourceController
+      belongs_to 'spree/promotion', find_by: :id
+
+      helper_method :allowed_action_types
+
+      before_action :set_calculator_type, only: [:new]
+
+      private
+
+      def model_class
+        @model_class = if params.dig(:promotion_action, :type).present?
+                         if allowed_action_types.map(&:to_s).include?(params.dig(:promotion_action, :type))
+                           params.dig(:promotion_action, :type).safe_constantize
+                         else
+                           raise 'Unknown promotion action type'
+                         end
+                       else
+                         Spree::PromotionAction
+                       end
+      end
+
+      def build_resource
+        model_class.new(promotion: parent)
+      end
+
+      def allowed_action_types
+        Rails.application.config.spree.promotions.actions
+      end
+
+      def location_after_save
+        collection_url
+      end
+
+      def collection_url
+        spree.admin_promotion_path(parent)
+      end
+
+      def set_calculator_type
+        if @promotion_action.respond_to?(:calculator_type)
+          @promotion_action.calculator_type = @promotion_action.class.calculators.first.name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Spree
+  module Admin
+    class PromotionRulesController < ResourceController
+      belongs_to 'spree/promotion', find_by: :id
+
+      helper_method :allowed_rule_types
+
+      private
+
+      def model_class
+        @model_class = if params.dig(:promotion_rule, :type).present?
+                         if allowed_rule_types.map(&:to_s).include?(params.dig(:promotion_rule, :type))
+                           params.dig(:promotion_rule, :type).safe_constantize
+                         else
+                           raise 'Unknown promotion rule type'
+                         end
+                       else
+                         Spree::PromotionAction
+                       end
+      end
+
+      def build_resource
+        model_class.new(promotion: parent)
+      end
+
+      def allowed_rule_types
+        Rails.application.config.spree.promotions.rules
+      end
+
+      def location_after_save
+        collection_url
+      end
+
+      def collection_url
+        spree.admin_promotion_path(parent)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Spree
+  module Admin
+    class PromotionsController < ResourceController
+      before_action :load_form_data, except: :index
+
+      # POST /admin/promotions/:id/clone
+      def clone
+        promotion = current_store.promotions.find(params[:id])
+        duplicator = Spree::PromotionHandler::PromotionDuplicator.new(promotion)
+
+        @new_promo = duplicator.duplicate
+
+        if @new_promo.errors.empty?
+          flash[:success] = Spree.t('promotion_cloned')
+          redirect_to spree.admin_promotion_path(@new_promo)
+        else
+          flash[:error] = Spree.t('promotion_not_cloned', error: @new_promo.errors.full_messages.to_sentence)
+          redirect_to spree.admin_promotions_path
+        end
+      end
+
+      protected
+
+      def location_after_save
+        spree.admin_promotion_path(@promotion)
+      end
+
+      def load_form_data
+        @promotion_rules = Rails.application.config.spree.promotions.rules
+        @rule_types = @promotion_rules.map do |promotion_rule|
+          [Spree.t("promotion_rule_types.#{promotion_rule.to_s.demodulize.underscore}.name"), promotion_rule.to_s]
+        end
+      end
+
+      def collection
+        return @collection if defined?(@collection)
+
+        params[:q] ||= {}
+
+        expired = params[:q].delete(:expired) == 'true'
+        active = params[:q].delete(:active) == 'true'
+
+        @collection = super
+
+        @collection = @collection.active if active
+        @collection = @collection.expired if expired
+
+        @search = @collection.ransack(params[:q])
+        @collection = @search.result(distinct: true).
+                      includes(:promotion_actions).
+                      page(params[:page]).
+                      per(params[:per_page])
+
+        params[:q][:expired] = expired
+        params[:q][:active] = active
+
+        @collection
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Spree
+  module Admin
+    class PropertiesController < ResourceController
+      protected
+
+      def update_turbo_stream_enabled?
+        true
+      end
+
+      def collection
+        return @collection if @collection.present?
+
+        # params[:q] can be blank upon pagination
+        params[:q] = {} if params[:q].blank?
+
+        @collection = super
+        @search = @collection.ransack(params[:q])
+        @collection = @search.result.
+                      page(params[:page])
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,43 @@
+module Spree
+  module Admin
+    class RefundsController < ResourceController
+      belongs_to 'spree/payment', find_by: :number
+
+      before_action :load_order
+      before_action :assign_refunder, only: :create
+
+      helper_method :refund_reasons
+
+      rescue_from Spree::Core::GatewayError, with: :spree_core_gateway_error
+
+      private
+
+      def location_after_save
+        spree.edit_admin_order_path(@payment.order)
+      end
+
+      def load_order
+        @order = @payment.order if @payment
+      end
+
+      def refund_reasons
+        @refund_reasons ||= RefundReason.active.all
+      end
+
+      def build_resource
+        super.tap do |refund|
+          refund.amount = refund.payment.credit_allowed
+        end
+      end
+
+      def spree_core_gateway_error(error)
+        flash[:error] = error.message
+        render :new
+      end
+
+      def assign_refunder
+        @refund.refunder = try_spree_current_user
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,47 @@
+module Spree
+  module Admin
+    class ReimbursementsController < ResourceController
+      belongs_to 'spree/order', find_by: :number
+
+      before_action :load_simulated_refunds, only: :edit
+
+      rescue_from Spree::Core::GatewayError, with: :spree_core_gateway_error
+
+      def perform
+        @reimbursement.perform!(try_spree_current_user)
+        redirect_to location_after_save
+      end
+
+      private
+
+      def build_resource
+        if params[:build_from_customer_return_id].present?
+          customer_return = current_store.customer_returns.find(params[:build_from_customer_return_id])
+
+          Reimbursement.build_from_customer_return(customer_return)
+        else
+          super
+        end
+      end
+
+      def location_after_save
+        if @reimbursement.reimbursed?
+          spree.admin_order_reimbursement_path(parent, @reimbursement)
+        else
+          spree.edit_admin_order_reimbursement_path(parent, @reimbursement)
+        end
+      end
+
+      def load_simulated_refunds
+        ActiveRecord::Base.connected_to(role: :writing) do
+          @reimbursement_objects = @reimbursement.simulate
+        end
+      end
+
+      def spree_core_gateway_error(error)
+        flash[:error] = error.message
+        redirect_to spree.edit_admin_order_reimbursement_path(parent, @reimbursement)
+      end
+    end
+  end
+end