crates/db_queries/src/source/activity.rs

   1 use crate::Crud;
   2 use diesel::{dsl::*, result::Error, *};
   3 use lemmy_db_schema::source::activity::*;
   4 use log::debug;
   5 use serde::Serialize;
   6 use std::{
   7   fmt::Debug,
   8   io::{Error as IoError, ErrorKind},
   9 };
  10
  11 impl Crud<ActivityForm> for Activity {
  12   fn read(conn: &PgConnection, activity_id: i32) -> Result<Self, Error> {
  13     use lemmy_db_schema::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 lemmy_db_schema::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 lemmy_db_schema::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 lemmy_db_schema::schema::activity::dsl::*;
  36     diesel::delete(activity.find(activity_id)).execute(conn)
  37   }
  38 }
  39
  40 pub trait Activity_ {
  41   fn insert<T>(
  42     conn: &PgConnection,
  43     ap_id: String,
  44     data: &T,
  45     local: bool,
  46     sensitive: bool,
  47   ) -> Result<Activity, IoError>
  48   where
  49     T: Serialize + Debug;
  50   fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Activity, Error>;
  51 }
  52
  53 impl Activity_ for Activity {
  54   fn insert<T>(
  55     conn: &PgConnection,
  56     ap_id: String,
  57     data: &T,
  58     local: bool,
  59     sensitive: bool,
  60   ) -> Result<Activity, IoError>
  61   where
  62     T: Serialize + Debug,
  63   {
  64     debug!("{}", serde_json::to_string_pretty(&data)?);
  65     let activity_form = ActivityForm {
  66       ap_id,
  67       data: serde_json::to_value(&data)?,
  68       local,
  69       sensitive,
  70       updated: None,
  71     };
  72     let result = Activity::create(&conn, &activity_form);
  73     match result {
  74       Ok(s) => Ok(s),
  75       Err(e) => Err(IoError::new(
  76         ErrorKind::Other,
  77         format!("Failed to insert activity into database: {}", e),
  78       )),
  79     }
  80   }
  81
  82   fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Activity, Error> {
  83     use lemmy_db_schema::schema::activity::dsl::*;
  84     activity.filter(ap_id.eq(object_id)).first::<Self>(conn)
  85   }
  86 }
  87
  88 #[cfg(test)]
  89 mod tests {
  90   use crate::{
  91     establish_unpooled_connection,
  92     source::activity::Activity_,
  93     Crud,
  94     ListingType,
  95     SortType,
  96   };
  97   use lemmy_db_schema::source::{
  98     activity::{Activity, ActivityForm},
  99     user::{UserForm, User_},
 100   };
 101   use serde_json::Value;
 102
 103   #[test]
 104   fn test_crud() {
 105     let conn = establish_unpooled_connection();
 106
 107     let creator_form = UserForm {
 108       name: "activity_creator_pm".into(),
 109       preferred_username: None,
 110       password_encrypted: "nope".into(),
 111       email: None,
 112       matrix_user_id: None,
 113       avatar: None,
 114       banner: None,
 115       admin: false,
 116       banned: Some(false),
 117       published: None,
 118       updated: None,
 119       show_nsfw: false,
 120       theme: "browser".into(),
 121       default_sort_type: SortType::Hot as i16,
 122       default_listing_type: ListingType::Subscribed as i16,
 123       lang: "browser".into(),
 124       show_avatars: true,
 125       send_notifications_to_email: false,
 126       actor_id: None,
 127       bio: None,
 128       local: true,
 129       private_key: None,
 130       public_key: None,
 131       last_refreshed_at: None,
 132     };
 133
 134     let inserted_creator = User_::create(&conn, &creator_form).unwrap();
 135
 136     let ap_id =
 137       "https://enterprise.lemmy.ml/activities/delete/f1b5d57c-80f8-4e03-a615-688d552e946c";
 138     let test_json: Value = serde_json::from_str(
 139       r#"{
 140     "@context": "https://www.w3.org/ns/activitystreams",
 141     "id": "https://enterprise.lemmy.ml/activities/delete/f1b5d57c-80f8-4e03-a615-688d552e946c",
 142     "type": "Delete",
 143     "actor": "https://enterprise.lemmy.ml/u/riker",
 144     "to": "https://www.w3.org/ns/activitystreams#Public",
 145     "cc": [
 146         "https://enterprise.lemmy.ml/c/main/"
 147     ],
 148     "object": "https://enterprise.lemmy.ml/post/32"
 149     }"#,
 150     )
 151     .unwrap();
 152     let activity_form = ActivityForm {
 153       ap_id: ap_id.to_string(),
 154       data: test_json.to_owned(),
 155       local: true,
 156       sensitive: false,
 157       updated: None,
 158     };
 159
 160     let inserted_activity = Activity::create(&conn, &activity_form).unwrap();
 161
 162     let expected_activity = Activity {
 163       ap_id: Some(ap_id.to_string()),
 164       id: inserted_activity.id,
 165       data: test_json,
 166       local: true,
 167       sensitive: Some(false),
 168       published: inserted_activity.published,
 169       updated: None,
 170     };
 171
 172     let read_activity = Activity::read(&conn, inserted_activity.id).unwrap();
 173     let read_activity_by_apub_id = Activity::read_from_apub_id(&conn, ap_id).unwrap();
 174     User_::delete(&conn, inserted_creator.id).unwrap();
 175     Activity::delete(&conn, inserted_activity.id).unwrap();
 176
 177     assert_eq!(expected_activity, read_activity);
 178     assert_eq!(expected_activity, read_activity_by_apub_id);
 179     assert_eq!(expected_activity, inserted_activity);
 180   }
 181 }