SNot/src/notification.rs

use crate::formats::serde::serialize_actions;
use serde::Serialize;
use std::collections::HashMap;
use zbus::{message::Body, Result};
use zvariant::OwnedValue;

// A notificaion object
#[derive(Serialize)] // To help with json, rson
pub struct Notification {
    // The application that sent the notification
    app_name: String,
    // (Optional) ID of an existing notification to be updated, replaced by this
    replace_id: u32,
    // See icon specifications: https://specifications.freedesktop.org/notification-spec/latest/icons-and-images.html
    icon: String,
    // Notification title
    summary: String,
    // Notification content/body
    body: String,
    // Action requests that can be sent back to the client - "Reply," "Mark as Read," "Play/Pause/Next," "Snooze/Dismiss," etc.
    #[serde(serialize_with = "serialize_actions")]
    actions: Vec<String>,
    // Useful extra data - notif type, urgency, notif sound, icon data, etc.
    //#[serde(serialize_with = "serialize_hints")]
    hints: HashMap<String, OwnedValue>,
    // Seconds till this notif expires. Optional
    expir_timeout: i32,
}

impl Notification {
    // App name
    pub fn app_name(&self) -> String {
        self.app_name.clone()
    }
    // Replace ID
    pub fn replace_id(&self) -> u32 {
        self.replace_id
    }
    // Icon
    pub fn icon(&self) -> String {
        self.icon.clone()
    }
    // Summary
    pub fn summary(&self) -> String {
        self.summary.clone()
    }
    // Body
    pub fn body(&self) -> String {
        self.body.clone()
    }

    // Key:Val pairs of actions
    pub fn actions(&self) -> Vec<(String, String)> {
        self.actions
            .chunks(2)
            .map(|chunk| (chunk[0].clone(), chunk[1].clone()))
            .collect()
    }

    // Hints
    pub fn hints(&self) -> &HashMap<String, OwnedValue> {
        &self.hints
    }

    // Expiry timeout
    pub fn expir_timeout(&self) -> i32 {
        self.expir_timeout
    }

    // Default action
    pub fn default_action(&self) -> Option<(String, String)> {
        if self.actions().is_empty() {
            None
        } else {
            Some(self.actions()[0].clone())
        }
    }

    // Urgency
    pub fn urgency(&self) -> String {
        match self.hints.get("urgency") {
            Some(value) => {
                // Attempt to convert OwnedValue to u8
                match u8::try_from(value) {
                    Ok(0) => "Low".to_string(),
                    Ok(1) => "Normal".to_string(),
                    Ok(2) => "Critical".to_string(),
                    _ => "Other".to_string(), // There are no accepted values other that these 3
                }
            }
            None => "Unknown".to_string(), // This possibly never occurs, or something might be wrong
        }
    }
}

// Convert the DBus message body into Notification
pub fn to_notif(msg_body: &Body) -> Result<Notification> {
    // Deserialize body into a tuple
    let (app_name, replace_id, icon, summary, body, actions, hints, expir_timeout) =
        msg_body.deserialize()?;
    // Form a Notification object from the obtained tuple's fields
    Ok(Notification {
        app_name,
        replace_id,
        icon,
        summary,
        body,
        actions,
        hints,
        expir_timeout,
    })
}