solidus_backend_devise_token_auth 2.8.0.alpha.2

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module BaseHelper
+      def field_container(model, method, options = {}, &block)
+        css_classes = options[:class].to_a
+        css_classes << 'field'
+        if error_message_on(model, method).present?
+          css_classes << 'withError'
+        end
+        content_tag(:div, capture(&block), class: css_classes.join(' '), id: "#{model}_#{method}_field")
+      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 admin_hint(title, text)
+        content_tag(:span, class: 'hint-tooltip', title: title, data: { content: text }) do
+          content_tag(:i, '', class: 'fa fa-info-circle')
+        end
+      end
+
+      def datepicker_field_value(date)
+        unless date.blank?
+          l(date, format: t('spree.date_picker.format', default: '%Y/%m/%d'))
+        end
+      end
+
+      # @deprecated Render `spree/admin/shared/preference_fields/\#{preference_type}' instead
+      def preference_field_tag(name, value, options)
+        type = options.delete(:type) || :text
+        render "spree/admin/shared/preference_fields/#{type}",
+          name: name, value: value, html_options: options
+      end
+      deprecate preference_field_tag:
+        "Render `spree/admin/shared/preference_fields/\#{preference_type}' instead",
+        deprecator: Spree::Deprecation
+
+      # @deprecated Render `spree/admin/shared/preference_fields/\#{preference_type}' instead
+      def preference_field_for(form, field, options)
+        type = options.delete(:type) || :text
+        render "spree/admin/shared/preference_fields/#{type}",
+          form: form, attribute: field, html_options: options
+      end
+      deprecate preference_field_for:
+        "Render `spree/admin/shared/preference_fields/\#{preference_type}' instead",
+        deprecator: Spree::Deprecation
+
+      # @deprecated Pass an `html_options' hash into preference field partial instead
+      def preference_field_options(options)
+        field_options = case options[:type]
+                        when :integer
+          { size: 10,
+            class: 'input_integer' }
+                        when :boolean
+          {}
+                        when :string
+          { size: 10,
+            class: 'input_string fullwidth' }
+                        when :password
+          { size: 10,
+            class: 'password_string fullwidth' }
+                        when :text
+          { rows: 15,
+            cols: 85,
+            class: 'fullwidth' }
+        else
+          { size: 10,
+            class: 'input_string fullwidth' }
+        end
+
+        field_options.merge!({
+          readonly: options[:readonly],
+          disabled: options[:disabled],
+          size: options[:size]
+        })
+      end
+      deprecate preference_field_options: "Pass an `html_options' hash into " \
+        "`render('spree/admin/shared/preference_fields/\#{preference_type}')` instead)",
+        deprecator: Spree::Deprecation
+
+      # @deprecated Please render each preference keys partial instead. Example:
+      # <% @object.preferences.keys.each do |key| %>
+      #   <%= render "spree/admin/shared/preference_fields/#{@object.preference_type(key)}",
+      #     form: f, attribute: "preferred_#{key}", label: t(key, scope: 'spree') %>
+      # <% end %>
+      def preference_fields(object, form)
+        return unless object.respond_to?(:preferences)
+        capture do
+          object.preferences.keys.each do |key|
+            concat render("spree/admin/shared/preference_fields/#{object.preference_type(key)}",
+              form: form, attribute: "preferred_#{key}", label: t(key, scope: 'spree'))
+          end
+        end
+      end
+      deprecate preference_fields: "Please render each preference key's partial instead. Example: \n" \
+        "<% @object.preferences.keys.each do |key| %>\n" \
+          "<%= render \"spree/admin/shared/preference_fields/\#{@object.preference_type(key)}\", \n" \
+             "form: f, attribute: \"preferred_\#{key}\", label: t(key, scope: 'spree') %>\n" \
+        "<% end %>", deprecator: Spree::Deprecation
+
+      def link_to_add_fields(name, target, options = {})
+        name = '' if options[:no_text]
+        css_classes = options[:class] ? options[:class] + " spree_add_fields" : "spree_add_fields"
+        link_to_with_icon('plus', name, 'javascript:', data: { target: target }, class: css_classes)
+      end
+
+      # renders hidden field and link to remove record using nested_attributes
+      def link_to_remove_fields(name, form, options = {})
+        name = '' if options[:no_text]
+        options[:class] = '' unless options[:class]
+        options[:class] += 'no-text with-tip' if options[:no_text]
+        url = form.object.persisted? ? [:admin, form.object] : '#'
+        link_to_with_icon('trash', name, url, class: "spree_remove_fields #{options[:class]}", data: { action: 'remove' }, title: t('spree.actions.remove')) +
+          form.hidden_field(:_destroy)
+      end
+
+      def spree_dom_id(record)
+        dom_id(record, 'spree')
+      end
+
+      def admin_layout(layout = nil)
+        @admin_layout = layout if layout
+        @admin_layout
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module CustomerReturnsHelper
+      def reimbursement_types
+        @reimbursement_types ||= Spree::ReimbursementType.accessible_by(current_ability, :read).active
+      end
+    end
+  end
+end

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

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module NavigationHelper
+      def admin_breadcrumbs
+        @admin_breadcrumbs ||= []
+      end
+
+      # Add items to current page breadcrumb heirarchy
+      def admin_breadcrumb(*ancestors, &block)
+        admin_breadcrumbs.concat(ancestors) if ancestors.present?
+        admin_breadcrumbs.push(capture(&block)) if block_given?
+      end
+
+      # Render Bootstrap style breadcrumbs
+      def render_admin_breadcrumbs
+        if content_for?(:page_title)
+          admin_breadcrumb(content_for(:page_title))
+        end
+
+        content_tag :ol, class: 'breadcrumb' do
+          segments = admin_breadcrumbs.map do |level|
+            content_tag(:li, level, class: "breadcrumb-item #{level == admin_breadcrumbs.last ? 'active' : ''}")
+          end
+          safe_join(segments)
+        end
+      end
+
+      def admin_page_title
+        if content_for?(:title)
+          content_for(:title)
+        elsif content_for?(:page_title)
+          content_for(:page_title)
+        elsif admin_breadcrumbs.any?
+          admin_breadcrumbs.map{ |x| strip_tags(x) }.reverse.join(' - ')
+        else
+          t(controller.controller_name, default: controller.controller_name.titleize, scope: 'spree')
+        end
+      end
+
+      # Make an admin tab that coveres one or more resources supplied by symbols
+      # Option hash may follow. Valid options are
+      #   * :label to override link text, otherwise based on the first resource name (translated)
+      #   * :route to override automatically determining the default route
+      #   * :match_path as an alternative way to control when the tab is active, /products would match /admin/products, /admin/products/5/variants etc.
+      def tab(*args, &_block)
+        options = { label: args.first.to_s }
+
+        if args.last.is_a?(Hash)
+          options = options.merge(args.pop)
+        end
+        options[:route] ||= "admin_#{args.first}"
+
+        destination_url = options[:url] || spree.send("#{options[:route]}_path")
+        label = t(options[:label], scope: [:spree, :admin, :tab])
+
+        css_classes = []
+
+        if options[:icon]
+          link = link_to_with_icon(options[:icon], label, destination_url)
+          css_classes << 'tab-with-icon'
+        else
+          link = link_to(label, destination_url)
+        end
+
+        selected = if options[:match_path].is_a? Regexp
+          request.fullpath =~ options[:match_path]
+        elsif options[:match_path]
+          request.fullpath.starts_with?("#{spree.admin_path}#{options[:match_path]}")
+        else
+          request.fullpath.starts_with?(destination_url) ||
+            args.include?(controller.controller_name.to_sym)
+        end
+        css_classes << 'selected' if selected
+
+        if options[:css_class]
+          css_classes << options[:css_class]
+        end
+        content_tag('li', link + (yield if block_given?), class: css_classes.join(' ') )
+      end
+
+      def link_to_clone(resource, options = {})
+        options[:data] = { action: 'clone' }
+        options[:method] = :post
+        link_to_with_icon('copy', t('spree.clone'), clone_object_url(resource), options)
+      end
+
+      def link_to_new(resource)
+        options[:data] = { action: 'new' }
+        link_to_with_icon('plus', t('spree.new'), edit_object_url(resource))
+      end
+
+      def link_to_edit(resource, options = {})
+        url = options[:url] || edit_object_url(resource)
+        options[:data] = { action: 'edit' }
+        link_to_with_icon('edit', t('spree.actions.edit'), url, options)
+      end
+
+      def link_to_edit_url(url, options = {})
+        options[:data] = { action: 'edit' }
+        link_to_with_icon('edit', t('spree.actions.edit'), url, options)
+      end
+
+      def link_to_delete(resource, options = {})
+        url = options[:url] || object_url(resource)
+        name = options[:name] || t('spree.actions.delete')
+        confirm = options[:confirm] || t('spree.are_you_sure')
+        options[:class] = "#{options[:class]} delete-resource".strip
+        options[:data] = { confirm: confirm, action: 'remove' }
+        link_to_with_icon 'trash', name, url, options
+      end
+
+      def link_to_with_icon(icon_name, text, url, options = {})
+        options[:class] = (options[:class].to_s + " fa fa-#{icon_name} icon_link with-tip").strip
+        options[:class] += ' no-text' if options[:no_text]
+        options[:title] = text if options[:no_text]
+        text = options[:no_text] ? '' : content_tag(:span, text, class: 'text')
+        options.delete(:no_text)
+        link_to(text, url, options)
+      end
+
+      def solidus_icon(icon_name)
+        icon_name ? content_tag(:i, '', class: icon_name) : ''
+      end
+
+      alias_method :icon, :solidus_icon
+      deprecate icon: :solidus_icon, deprecator: Spree::Deprecation
+
+      def button(text, icon_name = nil, button_type = 'submit', options = {})
+        Spree::Deprecation.warn "button helper is deprecated. Instead use button_tag"
+        class_names = "button"
+        if icon_name
+          Spree::Deprecation.warn "Using icon_name arg is deprecated. Icons could not be visible in future versions.", caller
+          class_names = "fa fa-#{icon_name} #{class_names}"
+        end
+        button_tag(text, options.merge(type: button_type, class: class_names))
+      end
+
+      def button_link_to(text, url, html_options = {})
+        Spree::Deprecation.warn "Passing button_link_to is deprecated. Use either link_to or button_to instead.", caller
+        html_options = { class: '' }.merge(html_options)
+        if html_options[:method] &&
+           !html_options[:method].to_s.casecmp('get').zero? &&
+           !html_options[:remote]
+          form_tag(url, method: html_options.delete(:method)) do
+            html_options.delete(:icon)
+            button_tag(text, html_options)
+          end
+        else
+          html_options[:class] += ' button'
+
+          if html_options[:icon]
+            html_options[:class] += " fa fa-#{html_options[:icon]}"
+          end
+          link_to(text, url, html_options)
+        end
+      end
+
+      def configurations_menu_item(link_text, url, description = '')
+        %(<tr>
+          <td>#{link_to(link_text, url)}</td>
+          <td>#{description}</td>
+        </tr>
+        ).html_safe
+      end
+
+      def configurations_sidebar_menu_item(link_text, url, options = {})
+        is_active = url.ends_with?(controller.controller_name) ||
+                    url.ends_with?("#{controller.controller_name}/edit") ||
+                    url.ends_with?("#{controller.controller_name.singularize}/edit")
+        options[:class] = is_active ? 'active' : nil
+        content_tag(:li, options) do
+          link_to(link_text, url)
+        end
+      end
+
+      def settings_tab_item(link_text, url, options = {})
+        is_active = url.ends_with?(controller.controller_name) ||
+                    url.ends_with?("#{controller.controller_name}/edit") ||
+                    url.ends_with?("#{controller.controller_name.singularize}/edit")
+        options[:class] = 'fa'
+        options[:class] += ' active' if is_active
+        options[:datahook] = "admin_settings_#{link_text.downcase.tr(' ', '_')}"
+        content_tag(:li, options) do
+          link_to(link_text, url)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module OrdersHelper
+      # Renders all the extension partials that may have been specified in the extensions
+      def event_links
+        links = []
+        @order_events.sort.each do |event|
+          next unless @order.send("can_#{event}?")
+          links << button_to(t(event, scope: 'spree'), [event, :admin, @order],
+                             method: :put,
+                             data: { confirm: t('spree.order_sure_want_to', event: t(event, scope: 'spree')) })
+        end
+        safe_join(links, '&nbsp;'.html_safe)
+      end
+
+      def line_item_shipment_price(line_item, quantity)
+        Spree::Money.new(line_item.price * quantity, { currency: line_item.currency })
+      end
+
+      def avs_response_code
+        {
+          "A" => "Street address matches, but 5-digit and 9-digit postal code do not match.",
+          "B" => "Street address matches, but postal code not verified.",
+          "C" => "Street address and postal code do not match.",
+          "D" => "Street address and postal code match. ",
+          "E" => "AVS data is invalid or AVS is not allowed for this card type.",
+          "F" => "Card member's name does not match, but billing postal code matches.",
+          "G" => "Non-U.S. issuing bank does not support AVS.",
+          "H" => "Card member's name does not match. Street address and postal code match.",
+          "I" => "Address not verified.",
+          "J" => "Card member's name, billing address, and postal code match.",
+          "K" => "Card member's name matches but billing address and billing postal code do not match.",
+          "L" => "Card member's name and billing postal code match, but billing address does not match.",
+          "M" => "Street address and postal code match. ",
+          "N" => "Street address and postal code do not match.",
+          "O" => "Card member's name and billing address match, but billing postal code does not match.",
+          "P" => "Postal code matches, but street address not verified.",
+          "Q" => "Card member's name, billing address, and postal code match.",
+          "R" => "System unavailable.",
+          "S" => "Bank does not support AVS.",
+          "T" => "Card member's name does not match, but street address matches.",
+          "U" => "Address information unavailable. Returned if the U.S. bank does not support non-U.S. AVS or if the AVS in a U.S. bank is not functioning properly.",
+          "V" => "Card member's name, billing address, and billing postal code match.",
+          "W" => "Street address does not match, but 9-digit postal code matches.",
+          "X" => "Street address and 9-digit postal code match.",
+          "Y" => "Street address and 5-digit postal code match.",
+          "Z" => "Street address does not match, but 5-digit postal code matches."
+        }
+      end
+
+      def cvv_response_code
+        {
+          "M" => "CVV2 Match",
+          "N" => "CVV2 No Match",
+          "P" => "Not Processed",
+          "S" => "Issuer indicates that CVV2 data should be present on the card, but the merchant has indicated data is not present on the card",
+          "U" => "Issuer has not certified for CVV2 or Issuer has not provided Visa with the CVV2 encryption keys",
+          ""  => "Transaction failed because wrong CVV2 number was entered or no CVV2 number was entered"
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module PaymentsHelper
+      def payment_method_name(payment)
+        Spree::Deprecation.warn "payment_method_name(payment) is deprecated. Instead use payment.payment_method.name"
+        payment.payment_method.name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module ProductsHelper
+      def show_rebuild_vat_checkbox?
+        Spree::TaxRate.included_in_price.exists?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module ReimbursementTypeHelper
+      def reimbursement_type_name(reimbursement_type)
+        reimbursement_type.present? ? reimbursement_type.name.humanize : ''
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module StockLocationsHelper
+      def admin_stock_location_display_name(stock_location)
+        name_parts = [stock_location.admin_name, stock_location.name]
+        name_parts.delete_if(&:blank?)
+        name_parts.join(' / ')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module StockMovementsHelper
+      def pretty_originator(stock_movement)
+        if stock_movement.originator.respond_to?(:number)
+          if stock_movement.originator.respond_to?(:order)
+            link_to stock_movement.originator.number, [:edit, :admin, stock_movement.originator.order]
+          else
+            stock_movement.originator.number
+          end
+        else
+          ""
+        end
+      end
+
+      def display_variant(stock_movement)
+        variant = stock_movement.stock_item.variant
+        output = [variant.name]
+        output << variant.options_text unless variant.options_text.blank?
+        safe_join(output, "<br />".html_safe)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Spree::Admin::StoreCreditEventsHelper
+  mattr_accessor :originator_links
+  self.originator_links = {
+    Spree::Payment.to_s => {
+      new_tab: true,
+      href_type: :payment,
+      translation_key: 'admin.store_credits.payment_originator'
+    },
+    Spree::Refund.to_s => {
+      new_tab: true,
+      href_type: :payments,
+      translation_key: 'admin.store_credits.refund_originator'
+    }
+  }
+
+  def store_credit_event_admin_action_name(store_credit_event)
+    if Spree::StoreCreditEvent::NON_EXPOSED_ACTIONS.include?(store_credit_event.action) ||
+       store_credit_event.action == Spree::StoreCredit::VOID_ACTION
+      t("spree.store_credit.display_action.admin.#{store_credit_event.action}")
+    else
+      store_credit_event.display_action
+    end
+  end
+
+  def store_credit_event_originator_link(store_credit_event)
+    originator = store_credit_event.originator
+    return unless originator
+
+    add_user_originator_link
+    unless originator_links.key?(store_credit_event.originator.class.to_s)
+      raise "Unexpected originator type #{originator.class}"
+    end
+
+    options = {}
+    link_options = originator_links[store_credit_event.originator.class.to_s]
+    options[:target] = '_blank' if link_options[:new_tab]
+
+    # Although not all href_types are used in originator_links
+    # they are necessary because they may be used within extensions
+    case link_options[:href_type]
+    when :user
+      link_to(
+        t(link_options[:translation_key], email: originator.email, scope: 'spree'),
+        spree.edit_admin_user_path(originator),
+        options
+      )
+    when :line_item
+      order = originator.line_item.order
+      link_to(
+        t(link_options[:translation_key], order_number: order.number, scope: 'spree'),
+        spree.edit_admin_order_path(order),
+        options
+      )
+    when :payment
+      order = originator.order
+      link_to(
+        t(link_options[:translation_key], order_number: order.number, scope: 'spree'),
+        spree.admin_order_payment_path(order, originator),
+        options
+      )
+    when :payments
+      order = originator.payment.order
+      link_to(
+        t(link_options[:translation_key], order_number: order.number, scope: 'spree'),
+        spree.admin_order_payments_path(order),
+        options
+      )
+    end
+  end
+
+  private
+
+  # Cannot set the value for a user originator
+  # because Spree.user_class is not defined at that time.
+  # Spree::UserClassHandle does not work here either as
+  # the assignment is evaluated before user_class is set
+  def add_user_originator_link
+    originator_links[Spree.user_class.to_s] = {
+      new_tab: true,
+      href_type: :user,
+      translation_key: 'admin.store_credits.user_originator'
+    }
+  end
+end

data/app/helpers/spree/promotion_rules_helper.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Spree
+  module PromotionRulesHelper
+    def options_for_promotion_rule_types(promotion)
+      existing = promotion.rules.map { |rule| rule.class.name }
+      rules = Rails.application.config.spree.promotions.rules.reject { |r| existing.include? r.name }
+      options = rules.map { |rule| [rule.model_name.human, rule.name] }
+      options_for_select(options)
+    end
+  end
+end