crates/db_schema/src/impls/activity.rs

   1 use crate::{newtypes::DbUrl, source::activity::*, traits::Crud};
   2 use diesel::{
   3   dsl::*,
   4   result::{DatabaseErrorKind, Error},
   5   *,
   6 };
   7 use serde_json::Value;
   8
   9 impl Crud for Activity {
  10   type Form = ActivityForm;
  11   type IdType = i32;
  12   fn read(conn: &mut 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: &mut 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: &mut 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: &mut 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   /// Returns true if the insert was successful
  42   pub fn insert(
  43     conn: &mut PgConnection,
  44     ap_id: DbUrl,
  45     data: Value,
  46     local: bool,
  47     sensitive: bool,
  48   ) -> Result<bool, Error> {
  49     let activity_form = ActivityForm {
  50       ap_id,
  51       data,
  52       local: Some(local),
  53       sensitive,
  54       updated: None,
  55     };
  56     match Activity::create(conn, &activity_form) {
  57       Ok(_) => Ok(true),
  58       Err(e) => {
  59         if let Error::DatabaseError(DatabaseErrorKind::UniqueViolation, _) = e {
  60           return Ok(false);
  61         }
  62         Err(e)
  63       }
  64     }
  65   }
  66
  67   pub fn read_from_apub_id(conn: &mut PgConnection, object_id: &DbUrl) -> Result<Activity, Error> {
  68     use crate::schema::activity::dsl::*;
  69     activity.filter(ap_id.eq(object_id)).first::<Self>(conn)
  70   }
  71
  72   pub fn delete_olds(conn: &mut PgConnection) -> Result<usize, Error> {
  73     use crate::schema::activity::dsl::*;
  74     diesel::delete(activity.filter(published.lt(now - 6.months()))).execute(conn)
  75   }
  76 }
  77
  78 #[cfg(test)]
  79 mod tests {
  80   use super::*;
  81   use crate::{
  82     newtypes::DbUrl,
  83     source::{
  84       activity::{Activity, ActivityForm},
  85       person::{Person, PersonForm},
  86     },
  87     utils::establish_unpooled_connection,
  88   };
  89   use serde_json::Value;
  90   use serial_test::serial;
  91   use url::Url;
  92
  93   #[test]
  94   #[serial]
  95   fn test_crud() {
  96     let conn = &mut establish_unpooled_connection();
  97
  98     let creator_form = PersonForm {
  99       name: "activity_creator_pm".into(),
 100       public_key: Some("pubkey".to_string()),
 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: 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 }