solidus_admin 0.3.2 → 0.4.0

data/app/controllers/solidus_admin/base_controller.rb

@@ -15,8 +15,19 @@ module SolidusAdmin
     include SolidusAdmin::ComponentsHelper
     include SolidusAdmin::AuthenticationAdapters::Backend if defined?(Spree::Backend)
 
-    layout 'solidus_admin/application'
+    layout :set_layout
+
     helper 'solidus_admin/components'
     helper 'solidus_admin/layout'
+
+    private
+
+    def set_layout
+      if turbo_frame_request?
+        'turbo_rails/frame'
+      else
+        'solidus_admin/application'
+      end
+    end
   end
 end

data/app/controllers/solidus_admin/properties_controller.rb

@@ -1,33 +1,15 @@
 # frozen_string_literal: true
 
 module SolidusAdmin
-  class PropertiesController < SolidusAdmin::BaseController
-    include SolidusAdmin::ControllerHelpers::Search
+  class PropertiesController < SolidusAdmin::ResourcesController
+    private
 
-    def index
-      properties = apply_search_to(
-        Spree::Property.order(created_at: :desc, id: :desc),
-        param: :q,
-      )
+    def resource_class = Spree::Property
 
-      set_page_and_extract_portion_from(
-        properties,
-      )
-
-      respond_to do |format|
-        format.html { render component('properties/index').new(page: @page) }
-      end
+    def permitted_resource_params
+      params.require(:property).permit(:name, :presentation)
     end
 
-    def destroy
-      @properties = Spree::Property.where(id: params[:id])
-
-      Spree::Property.transaction do
-        @properties.destroy_all
-      end
-
-      flash[:notice] = t('.success')
-      redirect_to properties_path, status: :see_other
-    end
+    def resources_collection = Spree::Property.unscoped
   end
 end

data/app/controllers/solidus_admin/refund_reasons_controller.rb

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

data/app/controllers/solidus_admin/resources_controller.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class ResourcesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    helper_method :search_filter_params
+
+    before_action :set_paginated_resources, only: %i[index]
+    before_action :set_resource, only: %i[edit update]
+
+    # GET /index
+    #
+    # Uses {set_paginated_resources} to set @resources
+    # and a instance variable with the plural name of the resource.
+    #
+    # Uses the geared_pagination gem to set @page for pagination.
+    #
+    # @see set_paginated_resources
+    # @see resources_collection
+    def index
+      respond_to do |format|
+        format.html { render index_component.new(page: @page) }
+      end
+    end
+
+    def new
+      @resource = resource_class.new
+      render new_component.new(@resource)
+    end
+
+    def create
+      @resource = resource_class.new(permitted_resource_params)
+
+      if @resource.save
+        flash[:notice] = t('.success')
+        redirect_to after_create_path, status: :see_other
+      else
+        page_component = new_component.new(@resource)
+        render_resource_form_with_errors(page_component)
+      end
+    end
+
+    def edit
+      render edit_component.new(@resource)
+    end
+
+    def update
+      if @resource.update(permitted_resource_params)
+        flash[:notice] = t('.success')
+        redirect_to after_update_path, status: :see_other
+      else
+        page_component = edit_component.new(@resource)
+        render_resource_form_with_errors(page_component)
+      end
+    end
+
+    def destroy
+      @resource = resource_class.where(id: params[:id])
+
+      resource_class.transaction { @resource.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to after_destroy_path, status: :see_other
+    end
+
+    private
+
+    def search_filter_params
+      request.params.slice(:q, :page)
+    end
+
+    def set_paginated_resources
+      @resources ||= apply_search_to(
+        resources_collection,
+          param: :q,
+        ).tap do |resources|
+          instance_variable_set("@#{plural_resource_name}", resources)
+          # sets @page instance variable in geared_pagination gem
+          set_page_and_extract_portion_from(resources, ordered_by: resources_sorting_options)
+        end
+    end
+
+    def resources_sorting_options
+      { id: :desc }
+    end
+
+    def resources_collection
+      resource_class.all
+    end
+
+    def set_resource
+      @resource ||= resource_class.find(params[:id]).tap do |resource|
+          instance_variable_set("@#{resource_name}", resource)
+      end
+    end
+
+    def resource_class
+      raise NotImplementedError,
+        "You must implement the resource_class method in #{self.class}"
+    end
+
+    def resource_name
+      resource_class.model_name.singular_route_key
+    end
+
+    def plural_resource_name
+      resource_class.model_name.route_key
+    end
+
+    def index_component
+      component("#{plural_resource_name}/index")
+    end
+
+    def new_component
+      component("#{plural_resource_name}/new")
+    end
+
+    def edit_component
+      component("#{plural_resource_name}/edit")
+    end
+
+    def render_resource_form_with_errors(page_component)
+      respond_to do |format|
+        format.html do
+          render page_component, status: :unprocessable_entity
+        end
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.replace(:resource_modal, page_component),
+            status: :unprocessable_entity
+        end
+      end
+    end
+
+    def permitted_resource_params
+      raise NotImplementedError,
+        "You must implement the permitted_resource_params method in #{self.class}"
+    end
+
+    def after_create_path
+      solidus_admin.send("#{plural_resource_name}_path", **search_filter_params)
+    end
+
+    def after_update_path
+      solidus_admin.send("#{plural_resource_name}_path", **search_filter_params)
+    end
+
+    def after_destroy_path
+      solidus_admin.send("#{plural_resource_name}_path", **search_filter_params)
+    end
+  end
+end

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