solidus_admin 0.0.2 → 0.2.0

data/app/components/solidus_admin/users/index/component.yml

@@ -0,0 +1,15 @@
+en:
+  batch_actions:
+    discontinue: 'Discontinue'
+    activate: 'Activate'
+  filters:
+    with_deleted: Include deleted
+  scopes:
+    customers: Customers
+    admin: Admins
+    with_orders: With Orders
+    without_orders: Without Orders
+    all: All
+  status:
+    active: Active
+    inactive: Inactive

data/app/components/solidus_admin/zones/index/component.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class SolidusAdmin::Zones::Index::Component < SolidusAdmin::UI::Pages::Index::Component
+  def model_class
+    Spree::Zone
+  end
+
+  def search_key
+    :name_or_description_cont
+  end
+
+  def search_url
+    solidus_admin.zones_path
+  end
+
+  def row_url(zone)
+    spree.edit_admin_zone_path(zone)
+  end
+
+  def page_actions
+    render component("ui/button").new(
+      tag: :a,
+      text: t('.add'),
+      href: spree.new_admin_zone_path,
+      icon: "add-line",
+      class: "align-self-end w-full",
+    )
+  end
+
+  def batch_actions
+    [
+      {
+        display_name: t('.batch_actions.delete'),
+        action: solidus_admin.zones_path,
+        method: :delete,
+        icon: 'delete-bin-7-line',
+      },
+    ]
+  end
+
+  def scopes
+    []
+  end
+
+  def filters
+    []
+  end
+
+  def columns
+    [
+      :name,
+      :description,
+      {
+        header: :kind,
+        data: -> { component('ui/badge').new(name: _1.kind, color: _1.kind == 'country' ? :green : :blue) },
+      },
+      {
+        header: :zone_members,
+        data: -> { _1.zone_members.map(&:zoneable).map(&:name).to_sentence },
+      },
+    ]
+  end
+end

data/app/controllers/solidus_admin/addresses_controller.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class AddressesController < BaseController
+    include Spree::Core::ControllerHelpers::StrongParameters
+
+    before_action :load_order, :load_address
+    before_action :validate_address_type
+
+    def show
+      respond_to do |format|
+        format.html do
+          render component('orders/show/address').new(
+            order: @order,
+            user: @order.user,
+            address: @address,
+            type: address_type,
+          )
+        end
+      end
+    end
+
+    def edit
+      redirect_to action: :show
+    end
+
+    def update
+      if @order.contents.update_cart(order_params)
+        redirect_to order_path(@order), status: :see_other, notice: t('.success')
+      else
+        flash.now[:error] = @order.errors[:base].join(", ") if @order.errors[:base].any?
+
+        respond_to do |format|
+          format.html do
+            render component('orders/show/address').new(
+              order: @order,
+              user: @order.user,
+              address: @order.send("#{address_type}_address"),
+              type: address_type,
+            ), status: :unprocessable_entity
+          end
+        end
+      end
+    end
+
+    private
+
+    def load_address
+      if params[:address_id].present? && @order.user
+        @address =
+          @order.user.addresses.find_by(id: params[:address_id]) ||
+          @order.user.addresses.build(country: default_country)
+      else
+        @address =
+          @order.public_send("#{address_type}_address") ||
+          @order.public_send("build_#{address_type}_address", country: default_country)
+      end
+    end
+
+    def address_type
+      params[:type].presence_in(%w[bill ship])
+    end
+
+    def validate_address_type
+      unless address_type
+        flash[:error] = t('.errors.address_type_invalid')
+        redirect_to spree.admin_order_url(@order)
+      end
+    end
+
+    def default_country
+      @default_country ||= begin
+        country = Spree::Country.default
+        country if Spree::Country.available.exists?(id: country.id)
+      end
+    end
+
+    def load_order
+      @order = Spree::Order.find_by!(number: params[:order_id])
+      authorize! action_name, @order
+    end
+
+    def order_params
+      params.require(:order).permit(
+        :use_billing,
+        :use_shipping,
+        bill_address_attributes: permitted_address_attributes,
+        ship_address_attributes: permitted_address_attributes
+      )
+    end
+  end
+end

data/app/controllers/solidus_admin/adjustment_reasons_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class AdjustmentReasonsController < SolidusAdmin::BaseController
+    include SolidusAdmin::ControllerHelpers::Search
+
+    def index
+      adjustment_reasons = apply_search_to(
+        Spree::AdjustmentReason.order(id: :desc),
+        param: :q,
+      )
+
+      set_page_and_extract_portion_from(adjustment_reasons)
+
+      respond_to do |format|
+        format.html { render component('adjustment_reasons/index').new(page: @page) }
+      end
+    end
+
+    def destroy
+      @adjustment_reason = Spree::AdjustmentReason.find_by!(id: params[:id])
+
+      Spree::AdjustmentReason.transaction { @adjustment_reason.destroy }
+
+      flash[:notice] = t('.success')
+      redirect_back_or_to adjustment_reasons_path, status: :see_other
+    end
+
+    private
+
+    def load_adjustment_reason
+      @adjustment_reason = Spree::AdjustmentReason.find_by!(id: params[:id])
+      authorize! action_name, @adjustment_reason
+    end
+
+    def adjustment_reason_params
+      params.require(:adjustment_reason).permit(:adjustment_reason_id, permitted_adjustment_reason_attributes)
+    end
+  end
+end

data/app/controllers/solidus_admin/base_controller.rb

@@ -11,6 +11,7 @@ module SolidusAdmin
     include SolidusAdmin::ControllerHelpers::Authentication
     include SolidusAdmin::ControllerHelpers::Authorization
     include SolidusAdmin::ControllerHelpers::Locale
+    include SolidusAdmin::ControllerHelpers::Theme
     include SolidusAdmin::ComponentsHelper
     include SolidusAdmin::AuthenticationAdapters::Backend if defined?(Spree::Backend)
 

data/app/controllers/solidus_admin/controller_helpers/authorization.rb

@@ -5,6 +5,10 @@ module SolidusAdmin::ControllerHelpers::Authorization
 
   included do
     before_action :authorize_solidus_admin_user!
+
+    rescue_from CanCan::AccessDenied do
+      render 'unauthorized', status: :forbidden
+    end
   end
 
   private
@@ -17,7 +21,7 @@ module SolidusAdmin::ControllerHelpers::Authorization
     subject = authorization_subject
 
     authorize! :admin, subject
-    authorize! action_name, subject
+    authorize! action_name.to_sym, subject
   end
 
   def authorization_subject

data/app/controllers/solidus_admin/controller_helpers/locale.rb

@@ -18,7 +18,7 @@ module SolidusAdmin::ControllerHelpers::Locale
       session[set_user_language_locale_key] = requested_locale
 
       flash[:notice] = t('spree.locale_changed')
-      redirect_to url_for(request.params.except(:switch_to_locale))
+      redirect_to params.except(:switch_to_locale).permit!.to_h.merge(account_menu_open: true)
     end
   end
 
@@ -27,6 +27,6 @@ module SolidusAdmin::ControllerHelpers::Locale
   end
 
   def set_locale
-    I18n.locale = user_locale
+    I18n.locale = I18n.locale_available?(user_locale) ? user_locale : I18n.default_locale
   end
 end

data/app/controllers/solidus_admin/controller_helpers/search.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SolidusAdmin::ControllerHelpers::Search
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def search_scope(name, default: false, &block)
+      search_scopes << SearchScope.new(
+        name: name.to_s,
+        block: block,
+        default: default,
+      )
+    end
+
+    def search_scopes
+      @search_scopes ||= []
+    end
+  end
+
+  private
+
+  def apply_search_to(relation, param:)
+    relation = apply_scopes_to(relation, param: param)
+    apply_ransack_search_to(relation, param: param)
+  end
+
+  def apply_ransack_search_to(relation, param:)
+    relation
+      .ransack(params[param]&.except(:scope))
+      .result(distinct: true)
+  end
+
+  def apply_scopes_to(relation, param:)
+    current_scope_name = params.dig(param, :scope)
+
+    search_block = (
+      self.class.search_scopes.find { _1.name == current_scope_name } ||
+      self.class.search_scopes.find { _1.default }
+    )&.block
+
+    # Run the search if a block is present, fall back to the relation even if the
+    # block is present but returns nil.
+    (search_block && instance_exec(relation, &search_block)) || relation
+  end
+
+  SearchScope = Struct.new(:name, :block, :default, keyword_init: true)
+  private_constant :SearchScope
+end

data/app/controllers/solidus_admin/controller_helpers/theme.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolidusAdmin::ControllerHelpers::Theme
+  extend ActiveSupport::Concern
+
+  included do
+    before_action :update_user_theme
+  end
+
+  private
+
+  def update_user_theme
+    requested_theme = params[:switch_to_theme].presence or return
+
+    # Avoid interpolating user content into the session key
+    system_theme = params[:system_theme].presence == "dark" ? "dark" : "light"
+    session_key = :"admin_#{system_theme}_theme"
+
+    if theme_is_available?(requested_theme) && requested_theme.to_sym != session[session_key]
+      session[session_key] = requested_theme
+
+      flash[:notice] = t('spree.theme_changed')
+      redirect_to params.except(:switch_to_theme, :system_theme).permit!.to_h.merge(account_menu_open: true)
+    end
+  end
+
+  def theme_is_available?(theme)
+    theme && SolidusAdmin::Config.themes.key?(theme.to_sym)
+  end
+end

data/app/controllers/solidus_admin/countries_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class CountriesController < SolidusAdmin::BaseController
+    skip_before_action :authorize_solidus_admin_user!
+
+    def states
+      @states = Spree::State.where(country_id: params[:country_id])
+      render json: @states.select(:id, :name)
+    end
+  end
+end

data/app/controllers/solidus_admin/customers_controller.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class SolidusAdmin::CustomersController < SolidusAdmin::BaseController
+  before_action :load_order, only: [:show, :destroy]
+
+  def show
+    render component('orders/show/email').new(order: @order)
+  end
+
+  def destroy
+    if @order.update(user: nil)
+      flash[:success] = t('.success')
+    else
+      flash[:error] = t('.error')
+    end
+
+    redirect_to order_path(@order), status: :see_other
+  end
+
+  private
+
+  def load_order
+    @order = Spree::Order.find_by!(number: params[:order_id])
+  end
+
+  def authorization_subject
+    @order || Spree::Order
+  end
+end

data/app/controllers/solidus_admin/line_items_controller.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SolidusAdmin
+  class LineItemsController < SolidusAdmin::BaseController
+    def destroy
+      load_order
+      load_line_item
+
+      @line_item.destroy!
+
+      redirect_to order_path(@order), status: :see_other, notice: t('.success')
+    end
+
+    def create
+      load_order
+      variant_id = params.require(:line_item).require(:variant_id)
+      @variant = Spree::Variant.find(variant_id)
+      @line_item = @order.contents.add(@variant)
+
+      redirect_to order_path(@order), status: :see_other, notice: t('.success')
+    end
+
+    def update
+      load_order
+      load_line_item
+
+      desired_quantity = params[:line_item][:quantity].to_i
+
+      @line_item = @order.contents.add(@line_item.variant, desired_quantity - @line_item.quantity)
+
+      redirect_to order_path(@order), status: :see_other, notice: t('.success')
+    end
+
+    private
+
+    def load_order
+      @order = Spree::Order.find_by!(number: params[:order_id])
+      authorize! action_name, @order
+    end
+
+    def load_line_item
+      @line_item = @order.line_items.find(params[:id])
+    end
+  end
+end

data/app/controllers/solidus_admin/option_types_controller.rb

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

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