macltok

//! the homeserver side of `POST /_matrix/push/v1/notify`, for a gateway that holds no session

use ruma_common::{OwnedEventId, OwnedRoomAliasId, OwnedRoomId, OwnedUserId};

use serde::{Deserialize, Serialize};

use serde_json::{Map, Value, value::RawValue};

#[derive(Clone, Debug, Deserialize)]

#[non_exhaustive]

pub struct GatewayNotification {

    pub event_id: Option<OwnedEventId>,

    pub room_id: Option<OwnedRoomId>,

    #[serde(rename = "type")]

    pub event_type: Option<String>,

    pub sender: Option<OwnedUserId>,

    pub sender_display_name: Option<String>,

    pub room_name: Option<String>,

    pub room_alias: Option<OwnedRoomAliasId>,

    #[serde(default)]

    pub user_is_target: bool,

    #[serde(default)]

    pub prio: NotifyPrio,

    /// only in the full format, and still encrypted for an encrypted room

    pub content: Option<Box<RawValue>>,

    #[serde(default)]

    pub counts: NotifyCounts,

    #[serde(default)]

    pub devices: Vec<GatewayDevice>,

}

impl GatewayNotification {

    /// a count-only push carries no event, and iOS punishes a web push that shows nothing

    pub fn is_event(&self) -> bool {

        self.event_id.is_some()

    }

}

#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq)]

#[serde(rename_all = "lowercase")]

pub enum NotifyPrio {

    #[default]

    High,

    Low,

}

#[derive(Clone, Copy, Debug, Default, Deserialize, Eq, PartialEq)]

#[non_exhaustive]

pub struct NotifyCounts {

    #[serde(default)]

    pub unread: u64,

    #[serde(default)]

    pub missed_calls: u64,

}

#[derive(Clone, Debug, Deserialize)]

#[non_exhaustive]

pub struct GatewayDevice {

    pub app_id: String,

    pub pushkey: String,

    pub pushkey_ts: Option<u64>,

    /// the pusher's data as it was set, `format` included

    #[serde(default)]

    pub data: Map<String, Value>,

    #[serde(default)]

    pub tweaks: Map<String, Value>,

}

#[derive(Deserialize)]

struct NotifyBody {

    notification: GatewayNotification,

}

pub fn parse_notify(body: &[u8]) -> Result<GatewayNotification, serde_json::Error> {

    serde_json::from_slice::<NotifyBody>(body).map(|body| body.notification)

}

/// the pushkeys the homeserver should drop, such as one whose web push endpoint answered 404 or 410

pub fn notify_response(rejected: &[String]) -> Vec<u8> {

    #[derive(Serialize)]

    struct Response<'a> {

        rejected: &'a [String],

    }

    serde_json::to_vec(&Response { rejected }).expect("a list of strings serialises")

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn a_count_only_push_is_no_event_and_devices_keep_their_data() {

        let body = br#"{"notification":{"counts":{"unread":2},"devices":[{"app_id":"me.malice","pushkey":"https://push.example/abc","data":{"format":"event_id_only","endpoint":"https://push.example/abc","auth":"secret"},"tweaks":{"sound":"default"}}]}}"#;

        let notification = parse_notify(body).unwrap();

        assert!(!notification.is_event());

        assert_eq!(notification.counts.unread, 2);

        assert_eq!(notification.prio, NotifyPrio::High);

        assert_eq!(notification.devices[0].data["auth"], "secret");

        assert_eq!(notification.devices[0].tweaks["sound"], "default");

        let body = br#"{"notification":{"event_id":"$e","room_id":"!r:example.org","type":"m.room.message","sender":"@a:example.org","prio":"low","content":{"body":"hi"},"devices":[]}}"#;

        let notification = parse_notify(body).unwrap();

        assert!(notification.is_event());

        assert_eq!(notification.prio, NotifyPrio::Low);

        assert_eq!(notification.content.unwrap().get(), r#"{"body":"hi"}"#);

        assert_eq!(

            notify_response(&["gone".to_owned()]),

            br#"{"rejected":["gone"]}"#

        );

    }

}