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