solidus_admin 0.0.2 → 0.2.0

data/app/controllers/solidus_admin/products_controller.rb

@@ -2,12 +2,37 @@
 
 module SolidusAdmin
   class ProductsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    search_scope(:all, default: true)
+    search_scope(:deleted) { _1.with_discarded.discarded }
+    search_scope(:discontinued) { _1.where(discontinue_on: ...Time.current) }
+    search_scope(:available) { _1.available }
+    search_scope(:in_stock) { _1.where(id: Spree::Variant.in_stock.distinct.select(:product_id)) }
+    search_scope(:out_of_stock) { _1.where.not(id: Spree::Variant.in_stock.distinct.select(:product_id)) }
+
+    def index
+      products = apply_search_to(
+        Spree::Product.includes(:master, :variants),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(
+        products,
+        ordered_by: { updated_at: :desc, id: :desc },
+      )
+
+      respond_to do |format|
+        format.html { render component('products/index').new(page: @page) }
+      end
+    end
+
     def edit
       redirect_to action: :show
     end
 
     def show
-      @product = Spree::Product.friendly.find(params[:id])
+      @product = Spree::Product.with_discarded.friendly.find(params[:id])
 
       respond_to do |format|
         format.html { render component('products/show').new(product: @product) }
@@ -33,22 +58,6 @@ module SolidusAdmin
       end
     end
 
-    def index
-      products = Spree::Product
-        .order(created_at: :desc, id: :desc)
-        .ransack(params[:q])
-        .result(distinct: true)
-
-      set_page_and_extract_portion_from(
-        products,
-        per_page: SolidusAdmin::Config[:products_per_page]
-      )
-
-      respond_to do |format|
-        format.html { render component('products/index').new(page: @page) }
-      end
-    end
-
     def destroy
       @products = Spree::Product.where(id: params[:id])
 

data/app/controllers/solidus_admin/promotion_categories_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class PromotionCategoriesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      promotion_categories = apply_search_to(
+        Spree::PromotionCategory.all,
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(promotion_categories)
+
+      respond_to do |format|
+        format.html { render component('promotion_categories/index').new(page: @page) }
+      end
+    end
+
+    def destroy
+      @promotion_categories = Spree::PromotionCategory.where(id: params[:id])
+
+      Spree::PromotionCategory.transaction { @promotion_categories.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to promotion_categories_path, status: :see_other
+    end
+  end
+end

data/app/controllers/solidus_admin/promotions_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class PromotionsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    search_scope(:active, default: true, &:active)
+    search_scope(:draft) { _1.where.not(id: _1.has_actions.select(:id)) }
+    search_scope(:future) { _1.has_actions.where(starts_at: Time.current..) }
+    search_scope(:expired) { _1.has_actions.where(expires_at: ..Time.current) }
+    search_scope(:all)
+
+    def index
+      promotions = apply_search_to(
+        Spree::Promotion.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(promotions)
+
+      respond_to do |format|
+        format.html { render component('promotions/index').new(page: @page) }
+      end
+    end
+
+    def destroy
+      @promotions = Spree::Promotion.where(id: params[:id])
+
+      Spree::Promotion.transaction { @promotions.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to promotions_path, status: :see_other
+    end
+
+    private
+
+    def load_promotion
+      @promotion = Spree::Promotion.find_by!(number: params[:id])
+      authorize! action_name, @promotion
+    end
+
+    def promotion_params
+      params.require(:promotion).permit(:user_id, permitted_promotion_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/properties_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class PropertiesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      properties = apply_search_to(
+        Spree::Property.order(created_at: :desc, id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(
+        properties,
+      )
+
+      respond_to do |format|
+        format.html { render component('properties/index').new(page: @page) }
+      end
+    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
+  end
+end

data/app/controllers/solidus_admin/refund_reasons_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class RefundReasonsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      refund_reasons = apply_search_to(
+        Spree::RefundReason.unscoped.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(refund_reasons)
+
+      respond_to do |format|
+        format.html { render component('refund_reasons/index').new(page: @page) }
+      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
+
+    private
+
+    def load_refund_reason
+      @refund_reason = Spree::RefundReason.find_by!(id: params[:id])
+      authorize! action_name, @refund_reason
+    end
+
+    def refund_reason_params
+      params.require(:refund_reason).permit(:refund_reason_id, permitted_refund_reason_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/reimbursement_types_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class ReimbursementTypesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      reimbursement_types = apply_search_to(
+        Spree::ReimbursementType.unscoped.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(reimbursement_types)
+
+      respond_to do |format|
+        format.html { render component('reimbursement_types/index').new(page: @page) }
+      end
+    end
+
+    private
+
+    def load_reimbursement_type
+      @reimbursement_type = Spree::ReimbursementType.find_by!(id: params[:id])
+      authorize! action_name, @reimbursement_type
+    end
+
+    def reimbursement_type_params
+      params.require(:reimbursement_type).permit(:reimbursement_type_id, permitted_reimbursement_type_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/return_reasons_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class ReturnReasonsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      return_reasons = apply_search_to(
+        Spree::ReturnReason.unscoped.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(return_reasons)
+
+      respond_to do |format|
+        format.html { render component('return_reasons/index').new(page: @page) }
+      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
+
+    private
+
+    def load_return_reason
+      @return_reason = Spree::ReturnReason.find_by!(id: params[:id])
+      authorize! action_name, @return_reason
+    end
+
+    def return_reason_params
+      params.require(:return_reason).permit(:return_reason_id, permitted_return_reason_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/shipping_categories_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class ShippingCategoriesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      shipping_categories = apply_search_to(
+        Spree::ShippingCategory.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(shipping_categories)
+
+      respond_to do |format|
+        format.html { render component('shipping_categories/index').new(page: @page) }
+      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
+
+    private
+
+    def load_shipping_category
+      @shipping_category = Spree::ShippingCategory.find_by!(id: params[:id])
+      authorize! action_name, @shipping_category
+    end
+
+    def shipping_category_params
+      params.require(:shipping_category).permit(:shipping_category_id, permitted_shipping_category_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/shipping_methods_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class ShippingMethodsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      shipping_methods = apply_search_to(
+        Spree::ShippingMethod.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(shipping_methods)
+
+      respond_to do |format|
+        format.html { render component('shipping_methods/index').new(page: @page) }
+      end
+    end
+
+    def destroy
+      @shipping_methods = Spree::ShippingMethod.where(id: params[:id])
+
+      Spree::ShippingMethod.transaction { @shipping_methods.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to shipping_methods_path, status: :see_other
+    end
+
+    private
+
+    def load_shipping_method
+      @shipping_method = Spree::ShippingMethod.find_by!(number: params[:id])
+      authorize! action_name, @shipping_method
+    end
+
+    def shipping_method_params
+      params.require(:shipping_method).permit(:shipping_method_id, permitted_shipping_method_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/stock_items_controller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class StockItemsController < SolidusAdmin::BaseController
+    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) }
+    search_scope(:out_of_stock) { _1.where('count_on_hand <= 0') }
+    search_scope(:low_stock) { _1.where('count_on_hand > 0 AND count_on_hand < ?', SolidusAdmin::Config[:low_stock_value]) }
+    search_scope(:in_stock) { _1.where('count_on_hand > 0') }
+
+    def index
+      respond_to do |format|
+        format.html { render component('stock_items/index').new(page: @page) }
+      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.except(:page, :q))
+      @stock_item.stock_movements.build(quantity: quantity_adjustment, originator: current_solidus_admin_user)
+
+      if @stock_item.save
+        redirect_to solidus_admin.stock_items_path(
+          page: stock_item_params[:page].to_i.presence,
+          q: stock_item_params[:q].presence&.then { |q| JSON.parse(q) }
+        ), 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
+      end
+    end
+
+    private
+
+    def load_stock_items
+      @stock_items = apply_search_to(
+        Spree::StockItem.reorder(nil),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(@stock_items, ordered_by: {
+        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
+      params.require(:stock_item).permit(:backorderable, :page, :q)
+    end
+  end
+end

data/app/controllers/solidus_admin/stock_locations_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class StockLocationsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      stock_locations = apply_search_to(
+        Spree::StockLocation.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(stock_locations)
+
+      respond_to do |format|
+        format.html { render component('stock_locations/index').new(page: @page) }
+      end
+    end
+
+    def destroy
+      @stock_locations = Spree::StockLocation.where(id: params[:id])
+
+      Spree::StockLocation.transaction { @stock_locations.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to stock_locations_path, status: :see_other
+    end
+
+    private
+
+    def load_stock_location
+      @stock_location = Spree::StockLocation.find_by!(number: params[:id])
+      authorize! action_name, @stock_location
+    end
+
+    def stock_location_params
+      params.require(:stock_location).permit(:stock_location_id, permitted_stock_location_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/store_credit_reasons_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class StoreCreditReasonsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      store_credit_reasons = apply_search_to(
+        Spree::StoreCreditReason.unscoped.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(store_credit_reasons)
+
+      respond_to do |format|
+        format.html { render component('store_credit_reasons/index').new(page: @page) }
+      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
+
+    private
+
+    def load_store_credit_reason
+      @store_credit_reason = Spree::StoreCreditReason.find_by!(id: params[:id])
+      authorize! action_name, @store_credit_reason
+    end
+
+    def store_credit_reason_params
+      params.require(:store_credit_reason).permit(:store_credit_reason_id, permitted_store_credit_reason_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/stores_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class StoresController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      stores = apply_search_to(
+        Spree::Store.order(id: :desc),
+        param: :q
+      )
+
+      set_page_and_extract_portion_from(stores)
+
+      respond_to do |format|
+        format.html { render component('stores/index').new(page: @page) }
+      end
+    end
+
+    def destroy
+      @stores = Spree::Store.where(id: params[:id])
+
+      Spree::Store.transaction { @stores.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to stores_path, status: :see_other
+    end
+
+    private
+
+    def load_store
+      @store = Spree::Store.find_by!(number: params[:id])
+      authorize! action_name, @store
+    end
+
+    def store_params
+      params.require(:store).permit(:store_id, permitted_store_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/tax_categories_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class TaxCategoriesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      tax_categories = apply_search_to(
+        Spree::TaxCategory.order(created_at: :desc, id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(tax_categories)
+
+      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
+
+    private
+
+    def load_tax_category
+      @tax_category = Spree::TaxCategory.find_by!(number: params[:id])
+      authorize! action_name, @tax_category
+    end
+
+    def tax_category_params
+      params.require(:tax_category).permit(:tax_category_id, permitted_tax_category_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/tax_rates_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class TaxRatesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      tax_rates = apply_search_to(
+        Spree::TaxRate.order(created_at: :desc, id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(tax_rates)
+
+      respond_to do |format|
+        format.html { render component('tax_rates/index').new(page: @page) }
+      end
+    end
+
+    def destroy
+      @tax_rates = Spree::TaxRate.where(id: params[:id])
+
+      Spree::TaxRate.transaction { @tax_rates.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to tax_rates_path, status: :see_other
+    end
+
+    private
+
+    def load_tax_rate
+      @tax_rate = Spree::TaxRate.find_by!(number: params[:id])
+      authorize! action_name, @tax_rate
+    end
+
+    def tax_rate_params
+      params.require(:tax_rate).permit(:tax_rate_id, permitted_tax_rate_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/taxonomies_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class TaxonomiesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    before_action :load_taxonomy, only: [:move]
+
+    def index
+      taxonomies = apply_search_to(
+        Spree::Taxonomy.all,
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(taxonomies)
+
+      respond_to do |format|
+        format.html { render component('taxonomies/index').new(page: @page) }
+      end
+    end
+
+    def move
+      @taxonomy.insert_at(params[:position].to_i)
+
+      respond_to do |format|
+        format.js { head :no_content }
+      end
+    end
+
+    def destroy
+      @taxonomies = Spree::Taxonomy.where(id: params[:id])
+
+      Spree::Taxonomy.transaction { @taxonomies.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to taxonomies_path, status: :see_other
+    end
+
+    private
+
+    def load_taxonomy
+      @taxonomy = Spree::Taxonomy.find(params[:id])
+      authorize! action_name, @taxonomy
+    end
+  end
+end