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 = fetch_remote_object::<Page>(
  36         context.client(),
  37         &context.settings(),
  38         post_ap_id,
  39         recursion_counter,
  40       )
  41       .await?;
  42       let post = Post::from_apub(&page, context, post_ap_id, recursion_counter).await?;
  43
  44       Ok(post)
  45     }
  46     Err(e) => Err(e.into()),
  47   }
  48 }
  49
  50 /// Gets a comment by its apub ID. If it exists locally, it is returned directly. Otherwise it is
  51 /// pulled from its apub ID, inserted and returned.
  52 ///
  53 /// The parent community, post and comment are also pulled if necessary.
  54 pub(crate) async fn get_or_fetch_and_insert_comment(
  55   comment_ap_id: &Url,
  56   context: &LemmyContext,
  57   recursion_counter: &mut i32,
  58 ) -> Result<Comment, LemmyError> {
  59   let comment_ap_id_owned = comment_ap_id.to_owned();
  60   let comment = blocking(context.pool(), move |conn| {
  61     Comment::read_from_apub_id(conn, &comment_ap_id_owned.into())
  62   })
  63   .await?;
  64
  65   match comment {
  66     Ok(p) => Ok(p),
  67     Err(NotFound {}) => {
  68       debug!(
  69         "Fetching and creating remote comment and its parents: {}",
  70         comment_ap_id
  71       );
  72       let comment = fetch_remote_object::<Note>(
  73         context.client(),
  74         &context.settings(),
  75         comment_ap_id,
  76         recursion_counter,
  77       )
  78       .await?;
  79       let comment = Comment::from_apub(&comment, context, comment_ap_id, recursion_counter).await?;
  80
  81       let post_id = comment.post_id;
  82       let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
  83       if post.locked {
  84         return Err(anyhow!("Post is locked").into());
  85       }
  86
  87       Ok(comment)
  88     }
  89     Err(e) => Err(e.into()),
  90   }
  91 }
  92
  93 pub(crate) async fn get_or_fetch_and_insert_post_or_comment(
  94   ap_id: &Url,
  95   context: &LemmyContext,
  96   recursion_counter: &mut i32,
  97 ) -> Result<PostOrComment, LemmyError> {
  98   Ok(
  99     match get_or_fetch_and_insert_post(ap_id, context, recursion_counter).await {
 100       Ok(p) => PostOrComment::Post(Box::new(p)),
 101       Err(_) => {
 102         let c = get_or_fetch_and_insert_comment(ap_id, context, recursion_counter).await?;
 103         PostOrComment::Comment(Box::new(c))
 104       }
 105     },
 106   )
 107 }