spree_admin 5.0.0.rc1

data/app/controllers/spree/admin/webhooks_subscribers_controller.rb

@@ -0,0 +1,48 @@
+module Spree
+  module Admin
+    class WebhooksSubscribersController < ResourceController
+      create.before :process_subscriptions
+      update.before :process_subscriptions
+
+      def index
+        params[:q] ||= {}
+        params[:q][:s] ||= 'created_at desc'
+
+        search = Webhooks::Subscriber.accessible_by(current_ability).ransack(params[:q])
+        @webhooks_subscribers = search.result.
+                                includes(:events).
+                                page(params[:page]).
+                                per(params[:per_page])
+      end
+
+      def show
+        @webhooks_subscriber = Webhooks::Subscriber.find(params[:id])
+        @events = @webhooks_subscriber.events.order(created_at: :desc).page(params[:page]).per(params[:per_page])
+      end
+
+      private
+
+      def resource
+        @resource ||= Spree::Admin::Resource.new 'spree/admin/webhooks/subscribers', 'subscribers', nil
+      end
+
+      def process_subscriptions
+        params[:webhooks_subscriber][:subscriptions] = if params[:subscribe_to_all_events] == 'true'
+                                                         ['*']
+                                                       else
+                                                         selected_events
+                                                       end
+
+        params[:webhooks_subscriber] = params[:webhooks_subscriber].except(*supported_events.keys)
+      end
+
+      def selected_events
+        supported_events.select { |resource, _events| params[:webhooks_subscriber][resource] == 'true' }.values.flatten
+      end
+
+      def supported_events
+        @supported_events ||= Spree::Webhooks::Subscriber.supported_events
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/zones_controller.rb

@@ -0,0 +1,37 @@
+module Spree
+  module Admin
+    class ZonesController < ResourceController
+      before_action :load_data, except: :index
+
+      def new
+        @zone.zone_members.build
+      end
+
+      protected
+
+      def location_after_save
+        edit_object_url(@object, states_country_id: @selected_country&.id)
+      end
+
+      def collection
+        params[:q] ||= {}
+        params[:q][:s] ||= 'name asc'
+        @search = super.ransack(params[:q])
+        @zones = @search.result.page(params[:page]).per(params[:per_page])
+      end
+
+      def load_data
+        @selected_country = if params[:states_country_id]
+          Spree::Country.find_by(id: params[:states_country_id])
+        elsif @zone && @zone.state? && @zone.zone_members.exists?
+          @zone.zone_members.first.zoneable.country
+        else
+          current_store.default_country
+        end
+        @countries = Country.order(:name)
+        @states = @selected_country&.states&.order(:name) || Spree::State.none
+        @zones = Zone.order(:name)
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/base_helper.rb

@@ -0,0 +1,246 @@
+module Spree
+  module Admin
+    module BaseHelper
+      include Spree::ImagesHelper
+
+      def enterprise_edition?
+        defined?(Vendo)
+      end
+
+      def spree_updater
+        @spree_updater ||= Spree::Admin::Updater
+      end
+
+      def spree_update_available?
+        @spree_update_available ||= !Rails.env.test? && spree_updater.update_available?
+      end
+
+      def settings_active?
+        %w[stores zones shipping_methods oauth_applications
+           payment_methods refund_reasons reimbursement_types
+           shipping_categories store_credit_categories
+           syncs tax_categories tax_rates webhooks accounts
+           custom_domains audits exports imports return_authorization_reasons
+           documents stripe_tax_registrations members subscriptions stock_locations webhooks_subscribers].include?(controller_name)
+      end
+
+      def available_countries_iso
+        @available_countries_iso ||= current_store.countries_available_for_checkout.pluck(:iso)
+      end
+
+      def avatar_url_for(user)
+        return unless user.present?
+
+        if user.respond_to?(:avatar) && user.avatar.attached? && user.avatar.variable?
+          main_app.cdn_image_url(
+            user.avatar.variant(spree_image_variant_options(resize_to_fill: [128, 128]))
+          )
+        else
+          "https://eu.ui-avatars.com/api/?name=#{user.name&.initials}&background=random"
+        end
+      end
+
+      def display_on_options
+        Spree::DisplayOn::DISPLAY.map do |display_on|
+          [Spree.t("admin.display_on_options.#{display_on}"), display_on]
+        end
+      end
+
+      def error_message_on(object, method, _options = {})
+        object = convert_to_model(object)
+        obj = object.respond_to?(:errors) ? object : instance_variable_get("@#{object}")
+
+        if obj && obj.errors[method].present?
+          errors = safe_join(obj.errors[method], '<br />'.html_safe)
+          content_tag(:span, errors, class: 'formError')
+        else
+          ''
+        end
+      end
+
+      def icon(icon_name, options = {})
+        if icon_name.ends_with?('.svg')
+          icon_name = File.basename(icon_name, File.extname(icon_name))
+        end
+
+        # translations for legacy icon names
+        icon_name = 'device-floppy' if icon_name == 'save'
+        icon_name = 'pencil' if icon_name == 'edit'
+        icon_name = 'trash' if icon_name == 'delete'
+        icon_name = 'plus' if icon_name == 'add'
+        icon_name = 'x' if icon_name == 'cancel'
+
+        styles = options[:style]
+        styles ||= ''
+        styles += ";font-size: #{options[:height]}px !important;line-height:#{options[:height]}px !important" if options[:height]
+
+        content_tag :i, nil, class: "ti ti-#{icon_name} #{options[:class]}", style: styles
+      end
+
+      def flag_emoji(iso)
+        ::Country.new(iso).emoji_flag
+      end
+
+      def preference_field_tag(name, value, options)
+        if options[:key] == :currency
+          return select_tag(
+            name,
+            currency_options_for_select(
+              value,
+              current_store.supported_currencies.split(',')
+            ),
+            class: 'custom-select',
+            disabled: current_store.supported_currencies.split(',').count == 1
+          )
+        end
+
+        case options[:type]
+        when :integer
+          number_field_tag(name, value, preference_field_options(options))
+        when :decimal
+          number_field_tag(name, value, preference_field_options(options))
+        when :boolean
+          hidden_field_tag(name, 0, id: "#{name}_hidden") +
+            check_box_tag(name, 1, value, preference_field_options(options))
+        when :string
+          text_field_tag(name, value, preference_field_options(options))
+        when :password
+          password_field_tag(name, value, preference_field_options(options))
+        when :text
+          text_area_tag(name, value, preference_field_options(options))
+        else
+          text_field_tag(name, value, preference_field_options(options))
+        end
+      end
+
+      def preference_field_for(form, field, options)
+        case options[:type]
+        when :integer
+          form.number_field(field, preference_field_options(options))
+        when :decimal
+          form.number_field(field, preference_field_options(options))
+        when :boolean
+          form.check_box(field, preference_field_options(options))
+        when :string
+          form.text_field(field, preference_field_options(options))
+        when :password
+          render 'spree/admin/preferences/password_field', form: form, field: field, options: options
+        when :text
+          form.text_area(field, preference_field_options(options))
+        else
+          form.text_field(field, preference_field_options(options))
+        end
+      end
+
+      def preference_field_options(options)
+        field_options = case options[:type]
+                        when :integer
+                          {
+                            size: 10,
+                            class: 'input_integer form-control'
+                          }
+                        when :decimal
+                          {
+                            size: 10,
+                            class: 'input_decimal form-control',
+                            step: options[:step] || 0.01
+                          }
+                        when :boolean
+                          {
+                            class: 'custom-control-input'
+                          }
+                        when :string
+                          {
+                            size: 10,
+                            class: 'input_string form-control'
+                          }
+                        when :password
+                          {
+                            size: 10,
+                            class: 'password_string form-control'
+                          }
+                        when :text
+                          {
+                            rows: 15,
+                            cols: 85,
+                            class: 'form-control'
+                          }
+                        else
+                          {
+                            size: 10,
+                            class: 'input_string form-control'
+                          }
+                        end
+
+        field_options.merge!(readonly: options[:readonly],
+                             disabled: options[:disabled],
+                             size: options[:size])
+      end
+
+      def preference_fields(object, form)
+        return unless object.respond_to?(:preferences)
+
+        fields = object.preferences.keys.map do |key|
+          if object.has_preference?(key)
+            case key
+            when :currency
+              content_tag(:div, form.label("preferred_#{key}", Spree.t(key)) +
+                form.currency_select("preferred_#{key}", current_store.supported_currencies.split(','), {}, { class: 'custom-select', disabled: current_store.supported_currencies.split(',').count == 1 }),
+                          class: 'form-group', id: [object.class.to_s.parameterize, 'preference', key].join('-'))
+            else
+              if object.preference_type(key).to_sym == :boolean
+                content_tag(:div, class: 'form-group custom-control custom-checkbox') do
+                  preference_field_for(form, "preferred_#{key}", type: object.preference_type(key)) +
+                    form.label(
+                      "preferred_#{key}",
+                      Spree.t(key),
+                      class: 'custom-control-label',
+                      id: [object.class.to_s.parameterize, 'preference', key].join('-')
+                    )
+                end
+              else
+                content_tag(:div, form.label("preferred_#{key}", Spree.t(key)) +
+                  preference_field_for(form, "preferred_#{key}", type: object.preference_type(key)),
+                            class: 'form-group', id: [object.class.to_s.parameterize, 'preference', key].join('-'))
+              end
+            end
+          end
+        end
+        safe_join(fields)
+      end
+
+      def spree_dom_id(record)
+        dom_id(record, 'spree')
+      end
+
+      def required_span_tag
+        content_tag(:span, ' *', class: 'required font-weight-bold text-danger')
+      end
+
+      def external_page_preview_link(resource, options = {})
+        resource_name = options[:name] || resource.class.name.demodulize
+
+        url = if [Spree::Product, Spree::Post].include?(resource.class)
+                spree_storefront_resource_url(resource, preview_id: resource.id)
+              else
+                spree_storefront_resource_url(resource)
+              end
+
+        link_to_with_icon(
+          'eye',
+          Spree.t('admin.utilities.preview', name: resource_name),
+          url,
+          class: 'text-left dropdown-item', id: "adminPreview#{resource_name}", target: :blank, data: { turbo: false }
+        )
+      end
+
+      def path_from_url(url)
+        url.to_s.gsub('https://', '').gsub('http://', '')
+      end
+
+      def allowed_file_types_for_upload
+        Rails.application.config.active_storage.web_image_content_types
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/custom_domains_helper.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Admin
+    module CustomDomainsHelper
+      def entri_enabled?
+        false
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/customer_returns_helper.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Admin
+    module CustomerReturnsHelper
+      def reimbursement_types
+        @reimbursement_types ||= Spree::ReimbursementType.accessible_by(current_ability).active
+      end
+
+      def reimbursement_status_color(reimbursement)
+        case reimbursement.reimbursement_status
+        when 'reimbursed' then 'success'
+        when 'pending' then 'notice'
+        when 'errored' then 'error'
+        else raise "unknown reimbursement status: #{reimbursement.reimbursement_status}"
+        end
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/flash_helper.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Admin
+    module FlashHelper
+      def admin_flash_class_for(flash_type)
+        {
+          success: 'alert-success',
+          error: 'alert-danger',
+          warning: 'alert-warning',
+          notice: 'alert-success',
+          alert: 'alert-danger'
+        }[flash_type.to_sym]
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/navigation_helper.rb

@@ -0,0 +1,195 @@
+module Spree
+  module Admin
+    module NavigationHelper
+      # the per_page_dropdown is used on index pages like orders, products, promotions etc.
+      # this method generates the select_tag
+      def per_page_dropdown
+        per_page_default = if @products
+                             Spree::Admin::RuntimeConfig.admin_products_per_page
+                           elsif @orders
+                             Spree::Admin::RuntimeConfig.admin_orders_per_page
+                           else
+                             Spree::Admin::RuntimeConfig.admin_records_per_page
+                           end
+
+        per_page_options = [
+          per_page_default,
+          per_page_default * 2,
+          per_page_default * 4,
+          per_page_default * 8
+        ]
+
+        selected_option = (params[:per_page].try(:to_i) || per_page_default).to_s
+
+        selected_option += icon('chevron-down', class: 'ml-1 mr-0 arrow')
+
+        content_tag :div, id: 'per-page-dropdown' do
+          button_tag(raw(selected_option), class: 'btn btn-light btn-sm', data: { toggle: 'dropdown', expanded: false }) +
+            content_tag(:div, class: 'dropdown-menu') do
+              per_page_options.map do |option|
+                link_to option, per_page_dropdown_params(option), class: "dropdown-item #{'active' if option == selected_option}"
+              end.join.html_safe
+            end
+        end
+      end
+
+      # helper method to create proper url to apply per page ing
+      # fixes https://github.com/spree/spree/issues/6888
+      def per_page_dropdown_params(per_page)
+        args = params.permit!.to_h.clone
+        args.delete(:page)
+        args.delete(:per_page)
+        args.merge!(per_page: per_page)
+        args
+      end
+
+      def link_to_edit(resource, options = {})
+        url = options[:url] || edit_object_url(resource)
+        options[:data] ||= {}
+        options[:data][:action] ||= 'edit'
+        options[:class] ||= 'btn btn-light btn-sm'
+        link_to_with_icon('pencil', Spree.t(:edit), url, options) if can?(:update, resource)
+      end
+
+      def link_to_delete(resource, options = {})
+        url = options[:url] || object_url(resource)
+        name = options[:name] || Spree.t('actions.destroy')
+        options[:class] ||= 'btn btn-danger btn-sm'
+        options[:data] ||= { turbo_confirm: Spree.t(:are_you_sure), turbo_method: :delete }
+
+        return unless can?(:destroy, resource)
+
+        if options[:no_text]
+          link_to_with_icon 'trash', name, url, options
+        elsif options[:icon]
+          link_to_with_icon options[:icon], name, url, options
+        else
+          link_to name, url, options
+        end
+      end
+
+      def link_to_with_icon(icon_name, text, url, options = {})
+        options[:class] ||= (options[:class].to_s + " with-tip").strip
+        options[:title] ||= text if options[:no_text]
+        no_text = options[:no_text]
+        label = options[:no_text] ? '' : content_tag(:span, text)
+        options.delete(:no_text)
+
+        if icon_name
+          icon = icon(icon_name, class: "icon icon-#{icon_name} #{text.blank? || no_text ? 'mr-0' : ''}")
+          text = "#{icon} #{label}"
+        end
+        link_to(text.html_safe, url, options)
+      end
+
+      def active_link_to_with_icon(icon_name, text, url, options = {})
+        options[:class] = (options[:class].to_s + " with-tip").strip
+        options[:title] = text if options[:no_text]
+        no_text = options[:no_text]
+        label = options[:no_text] ? '' : content_tag(:span, text)
+        options.delete(:no_text)
+
+        if icon_name
+          icon = icon(icon_name, class: "icon icon-#{icon_name}")
+          text = "#{icon} #{label}"
+        end
+        active_link_to(text.html_safe, url, options)
+      end
+
+      # Override: Add disable_with option to prevent multiple request on consecutive clicks
+      def button(text, icon_name = nil, button_type = 'submit', options = {})
+        if icon_name
+          text = "#{icon(icon_name, class: "icon icon-#{icon_name}")} #{text}"
+        end
+
+        css_classes = options[:class] || 'btn-primary'
+
+        button_tag(
+          text.html_safe,
+          options.merge(
+            type: button_type,
+            class: "btn #{css_classes}",
+            'data-turbo-submits-with' => content_tag(:span, '', class: 'spinner-border spinner-border-sm', role: 'status')
+          )
+        )
+      end
+
+      def button_link_to(text, url, html_options = {})
+        if html_options[:method] &&
+            !html_options[:method].to_s.casecmp('get').zero? &&
+            !html_options[:remote]
+
+          html_options[:class] = html_options[:class] ? "btn #{html_options[:class]}" : 'btn btn-primary'
+
+          form_tag(url, method: html_options.delete(:method)) do
+            button(text, html_options.delete(:icon), nil, html_options)
+          end
+        else
+          html_options[:class] = html_options[:class] ? "btn #{html_options[:class]}" : 'btn btn-light'
+
+          if html_options[:icon]
+            icon = icon(html_options[:icon], class: "icon icon-#{html_options[:icon]}")
+            text = "#{icon} #{text}"
+          end
+
+          link_to(text.html_safe, url, html_options.except(:icon))
+        end
+      end
+
+      def active_badge(condition, options = {})
+        label = options[:label]
+        label ||= condition ? Spree.t(:say_yes) : Spree.t(:say_no)
+        label = icon('check') + label if condition
+
+        css_class = condition ? 'badge-active' : 'badge-inactive'
+
+        content_tag(:span, class: "badge  #{css_class}") do
+          label
+        end
+      end
+
+      def page_header_back_button(default_url, object = nil, label = nil)
+        url = default_url
+
+        if object.present?
+          session_key = "#{object.class.to_s.demodulize.pluralize.downcase}_return_to".to_sym
+          url = session[session_key] if session[session_key].present?
+        end
+
+        link_to url, class: 'd-flex align-items-center text-decoration-none' do
+          content_tag(:span, icon('chevron-left', class: 'mr-0'), class: 'btn hover-gray px-2 d-flex align-items-center') +
+            content_tag(:span, label, class: 'font-size-base text-black')
+        end
+      end
+
+      def nav_pill_list_item(resource, url: nil, label: Spree.t(resource), active: nil, link_class: 'nav-link')
+        url = spree.send("admin_#{resource.to_s.pluralize}_path") if url.nil?
+        active = request.url.starts_with?(url) || request.fullpath.starts_with?(url) || controller_name == resource.to_s if active.nil?
+        link_class = "#{link_class} active" if active
+
+        content_tag :li, class: 'nav-item', role: 'presentation' do
+          link_to label, url, role: 'tab', 'aria-controls': 'pills-general', class: link_class, 'aria-selected': active
+        end
+      end
+
+      def external_link_to(label, url, opts = {}, &block)
+        opts[:target] ||= :blank
+        opts[:rel] ||= :nofollow
+        opts[:class] ||= "d-inline-flex align-items-center text-blue"
+
+        if block_given?
+          link_to url, opts, &block
+        else
+          link_to url, opts do
+            (label + icon('external-link', class: 'ml-1 mr-0 small')).html_safe
+          end
+        end
+      end
+
+      def help_bubble(text = '', placement = 'bottom', css: nil)
+        css ||= 'text-muted'
+        content_tag :small, icon('info-square-rounded', class: css), data: { placement: placement }, class: "with-tip #{css}", title: text
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/onboarding_helper.rb

@@ -0,0 +1,18 @@
+module Spree
+  module Admin
+    module OnboardingHelper
+      def onboarding_check_circle(condition, pending: false)
+        if pending
+          return icon('exclamation-circle', height: height,
+                                            class: 'rounded-circle d-inline-flex align-items-center bg-warning text-primary p-1').html_safe
+        end
+
+        if condition == true
+          icon('check', class: 'rounded-circle d-inline-flex align-items-center bg-success text-success p-1', style: 'border: 3px solid #C6F6D5')
+        else
+          icon('check', class: 'rounded-circle d-inline-flex align-items-center border-dashed text-light p-1')
+        end.html_safe
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/orders_filters_helper.rb

@@ -0,0 +1,68 @@
+module Spree
+  module Admin
+    module OrdersFiltersHelper
+      def params_to_filters(search_params:, vendor: nil, user: nil)
+        if search_params.is_a?(String)
+          search_params = JSON.parse(search_params).deep_symbolize_keys
+        end
+
+        search_params.delete(:inventory_units_shipment_id_null) if search_params[:inventory_units_shipment_id_null] == '0'
+
+        if search_params[:number_cont]
+          search_params[:number_cont] = search_params[:number_cont].split('-').first
+        end
+
+        if search_params[:created_at_gt].present?
+          search_params[:created_at_gt] = begin
+                                            Time.zone.parse(search_params[:created_at_gt]).beginning_of_day
+                                          rescue StandardError
+                                            ''
+                                          end
+        end
+
+        if search_params[:created_at_lt].present?
+          search_params[:created_at_lt] = begin
+                                            Time.zone.parse(search_params[:created_at_lt]).end_of_day
+                                          rescue StandardError
+                                            ''
+                                          end
+        end
+
+        if search_params[:completed_at_gt].present?
+          search_params[:completed_at_gt] = begin
+                                            Time.zone.parse(search_params[:completed_at_gt]).beginning_of_day
+                                          rescue StandardError
+                                            ''
+                                          end
+        end
+
+        if search_params[:completed_at_lt].present?
+          search_params[:completed_at_lt] = begin
+                                            Time.zone.parse(search_params[:completed_at_lt]).end_of_day
+                                          rescue StandardError
+                                            ''
+                                          end
+        end
+
+        search_params[:vendor_orders_vendor_id_eq] = vendor.id if vendor.present?
+        search_params[:user_id_eq] = user.id if user.present?
+
+        search_params
+      end
+
+      def load_orders
+        @search = scope.preload(:user).accessible_by(current_ability, :index).
+                  ransack(params_to_filters(search_params: params[:q].clone, vendor: @vendor, user: @user))
+
+        # lazy loading other models here (via includes) may result in an invalid query
+        # e.g. SELECT  DISTINCT DISTINCT "spree_orders".id, "spree_orders"."created_at" AS alias_0 FROM "spree_orders"
+        # see https://github.com/spree/spree/pull/3919
+        @orders = @search.result(distinct: true).page(params[:page]).per(params[:per_page])
+      end
+
+      def load_user
+        @user = Spree.user_class.find(params[:user_id]) if params[:user_id].present?
+      end
+    end
+  end
+end