solidus_admin 0.0.2 → 0.1.0

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class SolidusAdmin::Users::Index::Component < SolidusAdmin::BaseComponent
+  include SolidusAdmin::Layout::PageHelpers
+
+  def initialize(page:)
+    @page = page
+  end
+
+  def title
+    Spree.user_class.model_name.human.pluralize
+  end
+
+  def prev_page_path
+    solidus_admin.url_for(**request.params, page: @page.number - 1, only_path: true) unless @page.first?
+  end
+
+  def next_page_path
+    solidus_admin.url_for(**request.params, page: @page.next_param, only_path: true) unless @page.last?
+  end
+
+  def batch_actions
+    [
+      {
+        display_name: t('.batch_actions.delete'),
+        action: solidus_admin.users_path,
+        method: :delete,
+        icon: 'delete-bin-7-line',
+      },
+    ]
+  end
+
+  def scopes
+    [
+      { name: :customers, label: t('.scopes.customers'), default: true },
+      { name: :admin, label: t('.scopes.admin') },
+      { name: :with_orders, label: t('.scopes.with_orders') },
+      { name: :without_orders, label: t('.scopes.without_orders') },
+      { name: :all, label: t('.scopes.all') },
+    ]
+  end
+
+  def filters
+    [
+      {
+        presentation: Spree::Role.model_name.human.pluralize,
+        attribute: "spree_roles_id",
+        predicate: "in",
+        options: Spree::Role.pluck(:name, :id)
+      }
+    ]
+  end
+
+  def columns
+    [
+      {
+        header: :email,
+        data: :email,
+      },
+      {
+        header: :roles,
+        data: ->(user) do
+          roles = user.spree_roles.presence || [Spree::Role.new(name: 'customer')]
+          safe_join(roles.map {
+            color =
+              case _1.name
+              when 'admin' then :blue
+              when 'customer' then :green
+              else :graphite_light
+              end
+            render component('ui/badge').new(name: _1.name, color: color)
+          })
+        end,
+      },
+      {
+        header: :order_count,
+        data: ->(user) { user.order_count },
+      },
+      {
+        header: :lifetime_value,
+        data: -> { _1.display_lifetime_value.to_html },
+      },
+      {
+        header: :created_at,
+        data: ->(user) { l(user.created_at.to_date, format: :long) },
+      },
+    ]
+  end
+end

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

@@ -0,0 +1,18 @@
+en:
+  promotion_image: 'Image'
+  add: 'Add new'
+  batch_actions:
+    delete: 'Delete'
+    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.html.erb

@@ -0,0 +1,35 @@
+<%= page do %>
+  <%= page_header do %>
+    <%= page_header_title title %>
+    <%= page_header_actions do %>
+      <%= 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 %>
+  <% end %>
+
+  <%= render component('ui/table').new(
+    id: stimulus_id,
+    data: {
+      class: Spree::Zone,
+      rows: @page.records,
+      url: ->(zone) { spree.edit_admin_zone_path(zone) },
+      prev: prev_page_path,
+      next: next_page_path,
+      columns: columns,
+      batch_actions: batch_actions,
+    },
+    search: {
+      name: :q,
+      value: params[:q],
+      url: solidus_admin.zones_path,
+      searchbar_key: :name_or_description_cont,
+      scopes: scopes,
+      filters: filters,
+    },
+  ) %>
+<% end %>

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class SolidusAdmin::Zones::Index::Component < SolidusAdmin::BaseComponent
+  include SolidusAdmin::Layout::PageHelpers
+
+  def initialize(page:)
+    @page = page
+  end
+
+  def title
+    Spree::Zone.model_name.human.pluralize
+  end
+
+  def prev_page_path
+    solidus_admin.url_for(**request.params, page: @page.number - 1, only_path: true) unless @page.first?
+  end
+
+  def next_page_path
+    solidus_admin.url_for(**request.params, page: @page.next_param, only_path: true) unless @page.last?
+  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/components/solidus_admin/zones/index/component.yml

@@ -0,0 +1,4 @@
+en:
+  add: 'Add new'
+  batch_actions:
+    delete: 'Delete'

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