crates/db_views/src/private_message_report_view.rs

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