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