crates/apub/src/fetcher/objects.rs

   1 use crate::{
   2   fetcher::fetch::fetch_remote_object,
   3   objects::{comment::Note, post::Page, FromApub},
   4   PostOrComment,
   5 };
   6 use anyhow::anyhow;
   7 use diesel::result::Error::NotFound;
   8 use lemmy_api_common::blocking;
   9 use lemmy_db_queries::{ApubObject, Crud};
  10 use lemmy_db_schema::source::{comment::Comment, post::Post};
  11 use lemmy_utils::LemmyError;
  12 use lemmy_websocket::LemmyContext;
  13 use log::debug;
  14 use url::Url;
  15
  16 /// Gets a post by its apub ID. If it exists locally, it is returned directly. Otherwise it is
  17 /// pulled from its apub ID, inserted and returned.
  18 ///
  19 /// The parent community is also pulled if necessary. Comments are not pulled.
  20 pub(crate) async fn get_or_fetch_and_insert_post(
  21   post_ap_id: &Url,
  22   context: &LemmyContext,
  23   recursion_counter: &mut i32,
  24 ) -> Result<Post, LemmyError> {
  25   let post_ap_id_owned = post_ap_id.to_owned();
  26   let post = blocking(context.pool(), move |conn| {
  27     Post::read_from_apub_id(conn, &post_ap_id_owned.into())
  28   })
  29   .await?;
  30
  31   match post {
  32     Ok(p) => Ok(p),
  33     Err(NotFound {}) => {
  34       debug!("Fetching and creating remote post: {}", post_ap_id);
  35       let page =
  36         fetch_remote_object::<Page>(context.client(), post_ap_id, recursion_counter).await?;
  37       let post = Post::from_apub(&page, context, post_ap_id, recursion_counter).await?;
  38
  39       Ok(post)
  40     }
  41     Err(e) => Err(e.into()),
  42   }
  43 }
  44
  45 /// Gets a comment by its apub ID. If it exists locally, it is returned directly. Otherwise it is
  46 /// pulled from its apub ID, inserted and returned.
  47 ///
  48 /// The parent community, post and comment are also pulled if necessary.
  49 pub(crate) async fn get_or_fetch_and_insert_comment(
  50   comment_ap_id: &Url,
  51   context: &LemmyContext,
  52   recursion_counter: &mut i32,
  53 ) -> Result<Comment, LemmyError> {
  54   let comment_ap_id_owned = comment_ap_id.to_owned();
  55   let comment = blocking(context.pool(), move |conn| {
  56     Comment::read_from_apub_id(conn, &comment_ap_id_owned.into())
  57   })
  58   .await?;
  59
  60   match comment {
  61     Ok(p) => Ok(p),
  62     Err(NotFound {}) => {
  63       debug!(
  64         "Fetching and creating remote comment and its parents: {}",
  65         comment_ap_id
  66       );
  67       let comment =
  68         fetch_remote_object::<Note>(context.client(), comment_ap_id, recursion_counter).await?;
  69       let comment = Comment::from_apub(&comment, context, comment_ap_id, recursion_counter).await?;
  70
  71       let post_id = comment.post_id;
  72       let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
  73       if post.locked {
  74         return Err(anyhow!("Post is locked").into());
  75       }
  76
  77       Ok(comment)
  78     }
  79     Err(e) => Err(e.into()),
  80   }
  81 }
  82
  83 pub(crate) async fn get_or_fetch_and_insert_post_or_comment(
  84   ap_id: &Url,
  85   context: &LemmyContext,
  86   recursion_counter: &mut i32,
  87 ) -> Result<PostOrComment, LemmyError> {
  88   Ok(
  89     match get_or_fetch_and_insert_post(ap_id, context, recursion_counter).await {
  90       Ok(p) => PostOrComment::Post(Box::new(p)),
  91       Err(_) => {
  92         let c = get_or_fetch_and_insert_comment(ap_id, context, recursion_counter).await?;
  93         PostOrComment::Comment(Box::new(c))
  94       }
  95     },
  96   )
  97 }