crates/api/src/post_report.rs

   1 use crate::Perform;
   2 use actix_web::web::Data;
   3 use lemmy_api_common::{
   4   blocking,
   5   check_community_ban,
   6   get_local_user_view_from_jwt,
   7   is_mod_or_admin,
   8   post::{
   9     CreatePostReport,
  10     ListPostReports,
  11     ListPostReportsResponse,
  12     PostReportResponse,
  13     ResolvePostReport,
  14   },
  15 };
  16 use lemmy_apub::protocol::activities::community::report::Report;
  17 use lemmy_apub_lib::object_id::ObjectId;
  18 use lemmy_db_schema::{
  19   source::post_report::{PostReport, PostReportForm},
  20   traits::Reportable,
  21 };
  22 use lemmy_db_views::{
  23   post_report_view::{PostReportQueryBuilder, PostReportView},
  24   post_view::PostView,
  25 };
  26 use lemmy_utils::{ApiError, ConnectionId, LemmyError};
  27 use lemmy_websocket::{messages::SendModRoomMessage, LemmyContext, UserOperation};
  28
  29 /// Creates a post report and notifies the moderators of the community
  30 #[async_trait::async_trait(?Send)]
  31 impl Perform for CreatePostReport {
  32   type Response = PostReportResponse;
  33
  34   async fn perform(
  35     &self,
  36     context: &Data<LemmyContext>,
  37     websocket_id: Option<ConnectionId>,
  38   ) -> Result<PostReportResponse, LemmyError> {
  39     let data: &CreatePostReport = self;
  40     let local_user_view =
  41       get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
  42
  43     // check size of report and check for whitespace
  44     let reason = data.reason.trim();
  45     if reason.is_empty() {
  46       return Err(ApiError::err_plain("report_reason_required").into());
  47     }
  48     if reason.chars().count() > 1000 {
  49       return Err(ApiError::err_plain("report_too_long").into());
  50     }
  51
  52     let person_id = local_user_view.person.id;
  53     let post_id = data.post_id;
  54     let post_view = blocking(context.pool(), move |conn| {
  55       PostView::read(conn, post_id, None)
  56     })
  57     .await??;
  58
  59     check_community_ban(person_id, post_view.community.id, context.pool()).await?;
  60
  61     let report_form = PostReportForm {
  62       creator_id: person_id,
  63       post_id,
  64       original_post_name: post_view.post.name,
  65       original_post_url: post_view.post.url,
  66       original_post_body: post_view.post.body,
  67       reason: data.reason.to_owned(),
  68     };
  69
  70     let report = blocking(context.pool(), move |conn| {
  71       PostReport::report(conn, &report_form)
  72     })
  73     .await?
  74     .map_err(|e| ApiError::err("couldnt_create_report", e))?;
  75
  76     let post_report_view = blocking(context.pool(), move |conn| {
  77       PostReportView::read(conn, report.id, person_id)
  78     })
  79     .await??;
  80
  81     let res = PostReportResponse { post_report_view };
  82
  83     context.chat_server().do_send(SendModRoomMessage {
  84       op: UserOperation::CreatePostReport,
  85       response: res.clone(),
  86       community_id: post_view.community.id,
  87       websocket_id,
  88     });
  89
  90     Report::send(
  91       ObjectId::new(post_view.post.ap_id),
  92       &local_user_view.person.into(),
  93       ObjectId::new(post_view.community.actor_id),
  94       reason.to_string(),
  95       context,
  96     )
  97     .await?;
  98
  99     Ok(res)
 100   }
 101 }
 102
 103 /// Resolves or unresolves a post report and notifies the moderators of the community
 104 #[async_trait::async_trait(?Send)]
 105 impl Perform for ResolvePostReport {
 106   type Response = PostReportResponse;
 107
 108   async fn perform(
 109     &self,
 110     context: &Data<LemmyContext>,
 111     websocket_id: Option<ConnectionId>,
 112   ) -> Result<PostReportResponse, LemmyError> {
 113     let data: &ResolvePostReport = self;
 114     let local_user_view =
 115       get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
 116
 117     let report_id = data.report_id;
 118     let person_id = local_user_view.person.id;
 119     let report = blocking(context.pool(), move |conn| {
 120       PostReportView::read(conn, report_id, person_id)
 121     })
 122     .await??;
 123
 124     let person_id = local_user_view.person.id;
 125     is_mod_or_admin(context.pool(), person_id, report.community.id).await?;
 126
 127     let resolved = data.resolved;
 128     let resolve_fun = move |conn: &'_ _| {
 129       if resolved {
 130         PostReport::resolve(conn, report_id, person_id)
 131       } else {
 132         PostReport::unresolve(conn, report_id, person_id)
 133       }
 134     };
 135
 136     blocking(context.pool(), resolve_fun)
 137       .await?
 138       .map_err(|e| ApiError::err("couldnt_resolve_report", e))?;
 139
 140     let post_report_view = blocking(context.pool(), move |conn| {
 141       PostReportView::read(conn, report_id, person_id)
 142     })
 143     .await??;
 144
 145     let res = PostReportResponse { post_report_view };
 146
 147     context.chat_server().do_send(SendModRoomMessage {
 148       op: UserOperation::ResolvePostReport,
 149       response: res.clone(),
 150       community_id: report.community.id,
 151       websocket_id,
 152     });
 153
 154     Ok(res)
 155   }
 156 }
 157
 158 /// Lists post reports for a community if an id is supplied
 159 /// or returns all post reports for communities a user moderates
 160 #[async_trait::async_trait(?Send)]
 161 impl Perform for ListPostReports {
 162   type Response = ListPostReportsResponse;
 163
 164   async fn perform(
 165     &self,
 166     context: &Data<LemmyContext>,
 167     _websocket_id: Option<ConnectionId>,
 168   ) -> Result<ListPostReportsResponse, LemmyError> {
 169     let data: &ListPostReports = self;
 170     let local_user_view =
 171       get_local_user_view_from_jwt(&data.auth, context.pool(), context.secret()).await?;
 172
 173     let person_id = local_user_view.person.id;
 174     let admin = local_user_view.person.admin;
 175     let community_id = data.community_id;
 176     let unresolved_only = data.unresolved_only;
 177
 178     let page = data.page;
 179     let limit = data.limit;
 180     let post_reports = blocking(context.pool(), move |conn| {
 181       PostReportQueryBuilder::create(conn, person_id, admin)
 182         .community_id(community_id)
 183         .unresolved_only(unresolved_only)
 184         .page(page)
 185         .limit(limit)
 186         .list()
 187     })
 188     .await??;
 189
 190     let res = ListPostReportsResponse { post_reports };
 191
 192     Ok(res)
 193   }
 194 }