munawaba 0.1.0

data/app/controllers/munawaba/overrides_controller.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class OverridesController < ApplicationController
+    def new
+      @people = Person.where(active: true).order(:name)
+      render :new
+    end
+    alias_method :edit, :new
+
+    def preview
+      proposal(override_operation, @shift, override_attributes)
+    end
+
+    def create
+      confirm_override(:override)
+    end
+    alias_method :update, :create
+
+    def revoke
+      confirm_override(:revoke)
+    end
+
+    def restore
+      confirm_override(:restore_to_base)
+    end
+
+    private
+
+    def authorization_target
+      @shift = Shift.includes(:schedule, :base_person, :effective_person).find(params[:shift_id])
+      [:override_shifts, @shift]
+    end
+
+    def override_operation
+      { "apply" => :override, "revoke" => :revoke, "restore_to_base" => :restore_to_base }.fetch(
+        params[:operation].to_s, :override
+      )
+    end
+
+    def override_attributes
+      params.permit(:person_id, :reason, :lock_version).to_h.symbolize_keys
+    end
+
+    def confirm_override(operation)
+      command(operation, @shift, override_attributes, success_path: shift_path(@shift),
+                                                      template: "munawaba/shared/proposal") do
+        refresh_proposal(operation, @shift, override_attributes)
+      end
+    end
+  end
+end

data/app/controllers/munawaba/overviews_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class OverviewsController < ApplicationController
+    def show
+      @schedules = Schedule.order(:name).to_a
+      @now = Time.current
+      candidates = Shift.where(canceled_at: nil).where("ends_at > ?", @now)
+                        .select("id, row_number() OVER (PARTITION BY schedule_id ORDER BY starts_at, id) AS position")
+      nearest_ids = Shift.from("(#{candidates.to_sql}) upcoming").where("position <= 2").select("id")
+      @shifts = Shift.where(id: nearest_ids).order(:starts_at).includes(:effective_person).to_a.group_by(&:schedule_id)
+      @projected_through = Shift.where(canceled_at: nil).group(:schedule_id).maximum(:ends_at)
+      @roster_counts = ScheduleMembership.group(:schedule_id).count
+    end
+
+    private
+
+    def authorization_target
+      [:read, :overview]
+    end
+  end
+end

data/app/controllers/munawaba/people_controller.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class PeopleController < ApplicationController
+    def index
+      @people = Person.order(:name, :id)
+      @people = @people.where(active: params[:state] == "active") if %w[active inactive].include?(params[:state])
+      @people = @people.where("name ILIKE :q OR email ILIKE :q",
+                              q: "%#{Person.sanitize_sql_like(params[:q].to_s)}%") if params[:q].present?
+      @people = after_name_cursor(@people).limit(page_size + 1).to_a
+      @more = @people.size > page_size
+      @people = @people.first(page_size)
+      @membership_counts = ScheduleMembership.where(person_id: @people.map(&:id)).group(:person_id).count
+    end
+
+    def show
+      @memberships = ScheduleMembership.where(person_id: @person.id).includes(:schedule).order(:schedule_id)
+      @shifts = Shift.where(effective_person_id: @person.id, canceled_at: nil).where("ends_at > ?", Time.current)
+                     .includes(:schedule, :effective_person).order(:starts_at).limit(100)
+    end
+
+    def new
+      @person = Person.new
+    end
+
+    def create
+      @person = Person.new(person_attributes)
+      command(:create_person, @person, person_attributes, success_path: ->(record) {
+        person_path(record)
+      }, template: "new") do |result|
+        @person = result.record if result.record.is_a?(Person)
+      end
+    end
+
+    def edit; end
+
+    def update
+      command(:update_person, @person, person_attributes, success_path: person_path(@person),
+                                                          template: "edit") do |_result|
+        @person.assign_attributes(person_attributes.except(:lock_version))
+      end
+    end
+
+    def deactivation
+      proposal(:deactivate, @person)
+    end
+
+    def deactivate
+      command(:deactivate, @person, {}, success_path: person_path(@person),
+                                        template: "munawaba/shared/proposal") do
+        refresh_proposal(:deactivate, @person, {})
+      end
+    end
+
+    def reactivate
+      command(:reactivate, @person, { lock_version: params[:lock_version] }, success_path: person_path(@person),
+                                                                             template: "show") {
+        show
+      }
+    end
+
+    private
+
+    def authorization_target
+      @person = Person.find(params[:id]) if params[:id]
+      [(%w[index show].include?(action_name) ? :read : :manage_people), @person || Person]
+    end
+
+    def person_attributes
+      record_parameters(:person).permit(:name, :email, :slack_member_id, :lock_version).to_h.symbolize_keys
+    end
+  end
+end

data/app/controllers/munawaba/rotations_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class RotationsController < ApplicationController
+    def edit
+      @person_ids = computed_roster(@schedule,
+                                    ScheduleMembership.where(schedule_id: @schedule.id).order(:position)).map { |membership|
+        membership.person_id.to_s
+      }
+      prepare_people
+    end
+
+    def preview
+      @person_ids = array_parameter(:person_ids).map(&:to_s).reject(&:blank?)
+      move = params[:move].to_s.split(":", 2)
+      index = @person_ids.index(move[1])
+      if index
+        case move[0]
+        when "up" then @person_ids[index - 1], @person_ids[index] = @person_ids[index],
+@person_ids[index - 1] if index.positive?
+        when "down" then @person_ids[index + 1], @person_ids[index] = @person_ids[index],
+@person_ids[index + 1] if index < @person_ids.length - 1
+        when "next" then @person_ids.unshift(@person_ids.delete_at(index))
+        when "remove" then @person_ids.delete_at(index)
+        end
+      end
+      @person_ids << params[:add_person_id].to_s if params[:add_person_id].present? && !@person_ids.include?(params[:add_person_id].to_s)
+      prepare_people
+      result = Commands.preview(operation: :rotation, subject: @schedule, attributes: rotation_attributes, actor: actor)
+      @preview = result.preview
+      @errors = Array(result.errors)
+      @operation, @subject, @attributes = :rotation, @schedule, rotation_attributes
+      render :edit, status: @errors.present? ? :unprocessable_entity : :ok
+    end
+
+    def update
+      @person_ids = array_parameter(:person_ids).map(&:to_s).reject(&:blank?)
+      prepare_people
+      command(:rotation, @schedule, rotation_attributes, success_path: schedule_path(@schedule),
+                                                         template: "edit") do
+        refresh_proposal(:rotation, @schedule, rotation_attributes)
+      end
+    end
+
+    private
+
+    def authorization_target
+      @schedule = Schedule.find(params[:schedule_id])
+      [:manage_rotations, @schedule]
+    end
+
+    def prepare_people
+      @people_by_id = Person.where(id: @person_ids).index_by { |person| person.id.to_s }
+      @available_people = Person.where(active: true).where.not(id: @person_ids).order(:name)
+    end
+
+    def rotation_attributes
+      { person_ids: @person_ids, lock_version: params[:lock_version] || @schedule.lock_version }
+    end
+  end
+end

data/app/controllers/munawaba/schedules_controller.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class SchedulesController < ApplicationController
+    def index
+      @schedules = after_name_cursor(Schedule.order(:name, :id)).limit(page_size + 1).to_a
+      @more = @schedules.size > page_size
+      @schedules = @schedules.first(page_size)
+      @membership_counts = ScheduleMembership.where(schedule_id: @schedules.map(&:id)).group(:schedule_id).count
+    end
+
+    def show
+      @memberships = computed_roster(@schedule,
+                                     ScheduleMembership.where(schedule_id: @schedule.id).includes(:person).order(:position))
+      @shifts = Shift.where(schedule_id: @schedule.id, canceled_at: nil).where("ends_at > ?", Time.current)
+                     .includes(:effective_person, :base_person, :schedule).order(:starts_at).limit(100)
+      @current_shift = @shifts.find { |shift| shift.starts_at <= Time.current && shift.ends_at > Time.current }
+      prepare_resume_form if @schedule.state == "paused"
+    end
+
+    def new
+      @schedule = Schedule.new(cadence: "one_week", time_zone: Munawaba.config.default_schedule_time_zone,
+                               anchor_local_date: Date.current, anchor_local_seconds: 9 * 3600)
+    end
+
+    def create
+      @schedule = Schedule.new(schedule_attributes)
+      command(:create_schedule, @schedule, schedule_attributes, success_path: ->(record) {
+        schedule_path(record)
+      }, template: "new") do |result|
+        @schedule = result.record if result.record.is_a?(Schedule)
+      end
+    end
+
+    def edit; end
+
+    def update
+      command(:update_schedule, @schedule, schedule_attributes, success_path: schedule_path(@schedule),
+                                                                template: "edit") do |_result|
+        @schedule.assign_attributes(schedule_attributes.except(:lock_version))
+      end
+    end
+
+    def preview_activation
+      proposal(:activate, @schedule, lifecycle_attributes)
+    end
+
+    def preview_resume
+      if params[:edit_order] == "add"
+        prepare_resume_form
+        render :resume
+        return
+      end
+      proposal(:resume, @schedule, lifecycle_attributes)
+    end
+
+    def activate
+      confirm_lifecycle(:activate)
+    end
+
+    def resume
+      confirm_lifecycle(:resume)
+    end
+
+    def pause
+      return proposal(:pause, @schedule, lifecycle_attributes) if params[:proposal_token].blank?
+
+      confirm_lifecycle(:pause)
+    end
+
+    def cancel_scheduled
+      return proposal(:cancel_scheduled, @schedule, lifecycle_attributes) if params[:proposal_token].blank?
+
+      confirm_lifecycle(:cancel_scheduled)
+    end
+
+    private
+
+    def authorization_target
+      @schedule = Schedule.find(params[:id]) if params[:id]
+      [(%w[index show].include?(action_name) ? :read : :manage_schedules), @schedule || Schedule]
+    end
+
+    def schedule_attributes
+      attributes = record_parameters(:schedule).permit(:name, :cadence, :time_zone, :anchor_local_date,
+                                                       :anchor_local_time, :lock_version).to_h.symbolize_keys
+      if attributes.key?(:anchor_local_time)
+        value = attributes.delete(:anchor_local_time).to_s
+        attributes[:anchor_local_seconds] = value.match?(/\A(?:[01]\d|2[0-3]):[0-5]\d\z/) ? value.split(":").map(&:to_i).then { |h, m|
+          (h * 3600) + (m * 60)
+        } : -1
+      end
+      attributes
+    end
+
+    def lifecycle_attributes
+      array_parameter(:person_ids) if params.key?(:person_ids)
+      params.permit(:mode, :boundary_index, :lock_version, :lifecycle_revision, person_ids: []).to_h.symbolize_keys
+    end
+
+    def confirm_lifecycle(operation)
+      command(operation, @schedule, lifecycle_attributes, success_path: schedule_path(@schedule),
+                                                          template: "munawaba/shared/proposal") do
+        refresh_proposal(operation, @schedule, lifecycle_attributes)
+      end
+    end
+
+    def prepare_resume_form
+      @resume_people = Person.where(active: true).order(:name).to_a
+      ids = params.key?(:person_ids) ? array_parameter(:person_ids).reject(&:blank?) : ScheduleMembership.where(schedule_id: @schedule.id).order(:position).pluck(:person_id)
+      maximum = [Defaults::MAXIMUM_SCHEDULE_MEMBERS, @resume_people.length].min
+      @resume_ids = (ids + [nil]).first(maximum)
+    end
+  end
+end

data/app/controllers/munawaba/shifts_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class ShiftsController < ApplicationController
+    def show
+      @overrides = ShiftOverride.where(shift_id: @shift.id).order(created_at: :desc)
+    end
+
+    private
+
+    def authorization_target
+      @shift = Shift.includes(:schedule, :base_person, :effective_person).find(params[:id])
+      [:read, @shift]
+    end
+  end
+end

data/app/controllers/munawaba/slack_integrations_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class SlackIntegrationsController < ApplicationController
+    def edit; end
+
+    def update
+      finish Integrations.call(operation: :update, schedule: @schedule, attributes: integration_attributes, actor: actor)
+    end
+
+    def remove
+      finish Integrations.call(operation: :remove, schedule: @schedule, actor: actor, attributes: { lock_version: params[:lock_version] })
+    end
+
+    def test
+      finish Integrations.call(operation: :test, schedule: @schedule, actor: actor, attributes: { lock_version: params[:lock_version] })
+    end
+
+    private
+
+    def authorization_target
+      @schedule = Schedule.find(params[:schedule_id])
+      [:manage_integrations, @schedule]
+    end
+
+    def integration_attributes
+      record_parameters(:integration).permit(:slack_webhook_url, :slack_enabled, :notify_advance,
+                                             :advance_notice_seconds, :notify_shift_start, :notify_assignment_change,
+                                             :notify_next_assignment_change, :lock_version).to_h.symbolize_keys
+    end
+
+    def finish(result)
+      if result.success?
+        redirect_to edit_schedule_slack_integration_path(@schedule), status: :see_other, notice: "Slack settings saved."
+      else
+        @errors = Array(result.errors)
+        @stale = result.status.to_i == 409
+        @schedule.reload
+        if action_name == "update"
+          @schedule.assign_attributes(integration_attributes.except(:slack_webhook_url, :lock_version))
+        end
+        render :edit, status: result.status
+      end
+    end
+  end
+end

data/app/controllers/munawaba/themes_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class ThemesController < ApplicationController
+    def update
+      return head :unprocessable_entity unless %w[dark light].include?(params[:theme])
+
+      cookies.permanent[:munawaba_theme] =
+        { value: params[:theme], same_site: :lax, httponly: true, secure: request.ssl? }
+      redirect_back fallback_location: root_path, allow_other_host: false, status: :see_other
+    end
+
+    private
+
+    def authorization_target
+      [:read, :theme]
+    end
+  end
+end

data/app/helpers/munawaba/application_helper.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Munawaba
+  module ApplicationHelper
+    CADENCES = { "one_week" => "One week", "two_weeks" => "Two weeks", "calendar_month" => "One calendar month" }.freeze
+
+    def page_title(title, subtitle = nil)
+      content_for(:title, title)
+      content_tag(:div, class: "mn-heading") do
+        safe_join([content_tag(:h1, title), (content_tag(:p, subtitle, class: "mn-muted") if subtitle)].compact)
+      end
+    end
+
+    def state_badge(value)
+      content_tag(:span, value.to_s.humanize, class: "mn-badge mn-badge-#{value.to_s.parameterize}")
+    end
+
+    def effective_schedule_state(schedule)
+      @mn_display_now ||= Time.current
+      if schedule.state == "scheduled" && schedule.coverage_starts_at && schedule.coverage_starts_at <= @mn_display_now
+        "active"
+      elsif schedule.state == "pausing" && schedule.pause_effective_at && schedule.pause_effective_at <= @mn_display_now
+        "paused"
+      else
+        schedule.state
+      end
+    end
+
+    def lifecycle_maintenance_warning(schedule)
+      case [schedule.state, effective_schedule_state(schedule)]
+      when ["scheduled", "active"]
+        "Coverage has started. Waiting for the next maintenance run."
+      when ["pausing", "paused"]
+        "Coverage has paused. Waiting for the next maintenance run before you can resume."
+      end
+    end
+
+    def shift_dst_adjustments(shift)
+      @mn_boundary_calculators ||= {}
+      @mn_boundary_metadata ||= {}
+      calculator = (@mn_boundary_calculators[shift.schedule_id] ||= Timing::BoundaryCalculator.new(shift.schedule))
+      [["Start", shift.boundary_index, shift.starts_at],
+       ["End", shift.boundary_index + 1, shift.ends_at]].filter_map do |edge, index, persisted_at|
+        boundary = (@mn_boundary_metadata[[shift.schedule_id, index]] ||= calculator.boundary(index))
+        # Started shifts keep their saved times after timezone rules change.
+        # Describe a DST adjustment only when it matches the saved boundary.
+        next if boundary.resolution == "exact" || boundary.resolved_at != persisted_at
+
+        boundary_adjustment_text(boundary, edge: edge, zone: shift.schedule.time_zone)
+      end
+    end
+
+    def boundary_adjustment_text(boundary, edge:, zone:)
+      nominal_time = format("%02d:%02d", boundary.nominal_local_seconds / 3600,
+                            boundary.nominal_local_seconds % 3600 / 60)
+      offset = boundary.utc_offset_seconds
+      offset_text = format("UTC%s%02d:%02d", offset.negative? ? "-" : "+", offset.abs / 3600, offset.abs % 3600 / 60)
+      offset_text += format(":%02d", offset.abs % 60) unless (offset % 60).zero?
+      adjustment = boundary.adjustment_seconds
+      duration = (adjustment % 60).zero? ? pluralize(adjustment / 60, "minute") : pluralize(adjustment, "second")
+      resolution = boundary.resolution == "ambiguous_earlier" ? "earlier occurrence" : "moved forward"
+      "DST adjustment · #{edge}: scheduled #{boundary.nominal_local_date} #{nominal_time} #{zone} → #{local_time(
+        boundary.resolved_at, zone
+      )}, #{offset_text}; #{resolution}, #{duration}."
+    end
+
+    def local_time(value, zone = nil, format: "%b %-d, %Y · %H:%M")
+      return "—" unless value
+
+      value = Time.iso8601(value) if value.is_a?(String)
+      value.in_time_zone(zone || Munawaba.config.organization_time_zone).strftime(format)
+    end
+
+    def handoff_time(schedule)
+      seconds = schedule.anchor_local_seconds.to_i
+      format("%02d:%02d", seconds / 3600, seconds % 3600 / 60)
+    end
+
+    def cadence_name(schedule)
+      CADENCES.fetch(schedule.cadence, schedule.cadence.to_s.humanize)
+    end
+
+    def nav_link(label, path, key)
+      active = controller_name == key || (key == "schedules" && %w[rotations slack_integrations shifts
+                                                                   overrides].include?(controller_name))
+      link_to label, path, class: "mn-nav-link#{" mn-selected" if active}", aria: { current: ("page" if active) }
+    end
+
+    def model_errors(record, field)
+      return unless record && record.errors[field].present?
+
+      content_tag(:p, record.errors[field].join(", "), class: "mn-field-error",
+                                                       id: "#{record.model_name.param_key}_#{field}_error")
+    end
+
+    def preview_value(key, default = nil)
+      return default unless @preview
+
+      value = @preview.public_send(key)
+      value.nil? ? default : value
+    end
+
+    def detail_value(key, default = nil)
+      details = preview_value(:details, {})
+      details[key] || default
+    end
+
+    def projection_slots
+      Array(preview_value(:projection, []))
+    end
+
+    def person_label(id)
+      @mn_person_labels ||= Person.where(id: (projection_slots.map { |slot| slot[:effective_person_id] } +
+        Array(detail_value(:ordered_person_ids)) + Array(detail_value(:schedule_plans)).flat_map { |plan|
+                                                     Array(plan[:before_person_ids]) + Array(plan[:person_ids])
+                                                   }).compact.uniq).pluck(:id, :name).to_h
+      @mn_person_labels[id.to_i] || Person.where(id: id).pick(:name) || "Person ##{id}"
+    end
+
+    def confirmation_target
+      case @operation.to_sym
+      when :activate then [activate_schedule_path(@subject), :post]
+      when :resume then [resume_schedule_path(@subject), :post]
+      when :rotation then [schedule_rotation_path(@subject), :patch]
+      when :deactivate then [deactivate_person_path(@subject), :patch]
+      when :pause then [pause_schedule_path(@subject), :post]
+      when :cancel_scheduled then [cancel_scheduled_schedule_path(@subject), :post]
+      when :revoke then [revoke_shift_override_path(@subject), :patch]
+      when :restore_to_base then [restore_shift_override_path(@subject), :patch]
+      else [shift_override_path(@subject), :post]
+      end
+    end
+
+    def proposal_heading
+      { activate: "Review activation", resume: "Review resume", rotation: "Review rotation", deactivate: "Review deactivation",
+        override: "Review override", revoke: "Review override revocation", restore_to_base: "Review restore to base",
+        pause: "Review pause", cancel_scheduled: "Review scheduled cancellation" }.fetch(@operation.to_sym)
+    end
+
+    def proposal_back_path
+      @subject.is_a?(Person) ? person_path(@subject) : @subject.is_a?(Shift) ? shift_path(@subject) : schedule_path(@subject)
+    end
+
+    def submitted_hidden_fields(attributes)
+      safe_join(attributes.flat_map do |key, value|
+        value.is_a?(Array) ? value.map { |item|
+          hidden_field_tag("#{key}[]", item, id: nil)
+        } : hidden_field_tag(key, value, id: nil)
+      end)
+    end
+
+    def cursor_for(record, column)
+      "#{record.public_send(column).utc.iso8601(6)}|#{record.id}"
+    end
+
+    def name_cursor_for(record)
+      Base64.urlsafe_encode64(JSON.generate([record.name, record.id]), padding: false)
+    end
+
+    def calendar_link(date, view = @view)
+      calendar_path(request.query_parameters.except("date", "until", "view").merge(date: date.iso8601, view: view))
+    end
+
+    def calendar_days
+      first = @from.beginning_of_week(Munawaba.config.week_starts_on)
+      last = (@until - 1).end_of_week(Munawaba.config.week_starts_on)
+      (first..last).to_a
+    end
+
+    def future_boundaries(schedule)
+      Timing::BoundaryCalculator.new(schedule).selectable_boundaries(now: Time.current).map do |boundary|
+        [local_time(boundary.resolved_at, schedule.time_zone), boundary.index]
+      end
+    end
+
+    def readable_conflict(conflict, zone)
+      @mn_conflict_schedules ||= Schedule.where(id: Array(preview_value(:conflicts, [])).flat_map { |entry|
+        [entry[0], entry[4]]
+      }).pluck(:id, :name).to_h
+      from = Time.at(Rational(conflict[9], 1_000_000)).utc
+      until_at = Time.at(Rational(conflict[10], 1_000_000)).utc
+      "#{person_label(conflict[8])} · #{@mn_conflict_schedules[conflict[0]]} and #{@mn_conflict_schedules[conflict[4]]} · #{local_time(
+        from, zone
+      )} – #{local_time(until_at, zone)} · #{zone}"
+    end
+
+    def shifts_on(day)
+      zone = ActiveSupport::TimeZone[@time_zone]
+      start_at = zone.local(day.year, day.month, day.day)
+      next_day = day + 1
+      end_at = zone.local(next_day.year, next_day.month, next_day.day)
+      @shifts.select { |shift| shift.starts_at < end_at && shift.ends_at > start_at }
+    end
+
+    def conflicts_for(shifts)
+      ids = shifts.map(&:id)
+      return {} if ids.empty?
+
+      sql = Shift.sanitize_sql_array([<<~SQL, ids])
+        SELECT a.id, b.schedule_id, s.name FROM munawaba_shifts a
+        JOIN munawaba_shifts b ON a.effective_person_id = b.effective_person_id AND a.schedule_id <> b.schedule_id
+          AND b.canceled_at IS NULL AND tstzrange(a.starts_at, a.ends_at, '[)') && tstzrange(b.starts_at, b.ends_at, '[)')
+        JOIN munawaba_schedules s ON s.id = b.schedule_id WHERE a.id IN (?) AND a.canceled_at IS NULL
+      SQL
+      Shift.connection.select_all(sql).to_a.group_by { |row| row["id"].to_i }
+    end
+  end
+end

data/app/jobs/munawaba/application_job.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class ApplicationJob < ActiveJob::Base
+    queue_as { Munawaba.config.job_queue_name }
+  end
+end

data/app/jobs/munawaba/deliver_notification_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class DeliverNotificationJob < ApplicationJob
+    def perform(delivery_id, claim_token)
+      if ActiveRecord::Base.connection.transaction_open?
+        raise Munawaba::Error, "Delivery jobs must run outside host database transactions"
+      end
+
+      Notifications::Deliver.call(delivery_id, claim_token)
+    end
+  end
+end

data/app/jobs/munawaba/dispatch_due_notifications_job.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Munawaba
+  class DispatchDueNotificationsJob < ApplicationJob
+    def perform = Notifications::Dispatcher.call
+  end
+end

data/app/jobs/munawaba/maintain_projection_job.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Munawaba
+  # Run daily, or enqueue a single schedule after a scheduling change.
+  class MaintainProjectionJob < ApplicationJob
+    def perform(schedule_id = nil, observed_revision = nil)
+      scope = Schedule.where(state: %w[scheduled active pausing])
+      scope = scope.where(id: schedule_id) if schedule_id
+      failure = nil
+      scope.find_each(batch_size: 100) do |schedule|
+        if schedule.state == "pausing"
+          next if observed_revision
+
+          Shifts::NormalizeFutureTiming.call(schedule: schedule)
+        else
+          Shifts::Project.call(schedule: schedule, observed_revision: observed_revision)
+        end
+      rescue StandardError => error
+        failure ||= error
+        Munawaba.signal("maintenance_failed", task: "projection", schedule_id: schedule.id)
+      end
+      raise failure if failure
+    end
+  end
+end