lemmy/crates/apub/src/protocol/objects/mod.rs

use lemmy_api_common::utils::blocking;
use lemmy_db_schema::{newtypes::LanguageId, source::language::Language, utils::DbPool};
use lemmy_utils::error::LemmyError;
use serde::{Deserialize, Serialize};
use url::Url;

pub(crate) mod chat_message;
pub(crate) mod group;
pub(crate) mod instance;
pub(crate) mod note;
pub(crate) mod page;
pub(crate) mod person;
pub(crate) mod tombstone;

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Endpoints {
  pub shared_inbox: Url,
}

/// As specified in https://schema.org/Language
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct LanguageTag {
  pub(crate) identifier: String,
  pub(crate) name: String,
}

impl LanguageTag {
  pub(crate) async fn new_single(
    lang: LanguageId,
    pool: &DbPool,
  ) -> Result<Option<LanguageTag>, LemmyError> {
    let lang = blocking(pool, move |conn| Language::read_from_id(conn, lang)).await??;

    // undetermined
    if lang.code == "und" {
      Ok(None)
    } else {
      Ok(Some(LanguageTag {
        identifier: lang.code,
        name: lang.name,
      }))
    }
  }

  pub(crate) async fn new_multiple(
    langs: Vec<LanguageId>,
    pool: &DbPool,
  ) -> Result<Vec<LanguageTag>, LemmyError> {
    let langs = blocking(pool, move |conn| {
      langs
        .into_iter()
        .map(|l| Language::read_from_id(conn, l))
        .collect::<Result<Vec<Language>, diesel::result::Error>>()
    })
    .await??;

    let langs = langs
      .into_iter()
      .map(|l| LanguageTag {
        identifier: l.code,
        name: l.name,
      })
      .collect();
    Ok(langs)
  }

  pub(crate) async fn to_language_id_single(
    lang: Option<Self>,
    pool: &DbPool,
  ) -> Result<Option<LanguageId>, LemmyError> {
    let identifier = lang.map(|l| l.identifier);
    let language = blocking(pool, move |conn| {
      Language::read_id_from_code_opt(conn, identifier.as_deref())
    })
    .await??;

    Ok(language)
  }

  pub(crate) async fn to_language_id_multiple(
    langs: Vec<Self>,
    pool: &DbPool,
  ) -> Result<Vec<LanguageId>, LemmyError> {
    let languages = blocking(pool, move |conn| {
      langs
        .into_iter()
        .map(|l| l.identifier)
        .map(|l| Language::read_id_from_code(conn, &l))
        .collect::<Result<Vec<LanguageId>, diesel::result::Error>>()
    })
    .await??;
    Ok(languages)
  }
}

#[cfg(test)]
mod tests {
  use crate::protocol::{
    objects::{
      chat_message::ChatMessage,
      group::Group,
      instance::Instance,
      note::Note,
      page::Page,
      person::Person,
      tombstone::Tombstone,
    },
    tests::{test_json, test_parse_lemmy_item},
  };

  #[test]
  fn test_parse_objects_lemmy() {
    test_parse_lemmy_item::<Instance>("assets/lemmy/objects/instance.json").unwrap();
    test_parse_lemmy_item::<Group>("assets/lemmy/objects/group.json").unwrap();
    test_parse_lemmy_item::<Person>("assets/lemmy/objects/person.json").unwrap();
    test_parse_lemmy_item::<Page>("assets/lemmy/objects/page.json").unwrap();
    test_parse_lemmy_item::<Note>("assets/lemmy/objects/note.json").unwrap();
    test_parse_lemmy_item::<ChatMessage>("assets/lemmy/objects/chat_message.json").unwrap();
    test_parse_lemmy_item::<Tombstone>("assets/lemmy/objects/tombstone.json").unwrap();
  }

  #[test]
  fn test_parse_objects_pleroma() {
    test_json::<Person>("assets/pleroma/objects/person.json").unwrap();
    test_json::<Note>("assets/pleroma/objects/note.json").unwrap();
    test_json::<ChatMessage>("assets/pleroma/objects/chat_message.json").unwrap();
  }

  #[test]
  fn test_parse_objects_smithereen() {
    test_json::<Person>("assets/smithereen/objects/person.json").unwrap();
    test_json::<Note>("assets/smithereen/objects/note.json").unwrap();
  }

  #[test]
  fn test_parse_objects_mastodon() {
    test_json::<Person>("assets/mastodon/objects/person.json").unwrap();
    test_json::<Note>("assets/mastodon/objects/note.json").unwrap();
  }

  #[test]
  fn test_parse_objects_lotide() {
    test_json::<Group>("assets/lotide/objects/group.json").unwrap();
    test_json::<Person>("assets/lotide/objects/person.json").unwrap();
    test_json::<Note>("assets/lotide/objects/note.json").unwrap();
    test_json::<Page>("assets/lotide/objects/page.json").unwrap();
    test_json::<Tombstone>("assets/lotide/objects/tombstone.json").unwrap();
  }

  #[test]
  fn test_parse_object_friendica() {
    test_json::<Person>("assets/friendica/objects/person_1.json").unwrap();
    test_json::<Person>("assets/friendica/objects/person_2.json").unwrap();
    test_json::<Page>("assets/friendica/objects/page_1.json").unwrap();
    test_json::<Page>("assets/friendica/objects/page_2.json").unwrap();
    test_json::<Note>("assets/friendica/objects/note_1.json").unwrap();
    test_json::<Note>("assets/friendica/objects/note_2.json").unwrap();
  }

  #[test]
  fn test_parse_object_gnusocial() {
    test_json::<Person>("assets/gnusocial/objects/person.json").unwrap();
    test_json::<Group>("assets/gnusocial/objects/group.json").unwrap();
    test_json::<Page>("assets/gnusocial/objects/page.json").unwrap();
    test_json::<Note>("assets/gnusocial/objects/note.json").unwrap();
  }

  #[test]
  fn test_parse_object_peertube() {
    test_json::<Person>("assets/peertube/objects/person.json").unwrap();
    test_json::<Group>("assets/peertube/objects/group.json").unwrap();
    test_json::<Page>("assets/peertube/objects/video.json").unwrap();
    test_json::<Note>("assets/peertube/objects/note.json").unwrap();
  }
}