Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
Newsletter subscribers (#13060)
Szymon Chorobskid68c55af2df1
diff --git a/common_spree_dependencies.rb b/common_spree_dependencies.rbindex 521bd2d1c7..73116ac35f 100644--- a/common_spree_dependencies.rb+++ b/common_spree_dependencies.rb@@ -39,6 +39,7 @@ group :test dogem 'timecop'gem 'test-prof'gem 'rails-controller-testing'+ gem 'shoulda-matchers', '~> 6.0'endgroup :test, :development dodiff --git a/core/app/models/spree/newsletter_subscriber.rb b/core/app/models/spree/newsletter_subscriber.rbnew file mode 100644index 0000000000..5571ef5df6--- /dev/null+++ b/core/app/models/spree/newsletter_subscriber.rb@@ -0,0 +1,35 @@+require_dependency 'spree/newsletter_subscriber/emails'++module Spree+ class NewsletterSubscriber < Spree.base_class+ include Spree::NewsletterSubscriber::Emails++ has_secure_token :verification_token++ belongs_to :user, optional: true, class_name: Spree.user_class.name++ validates :email,+ presence: true,+ format: { with: URI::MailTo::EMAIL_REGEXP },+ uniqueness: { case_sensitive: false }++ scope :verified, -> { where.not(verified_at: nil) }+ scope :unverified, -> { where(verified_at: nil) }++ normalizes :email, with: ->(email) { email.to_s.strip.downcase.presence }++ def verified?+ verified_at.present?+ end++ def self.subscribe(email:, user: nil)+ Spree::Newsletter::Subscribe.new(email: email, user: user).call+ end++ def self.verify(token:)+ subscriber = unverified.find_by!(verification_token: token)++ Spree::Newsletter::Verify.new(subscriber: subscriber).call+ end+ end+enddiff --git a/core/app/models/spree/newsletter_subscriber/emails.rb b/core/app/models/spree/newsletter_subscriber/emails.rbnew file mode 100644index 0000000000..459a533071--- /dev/null+++ b/core/app/models/spree/newsletter_subscriber/emails.rb@@ -0,0 +1,12 @@+module Spree+ class NewsletterSubscriber < Spree.base_class+ module Emails+ extend ActiveSupport::Concern++ def deliver_newsletter_email_verification+ # you can overwrite this method in your application / extension to send out the confirmation email+ # or use `spree_emails` gem+ end+ end+ end+enddiff --git a/core/app/services/spree/newsletter/subscribe.rb b/core/app/services/spree/newsletter/subscribe.rbnew file mode 100644index 0000000000..c87825efba--- /dev/null+++ b/core/app/services/spree/newsletter/subscribe.rb@@ -0,0 +1,45 @@+module Spree+ module Newsletter+ class Subscribe+ def initialize(email:, user: nil)+ @email = email+ @user = user+ end++ def call+ return existed_subscription if existed_subscription.present?++ ActiveRecord::Base.transaction do+ upsert_subscriber+ return subscriber if subscriber.errors.any?++ if subscriber.email == user&.email+ # no need to verified since user email is already verified+ Spree::Newsletter::Verify.new(subscriber: subscriber).call+ end+ end++ # deliver confirmation email after the transaction is completed+ subscriber.deliver_newsletter_email_verification unless subscriber.verified?+ subscriber+ end++ private++ attr_reader :email, :user++ def upsert_subscriber+ @upsert_subscriber ||= Spree::NewsletterSubscriber.where(email: email).first_or_create do |new_record|+ new_record.user = Spree.user_class.find_by(email: new_record.email)+ rescue ActiveRecord::RecordNotFound+ retry+ end+ end+ alias_method :subscriber, :upsert_subscriber++ def existed_subscription+ @existed_subscription ||= Spree::NewsletterSubscriber.verified.find_by(email: email)+ end+ end+ end+enddiff --git a/core/app/services/spree/newsletter/verify.rb b/core/app/services/spree/newsletter/verify.rbnew file mode 100644index 0000000000..b9a2613411--- /dev/null+++ b/core/app/services/spree/newsletter/verify.rb@@ -0,0 +1,30 @@+module Spree+ module Newsletter+ class Verify+ def initialize(subscriber:)+ @subscriber = subscriber+ end++ def call+ verify_subscriber+ set_user_email_marketing_to_true++ subscriber+ end++ private++ attr_reader :subscriber++ def verify_subscriber+ subscriber.update!(verified_at: Time.current, verification_token: nil)+ end++ def set_user_email_marketing_to_true+ return if subscriber.user.blank?++ subscriber.user.update!(accepts_email_marketing: true)+ end+ end+ end+enddiff --git a/core/config/locales/en.yml b/core/config/locales/en.ymlindex 10cdb61643..ca35a931d5 100644--- a/core/config/locales/en.yml+++ b/core/config/locales/en.yml@@ -1351,6 +1351,16 @@ en:new_user: New Usernew_variant: New Variantnew_zone: New Zone+ newsletter_mailer:+ email_confirmation:+ dear_customer: Hey,+ ignore_disclaimer: If you didn't request this, please ignore this email.+ instructions: Please click the button below to verify your email address.+ message_copy_link: 'If the button doesn''t work please copy and paste the following link to your browser:'+ store_team: "%{store_name} Team"+ subject: Verify your email address+ thanks: Thank you+ verify_email_address_link: Verify email addressnewsletters: Newslettersnext: Nextno_actions_added: No actions addeddiff --git a/core/db/migrate/20250826093602_create_spree_newsletter_subscribers.rb b/core/db/migrate/20250826093602_create_spree_newsletter_subscribers.rbnew file mode 100644index 0000000000..b9bcb08633--- /dev/null+++ b/core/db/migrate/20250826093602_create_spree_newsletter_subscribers.rb@@ -0,0 +1,12 @@+class CreateSpreeNewsletterSubscribers < ActiveRecord::Migration[7.2]+ def change+ create_table :spree_newsletter_subscribers do |t|+ t.string :email, index: { unique: true }, null: false+ t.references :user, index: true+ t.datetime :verified_at, index: true+ t.string :verification_token, index: { unique: true }++ t.timestamps+ end+ end+enddiff --git a/core/lib/spree/testing_support/factories/newsletter_subscriber_factory.rb b/core/lib/spree/testing_support/factories/newsletter_subscriber_factory.rbnew file mode 100644index 0000000000..c32f54846a--- /dev/null+++ b/core/lib/spree/testing_support/factories/newsletter_subscriber_factory.rb@@ -0,0 +1,18 @@+FactoryBot.define do+ factory :newsletter_subscriber, class: Spree::NewsletterSubscriber do+ email { FFaker::Internet.unique.email }+ verified_at { nil }++ trait :with_user do+ association :user, factory: :user+ end++ trait :verified do+ verified_at { Time.current }+ end++ trait :unverified do+ verified_at { nil }+ end+ end+enddiff --git a/core/lib/tasks/core.rake b/core/lib/tasks/core.rakeindex fa574d2793..4d39956a75 100644--- a/core/lib/tasks/core.rake+++ b/core/lib/tasks/core.rake@@ -258,4 +258,22 @@ namespace :core dotask archive_products: :environment do |_t, _args|Spree::Product.where('discontinue_on <= ?', Time.current).where.not(status: 'archived').update_all(status: 'archived', updated_at: Time.current)end++ desc 'Migrate newsletter subscribers'+ task migrate_newsletter_subscribers: :environment do |_t, _args|+ Spree.user_class.where(accepts_email_marketing: true).in_batches(of: 500) do |user_batch|+ subscriber_attributes = user_batch.pluck(:id, :email, :updated_at).map do |id, email, updated_at|+ {+ email: Spree::NewsletterSubscriber.new(email: email).email, # normalized email+ user_id: id,+ verified_at: updated_at,+ verification_token: nil,+ updated_at: DateTime.current,+ created_at: DateTime.current+ }+ end++ Spree::NewsletterSubscriber.insert_all(subscriber_attributes.uniq { |attrs| attrs[:email] })+ end+ endenddiff --git a/core/spec/lib/tasks/core_spec.rb b/core/spec/lib/tasks/core_spec.rbindex 54c5a95da8..26bb7e3b2a 100644--- a/core/spec/lib/tasks/core_spec.rb+++ b/core/spec/lib/tasks/core_spec.rb@@ -34,6 +34,33 @@ describe 'core:activate_products' doendend+describe 'core:migrate_newsletter_subscribers' do+ include_context 'rake'++ let!(:user) { create(:user, accepts_email_marketing: true) }+ let(:conflicted_user) { create(:user, accepts_email_marketing: true) }++ before do+ create_list(:user, 5, accepts_email_marketing: true)+ create_list(:user, 5, accepts_email_marketing: false)+ create(:newsletter_subscriber, :verified, email: conflicted_user.email, user: conflicted_user)+ end++ it 'migrates newsletter subscribers' do+ subject.invoke++ expect(Spree::NewsletterSubscriber.unverified.count).to eq(0)+ expect(Spree::NewsletterSubscriber.verified.count).to eq(7)+ expect(Spree::NewsletterSubscriber.find_by(user: user).attributes).to include(+ 'email' => user.email,+ 'verified_at' => user.updated_at,+ 'verification_token' => nil,+ 'updated_at' => kind_of(ActiveSupport::TimeWithZone),+ 'created_at' => kind_of(ActiveSupport::TimeWithZone)+ )+ end+end+describe 'core:archive_products' doinclude_context 'rake'diff --git a/core/spec/models/spree/newsletter_subscriber_spec.rb b/core/spec/models/spree/newsletter_subscriber_spec.rbnew file mode 100644index 0000000000..6b3f264320--- /dev/null+++ b/core/spec/models/spree/newsletter_subscriber_spec.rb@@ -0,0 +1,115 @@+require 'spec_helper'++describe Spree::NewsletterSubscriber, type: :model do+ subject(:subscriber) { build(:newsletter_subscriber, email: email) }++ let(:email) { 'joe#example.com' }++ describe 'normalizations' do+ it { is_expected.to normalize(:email).from(" [email protected]\n").to('[email protected]') }+ it { is_expected.to normalize(:email).from('').to(nil) }+ it { is_expected.to normalize(:email).from(nil).to(nil) }+ end++ describe 'validations' do+ it { is_expected.to validate_presence_of(:email) }+ it { is_expected.to validate_uniqueness_of(:email).ignoring_case_sensitivity }+ it { is_expected.to allow_value('[email protected]').for(:email) }+ it { is_expected.not_to allow_value('test@').for(:email) }+ end++ describe 'scopes' do+ let!(:verified_subscriber) { create(:newsletter_subscriber, :verified) }+ let!(:unverified_subscriber) { create(:newsletter_subscriber, :unverified) }++ describe 'verified' do+ it 'returns verified subscribers only' do+ expect(described_class.verified).to eq([verified_subscriber])+ end+ end++ describe 'unverified' do+ it 'returns unverified subscribers only' do+ expect(described_class.unverified).to eq([unverified_subscriber])+ end+ end+ end++ describe 'subscribe' do+ let(:subscribe_service) { double(Spree::Newsletter::Subscribe) }++ context 'with user' do+ subject { described_class.subscribe(email: email, user: user) }++ let(:user) { create(:user) }++ before do+ allow(Spree::Newsletter::Subscribe).to receive(:new).with(email: email, user: user).and_return(subscribe_service)+ end++ it 'calls subscribe service' do+ expect(subscribe_service).to receive(:call)++ subject+ end+ end++ context 'without user' do+ subject { described_class.subscribe(email: email) }++ before do+ allow(Spree::Newsletter::Subscribe).to receive(:new).with(email: email, user: nil).and_return(subscribe_service)+ end++ it 'calls subscribe service' do+ expect(subscribe_service).to receive(:call)++ subject+ end+ end+ end++ describe 'verify' do+ subject { described_class.verify(token: token) }++ context 'when subscriber is found' do+ let(:subscriber) { create(:newsletter_subscriber, :unverified) }+ let(:token) { subscriber.verification_token }+ let(:verify_service) { double(Spree::Newsletter::Verify) }++ before do+ allow(Spree::Newsletter::Verify).to receive(:new).with(subscriber: kind_of(described_class)).and_return(verify_service)+ end++ it 'calls verify service' do+ expect(verify_service).to receive(:call)++ subject+ end+ end++ context 'when subscriber is not found' do+ let(:token) { 'invalid-token' }++ it 'returns ActiveRecord::RecordNotFound' do+ expect { subject }.to raise_error(ActiveRecord::RecordNotFound)+ end+ end+ end++ describe 'verified?' do+ subject { subscriber.verified? }++ context 'when email is not verified' do+ let(:subscriber) { create(:newsletter_subscriber, :unverified) }++ it { is_expected.to be_falsy }+ end++ context 'when email is verified' do+ let(:subscriber) { create(:newsletter_subscriber, :verified) }++ it { is_expected.to be_truthy }+ end+ end+enddiff --git a/core/spec/services/spree/newsletter/subscribe_spec.rb b/core/spec/services/spree/newsletter/subscribe_spec.rbnew file mode 100644index 0000000000..21e45bb603--- /dev/null+++ b/core/spec/services/spree/newsletter/subscribe_spec.rb@@ -0,0 +1,109 @@+require 'spec_helper'++module Spree+ describe Newsletter::Subscribe do+ subject(:service) { described_class.new(**params).call }++ let(:params) do+ {+ email: email,+ user: user+ }+ end++ let(:email) { '[email protected]' }+ let(:user) { nil }++ context 'with invalid params' do+ let(:email) { 'hehe' }++ it 'returns a record with errors' do+ expect(service.errors).to be_present+ end++ it 'does not send a confirmation email' do+ expect_any_instance_of(Spree::NewsletterSubscriber).not_to receive(:deliver_newsletter_email_verification)++ service+ end++ it 'does not create a new record' do+ expect { service }.not_to change(Spree::NewsletterSubscriber, :count)+ end+ end++ context 'when logged in user has the same email as inputed email' do+ let(:user) { create(:user) }+ let(:email) { user.email }++ it 'returns an instance of NewsletterSubscriber' do+ expect(service).to be_a(NewsletterSubscriber)+ end++ it 'does not send a confirmation email' do+ expect_any_instance_of(Spree::NewsletterSubscriber).not_to receive(:deliver_newsletter_email_verification)++ service+ end++ it 'creates a new verified subscriber' do+ expect { service }.to change { Spree::NewsletterSubscriber.verified.count }.by(1)+ end+ end++ context 'when logged in user inputs another email' do+ let(:user) { create(:user) }+ let(:email) { '[email protected]' }++ it 'sends a confirmation email' do+ expect_any_instance_of(Spree::NewsletterSubscriber).to receive(:deliver_newsletter_email_verification).once++ service+ end++ it 'returns an instance of NewsletterSubscriber' do+ expect(service).to be_a(NewsletterSubscriber)+ end++ it 'creates a new unverified subscriber' do+ expect { service }.to change { Spree::NewsletterSubscriber.unverified.count }.by(1)+ end+ end++ context 'when verified subscription already exists' do+ let!(:subscriber) { create(:newsletter_subscriber, :verified, email: email) }++ it 'returns an instance of NewsletterSubscriber' do+ expect(service).to be_a(NewsletterSubscriber)+ end++ it 'does not create new subscriber' do+ expect { service }.not_to change(Spree::NewsletterSubscriber, :count)+ end++ it 'does not send a confirmation email' do+ expect_any_instance_of(Spree::NewsletterSubscriber).not_to receive(:deliver_newsletter_email_verification)++ service+ end+ end++ context 'when unverified subscription has been already created' do+ let!(:subscriber) { create(:newsletter_subscriber, :unverified, email: email) }++ it 'returns an instance of NewsletterSubscriber' do+ expect(service).to be_a(NewsletterSubscriber)+ end++ it 'does not create new subscriber' do+ expect { service }.not_to change(Spree::NewsletterSubscriber, :count)+ end++ it 'sends a confirmation email' do+ expect_any_instance_of(Spree::NewsletterSubscriber).to receive(:deliver_newsletter_email_verification).once++ service+ end+ end+ end+enddiff --git a/core/spec/services/spree/newsletter/verify_spec.rb b/core/spec/services/spree/newsletter/verify_spec.rbnew file mode 100644index 0000000000..f2dfcdbafb--- /dev/null+++ b/core/spec/services/spree/newsletter/verify_spec.rb@@ -0,0 +1,41 @@+require 'spec_helper'++module Spree+ describe Newsletter::Verify do+ subject(:service) { described_class.new(**params).call }++ let(:params) do+ {+ subscriber: subscriber+ }+ end++ let(:subscriber) { create(:newsletter_subscriber, :unverified, user: user) }++ around do |example|+ Timecop.freeze('2137-01-01') { example.run }+ end++ context 'with associated user' do+ let(:user) { create(:user, accepts_email_marketing: false) }++ it 'verifies a subscription' do+ expect { service }.to change { subscriber.reload.verified_at }.from(nil).to('2137-01-01'.to_datetime).+ and change { subscriber.reload.verification_token }.to(nil)+ end++ it 'updates user email marketing attribute' do+ expect { service }.to change { subscriber.user.accepts_email_marketing }.to(true)+ end+ end++ context 'without user' do+ let(:user) { nil }++ it 'verifies a subscription' do+ expect { service }.to change { subscriber.reload.verified_at }.from(nil).to('2137-01-01'.to_datetime).+ and change { subscriber.reload.verification_token }.to(nil)+ end+ end+ end+enddiff --git a/core/spec/spec_helper.rb b/core/spec/spec_helper.rbindex 4db41f3faf..4bce192d2d 100644--- a/core/spec/spec_helper.rb+++ b/core/spec/spec_helper.rb@@ -35,6 +35,7 @@ endrequire 'rspec/rails'require 'database_cleaner/active_record'require 'ffaker'+require 'shoulda-matchers'Dir['./spec/support/**/*.rb'].sort.each { |f| require f }@@ -87,3 +88,10 @@ RSpec.configure do |config|config.order = :randomKernel.srand config.seedend++Shoulda::Matchers.configure do |config|+ config.integrate do |with|+ with.test_framework :rspec+ with.library :rails+ end+enddiff --git a/emails/app/mailers/spree/newsletter_mailer.rb b/emails/app/mailers/spree/newsletter_mailer.rbnew file mode 100644index 0000000000..53c8594e95--- /dev/null+++ b/emails/app/mailers/spree/newsletter_mailer.rb@@ -0,0 +1,9 @@+module Spree+ class NewsletterMailer < BaseMailer+ def email_confirmation(subscriber)+ @subscriber = subscriber+ @confirm_email_url = spree.verify_newsletter_subscribers_url(token: @subscriber.verification_token, host: Spree::Store.default.url)+ mail(to: @subscriber.email, from: from_address, subject: Spree.t('newsletter_mailer.email_confirmation.subject'))+ end+ end+enddiff --git a/emails/app/models/spree/newsletter_subscriber/emails.rb b/emails/app/models/spree/newsletter_subscriber/emails.rbnew file mode 100644index 0000000000..041653e61a--- /dev/null+++ b/emails/app/models/spree/newsletter_subscriber/emails.rb@@ -0,0 +1,9 @@+module Spree+ class NewsletterSubscriber < Spree.base_class+ module Emails+ def deliver_newsletter_email_verification+ NewsletterMailer.email_confirmation(self).deliver_later+ end+ end+ end+enddiff --git a/emails/app/views/spree/newsletter_mailer/email_confirmation.html.erb b/emails/app/views/spree/newsletter_mailer/email_confirmation.html.erbnew file mode 100644index 0000000000..66b7bbba20--- /dev/null+++ b/emails/app/views/spree/newsletter_mailer/email_confirmation.html.erb@@ -0,0 +1,23 @@+<h1><%= Spree.t('newsletter_mailer.email_confirmation.dear_customer') %></h1>++<p><%= Spree.t('newsletter_mailer.email_confirmation.instructions') %></p>++<p class="align-center">+<%= link_to Spree.t('newsletter_mailer.email_confirmation.verify_email_address_link'), @confirm_email_url, class: 'button' %>+</p>++<p>+ <%= Spree.t('newsletter_mailer.email_confirmation.message_copy_link') %>+ <br>+ <span style="word-break: break-all;">+ <%= link_to @confirm_email_url, @confirm_email_url %>+ </span>+</p>++<p><%= Spree.t('newsletter_mailer.email_confirmation.ignore_disclaimer') %></p>++<p>+ <%= Spree.t('newsletter_mailer.email_confirmation.thanks') %>+ <br />+ <%= Spree.t('newsletter_mailer.email_confirmation.store_team', store_name: current_store.name) %>+</p>\ No newline at end of filediff --git a/emails/app/views/spree/newsletter_mailer/email_confirmation.text.erb b/emails/app/views/spree/newsletter_mailer/email_confirmation.text.erbnew file mode 100644index 0000000000..ac62cbb570--- /dev/null+++ b/emails/app/views/spree/newsletter_mailer/email_confirmation.text.erb@@ -0,0 +1,9 @@+<%= Spree.t('newsletter_mailer.email_confirmation.dear_customer') %>+<%= Spree.t('newsletter_mailer.email_confirmation.instructions') %>++<%= @confirm_email_url %>++<%= Spree.t('newsletter_mailer.email_confirmation.ignore_disclaimer') %>+============================================================+<%= Spree.t('newsletter_mailer.email_confirmation.thanks') %>+<%= Spree.t('newsletter_mailer.email_confirmation.store_team', store_name: current_store.name) %>diff --git a/emails/spec/models/spree/newsletter_subscriber_spec.rb b/emails/spec/models/spree/newsletter_subscriber_spec.rbnew file mode 100644index 0000000000..bd60b3e67f--- /dev/null+++ b/emails/spec/models/spree/newsletter_subscriber_spec.rb@@ -0,0 +1,14 @@+require 'spec_helper'+describe Spree::NewsletterSubscriber, type: :model do+ let(:subscriber) { create(:newsletter_subscriber) }++ describe '#deliver_newsletter_email_verification' do+ subject(:deliver_newsletter_email_verification) { subscriber.deliver_newsletter_email_verification }++ it 'calls newsletter mailer' do+ expect(Spree::NewsletterMailer).to receive(:email_confirmation).with(subscriber).and_return(double(deliver_later: true))++ deliver_newsletter_email_verification+ end+ end+enddiff --git a/storefront/app/controllers/spree/account/newsletter_controller.rb b/storefront/app/controllers/spree/account/newsletter_controller.rbindex 0161e20794..3491f80e59 100644--- a/storefront/app/controllers/spree/account/newsletter_controller.rb+++ b/storefront/app/controllers/spree/account/newsletter_controller.rb@@ -14,8 +14,10 @@ module Spree}if try_spree_current_user.accepts_email_marketing?+ Spree::NewsletterSubscriber.subscribe(email: try_spree_current_user.email, user: try_spree_current_user)track_event('subscribed_to_newsletter', event_properties)else+ Spree::NewsletterSubscriber.find_by(email: try_spree_current_user.email)&.destroytrack_event('unsubscribed_from_newsletter', event_properties)endenddiff --git a/storefront/app/controllers/spree/newsletter_subscribers_controller.rb b/storefront/app/controllers/spree/newsletter_subscribers_controller.rbindex 010738444a..35f67f6b4e 100644--- a/storefront/app/controllers/spree/newsletter_subscribers_controller.rb+++ b/storefront/app/controllers/spree/newsletter_subscribers_controller.rb@@ -2,24 +2,19 @@ module Spreeclass NewsletterSubscribersController < StoreControllerskip_before_action :redirect_to_passwordbefore_action :load_newsletter_section, only: :create+ rescue_from ActiveRecord::RecordNotFound, with: :subscriber_not_found# POST /newsletter_subscribersdef create- user = Spree.user_class.find_or_initialize_by(email: newsletter_params[:email])+ subscriber = Spree::NewsletterSubscriber.subscribe(email: newsletter_params[:email], user: try_spree_current_user)- if user.new_record? && user.respond_to?(:password) && user.respond_to?(:password_confirmation)- user.password ||= SecureRandom.hex(16) # we need to set a password to pass validation- user.password_confirmation ||= user.password- end-- user.accepts_email_marketing = true if user.new_record? || try_spree_current_user == user-- if user.save- track_event('subscribed_to_newsletter', { email: user.email, user: user })-- flash[:success] = Spree.t('storefront.newsletter_subscribers.success')+ if subscriber.errors.any?+ flash[:error] = subscriber.errors.full_messages.to_sentence.presence || Spree.t('something_went_wrong')+ elsif subscriber.verified? && subscriber.previous_changes.blank?+ flash[:notice] = Spree.t('storefront.newsletter_subscribers.already_subscribed')else- flash[:error] = user.errors.full_messages.to_sentence.presence || Spree.t('something_went_wrong')+ track_event('subscribed_to_newsletter', { email: subscriber.email, user: try_spree_current_user })+ flash[:success] = Spree.t('storefront.newsletter_subscribers.success')endrespond_to do |format|@@ -28,8 +23,23 @@ module Spreeendend+ # GET /newsletter_subscribers/verify?token=VERIFICATION_TOKEN+ def verify+ subscriber = Spree::NewsletterSubscriber.verify(token: params[:token])++ if subscriber.verified?+ redirect_to spree.root_path, notice: Spree.t('storefront.newsletter_subscribers.verified')+ else+ redirect_to spree.root_path, alert: Spree.t('storefront.newsletter_subscribers.verification_failed')+ end+ end+private+ def subscriber_not_found+ redirect_to spree.root_path, alert: Spree.t('storefront.newsletter_subscribers.verification_failed')+ end+def newsletter_paramsparams.require(:newsletter).permit(:email)enddiff --git a/storefront/config/locales/en.yml b/storefront/config/locales/en.ymlindex 35cfeb47a9..92da1b7160 100644--- a/storefront/config/locales/en.yml+++ b/storefront/config/locales/en.yml@@ -50,7 +50,10 @@ en:message_not_sent: Unfortunately we weren't able to send the email at this time. Please try again latermessage_sent: Message sent!newsletter_subscribers:+ already_subscribed: You are already subscribed to our newslettersuccess: Thank you for subscribing to our newsletter!+ verification_failed: Verification failed+ verified: Your email has been verified!newsletter_subscription:description: Take control of your settings and tailor your experience according to your preferences. Customize your notifications to suit your needs.join: Email me about new products, sales, and more. You can unsubscribe at any time.diff --git a/storefront/config/routes.rb b/storefront/config/routes.rbindex 1943f5e5d0..192e7647c2 100644--- a/storefront/config/routes.rb+++ b/storefront/config/routes.rb@@ -75,7 +75,9 @@ Spree::Core::Engine.add_routes doresource :settings, only: [:update, :show]# Newsletter- resources :newsletter_subscribers, only: [:create]+ resources :newsletter_subscribers, only: [:create] do+ get :verify, on: :collection+ end# Contact formresources :contacts, only: [:new, :create]diff --git a/storefront/spec/controllers/spree/account/newsletter_controller_spec.rb b/storefront/spec/controllers/spree/account/newsletter_controller_spec.rbindex c409ea4e46..d0b5659530 100644--- a/storefront/spec/controllers/spree/account/newsletter_controller_spec.rb+++ b/storefront/spec/controllers/spree/account/newsletter_controller_spec.rb@@ -7,8 +7,7 @@ RSpec.describe Spree::Account::NewsletterController, type: :controller dorender_viewsbefore do- allow(controller).to receive(:current_store).and_return(store)- allow(controller).to receive(:try_spree_current_user).and_return(user)+ allow(controller).to receive_messages(current_store: store, try_spree_current_user: user)enddescribe 'GET #edit' do@@ -34,6 +33,10 @@ RSpec.describe Spree::Account::NewsletterController, type: :controller doexpect(response).to have_http_status(:ok)expect(user.reload.accepts_email_marketing).to be(true)end++ it 'creates newsletter subscriber record' do+ expect { subject }.to change { Spree::NewsletterSubscriber.where(email: user.email, user: user).count }.by(1)+ endendcontext 'when user unsubscribes from the newsletter' do@@ -46,6 +49,17 @@ RSpec.describe Spree::Account::NewsletterController, type: :controller doexpect(response).to have_http_status(:ok)expect(user.reload.accepts_email_marketing).to be(false)end++ context 'with newsletter subscriber record' do+ before do+ create(:newsletter_subscriber, email: user.email, user: user)+ create(:newsletter_subscriber, email: '[email protected]')+ end++ it 'removes newsletter subscriber record' do+ expect { subject }.to change { Spree::NewsletterSubscriber.where(email: user.email, user: user).count }.by(-1)+ end+ endendendenddiff --git a/storefront/spec/controllers/spree/newsletter_subscribers_controller_spec.rb b/storefront/spec/controllers/spree/newsletter_subscribers_controller_spec.rbindex 8599ebd649..9b16504379 100644--- a/storefront/spec/controllers/spree/newsletter_subscribers_controller_spec.rb+++ b/storefront/spec/controllers/spree/newsletter_subscribers_controller_spec.rb@@ -10,42 +10,102 @@ RSpec.describe Spree::NewsletterSubscribersController, type: :controller doenddescribe 'POST #create' do- let(:newsletter_params) { { newsletter: { email: '[email protected]' } } }- let(:user) { create(:user) }+ subject(:request) { post :create, params: newsletter_params, format: request_format }- context 'with valid params' do- it 'creates a new newsletter subscription' do- expect {- post :create, params: newsletter_params- }.to change { Spree.user_class.where(accepts_email_marketing: true).count }.by(1)+ let(:request_format) { :html }+ let(:newsletter_params) { { newsletter: { email: newsletter_email } } }+ let(:newsletter_email) { '[email protected]' }++ let(:user) { create(:user, email: newsletter_email, accepts_email_marketing: false) }++ context 'with new subscription' do+ it 'creates a new newsletter subscription record' do+ expect { request }.to change(Spree::NewsletterSubscriber, :count).by(1)endit 'sets success flash message' do- post :create, params: newsletter_params+ request+expect(flash[:success]).to eq Spree.t('storefront.newsletter_subscribers.success')endit 'redirects to root path for html format' do- post :create, params: newsletter_params+ request+expect(response).to redirect_to spree.root_pathend- it 'renders turbo stream template for turbo_stream format' do- post :create, params: newsletter_params, format: :turbo_stream- expect(response).to have_http_status(:success)- expect(response.media_type).to eq Mime[:turbo_stream]+ context 'with turbo stream format' do+ let(:request_format) { :turbo_stream }++ it 'renders turbo stream template for turbo_stream format' do+ request++ expect(response).to have_http_status(:success)+ expect(response.media_type).to eq Mime[:turbo_stream]+ endendend- context 'with existing user (when signed in as that user)' do+ context 'with existing subscription' dobefore do- allow(controller).to receive(:try_spree_current_user).and_return(user)- user.update(email: '[email protected]', accepts_email_marketing: false)+ create(:newsletter_subscriber, :verified, email: newsletter_email)+ end++ it 'sets notice flash message' do+ request++ expect(flash[:notice]).to eq Spree.t('storefront.newsletter_subscribers.already_subscribed')+ end++ it 'does not create a new newsletter subscription record' do+ expect { request }.not_to change(Spree::NewsletterSubscriber, :count)+ end++ it 'redirects to root path for html format' do+ request++ expect(response).to redirect_to spree.root_pathend- it 'updates accepts_email_marketing for existing user' do- post :create, params: newsletter_params- expect(user.reload.accepts_email_marketing).to be true+ context 'with turbo stream format' do+ let(:request_format) { :turbo_stream }++ it 'renders turbo stream template for turbo_stream format' do+ request++ expect(response).to have_http_status(:success)+ expect(response.media_type).to eq Mime[:turbo_stream]+ end+ end+ end++ context 'with signed in user' do+ context 'with the same email' do+ before do+ allow(controller).to receive(:try_spree_current_user).and_return(user)+ end++ it 'updates accepts_email_marketing for existing user' do+ expect { request }.to change { user.reload.accepts_email_marketing }.to(true)+ end+ end++ context 'with the different email' do+ let(:another_user) { create(:user, email: '[email protected]', accepts_email_marketing: false) }++ before do+ allow(controller).to receive(:try_spree_current_user).and_return(another_user)+ user+ end++ it 'does not update accepts_email_marketing for user with the same email' do+ expect { request }.not_to change { user.reload.accepts_email_marketing }+ end++ it 'does not update accepts_email_marketing for the current user' do+ expect { request }.not_to change { another_user.reload.accepts_email_marketing }+ endendend@@ -59,15 +119,62 @@ RSpec.describe Spree::NewsletterSubscribersController, type: :controller doendcontext 'with invalid params' do- let(:invalid_params) { { newsletter: { email: 'invalid_email' } } }+ let(:newsletter_email) { 'invalid_email' }++ it 'sets error flash message' do+ subject++ expect(flash[:error]).to be_present+ end+ end+ end+ describe 'GET #verify' do+ subject(:request) { get :verify, params: { token: token } }++ let(:token) { '1234567890' }++ context 'with valid token' dobefore do- allow_any_instance_of(Spree.user_class).to receive(:save).and_return(false)+ create(:newsletter_subscriber, :unverified, verification_token: token)+ end++ it 'verifies the newsletter subscriber' do+ expect { request }.to change { Spree::NewsletterSubscriber.verified.count }.by(1)+ end+ end++ context 'with already verified subscriber' do+ before do+ create(:newsletter_subscriber, :verified, verification_token: token)endit 'sets error flash message' do- post :create, params: invalid_params- expect(flash[:error]).to be_present+ subject++ expect(flash[:alert]).to be_present+ end++ it 'redirects to root path for html format' do+ request++ expect(response).to redirect_to spree.root_path+ end+ end++ context 'with invalid token' do+ let(:token) { 'invalid-token' }++ it 'sets error flash message' do+ subject++ expect(flash[:alert]).to be_present+ end++ it 'redirects to root path for html format' do+ request++ expect(response).to redirect_to spree.root_pathendendend