railsdrip-engine 0.0.1

data/app/models/rails_drips/step.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class Step < ApplicationRecord
+    include JsonData
+
+    DELAY_UNITS = %w[minutes hours days].freeze
+
+    belongs_to :campaign_version,
+      class_name: "RailsDrips::CampaignVersion",
+      inverse_of: :steps
+    has_many :deliveries,
+      class_name: "RailsDrips::Delivery",
+      dependent: :restrict_with_error,
+      inverse_of: :step
+
+    enum :kind, { email: 0 }, prefix: true
+
+    validates :position,
+      presence: true,
+      numericality: { only_integer: true, greater_than: 0 },
+      uniqueness: { scope: :campaign_version_id }
+    validates :name, :kind, :delay_unit, :email_key, presence: true
+    validates :delay_amount,
+      presence: true,
+      numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :delay_unit, inclusion: { in: DELAY_UNITS }
+    validate :email_key_registered
+
+    def resolved_email_category
+      email_category.presence || campaign_version.campaign.default_email_category
+    end
+
+    def delay_duration
+      case delay_unit
+      when "minutes" then delay_amount.minutes
+      when "hours" then delay_amount.hours
+      when "days" then delay_amount.days
+      else
+        raise ArgumentError, "Unsupported delay unit: #{delay_unit.inspect}"
+      end
+    end
+
+    private
+
+    def email_key_registered
+      return if email_key.blank? || RailsDrips.configuration.mailers.registered?(email_key)
+
+      errors.add(:email_key, "is not registered")
+    end
+  end
+end
+

data/app/services/rails_drips/activate_campaign.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class ActivateCampaign
+    def self.call(campaign:, version:, actor: nil)
+      campaign.activate_version!(version, actor: actor)
+      Result.new(status: :activated, campaign: campaign)
+    end
+  end
+end

data/app/services/rails_drips/archive_campaign.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class ArchiveCampaign
+    def self.call(campaign:, reason: nil, actor: nil)
+      campaign = campaign.is_a?(Campaign) ? campaign : Campaign.find_by(key: campaign.to_s)
+      return Result.new(status: :campaign_not_found) unless campaign
+      return Result.new(status: :already_archived, campaign: campaign) if campaign.archived?
+
+      Campaign.transaction do
+        campaign.update!(status: :archived)
+        campaign.enrollments.open.find_each do |enrollment|
+          enrollment.deliveries.scheduled.find_each { |delivery| delivery.cancel!(reason: :campaign_archived) }
+          RecordEvent.call(enrollment: enrollment, event_type: "campaign_archived", actor: actor,
+            data: { "reason" => reason }.compact)
+        end
+      end
+      Instrumentation.instrument("campaign.archived", campaign_id: campaign.id)
+      Result.new(status: :archived, campaign: campaign)
+    end
+  end
+end

data/app/services/rails_drips/cancel_delivery.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class CancelDelivery
+    def self.call(delivery:, reason:, actor: nil)
+      delivery.with_lock do
+        return Result.new(status: :not_cancellable, delivery: delivery) unless delivery.scheduled? || delivery.failed?
+
+        delivery.cancel!(reason: reason)
+        RecordEvent.call(enrollment: delivery.enrollment, event_type: "delivery_cancelled", actor: actor,
+          data: { "delivery_id" => delivery.id, "reason" => reason.to_s })
+      end
+      CompleteEnrollment.call(enrollment: delivery.enrollment)
+      Result.new(status: :cancelled, delivery: delivery, enrollment: delivery.enrollment)
+    end
+  end
+end

data/app/services/rails_drips/compare_definition.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailsDrips
+  class CompareDefinition
+    EXECUTABLE_FIELDS = %w[position name kind delay_amount delay_unit email_key email_category data].freeze
+
+    def self.fingerprint_definition(definition)
+      steps = definition.fetch("campaign").fetch("steps").map do |step|
+        EXECUTABLE_FIELDS.to_h { |field| [field, step[field]] }
+      end
+      JSON.generate(steps.sort_by { |step| step["position"] })
+    end
+
+    def self.fingerprint_version(version)
+      steps = version.steps.order(:position).map do |step|
+        {
+          "position" => step.position, "name" => step.name, "kind" => step.kind,
+          "delay_amount" => step.delay_amount, "delay_unit" => step.delay_unit,
+          "email_key" => step.email_key, "email_category" => step.email_category,
+          "data" => step.data_value.presence
+        }
+      end
+      JSON.generate(steps)
+    end
+  end
+end

data/app/services/rails_drips/complete_enrollment.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class CompleteEnrollment
+    BLOCKING_STATUSES = %w[scheduled sending failed].freeze
+
+    def self.call(enrollment:)
+      enrollment.with_lock do
+        return Result.new(status: :not_active, enrollment: enrollment) unless enrollment.active?
+        return Result.new(status: :pending, enrollment: enrollment) if enrollment.deliveries.where(status: BLOCKING_STATUSES).exists?
+
+        enrollment.complete!
+        RecordEvent.call(enrollment: enrollment, event_type: "completed")
+        Result.new(status: :completed, enrollment: enrollment)
+      end
+    end
+  end
+end

data/app/services/rails_drips/enqueue_due_deliveries.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class EnqueueDueDeliveries
+    def self.call(campaign: nil, dry_run: false)
+      campaign = Campaign.find_by(key: campaign.to_s) unless campaign.nil? || campaign.is_a?(Campaign)
+      scope = Delivery.due.joins(:enrollment).merge(Enrollment.status_active)
+      scope = scope.where(rails_drips_enrollments: { campaign_id: campaign.id }) if campaign
+      ids = scope.pluck(:id)
+      unless dry_run
+        ids.each { |id| RailsDrips.configuration.delivery_job.perform_later(id) }
+      end
+      Result.new(status: dry_run ? :dry_run : :enqueued, campaign: campaign, count: ids.length)
+    end
+  end
+end

data/app/services/rails_drips/enroll.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class Enroll
+    def self.call(...) = new(...).call
+
+    def initialize(campaign:, recipient:, actor: nil, source: nil, data: {}, force: false)
+      @campaign = campaign.is_a?(Campaign) ? campaign : Campaign.find_by(key: campaign.to_s)
+      @recipient = recipient
+      @actor = actor
+      @source = source
+      @data = data || {}
+      @force = force
+    end
+
+    def call
+      return result(:campaign_inactive) unless campaign&.active_for_enrollment?
+
+      existing = campaign.enrollments.open.find_by(recipient: recipient)
+      return result(:already_open, enrollment: existing) if existing
+      return result(:reenrollment_disallowed) if prior_enrollment? && !campaign.allow_reenrollment?
+
+      decision = eligibility_decision
+      return result(:ineligible, reason: decision.reason) unless force || decision.allowed
+
+      enrollment = persist_enrollment
+      result(:enrolled, enrollment: enrollment)
+    rescue ActiveRecord::RecordNotUnique
+      result(:already_open, enrollment: campaign.enrollments.open.find_by(recipient: recipient))
+    end
+
+    private
+
+    attr_reader :campaign, :recipient, :actor, :source, :data, :force
+
+    def prior_enrollment?
+      campaign.enrollments.where(recipient: recipient).exists?
+    end
+
+    def eligibility_decision
+      value = RailsDrips.configuration.eligibility_evaluator.call(
+        recipient: recipient, campaign: campaign, phase: :enrollment
+      )
+      PolicyDecision.call(value)
+    end
+
+    def persist_enrollment
+      email = RailsDrips.configuration.recipient_email(recipient)
+      now = RailsDrips.configuration.current_time
+      Enrollment.transaction do
+        enrollment = campaign.enrollments.create!(
+          campaign_version: campaign.current_version,
+          recipient: recipient,
+          added_by: actor,
+          entry_source: source,
+          enrolled_at: now,
+          data: data.stringify_keys.merge("forced_enrollment" => force)
+        )
+        RecordEvent.call(enrollment: enrollment, event_type: "enrolled", actor: actor,
+          data: { "source" => source, "forced" => force }.compact)
+        ScheduleDeliveries.call(enrollment: enrollment, recipient_email: email)
+        enrollment
+      end
+    end
+
+    def result(status, enrollment: nil, reason: nil)
+      Instrumentation.instrument("enrollment.#{status}", campaign_key: campaign&.key, campaign_id: campaign&.id,
+        enrollment_id: enrollment&.id, recipient_type: recipient.class.name)
+      Result.new(status: status, campaign: campaign, enrollment: enrollment, reason: reason)
+    end
+  end
+end

data/app/services/rails_drips/import_definition.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class ImportDefinition
+    METADATA_FIELDS = %w[name description allow_reenrollment default_email_category data].freeze
+
+    def self.call(definition:, dry_run: false, actor: nil)
+      new(definition, dry_run: dry_run, actor: actor).call
+    end
+
+    def initialize(definition, dry_run:, actor:)
+      @definition = definition
+      @attributes = definition.fetch("campaign")
+      @dry_run = dry_run
+      @actor = actor
+    end
+
+    def call
+      campaign = Campaign.find_by(key: attributes.fetch("key"))
+      return Result.new(status: :would_create) if dry_run && !campaign
+      return create_campaign unless campaign
+
+      latest = campaign.campaign_versions.order(version_number: :desc).first
+      executable_changed = latest.nil? || CompareDefinition.fingerprint_version(latest) != CompareDefinition.fingerprint_definition(definition)
+      metadata_changed = metadata_attributes.any? { |key, value| campaign.public_send(key) != value }
+      return Result.new(status: executable_changed ? :would_create_version : :would_update_metadata, campaign: campaign) if dry_run && (executable_changed || metadata_changed)
+      return Result.new(status: :unchanged, campaign: campaign) unless executable_changed || metadata_changed
+
+      Campaign.transaction do
+        campaign.update!(metadata_attributes) if metadata_changed
+        create_version(campaign) if executable_changed
+      end
+      Result.new(status: executable_changed ? :version_created : :metadata_updated, campaign: campaign)
+    end
+
+    private
+
+    attr_reader :definition, :attributes, :dry_run, :actor
+
+    def create_campaign
+      campaign = Campaign.transaction do
+        created = Campaign.create!({ key: attributes.fetch("key"), status: :draft }.merge(metadata_attributes))
+        create_version(created)
+        created
+      end
+      Result.new(status: :created, campaign: campaign)
+    end
+
+    def create_version(campaign)
+      version = campaign.campaign_versions.create!(
+        version_number: campaign.campaign_versions.maximum(:version_number).to_i + 1,
+        status: :draft,
+        created_by: actor
+      )
+      attributes.fetch("steps").each do |step|
+        version.steps.create!(step.slice(*CompareDefinition::EXECUTABLE_FIELDS))
+      end
+      version
+    end
+
+    def metadata_attributes
+      @metadata_attributes ||= attributes.slice(*METADATA_FIELDS).tap do |values|
+        values["allow_reenrollment"] = false unless values.key?("allow_reenrollment")
+        values["data"] ||= {}
+      end
+    end
+  end
+end

data/app/services/rails_drips/integrity_audit.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class IntegrityAudit
+    Finding = Struct.new(:code, :severity, :record_type, :record_id, :details, keyword_init: true)
+
+    def self.call(stuck_before: 1.hour.ago)
+      findings = []
+      Enrollment.status_active.includes({ campaign_version: :steps }, :deliveries).find_each do |enrollment|
+        missing = enrollment.campaign_version.steps.map(&:id) - enrollment.deliveries.map(&:step_id)
+        missing.each do |step_id|
+          findings << Finding.new(code: :missing_delivery, severity: :error,
+            record_type: enrollment.class.name, record_id: enrollment.id, details: { step_id: step_id })
+        end
+      end
+      Delivery.joins(:step, :enrollment)
+        .where("rails_drips_steps.campaign_version_id != rails_drips_enrollments.campaign_version_id")
+        .find_each { |delivery| findings << finding(:cross_version_step, :error, delivery) }
+      Delivery.status_sending.where("updated_at < ?", stuck_before).find_each do |delivery|
+        findings << finding(:stuck_sending, :error, delivery)
+      end
+      Delivery.status_sent.where(subject_snapshot: nil).find_each do |delivery|
+        findings << finding(:sent_without_snapshot, :warning, delivery)
+      end
+      Delivery.status_scheduled.joins(:enrollment).merge(Enrollment.status_removed).find_each do |delivery|
+        findings << finding(:removed_with_scheduled, :error, delivery)
+      end
+      Delivery.status_failed.joins(:enrollment).merge(Enrollment.status_completed).find_each do |delivery|
+        findings << finding(:completed_with_failed, :error, delivery)
+      end
+      queue = QueueInventory.call
+      findings << Finding.new(code: :queue_inventory_available, severity: :warning,
+        record_type: "Queue", record_id: nil, details: { size: queue.size }) if queue
+      findings
+    end
+
+    def self.finding(code, severity, record)
+      Finding.new(code: code, severity: severity, record_type: record.class.name,
+        record_id: record.id, details: {})
+    end
+    private_class_method :finding
+  end
+end

data/app/services/rails_drips/mail_snapshot.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module RailsDrips
+  class MailSnapshot
+    def self.call(message)
+      html = body_for(message, :html)
+      text = body_for(message, :text)
+      encoded = message.encoded
+      {
+        subject: message.subject.to_s,
+        html_body: html,
+        text_body: text,
+        sha256: Digest::SHA256.hexdigest(encoded),
+        byte_size: encoded.bytesize
+      }
+    end
+
+    def self.body_for(message, kind)
+      part = kind == :html ? message.html_part : message.text_part
+      return part.body.decoded if part
+      return nil if message.multipart?
+
+      mime = message.mime_type.to_s
+      return message.body.decoded if kind == :html && mime.include?("html")
+      return message.body.decoded if kind == :text && !mime.include?("html")
+    end
+    private_class_method :body_for
+  end
+end

data/app/services/rails_drips/pause_campaign.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class PauseCampaign
+    def self.call(campaign:, actor: nil)
+      campaign = campaign.is_a?(Campaign) ? campaign : Campaign.find_by(key: campaign.to_s)
+      return Result.new(status: :campaign_not_found) unless campaign
+      return Result.new(status: :already_paused, campaign: campaign) if campaign.paused?
+      return Result.new(status: :invalid_transition, campaign: campaign) unless campaign.active?
+
+      campaign.update!(status: :paused)
+      Instrumentation.instrument("campaign.paused", campaign_id: campaign.id, actor_type: actor&.class&.name)
+      Result.new(status: :paused, campaign: campaign)
+    end
+  end
+end

data/app/services/rails_drips/policy_decision.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class PolicyDecision
+    Decision = Struct.new(:allowed, :reason, keyword_init: true)
+
+    def self.call(value)
+      return Decision.new(allowed: value) if value == true || value == false
+
+      value = value.to_h.transform_keys(&:to_sym)
+      Decision.new(
+        allowed: value.fetch(:allowed, value.fetch(:eligible, false)),
+        reason: value[:reason]
+      )
+    end
+
+    def self.allowed?(value)
+      call(value).allowed
+    end
+  end
+end

data/app/services/rails_drips/record_event.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class RecordEvent
+    def self.call(enrollment:, event_type:, actor: nil, data: {})
+      enrollment.enrollment_events.create!(
+        event_type: event_type,
+        actor: actor,
+        occurred_at: RailsDrips.configuration.current_time,
+        data: data || {}
+      )
+    end
+  end
+end

data/app/services/rails_drips/remove.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class Remove
+    def self.call(campaign:, recipient:, reason:, actor: nil, data: {})
+      campaign = campaign.is_a?(Campaign) ? campaign : Campaign.find_by(key: campaign.to_s)
+      return Result.new(status: :campaign_not_found) unless campaign
+
+      enrollment = campaign.enrollments.open.find_by(recipient: recipient)
+      return Result.new(status: :not_open, campaign: campaign) unless enrollment
+
+      Enrollment.transaction do
+        enrollment.lock!
+        enrollment.remove!(reason: reason, actor: actor)
+        RecordEvent.call(enrollment: enrollment, event_type: "removed", actor: actor,
+          data: (data || {}).stringify_keys.merge("reason" => reason.to_s))
+        enrollment.deliveries.scheduled.find_each do |delivery|
+          delivery.cancel!(reason: :recipient_removed)
+          RecordEvent.call(enrollment: enrollment, event_type: "delivery_cancelled", actor: actor,
+            data: { "delivery_id" => delivery.id, "reason" => "recipient_removed" })
+        end
+      end
+      Instrumentation.instrument("enrollment.removed", campaign_key: campaign.key, enrollment_id: enrollment.id)
+      Result.new(status: :removed, campaign: campaign, enrollment: enrollment)
+    end
+  end
+end

data/app/services/rails_drips/resume_campaign.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class ResumeCampaign
+    def self.call(campaign:, actor: nil)
+      campaign = campaign.is_a?(Campaign) ? campaign : Campaign.find_by(key: campaign.to_s)
+      return Result.new(status: :campaign_not_found) unless campaign
+      return Result.new(status: :already_active, campaign: campaign) if campaign.active?
+      return Result.new(status: :invalid_transition, campaign: campaign) unless campaign.paused?
+
+      campaign.update!(status: :active)
+      EnqueueDueDeliveries.call(campaign: campaign)
+      Instrumentation.instrument("campaign.resumed", campaign_id: campaign.id, actor_type: actor&.class&.name)
+      Result.new(status: :resumed, campaign: campaign)
+    end
+  end
+end

data/app/services/rails_drips/retry_delivery.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class RetryDelivery
+    def self.call(delivery:, actor: nil)
+      delivery.with_lock do
+        enrollment = delivery.enrollment
+        unless delivery.failed? && enrollment.active? && enrollment.campaign.active?
+          return Result.new(status: :not_retryable, delivery: delivery, enrollment: enrollment)
+        end
+
+        delivery.update!(status: :scheduled, scheduled_for: RailsDrips.configuration.current_time,
+          failed_at: nil, last_error: nil)
+        RecordEvent.call(enrollment: enrollment, event_type: "delivery_retried", actor: actor,
+          data: { "delivery_id" => delivery.id })
+      end
+      RailsDrips.configuration.delivery_job.perform_later(delivery.id)
+      Result.new(status: :retried, delivery: delivery, enrollment: delivery.enrollment)
+    end
+  end
+end

data/app/services/rails_drips/schedule_deliveries.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class ScheduleDeliveries
+    def self.call(enrollment:, recipient_email:)
+      scheduled_for = enrollment.enrolled_at
+
+      enrollment.campaign_version.steps.order(:position).map do |step|
+        scheduled_for += step.delay_duration
+        enrollment.deliveries.create!(
+          step: step,
+          recipient: enrollment.recipient,
+          recipient_email: recipient_email,
+          scheduled_for: scheduled_for,
+          campaign_key: enrollment.campaign.key,
+          email_key: step.email_key,
+          email_category: step.resolved_email_category,
+          data: { "step_position" => step.position, "version_number" => enrollment.campaign_version.version_number }
+        )
+      end
+    end
+  end
+end

data/app/services/rails_drips/unarchive_campaign.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsDrips
+  class UnarchiveCampaign
+    def self.call(campaign:)
+      campaign = campaign.is_a?(Campaign) ? campaign : Campaign.find_by(key: campaign.to_s)
+      return Result.new(status: :campaign_not_found) unless campaign
+      return Result.new(status: :invalid_transition, campaign: campaign) unless campaign.archived?
+
+      campaign.update!(status: :draft, current_version: nil)
+      Result.new(status: :unarchived, campaign: campaign)
+    end
+  end
+end

data/app/views/layouts/rails_drips/application.html.erb

@@ -0,0 +1,5 @@
+<!doctype html>
+<html>
+  <head><title>RailsDrips</title><meta name="viewport" content="width=device-width,initial-scale=1"></head>
+  <body><main><%= yield %></main></body>
+</html>

data/app/views/rails_drips/campaigns/index.html.erb

@@ -0,0 +1,7 @@
+<h1>Drip campaigns</h1>
+<% if @campaigns.empty? %><p>No campaigns.</p><% end %>
+<ul>
+  <% @campaigns.each do |campaign| %>
+    <li><%= link_to campaign.key, campaign_path(campaign) %> — <%= campaign.status %></li>
+  <% end %>
+</ul>

data/app/views/rails_drips/campaigns/show.html.erb

@@ -0,0 +1,7 @@
+<p><%= link_to "Campaigns", campaigns_path %></p>
+<h1><%= @campaign.name %></h1>
+<p><code><%= @campaign.key %></code> — <%= @campaign.status %></p>
+<h2>Versions</h2>
+<ul><% @campaign.campaign_versions.each do |version| %><li>v<%= version.version_number %> — <%= version.status %> — <%= version.steps.size %> steps</li><% end %></ul>
+<h2>Enrollments</h2>
+<ul><% @enrollments.each do |enrollment| %><li><%= link_to "Enrollment ##{enrollment.id}", enrollment_path(enrollment) %> — <%= enrollment.status %></li><% end %></ul>

data/app/views/rails_drips/deliveries/show.html.erb

@@ -0,0 +1,9 @@
+<h1>Delivery #<%= @delivery.id %></h1>
+<dl><dt>Status</dt><dd><%= @delivery.status %></dd><dt>Email key</dt><dd><%= @delivery.email_key %></dd><dt>Scheduled</dt><dd><%= @delivery.scheduled_for %></dd></dl>
+<% if @show_snapshot %>
+  <h2><%= @delivery.subject_snapshot %></h2>
+  <h3>Text</h3><pre><%= @delivery.text_body_snapshot %></pre>
+  <h3>HTML source</h3><pre><%= @delivery.html_body_snapshot %></pre>
+<% else %>
+  <%= link_to "Show protected snapshot", delivery_path(@delivery, snapshot: 1) %>
+<% end %>

data/app/views/rails_drips/enrollments/show.html.erb

@@ -0,0 +1,6 @@
+<h1>Enrollment #<%= @enrollment.id %></h1>
+<p><%= recipient_label(@enrollment.recipient) %> — <%= @enrollment.status %></p>
+<h2>Events</h2>
+<ol><% @enrollment.enrollment_events.chronological.each do |event| %><li><%= event.occurred_at %> — <%= event.event_type %></li><% end %></ol>
+<h2>Deliveries</h2>
+<ul><% @enrollment.deliveries.order(:scheduled_for).each do |delivery| %><li><%= link_to delivery.email_key, delivery_path(delivery) %> — <%= delivery.status %></li><% end %></ul>

data/config/routes.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RailsDrips::Engine.routes.draw do
+  resources :campaigns, only: %i[index show] do
+    resource :pause, only: :create, controller: :campaign_pauses
+    resource :resumption, only: :create, controller: :campaign_resumptions
+    resource :archival, only: :create, controller: :campaign_archivals
+  end
+  resources :enrollments, only: :show
+  resources :deliveries, only: :show do
+    resource :retry, only: :create, controller: :delivery_retries
+    resource :cancellation, only: :create, controller: :delivery_cancellations
+  end
+end