spree_notification_providers 0.1.0

data/app/controllers/spree/webhooks/gupshup_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Spree
+  module Webhooks
+    # Receives Gupshup message events. Gupshup only learns that a number isn't
+    # on WhatsApp after accepting the send, so a "failed" event marks the
+    # delivery failed and publishes `notification.delivery_failed` (which, for
+    # login codes, triggers the email backup).
+    #
+    # Callbacks are unsigned; the URL carries the store's Gupshup webhook
+    # secret (Notification providers → Gupshup → Webhook secret), filtered
+    # from logs:
+    #   POST /webhooks/gupshup?secret=<webhook secret>
+    #
+    # The secret is checked against the store that owns the message, found
+    # from its delivery row or, for messages sent before this gem, through a
+    # registered message resolver.
+    class GupshupController < ActionController::API
+      def create
+        event = request.request_parameters.presence || parse_body
+        return head(:ok) unless failure_event?(event)
+
+        message_ids = [event.dig('payload', 'gsId'), event.dig('payload', 'id')].compact_blank
+        delivery = Spree::NotificationDelivery.where(provider_key: 'gupshup', provider_message_id: message_ids).first
+        store = delivery&.store || message_ids.lazy.filter_map do |id|
+          SpreeNotificationProviders.resolve_message_store(:gupshup, id)
+        end.first
+        return head(:not_found) unless store && secret_matches?(store)
+
+        reason = event.dig('payload', 'payload', 'reason').to_s.truncate(120)
+        delivery&.mark_failed!(reason)
+        Spree::Events.publish('notification.delivery_failed', {
+                                'store_id' => store.id, 'delivery_id' => delivery&.id,
+                                'provider_message_id' => delivery&.provider_message_id || message_ids.first,
+                                'reason' => reason
+                              })
+        head :ok
+      end
+
+      private
+
+      def failure_event?(event)
+        event.is_a?(Hash) && event['type'] == 'message-event' &&
+          event['payload'].is_a?(Hash) && event['payload']['type'] == 'failed'
+      end
+
+      def secret_matches?(store)
+        entry = Spree::NotificationProviderConfig.find_by(store_id: store.id, provider_key: 'gupshup')
+        input = SpreeNotificationProviders.provider(:gupshup)&.shared_inputs&.find { |i| i.name == :webhook_secret }
+        expected = entry && input ? entry.raw_value(input).to_s : ''
+        expected.present? && ActiveSupport::SecurityUtils.secure_compare(expected, params[:secret].to_s)
+      end
+
+      def parse_body
+        JSON.parse(request.raw_post.presence || '{}')
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    module NotificationMaskingHelper
+      MASK = '•••'
+
+      # "Set ••••1234" for long values, "Set" for short ones, so a short secret
+      # is never mostly revealed.
+      def secret_hint(value)
+        return nil if value.blank?
+
+        value.to_s.length >= 12 ? "••••#{value.to_s[-4..]}" : ''
+      end
+
+      # ka•••@gmail.com, +91•••••3210
+      def mask_recipient(value)
+        value = value.to_s
+        return value if value.blank? || value.start_with?('(')
+
+        if value.include?('@')
+          value.split(',').map { |address| mask_email(address.strip) }.join(', ')
+        else
+          mask_phone(value)
+        end
+      end
+
+      def notification_status_badge(status)
+        classes = {
+          ready: 'bg-green-100 text-green-800',
+          delivered: 'bg-green-100 text-green-800',
+          not_ready: 'bg-amber-100 text-amber-800',
+          unknown: 'bg-amber-100 text-amber-800',
+          failed: 'bg-red-100 text-red-800',
+          unavailable: 'bg-red-100 text-red-800',
+          disabled: 'bg-gray-100 text-gray-600',
+          skipped: 'bg-gray-100 text-gray-600'
+        }
+        key = status.to_sym
+        scope = %i[ready not_ready disabled unavailable].include?(key) ? 'statuses' : 'outcomes'
+        content_tag(:span, t("spree_notification_providers.#{scope}.#{key}"),
+                    class: "inline-flex items-center px-2 py-0.5 rounded text-xs font-medium #{classes[key]}")
+      end
+
+      def notification_channel_label(channel)
+        t("spree_notification_providers.channels.#{channel}")
+      end
+
+      private
+
+      def mask_email(address)
+        local, domain = address.split('@', 2)
+        "#{local.to_s.first(2)}#{MASK}@#{domain}"
+      end
+
+      def mask_phone(value)
+        digits = value.gsub(/\D/, '')
+        return "#{MASK}#{digits.last(2)}" if digits.length < 8
+
+        country = digits.length > 10 ? digits[0...(digits.length - 10)] : ''
+        "#{"+#{country}" if country.present?}•••••#{digits.last(4)}"
+      end
+    end
+  end
+end

data/app/jobs/spree/notification_deliveries/purge_job.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  module NotificationDeliveries
+    # Removes Delivery log rows older than `delivery_retention_days`.
+    # Schedule daily (e.g. sidekiq-cron: `0 4 * * *`).
+    class PurgeJob < ActiveJob::Base
+      queue_as :default
+
+      BATCH_SIZE = 1_000
+
+      def perform
+        days = SpreeNotificationProviders.configuration.delivery_retention_days
+        deleted = 0
+        loop do
+          ids = Spree::NotificationDelivery.older_than(days).limit(BATCH_SIZE).pluck(:id)
+          break if ids.empty?
+
+          deleted += Spree::NotificationDelivery.where(id: ids).delete_all
+        end
+        Rails.logger.info("[NotificationProviders] purged #{deleted} delivery rows older than #{days} days")
+        deleted
+      end
+    end
+  end
+end

data/app/models/concerns/spree/notification_provider_settings.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Spree
+  # Input storage shared by provider configs and channel entries: plain
+  # values in the `settings` jsonb column, secret values as a JSON object in
+  # the encrypted `secret_settings` text column.
+  module NotificationProviderSettings
+    extend ActiveSupport::Concern
+
+    included do
+      encrypts :secret_settings
+      attr_reader :input_errors
+
+      after_initialize { @input_errors = {} }
+    end
+
+    def plain_values
+      (settings || {}).to_h.stringify_keys
+    end
+
+    def secret_values
+      parsed = JSON.parse(secret_settings.presence || '{}')
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue JSON::ParserError
+      {}
+    end
+
+    def raw_value(input)
+      (input.secret? ? secret_values : plain_values)[input.key].presence
+    end
+
+    def write_raw(input, value)
+      if input.secret?
+        values = secret_values
+        value.present? ? values[input.key] = value.to_s : values.delete(input.key)
+        self.secret_settings = values.to_json
+      else
+        values = plain_values
+        value.present? ? values[input.key] = value.to_s : values.delete(input.key)
+        self.settings = values
+      end
+    end
+
+    # Applies a form submit. A blank secret keeps the stored value; a secret
+    # listed in `clear` is removed. Plain inputs not present in `values` are
+    # left alone.
+    def assign_inputs(inputs, values: {}, secrets: {}, clear: [])
+      values = values.to_h.stringify_keys
+      secrets = secrets.to_h.stringify_keys
+      clear = Array(clear).map(&:to_s)
+
+      inputs.each do |input|
+        if input.secret?
+          if clear.include?(input.key)
+            write_raw(input, nil)
+          elsif secrets[input.key].to_s.strip.present?
+            write_raw(input, secrets[input.key].to_s.strip)
+          end
+        elsif values.key?(input.key)
+          write_raw(input, values[input.key].to_s.strip)
+        end
+      end
+    end
+
+    def secret_set?(input)
+      raw_value(input).present?
+    end
+
+    private
+
+    def validate_inputs(inputs)
+      inputs.each do |input|
+        message = input.validate(raw_value(input))
+        next unless message
+
+        input_errors[input.key] = message
+        errors.add(:base, "#{input.label} #{message}")
+      end
+    end
+  end
+end

data/app/models/spree/notification_channel_provider.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module Spree
+  # A store's use of one provider on one channel: on/off, priority position,
+  # channel inputs and templates per message type.
+  class NotificationChannelProvider < Spree::Base
+    include Spree::NotificationProviderSettings
+
+    has_prefix_id :nchp
+
+    CHANNELS = %w[email sms whatsapp].freeze
+    STATUSES = %i[ready not_ready disabled unavailable].freeze
+
+    belongs_to :store, class_name: 'Spree::Store'
+
+    acts_as_list scope: %i[store_id channel], add_new_at: :bottom
+
+    validates :channel, inclusion: { in: CHANNELS }
+    validates :provider_key, presence: true, uniqueness: { scope: %i[store_id channel] }
+    validate :provider_supports_channel
+    validate { validate_inputs(channel_inputs) if capability }
+    validate :templates_valid
+
+    scope :enabled, -> { where(enabled: true) }
+    scope :for_channel, ->(channel) { where(channel: channel.to_s).order(:position) }
+
+    # Registry -------------------------------------------------------------
+
+    def definition
+      SpreeNotificationProviders.provider(provider_key)
+    end
+
+    def capability
+      definition&.capability(channel)
+    end
+
+    def channel_inputs
+      capability&.inputs || []
+    end
+
+    def shared_inputs
+      definition&.shared_inputs || []
+    end
+
+    def provider_config
+      @provider_config ||= Spree::NotificationProviderConfig.find_or_create_by!(store_id: store_id,
+                                                                               provider_key: provider_key)
+    end
+
+    def provider_config=(config)
+      @provider_config = config
+    end
+
+    def template_capable?
+      capability.present? && (capability.template_required? || capability.supports_kind?(:template) ||
+        capability.supports_kind?(:otp))
+    end
+
+    # Values ---------------------------------------------------------------
+
+    # Shared + channel inputs, secrets decrypted, defaults applied.
+    def values
+      config = provider_config
+      shared = shared_inputs.to_h { |input| [input.name, input.resolve(config.raw_value(input))] }
+      own = channel_inputs.to_h { |input| [input.name, input.resolve(raw_value(input))] }
+      shared.merge(own)
+    end
+
+    def template_for(message_type, message = nil)
+      message&.template_override(provider_key).presence || templates.to_h[message_type.to_s].presence
+    end
+
+    # Used by "Send test": the test template if set, else any configured one.
+    def test_template
+      templates.to_h['provider_test'].presence || templates.to_h.values.find(&:present?)
+    end
+
+    def context(template: nil)
+      SpreeNotificationProviders::Adapters::Context.new(
+        store: store, channel: channel.to_sym, settings: values, template: template,
+        templates: templates.to_h
+      )
+    end
+
+    # Readiness ------------------------------------------------------------
+
+    def missing_inputs
+      return [] unless definition
+
+      config = provider_config
+      missing = shared_inputs.select { |i| i.required? && i.resolve(config.raw_value(i)).blank? }.map(&:label)
+      missing += channel_inputs.select { |i| i.required? && i.resolve(raw_value(i)).blank? }.map(&:label)
+      missing += capability.extra_missing(values, templates.to_h) if capability
+      missing.uniq
+    end
+
+    def ready?
+      enabled? && definition.present? && capability.present? && missing_inputs.empty?
+    end
+
+    def ready_for?(message_type, message = nil)
+      ready? && skip_reason_for(message, message_type: message_type).nil?
+    end
+
+    # Why the router would skip this entry for the message, or nil.
+    def skip_reason_for(message, message_type: nil)
+      return 'unavailable' if definition.nil? || capability.nil?
+
+      missing = missing_inputs
+      return "not_ready: missing #{missing.join(', ')}" if missing.any?
+
+      kind = effective_kind(message)
+      return 'unsupported' if kind && !capability.supports_kind?(kind)
+
+      type = message&.type || message_type
+      return 'no_template' if capability.template_required? && template_for(type, message).blank?
+
+      nil
+    end
+
+    # An HTML email that names this provider's template is sent as that
+    # template (e.g. an email template with a MSG91 template id).
+    def effective_kind(message)
+      kind = message&.kind
+      if kind == :html && message.template_override(provider_key).present? && capability&.supports_kind?(:template)
+        :template
+      else
+        kind
+      end
+    end
+
+    def status
+      return :unavailable if definition.nil? || capability.nil?
+      return :disabled unless enabled?
+
+      missing_inputs.empty? ? :ready : :not_ready
+    end
+
+    # Used by: the channels whose entries share this provider's config.
+    def shared_with_channels
+      Spree::NotificationChannelProvider.where(store_id: store_id, provider_key: provider_key)
+                                        .order(:channel).pluck(:channel)
+    end
+
+    private
+
+    def provider_supports_channel
+      if definition.nil?
+        errors.add(:provider_key, 'is not a registered provider')
+      elsif !definition.supports?(channel)
+        errors.add(:channel, "is not supported by #{definition.label}")
+      end
+    end
+
+    def templates_valid
+      return unless capability&.template_format
+
+      templates.to_h.each do |type, value|
+        next if value.blank? || capability.template_valid?(value)
+
+        errors.add(:base, "Template for #{type} is not in the expected format")
+      end
+    end
+  end
+end

data/app/models/spree/notification_delivery.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Spree
+  # One attempt to send a message (or one recipient of a bulk send).
+  class NotificationDelivery < Spree::Base
+    has_prefix_id :ndel
+
+    OUTCOMES = %w[delivered failed unknown skipped].freeze
+
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :source, polymorphic: true, optional: true
+
+    validates :channel, :message_type, :recipient, :message_ref, presence: true
+    validates :outcome, inclusion: { in: OUTCOMES }
+
+    before_validation { self.reason = reason.to_s.truncate(255).presence }
+
+    scope :older_than, ->(days) { where(created_at: ...days.days.ago) }
+    scope :newest_first, -> { order(created_at: :desc, id: :desc) }
+
+    # `recipient` is deliberately not searchable: it is masked on screen.
+    self.whitelisted_ransackable_attributes = %w[channel provider_key outcome message_type created_at bulk]
+
+    def self.ransackable_attributes(_auth_object = nil)
+      whitelisted_ransackable_attributes
+    end
+
+    def self.ransackable_associations(_auth_object = nil)
+      []
+    end
+
+    # Only a provider callback may turn a delivered message into a failure.
+    def mark_failed!(reason)
+      return false unless outcome == 'delivered'
+
+      update!(outcome: 'failed', reason: reason.presence || 'provider_reported_failure')
+    end
+  end
+end

data/app/models/spree/notification_provider_config.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Spree
+  # A store's shared inputs for one provider (e.g. the MSG91 auth key that
+  # every MSG91 channel uses).
+  class NotificationProviderConfig < Spree::Base
+    include Spree::NotificationProviderSettings
+
+    has_prefix_id :nprov
+
+    IMPORT_SOURCES = %w[legacy_columns env mixed].freeze
+
+    belongs_to :store, class_name: 'Spree::Store'
+
+    validates :provider_key, presence: true, uniqueness: { scope: :store_id }
+    validates :import_source, inclusion: { in: IMPORT_SOURCES }, allow_nil: true
+    validate { validate_inputs(shared_inputs) }
+
+    # nil when the provider is no longer registered ("Unavailable").
+    def definition
+      SpreeNotificationProviders.provider(provider_key)
+    end
+
+    def shared_inputs
+      definition&.shared_inputs || []
+    end
+
+    def channel_providers
+      Spree::NotificationChannelProvider.where(store_id: store_id, provider_key: provider_key)
+    end
+  end
+end

data/app/models/spree/notification_providers_store_decorator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Spree
+  # File name matches the constant so Zeitwerk can eager-load it in any app.
+  module NotificationProvidersStoreDecorator
+    def self.prepended(base)
+      base.has_many :notification_provider_configs, class_name: 'Spree::NotificationProviderConfig',
+                                                    dependent: :destroy
+      base.has_many :notification_channel_providers, class_name: 'Spree::NotificationChannelProvider',
+                                                     dependent: :destroy
+      base.has_many :notification_deliveries, class_name: 'Spree::NotificationDelivery', dependent: :delete_all
+    end
+  end
+
+  Spree::Store.prepend(NotificationProvidersStoreDecorator) unless Spree::Store.ancestors.include?(NotificationProvidersStoreDecorator)
+end

data/app/models/spree/permission_sets/notification_provider_management.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Spree
+  module PermissionSets
+    # Grants the Notification providers and Delivery log screens to roles that
+    # are not full super users. Assign in the app's Spree initializer:
+    #
+    #   Spree.permissions.assign(:admin, [Spree::PermissionSets::NotificationProviderManagement])
+    #
+    # Delivery rows are written by the router, never by an admin, so :manage
+    # on them means "may open the Delivery log".
+    class NotificationProviderManagement < Base
+      def activate!
+        can :manage, Spree::NotificationProviderConfig
+        can :manage, Spree::NotificationChannelProvider
+        can :manage, Spree::NotificationDelivery
+      end
+    end
+  end
+end

data/app/views/spree/admin/notification_channel_providers/_input_field.html.erb

@@ -0,0 +1,51 @@
+<%# locals: (input:, record:, field_prefix:, secret_prefix:, clear_key:, errors: {}) %>
+<% field_id = "#{field_prefix.parameterize(separator: '_')}_#{input.key}" %>
+<% error = errors[input.key] %>
+<div class="form-group">
+  <%= label_tag field_id do %>
+    <%= input.label %><% if input.required? %> <span class="text-red-600" aria-hidden="true">*</span><% end %>
+  <% end %>
+
+  <% if input.secret? %>
+    <% stored = record.raw_value(input) %>
+    <%= password_field_tag "#{secret_prefix}[#{input.key}]", nil,
+                           id: field_id, class: "form-control #{'is-invalid' if error}",
+                           autocomplete: 'new-password',
+                           placeholder: (stored.present? ? t('spree_notification_providers.admin.configure.secret_placeholder') : nil) %>
+    <div class="text-xs text-gray-500 mt-1 flex items-center gap-3">
+      <span>
+        <%= stored.present? ? t('spree_notification_providers.admin.configure.secret_set', hint: secret_hint(stored)).strip : t('spree_notification_providers.admin.configure.secret_not_set') %>
+      </span>
+      <% if stored.present? %>
+        <label class="inline-flex items-center gap-1">
+          <%= check_box_tag "#{clear_key}[]", input.key, false, id: "#{field_id}_clear" %>
+          <%= t('spree_notification_providers.admin.configure.clear') %>
+        </label>
+      <% end %>
+    </div>
+  <% else %>
+    <% value = record.raw_value(input) %>
+    <% case input.type %>
+    <% when :select %>
+      <%= select_tag "#{field_prefix}[#{input.key}]",
+                     options_for_select(Array(input.options).map { |o| [o.to_s.humanize, o] }, value || input.default),
+                     id: field_id, class: "form-select #{'is-invalid' if error}" %>
+    <% when :boolean %>
+      <%= select_tag "#{field_prefix}[#{input.key}]",
+                     options_for_select([[Spree.t(:say_yes), 'true'], [Spree.t(:say_no), 'false']], (value || input.default).to_s),
+                     id: field_id, class: "form-select #{'is-invalid' if error}" %>
+    <% else %>
+      <%= text_field_tag "#{field_prefix}[#{input.key}]", value,
+                         id: field_id, class: "form-control #{'is-invalid' if error}",
+                         placeholder: input.default,
+                         inputmode: (input.type == :integer || input.type == :phone ? 'numeric' : nil) %>
+    <% end %>
+  <% end %>
+
+  <% if error %>
+    <div class="text-xs text-red-600 mt-1"><%= input.label %> <%= error %></div>
+  <% end %>
+  <% if input.help.present? %>
+    <div class="text-xs text-gray-500 mt-1"><%= input.help %></div>
+  <% end %>
+</div>

data/app/views/spree/admin/notification_channel_providers/edit.html.erb

@@ -0,0 +1,118 @@
+<% scope = 'spree_notification_providers.admin.configure' %>
+<% provider_label = @entry.definition&.label || @entry.provider_key.titleize %>
+<% channel_label = notification_channel_label(@entry.channel) %>
+<% content_for :page_title do %>
+  <%= t("#{scope}.title", provider: provider_label, channel: channel_label) %>
+<% end %>
+
+<% content_for :page_actions do %>
+  <%= link_to t("#{scope}.back"), spree.admin_notification_providers_path(channel: @entry.channel), class: 'btn btn-light' %>
+<% end %>
+
+<div class="grid grid-cols-12 gap-6">
+  <div class="col-span-12 lg:col-span-8">
+    <% if @entry.definition.nil? %>
+      <div class="alert alert-danger mb-4">
+        <%= t('spree_notification_providers.statuses.unavailable') %>: <%= @entry.provider_key %>
+      </div>
+    <% else %>
+      <% missing = @entry.missing_inputs %>
+      <div class="mb-4 flex items-center gap-2">
+        <%= notification_status_badge(@entry.status) %>
+        <% if missing.any? %>
+          <span class="text-sm text-amber-700"><%= t('spree_notification_providers.admin.providers.missing', inputs: missing.join(', ')) %></span>
+        <% end %>
+      </div>
+
+      <%= form_with url: spree.admin_notification_channel_provider_path(@entry), method: :patch, local: true,
+                    id: 'notification-provider-form' do %>
+        <div class="card mb-6">
+          <div class="card-body flex items-center justify-between">
+            <label for="entry_enabled" class="font-medium mb-0"><%= t('spree_notification_providers.admin.providers.enabled') %></label>
+            <%= hidden_field_tag 'entry[enabled]', '0', id: nil %>
+            <%= check_box_tag 'entry[enabled]', '1', @entry.enabled?, id: 'entry_enabled' %>
+          </div>
+        </div>
+
+        <% if @entry.shared_inputs.any? %>
+          <div class="card mb-6">
+            <div class="card-header">
+              <h5 class="card-title"><%= t("#{scope}.shared_header") %></h5>
+            </div>
+            <div class="card-body space-y-4">
+              <p class="text-xs text-gray-500">
+                <%= t("#{scope}.shared_used_by",
+                      channels: (@entry.shared_with_channels | [@entry.channel]).map { |c| notification_channel_label(c) }.to_sentence) %>
+              </p>
+              <% @entry.shared_inputs.each do |input| %>
+                <%= render 'input_field', input: input, record: @entry.provider_config,
+                                          field_prefix: 'entry[shared_settings]', secret_prefix: 'entry[shared_secret_settings]',
+                                          clear_key: 'entry[clear_shared_secrets]', errors: @config_errors || {} %>
+              <% end %>
+            </div>
+          </div>
+        <% end %>
+
+        <% if @entry.channel_inputs.any? %>
+          <div class="card mb-6">
+            <div class="card-header">
+              <h5 class="card-title"><%= t("#{scope}.channel_header", channel: channel_label) %></h5>
+            </div>
+            <div class="card-body space-y-4">
+              <% @entry.channel_inputs.each do |input| %>
+                <%= render 'input_field', input: input, record: @entry,
+                                          field_prefix: 'entry[settings]', secret_prefix: 'entry[secret_settings]',
+                                          clear_key: 'entry[clear_secrets]', errors: @entry.input_errors %>
+              <% end %>
+            </div>
+          </div>
+        <% end %>
+
+        <% if @entry.template_capable? %>
+          <div class="card mb-6">
+            <div class="card-header">
+              <h5 class="card-title"><%= t("#{scope}.templates_header") %></h5>
+            </div>
+            <div class="card-body space-y-4">
+              <p class="text-xs text-gray-500"><%= t("#{scope}.templates_help") %></p>
+              <% SpreeNotificationProviders.message_types_for(@entry.channel).each do |type| %>
+                <div class="form-group">
+                  <%= label_tag "entry_templates_#{type.key}", type.label %>
+                  <%= text_field_tag "entry[templates][#{type.key}]", @entry.templates.to_h[type.key.to_s],
+                                     id: "entry_templates_#{type.key}", class: 'form-control font-mono text-sm' %>
+                </div>
+              <% end %>
+            </div>
+          </div>
+        <% end %>
+
+        <div class="flex justify-end">
+          <%= submit_tag t("#{scope}.save"), class: 'btn btn-primary' %>
+        </div>
+      <% end %>
+    <% end %>
+  </div>
+
+  <div class="col-span-12 lg:col-span-4">
+    <% if @entry.definition %>
+      <div class="card">
+        <div class="card-header">
+          <h5 class="card-title"><%= t("#{scope}.test_header") %></h5>
+        </div>
+        <div class="card-body">
+          <p class="text-xs text-gray-500 mb-3"><%= t("#{scope}.test_help") %></p>
+          <%= form_with url: spree.test_admin_notification_channel_provider_path(@entry), method: :post, local: true,
+                        id: 'notification-provider-test-form' do %>
+            <div class="form-group">
+              <% label = @entry.channel == 'email' ? t("#{scope}.test_to_email") : t("#{scope}.test_to_phone") %>
+              <%= label_tag :test_to, label %>
+              <%= (@entry.channel == 'email' ? method(:email_field_tag) : method(:telephone_field_tag))
+                    .call(:to, nil, id: 'test_to', class: 'form-control', required: true) %>
+            </div>
+            <%= submit_tag t("#{scope}.test_send"), class: 'btn btn-light w-full' %>
+          <% end %>
+        </div>
+      </div>
+    <% end %>
+  </div>
+</div>