nyanoblog/src/job/inbox.rs

use crate::ap::processor::process_document;
use async_trait::async_trait;
use mime::Mime;
use serde::{de, de::Visitor, Deserialize, Deserializer, Serialize, Serializer};
use std::fmt;
use std::str::FromStr;

use super::Job;
use crate::core::*;
use crate::state::AppState;

#[derive(Serialize, Deserialize)]
pub struct InboxWorker {
    raw: String,
    #[serde(
        serialize_with = "serialize_mime",
        deserialize_with = "deserialize_mime"
    )]
    mime: Mime,
}

impl InboxWorker {
    pub fn new(raw: String, mime: Mime) -> InboxWorker {
        InboxWorker { raw, mime }
    }
}

#[async_trait]
impl Job for InboxWorker {
    async fn perform(&self, state: &AppState) -> Result<()> {
        process_document(state, &self.raw, &self.mime).await
    }

    fn name(&self) -> &'static str {
        "inbox"
    }
}

impl fmt::Debug for InboxWorker {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ActivityPub ingress: {}", &self.raw)
    }
}

fn serialize_mime<S: Serializer>(val: &Mime, ser: S) -> StdResult<S::Ok, S::Error> {
    let string = format!("{val}");
    ser.serialize_str(&string)
}

struct MimeVisitor;

impl<'de> Visitor<'de> for MimeVisitor {
    type Value = Mime;

    fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("a valid MIME media type")
    }

    fn visit_str<E: de::Error>(self, val: &str) -> StdResult<Mime, E> {
        Mime::from_str(val).map_err(|e| E::custom(e.to_string()))
    }
}

fn deserialize_mime<'de, D: Deserializer<'de>>(de: D) -> StdResult<Mime, D::Error> {
    de.deserialize_str(MimeVisitor)
}