solidus_admin 0.3.2 → 0.4.1

data/app/controllers/solidus_admin/shipping_categories_controller.rb

@@ -1,117 +1,13 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class ShippingCategoriesController < SolidusAdmin::BaseController
-    include SolidusAdmin::ControllerHelpers::Search
-
-    before_action :set_shipping_category, only: %i[edit update]
-
-    def new
-      @shipping_category = Spree::ShippingCategory.new
-
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('shipping_categories/new').new(page: @page, shipping_category: @shipping_category) }
-      end
-    end
-
-    def create
-      @shipping_category = Spree::ShippingCategory.new(shipping_category_params)
-
-      if @shipping_category.save
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.shipping_categories_path, status: :see_other
-          end
-
-          format.turbo_stream do
-            # we need to explicitly write the refresh tag for now.
-            # See https://github.com/hotwired/turbo-rails/issues/579
-            render turbo_stream: '<turbo-stream action="refresh" />'
-          end
-        end
-      else
-        set_index_page
-
-        respond_to do |format|
-          format.html do
-            page_component = component('shipping_categories/new').new(page: @page, shipping_category: @shipping_category)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def index
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('shipping_categories/index').new(page: @page) }
-      end
-    end
-
-    def edit
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('shipping_categories/edit').new(page: @page, shipping_category: @shipping_category) }
-      end
-    end
-
-    def update
-      if @shipping_category.update(shipping_category_params)
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.shipping_categories_path, status: :see_other
-          end
-
-          format.turbo_stream do
-            render turbo_stream: '<turbo-stream action="refresh" />'
-          end
-        end
-      else
-        set_index_page
-
-        respond_to do |format|
-          format.html do
-            page_component = component('shipping_categories/edit').new(page: @page, shipping_category: @shipping_category)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def destroy
-      @shipping_category = Spree::ShippingCategory.find_by!(id: params[:id])
-
-      Spree::ShippingCategory.transaction { @shipping_category.destroy }
-
-      flash[:notice] = t('.success')
-      redirect_back_or_to shipping_categories_path, status: :see_other
-    end
-
+  class ShippingCategoriesController < SolidusAdmin::ResourcesController
     private
 
-    def set_shipping_category
-      @shipping_category = Spree::ShippingCategory.find(params[:id])
-    end
+    def resource_class = Spree::ShippingCategory
 
-    def shipping_category_params
+    def permitted_resource_params
       params.require(:shipping_category).permit(:name)
     end
-
-    def set_index_page
-      shipping_categories = apply_search_to(
-        Spree::ShippingCategory.order(id: :desc),
-        param: :q,
-      )
-
-      set_page_and_extract_portion_from(shipping_categories)
-    end
   end
 end

data/app/controllers/solidus_admin/stock_items_controller.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class StockItemsController < SolidusAdmin::BaseController
+  class StockItemsController < SolidusAdmin::ResourcesController
     include SolidusAdmin::ControllerHelpers::Search
-    before_action :load_stock_items, only: [:index, :edit, :update]
-    before_action :load_stock_item, only: [:edit, :update]
 
     search_scope(:all, default: true) { _1 }
     search_scope(:back_orderable) { _1.where(backorderable: true) }
@@ -18,49 +16,34 @@ module SolidusAdmin
       end
     end
 
-    def edit
-      respond_to do |format|
-        format.html { render component('stock_items/edit').new(stock_item: @stock_item, page: @page) }
-      end
-    end
-
     def update
       quantity_adjustment = params[:quantity_adjustment].to_i
-      @stock_item.assign_attributes(stock_item_params)
+      @stock_item.assign_attributes(permitted_resource_params)
       @stock_item.stock_movements.build(quantity: quantity_adjustment, originator: current_solidus_admin_user)
 
       if @stock_item.save
-        respond_to do |format|
-          format.html { redirect_to solidus_admin.stock_items_path, status: :see_other }
-          format.turbo_stream { render turbo_stream: '<turbo-stream action="refresh" />' }
-        end
+        redirect_to after_update_path, status: :see_other
       else
-        respond_to do |format|
-          format.html { render component('stock_items/edit').new(stock_item: @stock_item, page: @page), status: :unprocessable_entity }
-        end
+        page_component = edit_component.new(@stock_item)
+        render_resource_form_with_errors(page_component)
       end
     end
 
     private
 
-    def load_stock_items
-      @stock_items = apply_search_to(
-        Spree::StockItem.reorder(nil),
-        param: :q,
-      )
+    def resource_class = Spree::StockItem
 
-      set_page_and_extract_portion_from(@stock_items, ordered_by: {
+    def resources_collection = Spree::StockItem.reorder(nil)
+
+    def resources_sorting_options
+      {
         variant_id: :desc,
         stock_location_id: :desc,
         id: :desc,
-      })
-    end
-
-    def load_stock_item
-      @stock_item = Spree::StockItem.find(params[:id])
+      }
     end
 
-    def stock_item_params
+    def permitted_resource_params
       params.require(:stock_item).permit(:backorderable)
     end
   end

data/app/controllers/solidus_admin/store_credit_reasons_controller.rb

@@ -1,115 +1,15 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class StoreCreditReasonsController < SolidusAdmin::BaseController
-    include SolidusAdmin::ControllerHelpers::Search
-
-    before_action :set_store_credit_reason, only: %i[edit update]
-
-    def index
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('store_credit_reasons/index').new(page: @page) }
-      end
-    end
-
-    def new
-      @store_credit_reason = Spree::StoreCreditReason.new
-
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('store_credit_reasons/new').new(page: @page, store_credit_reason: @store_credit_reason) }
-      end
-    end
-
-    def create
-      @store_credit_reason = Spree::StoreCreditReason.new(store_credit_reason_params)
-
-      if @store_credit_reason.save
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.store_credit_reasons_path, status: :see_other
-          end
-
-          format.turbo_stream do
-            render turbo_stream: '<turbo-stream action="refresh" />'
-          end
-        end
-      else
-        set_index_page
-
-        respond_to do |format|
-          format.html do
-            page_component = component('store_credit_reasons/new').new(page: @page, store_credit_reason: @store_credit_reason)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def edit
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('store_credit_reasons/edit').new(page: @page, store_credit_reason: @store_credit_reason) }
-      end
-    end
-
-    def update
-      if @store_credit_reason.update(store_credit_reason_params)
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.store_credit_reasons_path, status: :see_other
-          end
-
-          format.turbo_stream do
-            render turbo_stream: '<turbo-stream action="refresh" />'
-          end
-        end
-      else
-        set_index_page
-
-        respond_to do |format|
-          format.html do
-            page_component = component('store_credit_reasons/edit').new(page: @page, store_credit_reason: @store_credit_reason)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def destroy
-      @store_credit_reason = Spree::StoreCreditReason.find_by!(id: params[:id])
-
-      Spree::StoreCreditReason.transaction { @store_credit_reason.destroy }
-
-      flash[:notice] = t('.success')
-      redirect_back_or_to store_credit_reasons_path, status: :see_other
-    end
-
+  class StoreCreditReasonsController < SolidusAdmin::ResourcesController
     private
 
-    def set_store_credit_reason
-      @store_credit_reason = Spree::StoreCreditReason.find(params[:id])
-    end
-
-    def store_credit_reason_params
-      params.require(:store_credit_reason).permit(:name, :active)
-    end
+    def resource_class = Spree::StoreCreditReason
 
-    def set_index_page
-      store_credit_reasons = apply_search_to(
-        Spree::StoreCreditReason.unscoped.order(id: :desc),
-        param: :q,
-      )
+    def resources_collection = Spree::StoreCreditReason.unscoped
 
-      set_page_and_extract_portion_from(store_credit_reasons)
+    def permitted_resource_params
+      params.require(:store_credit_reason).permit(:name, :active)
     end
   end
 end

data/app/controllers/solidus_admin/store_credits_controller.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class StoreCreditsController < SolidusAdmin::ResourcesController
+    before_action :set_user
+    before_action :set_store_credit, only: [:show, :edit_amount, :update_amount, :edit_memo, :update_memo, :edit_validity, :invalidate]
+    before_action :set_store_credit_reasons, only: [:edit_amount, :update_amount, :edit_validity, :invalidate]
+    before_action :set_store_credit_events, only: [:show]
+    before_action :set_store_credit_categories, only: [:new]
+
+    def index
+      @store_credits = Spree::StoreCredit.where(user_id: @user.id).order(id: :desc)
+
+      respond_to do |format|
+        format.html { render component("users/store_credits/index").new(user: @user, store_credits: @store_credits) }
+      end
+    end
+
+    def show
+      respond_to do |format|
+        format.html { render component("users/store_credits/show").new(user: @user, store_credit: @store_credit, events: @store_credit_events) }
+      end
+    end
+
+    def new
+      @store_credit ||= Spree::StoreCredit.new
+
+      respond_to do |format|
+        format.html {
+          render component("users/store_credits/new").new(
+            user: @user,
+            store_credit: @store_credit,
+            categories: @store_credit_categories
+          )
+        }
+      end
+    end
+
+    def create
+      @store_credit = @user.store_credits.build(
+        permitted_resource_params.merge({
+          created_by: spree_current_user,
+          action_originator: spree_current_user
+        })
+      )
+
+      return unless ensure_amount { render_new_with_errors }
+      return unless ensure_store_credit_category { render_new_with_errors }
+
+      if @store_credit.save
+        flash[:notice] = t('.success')
+        redirect_to after_create_path, status: :see_other
+      else
+        render_new_with_errors
+      end
+    end
+
+    def edit_amount
+      respond_to do |format|
+        format.html {
+          render component("users/store_credits/edit_amount").new(
+            user: @user,
+            store_credit: @store_credit,
+            reasons: @store_credit_reasons
+          )
+        }
+      end
+    end
+
+    def update_amount
+      return unless ensure_amount { render_edit_with_errors }
+      return unless ensure_store_credit_reason { render_edit_with_errors }
+
+      if @store_credit.update_amount(permitted_resource_params[:amount], @store_credit_reason, spree_current_user)
+        flash[:notice] = t('.success')
+        redirect_to after_update_path, status: :see_other
+      else
+        render_edit_with_errors
+      end
+    end
+
+    def edit_memo
+      respond_to do |format|
+        format.html {
+          render component("users/store_credits/edit_memo").new(
+            user: @user,
+            store_credit: @store_credit,
+          )
+        }
+      end
+    end
+
+    def update_memo
+      if @store_credit.update(memo: permitted_resource_params[:memo])
+        flash[:notice] = t('.success')
+      else
+        # Memo update failures are nearly impossible to trigger due to lack of validation.
+        flash[:error] = t('.failure')
+      end
+
+      redirect_to after_update_path, status: :see_other
+    end
+
+    def edit_validity
+      respond_to do |format|
+        format.html {
+          render component("users/store_credits/edit_validity").new(
+            user: @user,
+            store_credit: @store_credit,
+            reasons: @store_credit_reasons
+          )
+        }
+      end
+    end
+
+    def invalidate
+      return unless ensure_store_credit_reason { render_edit_with_errors }
+
+      if @store_credit.invalidate(@store_credit_reason, spree_current_user)
+        flash[:notice] = t('.success')
+      else
+        # Ensure store_credit_reason handles invalid param/form submissions and modal re-rendering.
+        # This is just a fallback error state in case anything goes wrong with StoreCredit#invalidate.
+        flash[:error] = t('.failure')
+      end
+
+      redirect_to after_update_path, status: :see_other
+    end
+
+    private
+
+    def resource_class = Spree::StoreCredit
+
+    def set_store_credit
+      @store_credit ||= Spree::StoreCredit.find(params[:id])
+    end
+
+    def set_user
+      @user = Spree.user_class.find(params[:user_id])
+    end
+
+    def set_store_credit_reasons
+      @store_credit_reasons = Spree::StoreCreditReason.active.order(:name)
+    end
+
+    def set_store_credit_categories
+      @store_credit_categories = Spree::StoreCreditCategory.all.order(:name)
+    end
+
+    def set_store_credit_events
+      @store_credit_events = @store_credit.store_credit_events.chronological
+    end
+
+    def permitted_resource_params
+      permitted_params = [:amount, :currency, :category_id, :memo]
+      permitted_params << :category_id if action_name.to_sym == :create
+      permitted_params << :store_credit_reason_id if [:update_amount, :invalidate].include?(action_name.to_sym)
+
+      params.require(:store_credit).permit(permitted_params).merge(created_by: spree_current_user)
+    end
+
+    def render_new_with_errors
+      set_store_credit_categories
+
+      page_component = component("users/store_credits/new").new(
+        user: @user,
+        store_credit: @store_credit,
+        categories: @store_credit_categories
+      )
+
+      render_resource_form_with_errors(page_component)
+    end
+
+    def render_edit_with_errors
+      set_store_credit_events
+
+      template = if action_name.to_sym == :invalidate
+        "edit_validity"
+      else
+        "edit_amount"
+      end
+
+      page_component = component("users/store_credits/#{template}").new(
+        user: @user,
+        store_credit: @store_credit,
+        reasons: @store_credit_reasons
+      )
+
+      render_resource_form_with_errors(page_component)
+    end
+
+    def ensure_amount
+      if permitted_resource_params[:amount].blank?
+        @store_credit.errors.add(:amount, :greater_than, count: 0, value: permitted_resource_params[:amount])
+        yield if block_given? # Block is for error template rendering on a per-action basis so this can be re-used.
+        return false
+      end
+      true
+    end
+
+    def ensure_store_credit_reason
+      @store_credit_reason = Spree::StoreCreditReason.find_by(id: permitted_resource_params[:store_credit_reason_id])
+
+      if @store_credit_reason.blank?
+        @store_credit.errors.add(:store_credit_reason_id, "Store Credit reason must be provided")
+        yield if block_given? # Block is for error template rendering on a per-action basis so this can be re-used.
+        return false
+      end
+      true
+    end
+
+    def ensure_store_credit_category
+      @store_credit_category = Spree::StoreCreditCategory.find_by(id: permitted_resource_params[:category_id])
+
+      if @store_credit_category.blank?
+        @store_credit.errors.add(:category_id, "Store Credit category must be provided")
+        yield if block_given? # Block is for error template rendering on a per-action basis so this can be re-used.
+        return false
+      end
+      true
+    end
+
+    def after_create_path
+      solidus_admin.user_store_credits_path(@user)
+    end
+
+    def after_update_path
+      solidus_admin.user_store_credit_path(@user, @store_credit)
+    end
+  end
+end

data/app/controllers/solidus_admin/tax_categories_controller.rb

@@ -1,119 +1,13 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class TaxCategoriesController < SolidusAdmin::BaseController
-    include SolidusAdmin::ControllerHelpers::Search
-
-    before_action :set_tax_category, only: %i[edit update]
-
-    def new
-      @tax_category = Spree::TaxCategory.new
-
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('tax_categories/new').new(page: @page, tax_category: @tax_category) }
-      end
-    end
-
-    def edit
-      @tax_category = Spree::TaxCategory.find(params[:id])
-
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('tax_categories/edit').new(page: @page, tax_category: @tax_category) }
-      end
-    end
-
-    def create
-      @tax_category = Spree::TaxCategory.new(tax_category_params)
-
-      if @tax_category.save
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.tax_categories_path, status: :see_other
-          end
-
-          format.turbo_stream do
-            # we need to explicitly write the refresh tag for now.
-            # See https://github.com/hotwired/turbo-rails/issues/579
-            render turbo_stream: '<turbo-stream action="refresh" />'
-          end
-        end
-      else
-        set_index_page
-
-        respond_to do |format|
-          format.html do
-            page_component = component('tax_categories/new').new(page: @page, tax_category: @tax_category)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def update
-      if @tax_category.update(tax_category_params)
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.tax_categories_path, status: :see_other
-          end
-
-          format.turbo_stream do
-            render turbo_stream: '<turbo-stream action="refresh" />'
-          end
-        end
-      else
-        set_index_page
-
-        respond_to do |format|
-          format.html do
-            page_component = component('tax_categories/edit').new(page: @page, tax_category: @tax_category)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def index
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('tax_categories/index').new(page: @page) }
-      end
-    end
-
-    def destroy
-      @tax_categories = Spree::TaxCategory.where(id: params[:id])
-
-      Spree::TaxCategory.transaction { @tax_categories.destroy_all }
-
-      flash[:notice] = t('.success')
-      redirect_back_or_to tax_categories_path, status: :see_other
-    end
-
+  class TaxCategoriesController < SolidusAdmin::ResourcesController
     private
 
-    def set_tax_category
-      @tax_category = Spree::TaxCategory.find(params[:id])
-    end
+    def resource_class = Spree::TaxCategory
 
-    def tax_category_params
+    def permitted_resource_params
       params.require(:tax_category).permit(:name, :description, :is_default, :tax_code)
     end
-
-    def set_index_page
-      tax_categories = apply_search_to(
-        Spree::TaxCategory.order(created_at: :desc, id: :desc),
-        param: :q,
-      )
-
-      set_page_and_extract_portion_from(tax_categories)
-    end
   end
 end

data/app/controllers/solidus_admin/users_controller.rb

@@ -5,7 +5,7 @@ module SolidusAdmin
     include SolidusAdmin::ControllerHelpers::Search
     include Spree::Core::ControllerHelpers::StrongParameters
 
-    before_action :set_user, only: [:edit, :addresses, :update_addresses, :orders, :items, :store_credits]
+    before_action :set_user, only: [:edit, :addresses, :update_addresses, :orders, :items]
 
     search_scope(:all, default: true)
     search_scope(:customers) { _1.left_outer_joins(:role_users).where(role_users: { id: nil }) }
@@ -81,14 +81,6 @@ module SolidusAdmin
       redirect_back_or_to users_path, status: :see_other
     end
 
-    def store_credits
-      @store_credits = Spree::StoreCredit.where(user_id: @user.id).order(id: :desc)
-
-      respond_to do |format|
-        format.html { render component("users/store_credits/index").new(user: @user, store_credits: @store_credits) }
-      end
-    end
-
     private
 
     def set_user

data/app/helpers/solidus_admin/void_elements_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  module VoidElementsHelper
+    # https://github.com/rails/rails/blob/194d697036c61af0caa66de5659721ded2478ce9/actionview/lib/action_view/helpers/tag_helper.rb#L84
+    HTML_VOID_ELEMENTS = %i(area base br col embed hr img input keygen link meta source track wbr)
+
+    # @param element [Symbol]
+    def void_element?(element)
+      HTML_VOID_ELEMENTS.include?(element)
+    end
+  end
+end