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       instance::Instance,
 152       person::{Person, PersonInsertForm},
 153       private_message::{PrivateMessage, PrivateMessageInsertForm},
 154       private_message_report::{PrivateMessageReport, PrivateMessageReportForm},
 155     },
 156     traits::{Crud, Reportable},
 157     utils::establish_unpooled_connection,
 158   };
 159   use serial_test::serial;
 160
 161   #[test]
 162   #[serial]
 163   fn test_crud() {
 164     let conn = &mut establish_unpooled_connection();
 165
 166     let inserted_instance = Instance::create(conn, "my_domain.tld").unwrap();
 167
 168     let new_person_1 = PersonInsertForm::builder()
 169       .name("timmy_mrv".into())
 170       .public_key("pubkey".to_string())
 171       .instance_id(inserted_instance.id)
 172       .build();
 173     let inserted_timmy = Person::create(conn, &new_person_1).unwrap();
 174
 175     let new_person_2 = PersonInsertForm::builder()
 176       .name("jessica_mrv".into())
 177       .public_key("pubkey".to_string())
 178       .instance_id(inserted_instance.id)
 179       .build();
 180     let inserted_jessica = Person::create(conn, &new_person_2).unwrap();
 181
 182     // timmy sends private message to jessica
 183     let pm_form = PrivateMessageInsertForm::builder()
 184       .creator_id(inserted_timmy.id)
 185       .recipient_id(inserted_jessica.id)
 186       .content("something offensive".to_string())
 187       .build();
 188     let pm = PrivateMessage::create(conn, &pm_form).unwrap();
 189
 190     // jessica reports private message
 191     let pm_report_form = PrivateMessageReportForm {
 192       creator_id: inserted_jessica.id,
 193       original_pm_text: pm.content.clone(),
 194       private_message_id: pm.id,
 195       reason: "its offensive".to_string(),
 196     };
 197     let pm_report = PrivateMessageReport::report(conn, &pm_report_form).unwrap();
 198
 199     let reports = PrivateMessageReportQuery::builder()
 200       .conn(conn)
 201       .build()
 202       .list()
 203       .unwrap();
 204     assert_eq!(1, reports.len());
 205     assert!(!reports[0].private_message_report.resolved);
 206     assert_eq!(inserted_timmy.name, reports[0].private_message_creator.name);
 207     assert_eq!(inserted_jessica.name, reports[0].creator.name);
 208     assert_eq!(pm_report.reason, reports[0].private_message_report.reason);
 209     assert_eq!(pm.content, reports[0].private_message.content);
 210
 211     let new_person_3 = PersonInsertForm::builder()
 212       .name("admin_mrv".into())
 213       .public_key("pubkey".to_string())
 214       .instance_id(inserted_instance.id)
 215       .build();
 216     let inserted_admin = Person::create(conn, &new_person_3).unwrap();
 217
 218     // admin resolves the report (after taking appropriate action)
 219     PrivateMessageReport::resolve(conn, pm_report.id, inserted_admin.id).unwrap();
 220
 221     let reports = PrivateMessageReportQuery::builder()
 222       .conn(conn)
 223       .unresolved_only(Some(false))
 224       .build()
 225       .list()
 226       .unwrap();
 227     assert_eq!(1, reports.len());
 228     assert!(reports[0].private_message_report.resolved);
 229     assert!(reports[0].resolver.is_some());
 230     assert_eq!(
 231       inserted_admin.name,
 232       reports[0].resolver.as_ref().unwrap().name
 233     );
 234
 235     Instance::delete(conn, inserted_instance.id).unwrap();
 236   }
 237 }