spree_admin 5.0.0.rc1

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

@@ -0,0 +1,93 @@
+module Spree
+  module Admin
+    class StoreCreditError < StandardError; end
+
+    class StoreCreditsController < Spree::Admin::BaseController
+      before_action :load_user
+      before_action :load_store_credit, only: [:new, :edit, :update]
+      before_action :ensure_unused_store_credit, only: [:update]
+
+      def index
+        @store_credits = scope.includes(:category).order(created_at: :desc)
+        @store_credits = @store_credits.page(params[:page]).per(params[:per_page])
+
+        @collection = @store_credits
+      end
+
+      def create
+        @store_credit = @user.store_credits.build(
+          permitted_store_credit_params.merge(
+            created_by: try_spree_current_user,
+            action_originator: try_spree_current_user,
+            store: current_store
+          )
+        )
+
+        if @store_credit.save
+          flash[:success] = flash_message_for(@store_credit, :successfully_created)
+          redirect_to spree.admin_user_path(@user)
+        else
+          flash[:error] = Spree.t('store_credit.errors.unable_to_create')
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        @store_credit.assign_attributes(permitted_store_credit_params)
+        @store_credit.created_by = try_spree_current_user
+
+        if @store_credit.save
+          flash[:success] = flash_message_for(@store_credit, :successfully_updated)
+          redirect_to spree.admin_user_path(@user)
+        else
+          flash[:error] = Spree.t('store_credit.errors.unable_to_update')
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        @store_credit = @user.store_credits.for_store(current_store).find(params[:id])
+        ensure_unused_store_credit
+
+        if @store_credit.destroy
+          flash[:success] = flash_message_for(@store_credit, :successfully_removed)
+        else
+          flash[:error] = Spree.t('store_credit.errors.unable_to_delete')
+        end
+
+        redirect_to spree.admin_user_path(@user)
+      end
+
+      protected
+
+      def permitted_store_credit_params
+        params.require(:store_credit).permit(permitted_store_credit_attributes)
+      end
+
+      private
+
+      def load_user
+        @user = Spree.user_class.find_by(id: params[:user_id])
+
+        unless @user
+          flash[:error] = Spree.t(:user_not_found)
+          redirect_to spree.admin_path
+        end
+      end
+
+      def load_store_credit
+        @store_credit = scope.find_by(id: params[:id]) || scope.new
+      end
+
+      def scope
+        current_store.store_credits.where(user: @user)
+      end
+
+      def ensure_unused_store_credit
+        unless @store_credit.amount_used.zero?
+          raise StoreCreditError, Spree.t('store_credit.errors.cannot_change_used_store_credit')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Spree
+  module Admin
+    class StorefrontController < BaseController
+      def edit
+        @store = current_store
+      end
+
+      def update
+        @store = current_store
+        if @store.update(store_params)
+          remove_assets(%w[favicon_image social_image], object: @store)
+          flash[:success] = flash_message_for(@store, :successfully_updated)
+        else
+          flash[:error] = @store.errors.full_messages.to_sentence
+        end
+
+        redirect_to spree.edit_admin_storefront_path
+      end
+
+      private
+
+      def store_params
+        params.require(:store).permit(
+          :preferred_index_in_search_engines,
+          :preferred_password_protected, :social_image, :favicon_image, :name,
+          :meta_description, :meta_title, :meta_keywords, :seo_robots,
+          :facebook, :twitter, :instagram, :linkedin, :youtube, :tiktok, :pinterest,
+          :storefront_custom_code_head, :storefront_custom_code_body_start,
+          :storefront_custom_code_body_end
+        )
+      end
+
+      def model_class
+        Spree::Store
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Spree
+  module Admin
+    class StoresController < Spree::Admin::BaseController
+      before_action :load_store, only: [:edit, :update]
+      before_action :normalize_supported_currencies, only: [:update]
+      before_action :normalize_supported_locales, only: [:update]
+      before_action :load_all_countries, only: [:edit, :update]
+      before_action :load_all_zones, only: [:edit, :update]
+
+      def new
+        @store = Spree::Store.new(
+          default_country_iso: current_store.default_country_iso,
+          default_currency: current_store.default_currency
+        )
+      end
+
+      def create
+        @store = Spree::Store.new(permitted_store_params)
+        @store.mail_from_address = current_store.mail_from_address
+
+        if @store.save
+          flash[:success] = flash_message_for(@store, :successfully_created)
+          # redirect in view, Turbo doesn't support redirecting to a different host
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def edit; end
+
+      def edit_emails; end
+
+      def update
+        @store.assign_attributes(permitted_store_params)
+
+        if @store.save
+          remove_assets(%w[logo mailer_logo], object: @store)
+          flash[:success] = flash_message_for(@store, :successfully_updated)
+        else
+          flash[:error] = "#{Spree.t('store_errors.unable_to_update')}: #{@store.errors.full_messages.join(', ')}"
+        end
+
+        if @store.saved_changes? && permitted_store_params[:code].present?
+          redirect_to spree.admin_custom_domains_url(host: @store.url), allow_other_host: true
+        else
+          respond_to do |format|
+            format.turbo_stream
+            format.html { redirect_to spree.edit_admin_store_path(section: params[:section]) }
+          end
+        end
+      end
+
+      protected
+
+      def permitted_store_params
+        params.require(:store).permit(permitted_store_attributes)
+      end
+
+      private
+
+      def load_store
+        @store = current_store
+      end
+
+      def load_all_countries
+        @countries = Spree::Country.pluck(:name, :id)
+      end
+
+      def load_all_zones
+        @zones = Spree::Zone.pluck(:name, :id)
+        @zones.prepend([Spree.t(:no_limits_zone), ' '])
+      end
+
+      def normalize_supported_currencies
+        if params.dig(:store, :supported_currencies)&.is_a?(Array)
+          params[:store][:supported_currencies] = params[:store][:supported_currencies].compact.uniq.reject(&:blank?).join(',')
+        end
+      end
+
+      def normalize_supported_locales
+        if params.dig(:store, :supported_locales)&.is_a?(Array)
+          params[:store][:supported_locales] = params[:store][:supported_locales].compact.uniq.reject(&:blank?).join(',')
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+module Spree
+  module Admin
+    class TaxRatesController < ResourceController
+      before_action :load_data
+      before_action :set_defaults, only: :new
+
+      private
+
+      def set_defaults
+        @object.calculator_type = 'Spree::Calculator::DefaultTax'
+      end
+
+      def load_data
+        @available_zones = Spree::Zone.order(:name)
+        @available_categories = Spree::TaxCategory.order(:name)
+        @calculators = Spree::TaxRate.calculators.sort_by(&:name)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Spree
+  module Admin
+    class TaxonomiesController < ResourceController
+      private
+
+      def collection
+        return @collection if @collection.present?
+
+        @collection = super
+
+        params[:q] ||= {}
+        @search = @collection.ransack(params[:q])
+        @collection = @search.result.all
+      end
+
+      def location_after_save
+        spree.admin_taxonomy_path(@taxonomy)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+module Spree
+  module Admin
+    class TaxonsController < ResourceController
+      belongs_to 'spree/taxonomy'
+
+      include Spree::Admin::TaxonsHelper
+      include Spree::Admin::TagsHelper
+
+      before_action :set_parent_permalink, only: :new
+      before_action :set_permalink_part, only: [:edit, :update]
+      before_action :set_permalink_params, only: [:update]
+
+      update.before :set_parent
+      update.before :set_position
+
+      before_action :load_form_data, only: [:new, :create, :edit, :update]
+
+      def show
+        redirect_to location_after_save
+      end
+
+      def select_options
+        render json: taxons_options_json_array(with_automatic: params[:with_automatic].to_b)
+      end
+
+      def reposition
+        authorize! :update, @taxon
+
+        new_parent = @taxonomy.taxons.find(params.dig(:taxon, :new_parent_id))
+        new_index = params.dig(:taxon, :new_position_idx).to_i
+
+        if @taxon.move_to_child_with_index(new_parent, new_index)
+          head :ok
+        else
+          head :unprocessable_entity
+        end
+      end
+
+      private
+
+      def parent_data
+        super unless action == :select_options
+      end
+
+      def location_after_save
+        spree.edit_admin_taxonomy_taxon_path(@taxon.taxonomy_id, @taxon.id)
+      end
+
+      def destroy_turbo_stream_enabled?
+        true && !params[:force_redirect].to_b
+      end
+
+      def set_parent_permalink
+        @parent_permalink = @taxon.parent.present? ? @taxon.parent.permalink : @taxon.taxonomy.root.permalink
+      end
+
+      def set_permalink_part
+        @permalink_part = @taxon.permalink.split('/').last
+        @parent_permalink = @taxon.permalink.split('/')[0...-1].join('/')
+      end
+
+      def set_position
+        new_position = params[:taxon][:position]
+        @taxon.child_index = new_position.to_i if new_position
+      end
+
+      def set_parent
+        return unless params.dig(:taxon, :parent_id).present?
+
+        @taxon.parent = @taxonomy.taxons.find_by(id: params.dig(:taxon, :parent_id))
+      end
+
+      def set_permalink_params
+        params[:taxon][:permalink] = "#{@parent_permalink}/" + params[:permalink_part] if params.key? 'permalink_part'
+      end
+
+      def collection_url
+        spree.admin_taxonomy_path(@taxonomy)
+      end
+
+      # this is needed to set the parent_id for the newly initialized taxons
+      def build_resource
+        parent.send(controller_name).build(parent_id: params.dig(:taxon, :parent_id))
+      end
+
+      def load_form_data
+        @taxon_rules = Rails.application.config.spree.taxon_rules
+        @rule_types = @taxon_rules.map do |taxon_rule|
+          [Spree.t("admin.taxon_rules.#{taxon_rule.to_s.demodulize.underscore}"), taxon_rule.to_s]
+        end
+
+        @rule_match_policies = Spree::TaxonRule::MATCH_POLICIES.map do |policy|
+          [Spree.t("admin.taxon_rules.match_policies.#{policy}"), policy]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Spree
+  module Admin
+    class ThemesController < ResourceController
+      layout :choose_layout
+
+      def edit
+        @theme_preview = params[:theme_preview_id].present? ? @theme.previews.find(params[:theme_preview_id]) : @theme.create_preview
+        @page = if params[:page_id].present?
+                  @theme.pages.find_by(id: params[:page_id]) || current_store.pages.find(params[:page_id])
+                else
+                  @theme.pages.find_by(type: 'Spree::Pages::Homepage')
+                end
+        @page_preview = params[:page_preview_id].present? ? @page.previews.find(params[:page_preview_id]) : @page.create_preview
+
+        session[:theme_preview_id] = @theme_preview.id
+        session[:page_preview_id] = @page_preview.id
+      end
+
+      def update_with_page
+        @theme_preview = @theme.previews.find(params[:theme_preview_id])
+        @page_preview = @theme.page_previews.find_by(id: params[:page_preview_id]) || current_store.page_previews.find(params[:page_preview_id])
+
+        ApplicationRecord.transaction do
+          @page_preview.promote && @theme_preview.promote
+        end
+        flash[:success] = Spree.t('changes_published')
+
+        redirect_to spree.edit_admin_theme_path(@theme_preview, page_id: @page_preview.id), status: :see_other
+      rescue ActiveRecord::RecordInvalid
+        redirect_to spree.edit_admin_theme_path(@theme_preview, page_id: @page_preview.id), alert: Spree.t('something_went_wrong')
+      end
+
+      def publish
+        @theme = current_store.themes.find(params[:id])
+
+        if @theme.update(default: true)
+          flash[:success] = Spree.t('theme_is_now_live')
+        else
+          flash[:error] = "#{Spree.t('something_went_wrong')}: #{@theme.errors.full_messages.to_sentence}"
+        end
+        redirect_to spree.admin_themes_path
+      end
+
+      def clone
+        @new = @theme.duplicate
+
+        if @new.persisted?
+          flash[:success] = Spree.t('theme_copied')
+        else
+          flash[:error] = Spree.t('theme_not_copied', error: @new.errors.full_messages.to_sentence)
+        end
+
+        redirect_to spree.admin_themes_path
+      end
+
+      private
+
+      def choose_layout
+        if action_name == 'index'
+          'spree/admin'
+        else
+          'spree/page_builder'
+        end
+      end
+
+      def update_turbo_stream_enabled?
+        true
+      end
+
+      def collection
+        super.without_previews.order(default: :desc).includes(screenshot_attachment: :blob)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Spree
+  module Admin
+    class TranslationsController < Spree::Admin::BaseController
+      before_action :set_resource, only: [:edit, :update]
+      before_action :load_data, only: [:edit]
+      before_action :set_translation_locale, only: [:edit, :update]
+
+      def edit; end
+
+      def update
+        locale_translation_params = permitted_translation_params.to_h.transform_values do |translations|
+          translations[@selected_translation_locale]
+        end
+
+        Mobility.with_locale(@selected_translation_locale) do
+          @resource.update!(locale_translation_params)
+        end
+
+        flash[:success] = Spree.t('notice_messages.translations_saved')
+
+        redirect_to spree.edit_admin_translation_path(
+          @resource,
+          resource_type: @resource.class.to_s,
+          translation_locale: @selected_translation_locale
+        )
+      end
+
+      private
+
+      def permitted_translation_params
+        params.require(:translation).permit(
+          resource_class.translatable_fields.each_with_object({}) do |field, acc|
+            acc[field] = current_store.supported_locales_list.map(&:to_sym)
+          end
+        )
+      end
+
+      def resource_class
+        @resource_class ||= params[:resource_type].constantize
+      end
+
+      def set_resource
+        @resource = if resource_class.respond_to?(:friendly)
+                      resource_class.friendly.find(params[:id])
+                    else
+                      resource_class.find(params[:id])
+                    end
+      end
+
+      def set_translation_locale
+        @selected_translation_locale = params[:translation_locale].presence || @locales&.first || current_store.supported_locales_list.first
+      end
+
+      def load_data
+        @locales = (current_store.supported_locales_list - [@default_locale]).sort
+
+        case @resource
+        when Spree::Product
+          @resource_name = @resource.name
+          @back_path = spree.edit_admin_product_path(@resource)
+        when Spree::Taxon
+          @resource_name = @resource.name
+          @back_path = spree.edit_admin_taxonomy_taxon_path(@resource.taxonomy, @resource.id)
+        when Spree::Taxonomy
+          @resource_name = @resource.name
+          @back_path = spree.edit_admin_taxonomy_path(@resource)
+        when Spree::Store
+          @resource_name = @resource.name
+          @back_path = spree.edit_admin_store_path(@resource, section: "general-settings")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+module Spree
+  module Admin
+    class UsersController < ResourceController
+      helper UsersHelper
+
+      include Spree::Admin::BulkOperationsConcern
+
+      rescue_from Spree::Core::DestroyWithOrdersError, with: :user_destroy_with_orders_error
+
+      before_action :load_last_order_data, only: :show
+      before_action :remove_empty_params, only: :update
+
+      def show; end
+
+      def create
+        @user = Spree.user_class.new(user_params)
+        @user.password ||= SecureRandom.hex(16) # we need to set a password to pass validation
+        @user.password_confirmation ||= @user.password
+
+        if @user.save
+          flash[:success] = flash_message_for(@user, :successfully_created)
+          redirect_to spree.admin_user_path(@user)
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        if @user.update(user_params)
+          flash[:success] = Spree.t(:account_updated)
+          redirect_to spree.admin_user_path(@user)
+        else
+          render :edit, status: :unprocessable_entity
+        end
+      end
+
+      def model_class
+        Spree.user_class
+      end
+
+      def bulk_modal
+        @title = Spree.t("admin.bulk_ops.users.title.#{params[:kind]}")
+        @body = Spree.t("admin.bulk_ops.users.body.#{params[:kind]}")
+      end
+
+      protected
+
+      def collection
+        return @collection if @collection.present?
+
+        params[:q] ||= {}
+        params[:q][:s] ||= 'created_at desc'
+        params[:q][:created_at_not_null] ||= 1
+
+        @collection = super
+        @search = @collection.ransack(params[:q])
+        @collection = @search.result(distinct: true).
+                      includes(
+                        addresses: [:country, :state],
+                        ship_address: [:country, :state],
+                        bill_address: [:country, :state],
+                        avatar_attachment: :blob
+                      ).
+                      page(params[:page]).per(params[:per_page])
+      end
+
+      private
+
+      def user_params
+        params.require(:user).permit(permitted_user_attributes | [spree_role_ids: []])
+      end
+
+      # handling raise from Spree::Admin::ResourceController#destroy
+      def user_destroy_with_orders_error
+        invoke_callbacks(:destroy, :fails)
+        render status: :forbidden, plain: Spree.t(:error_user_destroy_with_orders)
+      end
+
+      def remove_empty_params
+        return if params[:user].blank?
+
+        params[:user][:tag_list] = params.dig(:user, :tag_list).present? ? params.dig(:user, :tag_list).reject(&:empty?) : []
+      end
+
+      def load_last_order_data
+        @last_order = @user.completed_orders.last
+        @last_order_line_items = @last_order.line_items.includes(variant: :product) if @last_order.present?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+module Spree
+  module Admin
+    class VariantsController < ResourceController
+      include StockLocationsHelper
+
+      belongs_to 'spree/product', find_by: :slug
+      before_action :load_data, only: [:edit, :update]
+      before_action :strip_attributes, only: [:update]
+
+      edit_action.before :build_prices
+      edit_action.before :build_stock_items
+
+      def search
+        query = params[:q]&.strip
+
+        if query.blank? || query.length < 3
+          respond_to do |format|
+            format.turbo_stream { head :ok }
+            format.json { render json: [] }
+          end
+        else
+          access_action = request.post? ? :manage : :index
+
+          scope = current_store.variants.accessible_by(current_ability, access_action)
+          unless params[:all].to_b.present?
+            scope = if params[:currency].present?
+                      scope.active(params[:currency]).merge(current_store.products.published)
+                    else
+                      scope.active.merge(current_store.products.published)
+                    end
+          end
+          scope = scope.where.not(id: params[:omit_ids].split(',')) if params[:omit_ids].present?
+          scope = scope.where(spree_stock_items: { stock_location_id: params[:stock_location_id] }) if params[:stock_location_id].present?
+
+          @variants = scope.
+                      eligible.
+                      multi_search(query).
+                      includes(:images, :prices, :stock_items, :stock_locations, :product, option_values: :option_type).
+                      limit(params[:limit] || 20).
+                      reorder('').
+                      distinct(false)
+
+          respond_to do |format|
+            format.turbo_stream do
+              render turbo_stream: [
+                turbo_stream.replace(
+                  "variants_search_results",
+                  partial: "spree/admin/variants/search_results",
+                  locals: { variants: @variants }
+                )
+              ]
+            end
+
+            format.json do
+              # we cannot use pluck here, as `descriptive_name` is not a column
+              render json: @variants.map { |v| { id: v.id, name: v.descriptive_name } }
+            end
+          end
+        end
+      end
+
+      private
+
+      def load_data
+        @tax_categories = TaxCategory.order(:name)
+      end
+
+      def location_after_destroy
+        spree.edit_admin_product_path(@product)
+      end
+
+      def build_prices
+        current_store.supported_currencies_list.each do |currency|
+          @variant.prices.build(currency: currency) unless @variant.prices.exists?(currency: currency.iso_code)
+        end
+      end
+
+      def build_stock_items
+        available_stock_locations.each do |stock_location|
+          @variant.stock_items.build(stock_location: stock_location) unless @variant.stock_items.exists?(stock_location: stock_location)
+        end
+      end
+
+      def strip_attributes
+        params[:variant].delete(:prices_attributes) unless can?(:manage, @variant.prices.first)
+        params[:variant].delete(:stock_items_attributes) unless can?(:manage, @variant.stock_items.first)
+      end
+    end
+  end
+end