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

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