solidus_core_devise_token_auth 2.8.0.alpha.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e34a4a1367976012b51d7d008e49a354372ba012479d77b94bc9afe4240e654c
+  data.tar.gz: e5d78924d9682dfa37440ebc402d384be9ee94c7e7895e89c31f1db8765c811d
+SHA512:
+  metadata.gz: a455c0c49627897351de0fea1317b648a78cc0d5160413585d9936ba7a8b0e241c1e5de5cf8ce2b13f7d5e82262a0c13661b4cd646547619eac9b4df15fe0f8f
+  data.tar.gz: 23d4aa3277f39ecd22f0e3190fa0c7e0729f9c7291a27ab3458b2fed6423edbd72dbd288c8b5ceebdf9e1effa071fd6dfb2a16ccd303c628202a63bafa25116f

data/.yardopts

@@ -0,0 +1 @@
+--no-private

data/LICENSE

@@ -0,0 +1,26 @@
+Copyright (c) 2007-2014, Spree Commerce, Inc. and other contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name Spree nor the names of its contributors may be used to
+      endorse or promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,69 @@
+Summary
+------
+Solidus Core provides the essential ecommerce data models upon which the
+Solidus system depends.
+
+Core models
+-----------
+Solidus implements over 200 [models](https://github.com/solidusio/solidus/tree/master/core/app/models/spree),
+and thus a deep inspection of each in this README would be overkill. Instead,
+let's take a quick look at the fundamental models upon which all else depend.
+Currently, these models remain in the Spree namespace as part of the legacy of
+[forking Spree](https://solidus.io/blog/2015/10/28/future-of-spree.html).
+
+## NOTE: Documentation is a work in progress
+The documentation of Solidus Core is still in progress. Contributions following
+this form are welcome and encouraged!
+
+* [Order sub-system](#order-sub-system)
+* [User sub-system](#user-sub-system)
+* [Payment sub-system](#payment-sub-system)
+* [Inventory sub-system](#inventory-sub-system)
+* [Shipments sub-system](#shipments-sub-system)
+
+## Order sub-system
+* `Spree::Store` - Records store specific configuration such as store name and URL.
+* `Spree::Order` - The customers cart until completed, then acts as
+permanent record of the transaction.
+* `Spree::LineItem` - Variants placed in the order at a particular price.
+
+## User sub-system
+* `Spree::LegacyUser` - Default implementation of User.
+* `Spree::UserClassHandle` - Configuration point for User model implementation.
+* [solidus_auth_devise](https://github.com/solidusio/solidus_auth_devise) -
+An official, more robust implementation of a User class with Devise
+integration.
+
+## Payment sub-system
+* `Spree::Payment` - Manage and process a payment for an order, from a specific
+source (e.g. `Spree::CreditCard`) using a specific payment method (e.g
+`Solidus::Gateway::Braintree`).
+* `Spree::PaymentMethod` - A base class which is used for implementing payment methods.
+* `Spree::PaymentMethod::CreditCard` - An implementation of a `Spree::PaymentMethod` for credit card payments.
+See https://github.com/solidusio/solidus_gateway/ for officially supported payment method implementations.
+* `Spree::CreditCard` - The `source` of a `Spree::Payment` using `Spree::PaymentMethod::CreditCard` as payment method.
+
+## Inventory sub-system
+* `Spree::ReturnAuthorization` - Models the return of Inventory Units to
+a Stock Location for an Order.
+* `Spree::StockLocation` - Records the name and addresses from which stock items
+are fulfilled in cartons.
+* `Spree::InventoryUnit` - Tracks the state of line items' fulfillment.
+* `Spree::ShippingRate` - Records the costs of different shipping methods for a
+shipment and which method has been selected to deliver the shipment.
+* `Spree::ShippingMethod` - Represents a means of having a shipment delivered,
+such as FedEx or UPS.
+
+## Shipments sub-system
+* `Spree::Shipment` - An order's planned shipments including
+tracking and cost. Shipments are fulfilled from Stock Locations.
+
+Developer notes
+---------------
+## Testing
+
+Run the tests:
+
+```bash
+bundle exec rspec
+```

data/Rakefile

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'spree/testing_support/dummy_app/rake_tasks'
+
+RSpec::Core::RakeTask.new
+task default: :spec
+
+DummyApp::RakeTasks.new(
+  gem_root: File.dirname(__FILE__),
+  lib_name: 'solidus_core'
+)
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+namespace :spec do
+  task :isolated do
+    spec_files = Dir['spec/**/*_spec.rb']
+    failed_specs =
+      spec_files.reject do |file|
+        puts "rspec #{file}"
+        system('rspec', file)
+      end
+
+    if !failed_specs.empty?
+      puts "Failed specs:"
+      puts failed_specs
+      exit 1
+    end
+  end
+end
+
+task test_app: 'db:reset'

data/app/assets/config/solidus_core_manifest.js

@@ -0,0 +1 @@
+//= link_tree ../images

data/app/assets/javascripts/spree.js.erb

@@ -0,0 +1,72 @@
+//= require jsuri
+
+window.Spree = {};
+
+Spree.ready = function(callback) {
+  if (typeof Turbolinks !== 'undefined' && Turbolinks.supported) {
+    jQuery(document).on('turbolinks:load', function() {
+      callback(jQuery);
+    });
+  } else {
+    jQuery(document).ready(callback);
+  }
+};
+
+Spree.mountedAt = function() {
+  return "<%= Rails.application.routes.url_helpers.spree_path(trailing_slash: true) %>";
+};
+
+Spree.pathFor = function(path) {
+  var locationOrigin;
+  locationOrigin = (window.location.protocol + "//" + window.location.hostname) + (window.location.port ? ":" + window.location.port : "");
+  return locationOrigin + Spree.mountedAt() + path;
+};
+
+Spree.url = function(uri, query) {
+  if (console && console.warn) {
+    console.warn('Spree.url is deprecated, and will be removed from a future Solidus version.');
+  }
+  if (uri.path === undefined) {
+    uri = new Uri(uri);
+  }
+  if (query) {
+    $.each(query, function(key, value) {
+      return uri.addQueryParam(key, value);
+    });
+  }
+  return uri;
+};
+
+Spree.ajax = function(url, options) {
+  if (typeof url === "object") {
+    options = url;
+    url = undefined;
+  }
+  options = options || {};
+  options = $.extend(options, {
+    headers: {
+      "X-Spree-Token": Spree.api_key
+    }
+  });
+  return $.ajax(url, options);
+};
+
+Spree.routes = {
+  states_search: Spree.pathFor('api/states'),
+  apply_coupon_code: function(order_id) {
+    return Spree.pathFor("api/orders/" + order_id + "/apply_coupon_code");
+  }
+};
+
+Spree.getJSON = function(url, data, success) {
+  if (typeof data === 'function') {
+    success = data;
+    data = undefined;
+  }
+  return Spree.ajax({
+    dataType: "json",
+    url: url,
+    data: data,
+    success: success
+  });
+};

data/app/controllers/spree/base_controller.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'cancan'
+require_dependency 'spree/core/controller_helpers/strong_parameters'
+
+class Spree::BaseController < ApplicationController
+  include Spree::Core::ControllerHelpers::Auth
+  include Spree::Core::ControllerHelpers::Common
+  include Spree::Core::ControllerHelpers::PaymentParameters
+  include Spree::Core::ControllerHelpers::Search
+  include Spree::Core::ControllerHelpers::Store
+  include Spree::Core::ControllerHelpers::StrongParameters
+
+  respond_to :html
+end

data/app/helpers/spree/base_helper.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'carmen'
+
+module Spree
+  module BaseHelper
+    def link_to_cart(text = nil)
+      text = text ? h(text) : t('spree.cart')
+      css_class = nil
+
+      if current_order.nil? || current_order.item_count.zero?
+        text = "#{text}: (#{t('spree.empty')})"
+        css_class = 'empty'
+      else
+        text = "#{text}: (#{current_order.item_count})  <span class='amount'>#{current_order.display_total.to_html}</span>"
+        css_class = 'full'
+      end
+
+      link_to text.html_safe, spree.cart_path, class: "cart-info #{css_class}"
+    end
+
+    # human readable list of variant options
+    def variant_options(variant, _options = {})
+      variant.options_text
+    end
+
+    def meta_data
+      object = instance_variable_get('@' + controller_name.singularize)
+      meta = {}
+
+      if object.is_a? ActiveRecord::Base
+        meta[:keywords] = object.meta_keywords if object[:meta_keywords].present?
+        meta[:description] = object.meta_description if object[:meta_description].present?
+      end
+
+      if meta[:description].blank? && object.is_a?(Spree::Product)
+        meta[:description] = truncate(strip_tags(object.description), length: 160, separator: ' ')
+      end
+
+      if meta[:keywords].blank? || meta[:description].blank?
+        meta.reverse_merge!({
+          keywords: current_store.meta_keywords,
+          description: current_store.meta_description
+        })
+      end
+      meta
+    end
+
+    def meta_data_tags
+      meta_data.map do |name, content|
+        tag('meta', name: name, content: content)
+      end.join("\n")
+    end
+
+    def body_class
+      @body_class ||= content_for?(:sidebar) ? 'two-col' : 'one-col'
+      @body_class
+    end
+
+    def logo(image_path = Spree::Config[:logo])
+      link_to image_tag(image_path), spree.root_path
+    end
+
+    def flash_messages(opts = {})
+      ignore_types = ["order_completed"].concat(Array(opts[:ignore_types]).map(&:to_s) || [])
+
+      flash.each do |msg_type, text|
+        unless ignore_types.include?(msg_type)
+          concat(content_tag(:div, text, class: "flash #{msg_type}"))
+        end
+      end
+      nil
+    end
+
+    def taxon_breadcrumbs(taxon, separator = '&nbsp;&raquo;&nbsp;', breadcrumb_class = 'inline')
+      return '' if current_page?('/') || taxon.nil?
+
+      crumbs = [[t('spree.home'), spree.root_path]]
+
+      crumbs << [t('spree.products'), products_path]
+      if taxon
+        crumbs += taxon.ancestors.collect { |a| [a.name, spree.nested_taxons_path(a.permalink)] } unless taxon.ancestors.empty?
+        crumbs << [taxon.name, spree.nested_taxons_path(taxon.permalink)]
+      end
+
+      separator = raw(separator)
+
+      items = crumbs.each_with_index.collect do |crumb, i|
+        content_tag(:li, itemprop: 'itemListElement', itemscope: '', itemtype: 'https://schema.org/ListItem') do
+          link_to(crumb.last, itemprop: 'item') do
+            content_tag(:span, crumb.first, itemprop: 'name') + tag('meta', { itemprop: 'position', content: (i + 1).to_s }, false, false)
+          end + (crumb == crumbs.last ? '' : separator)
+        end
+      end
+
+      content_tag(:nav, content_tag(:ol, raw(items.map(&:mb_chars).join), class: breadcrumb_class, itemscope: '', itemtype: 'https://schema.org/BreadcrumbList'), id: 'breadcrumbs', class: 'sixteen columns')
+    end
+
+    def taxons_tree(root_taxon, current_taxon, max_level = 1)
+      return '' if max_level < 1 || root_taxon.children.empty?
+      content_tag :ul, class: 'taxons-list' do
+        taxons = root_taxon.children.map do |taxon|
+          css_class = (current_taxon && current_taxon.self_and_ancestors.include?(taxon)) ? 'current' : nil
+          content_tag :li, class: css_class do
+           link_to(taxon.name, seo_url(taxon)) +
+             taxons_tree(taxon, current_taxon, max_level - 1)
+          end
+        end
+        safe_join(taxons, "\n")
+      end
+    end
+
+    def available_countries(restrict_to_zone: Spree::Config[:checkout_zone])
+      checkout_zone = Zone.find_by(name: restrict_to_zone)
+
+      if checkout_zone && checkout_zone.kind == 'country'
+        countries = checkout_zone.country_list
+      else
+        countries = Country.all
+      end
+
+      country_names = Carmen::Country.all.map do |country|
+        [country.code, country.name]
+      end.to_h
+
+      country_names.update I18n.t('spree.country_names', default: {}).stringify_keys
+
+      countries.collect do |country|
+        country.name = country_names.fetch(country.iso, country.name)
+        country
+      end.sort_by { |c| c.name.parameterize }
+    end
+
+    def seo_url(taxon)
+      spree.nested_taxons_path(taxon.permalink)
+    end
+
+    def display_price(product_or_variant)
+      product_or_variant.price_for(current_pricing_options).to_html
+    end
+
+    def pretty_time(time, format = :long)
+      I18n.l(time, format: :"solidus.#{format}")
+    end
+
+    def link_to_tracking(shipment, options = {})
+      return unless shipment.tracking && shipment.shipping_method
+
+      if shipment.tracking_url
+        link_to(shipment.tracking, shipment.tracking_url, options)
+      else
+        content_tag(:span, shipment.tracking)
+      end
+    end
+
+    def plural_resource_name(resource_class)
+      resource_class.model_name.human(count: Spree::I18N_GENERIC_PLURAL)
+    end
+  end
+end

data/app/helpers/spree/checkout_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Spree
+  module CheckoutHelper
+    def checkout_states
+      @order.checkout_steps
+    end
+
+    def checkout_progress
+      states = checkout_states
+      items = states.map do |state|
+        text = I18n.t("spree.order_state.#{state}").titleize
+
+        css_classes = []
+        current_index = states.index(@order.state)
+        state_index = states.index(state)
+
+        if state_index < current_index
+          css_classes << 'completed'
+          text = link_to text, checkout_state_path(state)
+        end
+
+        css_classes << 'next' if state_index == current_index + 1
+        css_classes << 'current' if state == @order.state
+        css_classes << 'first' if state_index == 0
+        css_classes << 'last' if state_index == states.length - 1
+        # It'd be nice to have separate classes but combining them with a dash helps out for IE6 which only sees the last class
+        content_tag('li', content_tag('span', text), class: css_classes.join('-'))
+      end
+      content_tag('ol', raw(items.join("\n")), class: 'progress-steps', id: "checkout-step-#{@order.state}")
+    end
+  end
+end

data/app/helpers/spree/products_helper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Spree
+  module ProductsHelper
+    # Returns the formatted price for the specified variant as a full price or
+    # a difference depending on configuration
+    #
+    # @param variant [Spree::Variant] the variant
+    # @return [Spree::Money] the price or price diff
+    def variant_price(variant)
+      if Spree::Config[:show_variant_full_price]
+        variant_full_price(variant)
+      else
+        variant_price_diff(variant)
+      end
+    end
+
+    # Returns the formatted price for the specified variant as a difference
+    # from product price
+    #
+    # @param variant [Spree::Variant] the variant
+    # @return [String] formatted string with label and amount
+    def variant_price_diff(variant)
+      return if variant.price_same_as_master?(current_pricing_options)
+      difference = variant.price_difference_from_master(current_pricing_options)
+      absolute_amount = Spree::Money.new(difference.to_d.abs, currency: difference.currency.iso_code)
+      i18n_key = difference.to_d > 0 ? :price_diff_add_html : :price_diff_subtract_html
+      t(i18n_key, scope: [:spree, :helpers, :products], amount_html: absolute_amount.to_html)
+    end
+
+    # Returns the formatted full price for the variant, if at least one variant
+    # price differs from product price.
+    #
+    # @param variant [Spree::Variant] the variant
+    # @return [Spree::Money] the full price
+    def variant_full_price(variant)
+      return if variant.product.variants
+                  .with_prices(current_pricing_options)
+                  .all? { |v| v.price_same_as_master?(current_pricing_options) }
+      variant.price_for(current_pricing_options).to_html
+    end
+
+    # Converts line breaks in product description into <p> tags.
+    #
+    # @param product [Spree::Product] the product whose description you want to filter
+    # @return [String] the generated HTML
+    def product_description(product)
+      if Spree::Config[:show_raw_product_description]
+        raw(product.description)
+      else
+        raw(product.description.gsub(/(.*?)\r?\n\r?\n/m, '<p>\1</p>'))
+      end
+    end
+
+    # Filters and truncates the given description.
+    #
+    # @param description_text [String] the text to filter
+    # @return [String] the filtered text
+    def line_item_description_text(description_text)
+      if description_text.present?
+        truncate(strip_tags(description_text.gsub('&nbsp;', ' ')), length: 100)
+      else
+        t('spree.product_has_no_description')
+      end
+    end
+
+    # @return [String] a cache invalidation key for products
+    def cache_key_for_products
+      count = @products.count
+      max_updated_at = (@products.maximum(:updated_at) || Date.today).to_s(:number)
+      "#{I18n.locale}/#{current_pricing_options.cache_key}/spree/products/all-#{params[:page]}-#{max_updated_at}-#{count}"
+    end
+  end
+end

data/app/helpers/spree/store_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Spree
+  # Methods added to this helper will be available to all templates in the
+  # frontend.
+  module StoreHelper
+    # @return [Boolean] true when it is appropriate to show the store menu
+    def store_menu?
+      %w{thank_you}.exclude? params[:action]
+    end
+
+    def cache_key_for_taxons
+      Spree::Deprecation.warn <<-WARN.strip_heredoc
+        cache_key_for_taxons is deprecated. Rails >= 5 has built-in support for collection cache keys.
+        Instead in your view use:
+        cache [I18n.locale, @taxons] do
+      WARN
+      max_updated_at = @taxons.maximum(:updated_at).to_i
+      parts = [@taxon.try(:id), max_updated_at].compact.join("-")
+      "#{I18n.locale}/taxons/#{parts}"
+    end
+  end
+end

data/app/helpers/spree/taxons_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Spree
+  module TaxonsHelper
+    # Retrieves the collection of products to display when "previewing" a taxon.  This is abstracted into a helper so
+    # that we can use configurations as well as make it easier for end users to override this determination.  One idea is
+    # to show the most popular products for a particular taxon (that is an exercise left to the developer.)
+    def taxon_preview(taxon, max = 4)
+      price_scope = Spree::Price.where(current_pricing_options.search_arguments)
+      products = taxon.active_products.joins(:prices).merge(price_scope).select("DISTINCT (spree_products.id), spree_products.*, spree_products_taxons.position").limit(max)
+      if products.size < max
+        products_arel = Spree::Product.arel_table
+        taxon.descendants.each do |descendent_taxon|
+          to_get = max - products.length
+          products += descendent_taxon.active_products.joins(:prices).merge(price_scope).select("DISTINCT (spree_products.id), spree_products.*, spree_products_taxons.position").where(products_arel[:id].not_in(products.map(&:id))).limit(to_get)
+          break if products.size >= max
+        end
+      end
+      products
+    end
+  end
+end

data/app/jobs/spree/promotion_code_batch_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionCodeBatchJob < ActiveJob::Base
+    queue_as :default
+
+    def perform(promotion_code_batch)
+      PromotionCode::BatchBuilder.new(
+        promotion_code_batch
+      ).build_promotion_codes
+
+      if promotion_code_batch.email?
+        Spree::Config.promotion_code_batch_mailer_class
+          .promotion_code_batch_finished(promotion_code_batch)
+          .deliver_now
+      end
+    rescue StandardError => e
+      if promotion_code_batch.email?
+        Spree::Config.promotion_code_batch_mailer_class
+          .promotion_code_batch_errored(promotion_code_batch)
+          .deliver_now
+      end
+      raise e
+    end
+  end
+end

data/app/mailers/spree/base_mailer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Spree
+  class BaseMailer < ActionMailer::Base
+    def from_address(store)
+      store.mail_from_address
+    end
+
+    def money(amount, currency = Spree::Config[:currency])
+      Spree::Money.new(amount, currency: currency).to_s
+    end
+    helper_method :money
+
+    def mail(headers = {}, &block)
+      super if Spree::Config[:send_core_emails]
+    end
+  end
+end

data/app/mailers/spree/carton_mailer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Spree
+  class CartonMailer < BaseMailer
+    # Send an email to customers to notify that an individual carton has been
+    # shipped. If a carton contains items from multiple orders then this will be
+    # called with that carton one time for each order.
+    #
+    # @param carton [Spree::Carton] the shipped carton
+    # @param order [Spree::Order] one of the orders with items in the carton
+    # @param resend [Boolean] indicates whether the email is a 'resend' (e.g.
+    #        triggered by the admin "resend" button)
+    # @return [Mail::Message]
+    #
+    # Note: The signature of this method has changed. The new (non-deprecated)
+    # signature is:
+    #   def shipped_email(carton:, order:, resend: false)
+    def shipped_email(options, _deprecated_options = {})
+      @order = options.fetch(:order)
+      @carton = options.fetch(:carton)
+      @manifest = @carton.manifest_for_order(@order)
+      options = { resend: false }.merge(options)
+      @store = @order.store
+      subject = (options[:resend] ? "[#{t('spree.resend').upcase}] " : '')
+      subject += "#{@store.name} #{t('spree.shipment_mailer.shipped_email.subject')} ##{@order.number}"
+      mail(to: @order.email, from: from_address(@store), subject: subject)
+    end
+  end
+end

data/app/mailers/spree/order_mailer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Spree
+  class OrderMailer < BaseMailer
+    def confirm_email(order, resend = false)
+      @order = order
+      @store = @order.store
+      subject = build_subject(t('.subject'), resend)
+
+      mail(to: @order.email, from: from_address(@store), subject: subject)
+    end
+
+    def cancel_email(order, resend = false)
+      @order = order
+      @store = @order.store
+      subject = build_subject(t('.subject'), resend)
+
+      mail(to: @order.email, from: from_address(@store), subject: subject)
+    end
+
+    def inventory_cancellation_email(order, inventory_units, resend = false)
+      @order, @inventory_units = order, inventory_units
+      @store = @order.store
+      subject = build_subject(t('spree.order_mailer.inventory_cancellation.subject'), resend)
+
+      mail(to: @order.email, from: from_address(@store), subject: subject)
+    end
+
+    private
+
+    def build_subject(subject_text, resend)
+      resend_text = (resend ? "[#{t('spree.resend').upcase}] " : '')
+      "#{resend_text}#{@order.store.name} #{subject_text} ##{@order.number}"
+    end
+  end
+end