crates/db_schema/src/impls/activity.rs

   1 use crate::{newtypes::DbUrl, source::activity::*, traits::Crud};
   2 use diesel::{dsl::*, result::Error, *};
   3 use serde::Serialize;
   4 use std::{
   5   fmt::Debug,
   6   io::{Error as IoError, ErrorKind},
   7 };
   8
   9 impl Crud for Activity {
  10   type Form = ActivityForm;
  11   type IdType = i32;
  12   fn read(conn: &PgConnection, activity_id: i32) -> Result<Self, Error> {
  13     use crate::schema::activity::dsl::*;
  14     activity.find(activity_id).first::<Self>(conn)
  15   }
  16
  17   fn create(conn: &PgConnection, new_activity: &ActivityForm) -> Result<Self, Error> {
  18     use crate::schema::activity::dsl::*;
  19     insert_into(activity)
  20       .values(new_activity)
  21       .get_result::<Self>(conn)
  22   }
  23
  24   fn update(
  25     conn: &PgConnection,
  26     activity_id: i32,
  27     new_activity: &ActivityForm,
  28   ) -> Result<Self, Error> {
  29     use crate::schema::activity::dsl::*;
  30     diesel::update(activity.find(activity_id))
  31       .set(new_activity)
  32       .get_result::<Self>(conn)
  33   }
  34   fn delete(conn: &PgConnection, activity_id: i32) -> Result<usize, Error> {
  35     use crate::schema::activity::dsl::*;
  36     diesel::delete(activity.find(activity_id)).execute(conn)
  37   }
  38 }
  39
  40 impl Activity {
  41   pub fn insert<T>(
  42     conn: &PgConnection,
  43     ap_id: DbUrl,
  44     data: &T,
  45     local: bool,
  46     sensitive: bool,
  47   ) -> Result<Activity, IoError>
  48   where
  49     T: Serialize + Debug,
  50   {
  51     let activity_form = ActivityForm {
  52       ap_id,
  53       data: serde_json::to_value(&data)?,
  54       local: Some(local),
  55       sensitive,
  56       updated: None,
  57     };
  58     let result = Activity::create(conn, &activity_form);
  59     match result {
  60       Ok(s) => Ok(s),
  61       Err(e) => Err(IoError::new(
  62         ErrorKind::Other,
  63         format!("Failed to insert activity into database: {}", e),
  64       )),
  65     }
  66   }
  67
  68   pub fn read_from_apub_id(conn: &PgConnection, object_id: &DbUrl) -> Result<Activity, Error> {
  69     use crate::schema::activity::dsl::*;
  70     activity.filter(ap_id.eq(object_id)).first::<Self>(conn)
  71   }
  72
  73   pub fn delete_olds(conn: &PgConnection) -> Result<usize, Error> {
  74     use crate::schema::activity::dsl::*;
  75     diesel::delete(activity.filter(published.lt(now - 6.months()))).execute(conn)
  76   }
  77 }
  78
  79 #[cfg(test)]
  80 mod tests {
  81   use super::*;
  82   use crate::{
  83     establish_unpooled_connection,
  84     newtypes::DbUrl,
  85     source::{
  86       activity::{Activity, ActivityForm},
  87       person::{Person, PersonForm},
  88     },
  89   };
  90   use serde_json::Value;
  91   use serial_test::serial;
  92   use url::Url;
  93
  94   #[test]
  95   #[serial]
  96   fn test_crud() {
  97     let conn = establish_unpooled_connection();
  98
  99     let creator_form = PersonForm {
 100       name: "activity_creator_pm".into(),
 101       ..PersonForm::default()
 102     };
 103
 104     let inserted_creator = Person::create(&conn, &creator_form).unwrap();
 105
 106     let ap_id: DbUrl = Url::parse(
 107       "https://enterprise.lemmy.ml/activities/delete/f1b5d57c-80f8-4e03-a615-688d552e946c",
 108     )
 109     .unwrap()
 110     .into();
 111     let test_json: Value = serde_json::from_str(
 112       r#"{
 113     "@context": "https://www.w3.org/ns/activitystreams",
 114     "id": "https://enterprise.lemmy.ml/activities/delete/f1b5d57c-80f8-4e03-a615-688d552e946c",
 115     "type": "Delete",
 116     "actor": "https://enterprise.lemmy.ml/u/riker",
 117     "to": "https://www.w3.org/ns/activitystreams#Public",
 118     "cc": [
 119         "https://enterprise.lemmy.ml/c/main/"
 120     ],
 121     "object": "https://enterprise.lemmy.ml/post/32"
 122     }"#,
 123     )
 124     .unwrap();
 125     let activity_form = ActivityForm {
 126       ap_id: ap_id.clone(),
 127       data: test_json.to_owned(),
 128       local: Some(true),
 129       sensitive: false,
 130       updated: None,
 131     };
 132
 133     let inserted_activity = Activity::create(&conn, &activity_form).unwrap();
 134
 135     let expected_activity = Activity {
 136       ap_id: Some(ap_id.clone()),
 137       id: inserted_activity.id,
 138       data: test_json,
 139       local: true,
 140       sensitive: Some(false),
 141       published: inserted_activity.published,
 142       updated: None,
 143     };
 144
 145     let read_activity = Activity::read(&conn, inserted_activity.id).unwrap();
 146     let read_activity_by_apub_id = Activity::read_from_apub_id(&conn, &ap_id).unwrap();
 147     Person::delete(&conn, inserted_creator.id).unwrap();
 148     Activity::delete(&conn, inserted_activity.id).unwrap();
 149
 150     assert_eq!(expected_activity, read_activity);
 151     assert_eq!(expected_activity, read_activity_by_apub_id);
 152     assert_eq!(expected_activity, inserted_activity);
 153   }
 154 }