crates/db_views/src/private_message_report_view.rs

   1 use crate::structs::PrivateMessageReportView;
   2 use diesel::{result::Error, ExpressionMethods, JoinOnDsl, NullableExpressionMethods, QueryDsl};
   3 use diesel_async::RunQueryDsl;
   4 use lemmy_db_schema::{
   5   newtypes::PrivateMessageReportId,
   6   schema::{person, private_message, private_message_report},
   7   source::{
   8     person::Person,
   9     private_message::PrivateMessage,
  10     private_message_report::PrivateMessageReport,
  11   },
  12   traits::JoinView,
  13   utils::{get_conn, limit_and_offset, DbPool},
  14 };
  15 use typed_builder::TypedBuilder;
  16
  17 type PrivateMessageReportViewTuple = (
  18   PrivateMessageReport,
  19   PrivateMessage,
  20   Person,
  21   Person,
  22   Option<Person>,
  23 );
  24
  25 impl PrivateMessageReportView {
  26   /// returns the PrivateMessageReportView for the provided report_id
  27   ///
  28   /// * `report_id` - the report id to obtain
  29   pub async fn read(
  30     pool: &mut DbPool<'_>,
  31     report_id: PrivateMessageReportId,
  32   ) -> Result<Self, Error> {
  33     let conn = &mut get_conn(pool).await?;
  34     let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
  35
  36     let (private_message_report, private_message, private_message_creator, creator, resolver) =
  37       private_message_report::table
  38         .find(report_id)
  39         .inner_join(private_message::table)
  40         .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
  41         .inner_join(
  42           person_alias_1
  43             .on(private_message_report::creator_id.eq(person_alias_1.field(person::id))),
  44         )
  45         .left_join(
  46           person_alias_2.on(
  47             private_message_report::resolver_id.eq(person_alias_2.field(person::id).nullable()),
  48           ),
  49         )
  50         .select((
  51           private_message_report::all_columns,
  52           private_message::all_columns,
  53           person::all_columns,
  54           person_alias_1.fields(person::all_columns),
  55           person_alias_2.fields(person::all_columns).nullable(),
  56         ))
  57         .first::<PrivateMessageReportViewTuple>(conn)
  58         .await?;
  59
  60     Ok(Self {
  61       private_message_report,
  62       private_message,
  63       private_message_creator,
  64       creator,
  65       resolver,
  66     })
  67   }
  68
  69   /// Returns the current unresolved post report count for the communities you mod
  70   pub async fn get_report_count(pool: &mut DbPool<'_>) -> Result<i64, Error> {
  71     use diesel::dsl::count;
  72     let conn = &mut get_conn(pool).await?;
  73
  74     private_message_report::table
  75       .inner_join(private_message::table)
  76       .filter(private_message_report::resolved.eq(false))
  77       .into_boxed()
  78       .select(count(private_message_report::id))
  79       .first::<i64>(conn)
  80       .await
  81   }
  82 }
  83
  84 #[derive(TypedBuilder)]
  85 #[builder(field_defaults(default))]
  86 pub struct PrivateMessageReportQuery<'a, 'b: 'a> {
  87   #[builder(!default)]
  88   pool: &'a mut DbPool<'b>,
  89   page: Option<i64>,
  90   limit: Option<i64>,
  91   unresolved_only: Option<bool>,
  92 }
  93
  94 impl<'a, 'b: 'a> PrivateMessageReportQuery<'a, 'b> {
  95   pub async fn list(self) -> Result<Vec<PrivateMessageReportView>, Error> {
  96     let conn = &mut get_conn(self.pool).await?;
  97     let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
  98
  99     let mut query = private_message_report::table
 100       .inner_join(private_message::table)
 101       .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
 102       .inner_join(
 103         person_alias_1.on(private_message_report::creator_id.eq(person_alias_1.field(person::id))),
 104       )
 105       .left_join(
 106         person_alias_2
 107           .on(private_message_report::resolver_id.eq(person_alias_2.field(person::id).nullable())),
 108       )
 109       .select((
 110         private_message_report::all_columns,
 111         private_message::all_columns,
 112         person::all_columns,
 113         person_alias_1.fields(person::all_columns),
 114         person_alias_2.fields(person::all_columns).nullable(),
 115       ))
 116       .into_boxed();
 117
 118     if self.unresolved_only.unwrap_or(false) {
 119       query = query.filter(private_message_report::resolved.eq(false));
 120     }
 121
 122     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 123
 124     query = query
 125       .order_by(private_message::published.desc())
 126       .limit(limit)
 127       .offset(offset);
 128
 129     let res = query.load::<PrivateMessageReportViewTuple>(conn).await?;
 130
 131     Ok(
 132       res
 133         .into_iter()
 134         .map(PrivateMessageReportView::from_tuple)
 135         .collect(),
 136     )
 137   }
 138 }
 139
 140 impl JoinView for PrivateMessageReportView {
 141   type JoinTuple = PrivateMessageReportViewTuple;
 142   fn from_tuple(a: Self::JoinTuple) -> Self {
 143     Self {
 144       private_message_report: a.0,
 145       private_message: a.1,
 146       private_message_creator: a.2,
 147       creator: a.3,
 148       resolver: a.4,
 149     }
 150   }
 151 }
 152
 153 #[cfg(test)]
 154 mod tests {
 155   use crate::private_message_report_view::PrivateMessageReportQuery;
 156   use lemmy_db_schema::{
 157     source::{
 158       instance::Instance,
 159       person::{Person, PersonInsertForm},
 160       private_message::{PrivateMessage, PrivateMessageInsertForm},
 161       private_message_report::{PrivateMessageReport, PrivateMessageReportForm},
 162     },
 163     traits::{Crud, Reportable},
 164     utils::build_db_pool_for_tests,
 165   };
 166   use serial_test::serial;
 167
 168   #[tokio::test]
 169   #[serial]
 170   async fn test_crud() {
 171     let pool = &build_db_pool_for_tests().await;
 172     let pool = &mut pool.into();
 173
 174     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 175       .await
 176       .unwrap();
 177
 178     let new_person_1 = PersonInsertForm::builder()
 179       .name("timmy_mrv".into())
 180       .public_key("pubkey".to_string())
 181       .instance_id(inserted_instance.id)
 182       .build();
 183     let inserted_timmy = Person::create(pool, &new_person_1).await.unwrap();
 184
 185     let new_person_2 = PersonInsertForm::builder()
 186       .name("jessica_mrv".into())
 187       .public_key("pubkey".to_string())
 188       .instance_id(inserted_instance.id)
 189       .build();
 190     let inserted_jessica = Person::create(pool, &new_person_2).await.unwrap();
 191
 192     // timmy sends private message to jessica
 193     let pm_form = PrivateMessageInsertForm::builder()
 194       .creator_id(inserted_timmy.id)
 195       .recipient_id(inserted_jessica.id)
 196       .content("something offensive".to_string())
 197       .build();
 198     let pm = PrivateMessage::create(pool, &pm_form).await.unwrap();
 199
 200     // jessica reports private message
 201     let pm_report_form = PrivateMessageReportForm {
 202       creator_id: inserted_jessica.id,
 203       original_pm_text: pm.content.clone(),
 204       private_message_id: pm.id,
 205       reason: "its offensive".to_string(),
 206     };
 207     let pm_report = PrivateMessageReport::report(pool, &pm_report_form)
 208       .await
 209       .unwrap();
 210
 211     let reports = PrivateMessageReportQuery::builder()
 212       .pool(pool)
 213       .build()
 214       .list()
 215       .await
 216       .unwrap();
 217     assert_eq!(1, reports.len());
 218     assert!(!reports[0].private_message_report.resolved);
 219     assert_eq!(inserted_timmy.name, reports[0].private_message_creator.name);
 220     assert_eq!(inserted_jessica.name, reports[0].creator.name);
 221     assert_eq!(pm_report.reason, reports[0].private_message_report.reason);
 222     assert_eq!(pm.content, reports[0].private_message.content);
 223
 224     let new_person_3 = PersonInsertForm::builder()
 225       .name("admin_mrv".into())
 226       .public_key("pubkey".to_string())
 227       .instance_id(inserted_instance.id)
 228       .build();
 229     let inserted_admin = Person::create(pool, &new_person_3).await.unwrap();
 230
 231     // admin resolves the report (after taking appropriate action)
 232     PrivateMessageReport::resolve(pool, pm_report.id, inserted_admin.id)
 233       .await
 234       .unwrap();
 235
 236     let reports = PrivateMessageReportQuery::builder()
 237       .pool(pool)
 238       .unresolved_only(Some(false))
 239       .build()
 240       .list()
 241       .await
 242       .unwrap();
 243     assert_eq!(1, reports.len());
 244     assert!(reports[0].private_message_report.resolved);
 245     assert!(reports[0].resolver.is_some());
 246     assert_eq!(
 247       inserted_admin.name,
 248       reports[0].resolver.as_ref().unwrap().name
 249     );
 250
 251     Instance::delete(pool, inserted_instance.id).await.unwrap();
 252   }
 253 }