solidus_admin 0.0.2 → 0.1.0

data/app/controllers/solidus_admin/orders_controller.rb

@@ -2,20 +2,117 @@
 
 module SolidusAdmin
   class OrdersController < SolidusAdmin::BaseController
+    include Spree::Core::ControllerHelpers::StrongParameters
+    include SolidusAdmin::ControllerHelpers::Search
+
+    search_scope(:completed, default: true) { _1.complete }
+    search_scope(:canceled) { _1.canceled }
+    search_scope(:returned) { _1.with_state(:returned) }
+    search_scope(:in_progress) { _1.with_state([:cart] + _1.checkout_step_names) }
+    search_scope(:all) { _1 }
+
     def index
-      orders = Spree::Order
+      orders = apply_search_to(
+        Spree::Order.order(created_at: :desc, id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(orders)
+
+      respond_to do |format|
+        format.html { render component('orders/index').new(page: @page) }
+      end
+    end
+
+    def new
+      order = Spree::Order.create!(
+        created_by: current_solidus_admin_user,
+        frontend_viewable: false,
+        store_id: current_store.try(:id)
+      )
+
+      redirect_to order_url(order), status: :see_other
+    end
+
+    def show
+      load_order
+
+      respond_to do |format|
+        format.html { render component('orders/show').new(order: @order) }
+      end
+    end
+
+    def update
+      load_order
+
+      @order.assign_attributes(order_params)
+      @order.email ||= @order.user.email if @order.user && @order.user.changed?
+
+      if @order.save
+        flash[:notice] = t('.success')
+      else
+        flash[:error] = t('.error')
+      end
+
+      redirect_to spree.edit_admin_order_path(@order)
+    end
+
+    def edit
+      redirect_to action: :show
+    end
+
+    def variants_for
+      load_order
+
+      # We need to eager load active storage attachments when using it
+      if Spree::Image.include?(Spree::Image::ActiveStorageAttachment)
+        image_includes = {
+          attachment_attachment: { blob: { variant_records: { image_attachment: :blob } } }
+        }
+      end
+
+      @variants = Spree::Variant
+        .where.not(id: @order.line_items.select(:variant_id))
+        .order(created_at: :desc, id: :desc)
+        .where(product_id: Spree::Product.ransack(params[:q]).result.select(:id))
+        .limit(10)
+        .eager_load(
+          :prices,
+          images: image_includes || {},
+          option_values: :option_type,
+          stock_items: :stock_location,
+        )
+
+      respond_to do |format|
+        format.html { render component('orders/cart/result').with_collection(@variants, order: @order), layout: false }
+      end
+    end
+
+    def customers_for
+      load_order
+
+      @users = Spree.user_class
+        .where.not(id: @order.user_id)
         .order(created_at: :desc, id: :desc)
         .ransack(params[:q])
         .result(distinct: true)
-
-      set_page_and_extract_portion_from(
-        orders,
-        per_page: SolidusAdmin::Config[:orders_per_page]
-      )
+        .includes(:default_user_bill_address, :default_user_ship_address)
+        .limit(10)
 
       respond_to do |format|
-        format.html { render component('orders/index').new(page: @page) }
+        format.html { render component('orders/show/customer_search/result').with_collection(@users, order: @order), layout: false }
       end
     end
+
+    private
+
+    def load_order
+      @order = Spree::Order.find_by!(number: params[:id])
+      authorize! action_name, @order
+    end
+
+    def order_params
+      params.require(:order).permit(:user_id, permitted_order_attributes)
+    end
   end
 end

data/app/controllers/solidus_admin/payment_methods_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class PaymentMethodsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    before_action :load_payment_method, only: [:move]
+
+    search_scope(:all)
+    search_scope(:active, default: true, &:active)
+    search_scope(:inactive) { _1.where.not(active: true) }
+    search_scope(:storefront, &:available_to_users)
+    search_scope(:admin, &:available_to_admin)
+
+    def index
+      payment_methods = apply_search_to(
+        Spree::PaymentMethod.ordered_by_position,
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(payment_methods)
+
+      respond_to do |format|
+        format.html { render component('payment_methods/index').new(page: @page) }
+      end
+    end
+
+    def move
+      @payment_method.insert_at(params[:position].to_i)
+
+      respond_to do |format|
+        format.js { head :no_content }
+      end
+    end
+
+    def destroy
+      @payment_methods = Spree::PaymentMethod.where(id: params[:id])
+
+      Spree::PaymentMethod.transaction { @payment_methods.destroy_all }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to payment_methods_path, status: :see_other
+    end
+
+    private
+
+    def load_payment_method
+      @payment_method = Spree::PaymentMethod.find_by!(id: params[:id])
+      authorize! action_name, @payment_method
+    end
+  end
+end

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,38 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class PromotionCategoriesController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    before_action :load_promotion_category, only: [:move]
+
+    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
+
+    private
+
+    def load_promotion_category
+      @promotion_category = Spree::PromotionCategory.find(params[:id])
+      authorize! action_name, @promotion_category
+    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.discard_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