Notification preferences

use navree::mail::TemplateMail;
use navree::notify::{Channel, Notifiable, Notification, SmsMessage, notification};
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use uuid::Uuid;

/// A deal the user follows was won.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct DealWon {
    pub deal_id: Uuid,
    pub title: String,
}

#[notification(category = "deals", digest = "daily")]
impl Notification for DealWon {
    const TYPE: &'static str = "deal.won";

    fn via(&self, _notifiable: &dyn Notifiable) -> Vec<Channel> {
        vec![Channel::Database, Channel::Mail, Channel::Sms]
    }

    fn to_database(&self, _notifiable: &dyn Notifiable) -> Option<Value> {
        Some(json!({
            "title": "Deal won",
            "message": self.title,
            "url": format!("/deals/{}", self.deal_id),
        }))
    }

    fn to_mail(&self, _notifiable: &dyn Notifiable) -> Option<TemplateMail> {
        Some(TemplateMail {
            subject: format!("Deal won: {}", self.title),
            template: "mail/deal-won".into(),
            context: json!({ "title": self.title }),
            ..TemplateMail::default()
        })
    }

    fn to_sms(&self, _notifiable: &dyn Notifiable) -> Option<SmsMessage> {
        Some(SmsMessage::new(format!("Deal won: {}", self.title)))
    }
}

/// A one-time sign-in code.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SignInCode {
    pub code: String,
}

#[notification(category = "security", urgent)]
impl Notification for SignInCode {
    const TYPE: &'static str = "auth.sign_in_code";

    fn via(&self, _notifiable: &dyn Notifiable) -> Vec<Channel> {
        vec![Channel::Sms]
    }

    fn to_sms(&self, _notifiable: &dyn Notifiable) -> Option<SmsMessage> {
        Some(SmsMessage::new(format!("Your sign-in code is {}", self.code)))
    }
}

#[module(imports = [
    NotifyModule::for_feature::<DealWon>(),
    NotifyModule::for_feature::<SignInCode>(),
    NotifyModule::for_feature::<TrainingDue>(),
])]
pub struct DealsModule;

{
  "channels": { "sms": false },
  "categories": {
    "deals": { "channels": { "mail": true }, "digest": "weekly" },
    "training": { "channels": { "web_push": false } }
  },
  "digest": "daily",
  "quiet_hours": { "start": "22:00", "end": "07:00" }
}

/// A member of a workspace, as the recipient of notifications.
#[derive(Clone, Debug)]
pub struct Member {
    pub user_id: Uuid,
    pub workspace_id: Uuid,
    pub email: String,
    pub mobile: Option<String>,
    /// The zone the member picked in their profile, if any.
    pub time_zone: Option<String>,
}

impl Notifiable for Member {
    fn notifiable_type(&self) -> &'static str {
        USER_NOTIFIABLE_TYPE
    }

    fn notifiable_id(&self) -> String {
        self.user_id.to_string()
    }

    fn route_mail(&self) -> Option<String> {
        Some(self.email.clone())
    }

    fn route_sms(&self) -> Option<String> {
        self.mobile.clone()
    }

    fn workspace_id(&self) -> Option<Uuid> {
        Some(self.workspace_id)
    }

    fn time_zone(&self) -> Option<String> {
        self.time_zone.clone()
    }
}

let owner = PreferenceOwner::user(user_id);
preferences
    .update(
        &owner,
        &json!({
            "categories": { "deals": { "channels": { "sms": false }, "digest": "weekly" } },
            "quiet_hours": { "start": "22:00", "end": "07:00" },
        }),
    )
    .await?;

let resolved = preferences.resolve(&member, Some(member.workspace_id)).await?;
assert!(!resolved.allows("deals", Channel::Sms));
assert_eq!(resolved.digest("deals", Digest::Daily), Digest::Weekly);

GET /api/notifications/preferences
Authorization: Bearer eyJhbGciOiJFZERTQSJ9...

{
  "data": { "categories": { "deals": { "channels": { "sms": false } } } },
  "workspace": { "channels": { "whatsapp": false } },
  "categories": [
    {
      "category": "deals",
      "types": ["deal.won"],
      "required": false,
      "digest": "daily",
      "channels": { "mail": true, "database": true, "slack": true, "teams": true, "sms": false, "whatsapp": false, "web_push": true }
    },
    {
      "category": "security",
      "types": ["auth.sign_in_code"],
      "required": true,
      "digest": "off",
      "channels": { "mail": true, "database": true, "slack": true, "teams": true, "sms": true, "whatsapp": true, "web_push": true }
    }
  ],
  "channels": ["mail", "database", "slack", "teams", "sms", "whatsapp", "web_push"],
  "time_zone": "Asia/Kolkata"
}

PATCH /api/notifications/preferences
Content-Type: application/json

{ "categories": { "deals": { "digest": "weekly", "channels": { "sms": null } } }, "quiet_hours": { "start": "22:00", "end": "07:00" } }

{ "statusCode": 400, "message": "security notifications cannot be turned off", "error": "Bad Request", "code": "validation_failed", "errors": { "categories.security.channels.sms": ["security notifications cannot be turned off"] } }

{{ count }} update{% if count != 1 %}s{% endif %} since your last digest
{% for item in items %}
- {{ item.subject }}{% if item.text %}
  {{ item.text }}{% endif %}
{% endfor %}

/// A training module is due.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct TrainingDue {
    pub module: String,
}

impl Notification for TrainingDue {
    const TYPE: &'static str = "training.due";
    const CATEGORY: &'static str = "training";

    fn via(&self, _notifiable: &dyn Notifiable) -> Vec<Channel> {
        vec![Channel::Database, Channel::Mail]
    }

    fn send_window(&self, _notifiable: &dyn Notifiable) -> Option<SendWindow> {
        Some(SendWindow::weekdays().between("09:00", "17:00"))
    }

    fn to_mail(&self, _notifiable: &dyn Notifiable) -> Option<TemplateMail> {
        Some(TemplateMail {
            subject: format!("{} is due", self.module),
            template: "mail/training-due".into(),
            context: json!({ "module": self.module }),
            ..TemplateMail::default()
        })
    }
}

cargo run -- notify:release

released 3 held notifications, 1 digest (4 mails batched); 0 dropped, 0 to retry

PATCH /api/settings/notification-templates?scope=workspace
Content-Type: application/json

{
  "logo_url": "https://cdn.acme.test/logo.png",
  "brand_color": "#0F766E",
  "footer": "Acme Corp, 12 Harbour Road, Pune",
  "templates": {
    "training.due": { "subject": "Acme Academy: {{ module }}" }
  }
}

{% if style.logo_url %}<img src="{{ style.logo_url }}" alt="" height="32">{% endif %}
<h1{% if style.brand_color %} style="color: {{ style.brand_color }}"{% endif %}>{{ title }} was won</h1>
{% if style.footer %}<p>{{ style.footer }}</p>{% endif %}

[notify.preferences]
enabled = true                        # apply stored preferences when sending
channels = ["mail", "database", "slack", "teams", "sms", "whatsapp", "web_push"]
required = ["security"]               # categories that can't be turned off
workspace_permission = "workspace.update"

[notify.digest]
at = "09:00"                          # daily and weekly digests, recipient's clock
weekly_on = "monday"
subject = "Your notifications"
template = "notify/digest"

[notify.deferred]
channels = ["mail", "slack", "teams", "sms", "whatsapp", "web_push"]
batch = 500
max_attempts = 5
retry_secs = 300
schedule = true

#[tokio::test]
async fn deal_mail_waits_for_the_morning_digest() {
    // Wednesday 20:00 UTC is 01:30 on Thursday in Kolkata.
    let clock = Arc::new(FixedClock::new("2026-10-28T20:00:00Z".parse().unwrap()));
    let sms = SmsFake::new();
    let app = TestApp::builder()
        .temp_database()
        .config("mail.transport", "array")
        .config("notify.routes", false)
        .module(DatabaseModule::from_config())
        .module(ViewModule::from_config())
        .module(Templates)
        .module(MailModule::from_config())
        .module(NotifyModule::from_config())
        .override_value::<dyn Clock>(clock.clone())
        .override_value::<dyn SmsDriver>(sms.driver())
        .build()
        .await;
    let notifier = app.get::<Notifier>().await;
    let priya = member("Asia/Kolkata");

    for title in ["Acme renewal", "Globex expansion"] {
        let won = DealWon {
            deal_id: Uuid::now_v7(),
            title: title.into(),
        };
        notifier.send(&priya, won).await.unwrap();
    }
    // The texts go out at once; the mail waits for the digest.
    assert_eq!(sms.sent().len(), 2);
    let mailer = app.get::<Mailer>().await;
    let mail = mailer.array_transport().unwrap();
    assert!(mail.sent().is_empty());

    // 09:00 in Kolkata: one mail lists both deals.
    clock.set("2026-10-29T03:30:00Z".parse().unwrap());
    let released = notifier.release_due().await.unwrap();
    assert_eq!((released.digests, released.batched), (1, 2));
    let digest = &mail.sent()[0];
    assert_eq!(digest.to, [priya.email.as_str()]);
    assert!(digest.text.as_deref().unwrap().contains("Deal won: Acme renewal"));
}