solidus_admin 0.3.1 → 0.4.0

data/app/controllers/solidus_admin/return_reasons_controller.rb

@@ -1,114 +1,14 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class ReturnReasonsController < SolidusAdmin::BaseController
-    include SolidusAdmin::ControllerHelpers::Search
-
-    before_action :set_return_reason, only: %i[edit update]
-
-    def index
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('return_reasons/index').new(page: @page) }
-      end
-    end
-
-    def new
-      @return_reason = Spree::ReturnReason.new
-
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('return_reasons/new').new(page: @page, return_reason: @return_reason) }
-      end
-    end
-
-    def create
-      @return_reason = Spree::ReturnReason.new(return_reason_params)
-
-      if @return_reason.save
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.return_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('return_reasons/new').new(page: @page, return_reason: @return_reason)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def edit
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('return_reasons/edit').new(page: @page, return_reason: @return_reason) }
-      end
-    end
-
-    def update
-      if @return_reason.update(return_reason_params)
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.return_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('return_reasons/edit').new(page: @page, return_reason: @return_reason)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def destroy
-      @return_reason = Spree::ReturnReason.find_by!(id: params[:id])
-
-      Spree::ReturnReason.transaction { @return_reason.destroy }
-
-      flash[:notice] = t('.success')
-      redirect_back_or_to return_reasons_path, status: :see_other
-    end
-
+  class ReturnReasonsController < SolidusAdmin::ResourcesController
     private
 
-    def set_return_reason
-      @return_reason = Spree::ReturnReason.find(params[:id])
-    end
-
-    def set_index_page
-      return_reasons = apply_search_to(
-        Spree::ReturnReason.unscoped.order(id: :desc),
-        param: :q,
-      )
+    def resource_class = Spree::ReturnReason
 
-      set_page_and_extract_portion_from(return_reasons)
-    end
+    def resources_collection = Spree::ReturnReason.unscoped
 
-    def return_reason_params
+    def permitted_resource_params
       params.require(:return_reason).permit(:name, :active)
     end
   end

data/app/controllers/solidus_admin/roles_controller.rb

@@ -1,117 +1,15 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class RolesController < SolidusAdmin::BaseController
-    include SolidusAdmin::ControllerHelpers::Search
-
-    before_action :set_role, only: %i[edit update]
-
+  class RolesController < SolidusAdmin::ResourcesController
     search_scope(:all)
     search_scope(:admin) { _1.where(name: "admin") }
 
-    def index
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('roles/index').new(page: @page) }
-      end
-    end
-
-    def new
-      @role = Spree::Role.new
-
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('roles/new').new(page: @page, role: @role) }
-      end
-    end
-
-    def create
-      @role = Spree::Role.new(role_params)
-
-      if @role.save
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.roles_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('roles/new').new(page: @page, role: @role)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def edit
-      set_index_page
-
-      respond_to do |format|
-        format.html { render component('roles/edit').new(page: @page, role: @role) }
-      end
-    end
-
-    def update
-      if @role.update(role_params)
-        respond_to do |format|
-          flash[:notice] = t('.success')
-
-          format.html do
-            redirect_to solidus_admin.roles_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('roles/edit').new(page: @page, role: @role)
-            render page_component, status: :unprocessable_entity
-          end
-        end
-      end
-    end
-
-    def destroy
-      @roles = Spree::Role.where(id: params[:id])
-
-      Spree::Role.transaction { @roles.destroy_all }
-
-      flash[:notice] = t('.success')
-      redirect_back_or_to solidus_admin.roles_path, status: :see_other
-    end
-
     private
 
-    def set_role
-      @role = Spree::Role.find(params[:id])
-    end
-
-    def set_index_page
-      roles = apply_search_to(
-        Spree::Role.unscoped.order(id: :desc),
-        param: :q,
-      )
-
-      set_page_and_extract_portion_from(roles)
-    end
+    def resource_class = Spree::Role
 
-    def role_params
+    def permitted_resource_params
       params.require(:role).permit(:role_id, :name, :description, permission_set_ids: [])
     end
   end

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