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

   1 use lemmy_db_schema::{
   2   impls::actor_language::UNDETERMINED_ID,
   3   newtypes::LanguageId,
   4   source::language::Language,
   5   utils::DbPool,
   6 };
   7 use lemmy_utils::error::LemmyError;
   8 use serde::{Deserialize, Serialize};
   9 use url::Url;
  10
  11 pub(crate) mod chat_message;
  12 pub(crate) mod group;
  13 pub(crate) mod instance;
  14 pub(crate) mod note;
  15 pub(crate) mod page;
  16 pub(crate) mod person;
  17 pub(crate) mod tombstone;
  18
  19 #[derive(Clone, Debug, Deserialize, Serialize)]
  20 #[serde(rename_all = "camelCase")]
  21 pub struct Endpoints {
  22   pub shared_inbox: Url,
  23 }
  24
  25 /// As specified in https://schema.org/Language
  26 #[derive(Clone, Debug, Deserialize, Serialize)]
  27 #[serde(rename_all = "camelCase")]
  28 pub(crate) struct LanguageTag {
  29   pub(crate) identifier: String,
  30   pub(crate) name: String,
  31 }
  32
  33 impl LanguageTag {
  34   pub(crate) async fn new_single(
  35     lang: LanguageId,
  36     pool: &mut DbPool<'_>,
  37   ) -> Result<Option<LanguageTag>, LemmyError> {
  38     let lang = Language::read_from_id(pool, lang).await?;
  39
  40     // undetermined
  41     if lang.id == UNDETERMINED_ID {
  42       Ok(None)
  43     } else {
  44       Ok(Some(LanguageTag {
  45         identifier: lang.code,
  46         name: lang.name,
  47       }))
  48     }
  49   }
  50
  51   pub(crate) async fn new_multiple(
  52     lang_ids: Vec<LanguageId>,
  53     pool: &mut DbPool<'_>,
  54   ) -> Result<Vec<LanguageTag>, LemmyError> {
  55     let mut langs = Vec::<Language>::new();
  56
  57     for l in lang_ids {
  58       langs.push(Language::read_from_id(pool, l).await?);
  59     }
  60
  61     let langs = langs
  62       .into_iter()
  63       .map(|l| LanguageTag {
  64         identifier: l.code,
  65         name: l.name,
  66       })
  67       .collect();
  68     Ok(langs)
  69   }
  70
  71   pub(crate) async fn to_language_id_single(
  72     lang: Option<Self>,
  73     pool: &mut DbPool<'_>,
  74   ) -> Result<Option<LanguageId>, LemmyError> {
  75     let identifier = lang.map(|l| l.identifier);
  76     let language = Language::read_id_from_code(pool, identifier.as_deref()).await?;
  77
  78     Ok(language)
  79   }
  80
  81   pub(crate) async fn to_language_id_multiple(
  82     langs: Vec<Self>,
  83     pool: &mut DbPool<'_>,
  84   ) -> Result<Vec<LanguageId>, LemmyError> {
  85     let mut language_ids = Vec::new();
  86
  87     for l in langs {
  88       let id = l.identifier;
  89       language_ids.push(Language::read_id_from_code(pool, Some(&id)).await?);
  90     }
  91
  92     Ok(language_ids.into_iter().flatten().collect())
  93   }
  94 }
  95
  96 #[cfg(test)]
  97 mod tests {
  98   use crate::protocol::{
  99     objects::{
 100       chat_message::ChatMessage,
 101       group::Group,
 102       instance::Instance,
 103       note::Note,
 104       page::Page,
 105       person::Person,
 106       tombstone::Tombstone,
 107     },
 108     tests::{test_json, test_parse_lemmy_item},
 109   };
 110
 111   #[test]
 112   fn test_parse_objects_lemmy() {
 113     test_parse_lemmy_item::<Instance>("assets/lemmy/objects/instance.json").unwrap();
 114     test_parse_lemmy_item::<Group>("assets/lemmy/objects/group.json").unwrap();
 115     test_parse_lemmy_item::<Person>("assets/lemmy/objects/person.json").unwrap();
 116     test_parse_lemmy_item::<Page>("assets/lemmy/objects/page.json").unwrap();
 117     test_parse_lemmy_item::<Note>("assets/lemmy/objects/note.json").unwrap();
 118     test_parse_lemmy_item::<ChatMessage>("assets/lemmy/objects/chat_message.json").unwrap();
 119     test_parse_lemmy_item::<Tombstone>("assets/lemmy/objects/tombstone.json").unwrap();
 120   }
 121
 122   #[test]
 123   fn test_parse_objects_pleroma() {
 124     test_json::<Person>("assets/pleroma/objects/person.json").unwrap();
 125     test_json::<Note>("assets/pleroma/objects/note.json").unwrap();
 126     test_json::<ChatMessage>("assets/pleroma/objects/chat_message.json").unwrap();
 127   }
 128
 129   #[test]
 130   fn test_parse_objects_smithereen() {
 131     test_json::<Person>("assets/smithereen/objects/person.json").unwrap();
 132     test_json::<Note>("assets/smithereen/objects/note.json").unwrap();
 133   }
 134
 135   #[test]
 136   fn test_parse_objects_mastodon() {
 137     test_json::<Person>("assets/mastodon/objects/person.json").unwrap();
 138     test_json::<Note>("assets/mastodon/objects/note.json").unwrap();
 139     test_json::<Page>("assets/mastodon/objects/page.json").unwrap();
 140   }
 141
 142   #[test]
 143   fn test_parse_objects_lotide() {
 144     test_json::<Group>("assets/lotide/objects/group.json").unwrap();
 145     test_json::<Person>("assets/lotide/objects/person.json").unwrap();
 146     test_json::<Note>("assets/lotide/objects/note.json").unwrap();
 147     test_json::<Page>("assets/lotide/objects/page.json").unwrap();
 148     test_json::<Tombstone>("assets/lotide/objects/tombstone.json").unwrap();
 149   }
 150
 151   #[test]
 152   fn test_parse_object_friendica() {
 153     test_json::<Person>("assets/friendica/objects/person_1.json").unwrap();
 154     test_json::<Person>("assets/friendica/objects/person_2.json").unwrap();
 155     test_json::<Page>("assets/friendica/objects/page_1.json").unwrap();
 156     test_json::<Page>("assets/friendica/objects/page_2.json").unwrap();
 157     test_json::<Note>("assets/friendica/objects/note_1.json").unwrap();
 158     test_json::<Note>("assets/friendica/objects/note_2.json").unwrap();
 159   }
 160
 161   #[test]
 162   fn test_parse_object_gnusocial() {
 163     test_json::<Person>("assets/gnusocial/objects/person.json").unwrap();
 164     test_json::<Group>("assets/gnusocial/objects/group.json").unwrap();
 165     test_json::<Page>("assets/gnusocial/objects/page.json").unwrap();
 166     test_json::<Note>("assets/gnusocial/objects/note.json").unwrap();
 167   }
 168
 169   #[test]
 170   fn test_parse_object_peertube() {
 171     test_json::<Person>("assets/peertube/objects/person.json").unwrap();
 172     test_json::<Group>("assets/peertube/objects/group.json").unwrap();
 173     test_json::<Page>("assets/peertube/objects/video.json").unwrap();
 174     test_json::<Note>("assets/peertube/objects/note.json").unwrap();
 175   }
 176
 177   #[test]
 178   fn test_parse_object_mobilizon() {
 179     test_json::<Group>("assets/mobilizon/objects/group.json").unwrap();
 180     test_json::<Page>("assets/mobilizon/objects/event.json").unwrap();
 181     test_json::<Person>("assets/mobilizon/objects/person.json").unwrap();
 182   }
 183 }