server/src/db/post.rs

   1 use crate::schema::{post, post_like, post_saved, post_read};
   2 use super::*;
   3
   4 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
   5 #[table_name="post"]
   6 pub struct Post {
   7   pub id: i32,
   8   pub name: String,
   9   pub url: Option<String>,
  10   pub body: Option<String>,
  11   pub creator_id: i32,
  12   pub community_id: i32,
  13   pub removed: bool,
  14   pub locked: bool,
  15   pub published: chrono::NaiveDateTime,
  16   pub updated: Option<chrono::NaiveDateTime>,
  17   pub deleted: bool,
  18   pub nsfw: bool,
  19 }
  20
  21 #[derive(Insertable, AsChangeset, Clone)]
  22 #[table_name="post"]
  23 pub struct PostForm {
  24   pub name: String,
  25   pub url: Option<String>,
  26   pub body: Option<String>,
  27   pub creator_id: i32,
  28   pub community_id: i32,
  29   pub removed: Option<bool>,
  30   pub locked: Option<bool>,
  31   pub updated: Option<chrono::NaiveDateTime>,
  32   pub deleted: Option<bool>,
  33   pub nsfw: bool,
  34 }
  35
  36 impl Crud<PostForm> for Post {
  37   fn read(conn: &PgConnection, post_id: i32) -> Result<Self, Error> {
  38     use crate::schema::post::dsl::*;
  39     post.find(post_id)
  40       .first::<Self>(conn)
  41   }
  42
  43   fn delete(conn: &PgConnection, post_id: i32) -> Result<usize, Error> {
  44     use crate::schema::post::dsl::*;
  45     diesel::delete(post.find(post_id))
  46       .execute(conn)
  47   }
  48
  49   fn create(conn: &PgConnection, new_post: &PostForm) -> Result<Self, Error> {
  50     use crate::schema::post::dsl::*;
  51       insert_into(post)
  52         .values(new_post)
  53         .get_result::<Self>(conn)
  54   }
  55
  56   fn update(conn: &PgConnection, post_id: i32, new_post: &PostForm) -> Result<Self, Error> {
  57     use crate::schema::post::dsl::*;
  58     diesel::update(post.find(post_id))
  59       .set(new_post)
  60       .get_result::<Self>(conn)
  61   }
  62 }
  63
  64 #[derive(Identifiable, Queryable, Associations, PartialEq, Debug)]
  65 #[belongs_to(Post)]
  66 #[table_name = "post_like"]
  67 pub struct PostLike {
  68   pub id: i32,
  69   pub post_id: i32,
  70   pub user_id: i32,
  71   pub score: i16,
  72   pub published: chrono::NaiveDateTime,
  73 }
  74
  75 #[derive(Insertable, AsChangeset, Clone)]
  76 #[table_name="post_like"]
  77 pub struct PostLikeForm {
  78   pub post_id: i32,
  79   pub user_id: i32,
  80   pub score: i16
  81 }
  82
  83 impl Likeable <PostLikeForm> for PostLike {
  84   fn read(conn: &PgConnection, post_id_from: i32) -> Result<Vec<Self>, Error> {
  85     use crate::schema::post_like::dsl::*;
  86     post_like
  87       .filter(post_id.eq(post_id_from))
  88       .load::<Self>(conn)
  89   }
  90   fn like(conn: &PgConnection, post_like_form: &PostLikeForm) -> Result<Self, Error> {
  91     use crate::schema::post_like::dsl::*;
  92     insert_into(post_like)
  93       .values(post_like_form)
  94       .get_result::<Self>(conn)
  95   }
  96   fn remove(conn: &PgConnection, post_like_form: &PostLikeForm) -> Result<usize, Error> {
  97     use crate::schema::post_like::dsl::*;
  98     diesel::delete(post_like
  99       .filter(post_id.eq(post_like_form.post_id))
 100       .filter(user_id.eq(post_like_form.user_id)))
 101       .execute(conn)
 102   }
 103 }
 104
 105 #[derive(Identifiable, Queryable, Associations, PartialEq, Debug)]
 106 #[belongs_to(Post)]
 107 #[table_name = "post_saved"]
 108 pub struct PostSaved {
 109   pub id: i32,
 110   pub post_id: i32,
 111   pub user_id: i32,
 112   pub published: chrono::NaiveDateTime,
 113 }
 114
 115 #[derive(Insertable, AsChangeset, Clone)]
 116 #[table_name="post_saved"]
 117 pub struct PostSavedForm {
 118   pub post_id: i32,
 119   pub user_id: i32,
 120 }
 121
 122 impl Saveable <PostSavedForm> for PostSaved {
 123   fn save(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result<Self, Error> {
 124     use crate::schema::post_saved::dsl::*;
 125     insert_into(post_saved)
 126       .values(post_saved_form)
 127       .get_result::<Self>(conn)
 128   }
 129   fn unsave(conn: &PgConnection, post_saved_form: &PostSavedForm) -> Result<usize, Error> {
 130     use crate::schema::post_saved::dsl::*;
 131     diesel::delete(post_saved
 132       .filter(post_id.eq(post_saved_form.post_id))
 133       .filter(user_id.eq(post_saved_form.user_id)))
 134       .execute(conn)
 135   }
 136 }
 137
 138 #[derive(Identifiable, Queryable, Associations, PartialEq, Debug)]
 139 #[belongs_to(Post)]
 140 #[table_name = "post_read"]
 141 pub struct PostRead {
 142   pub id: i32,
 143   pub post_id: i32,
 144   pub user_id: i32,
 145   pub published: chrono::NaiveDateTime,
 146 }
 147
 148 #[derive(Insertable, AsChangeset, Clone)]
 149 #[table_name="post_read"]
 150 pub struct PostReadForm {
 151   pub post_id: i32,
 152   pub user_id: i32,
 153 }
 154
 155 impl Readable <PostReadForm> for PostRead {
 156   fn mark_as_read(conn: &PgConnection, post_read_form: &PostReadForm) -> Result<Self, Error> {
 157     use crate::schema::post_read::dsl::*;
 158     insert_into(post_read)
 159       .values(post_read_form)
 160       .get_result::<Self>(conn)
 161   }
 162   fn mark_as_unread(conn: &PgConnection, post_read_form: &PostReadForm) -> Result<usize, Error> {
 163     use crate::schema::post_read::dsl::*;
 164     diesel::delete(post_read
 165       .filter(post_id.eq(post_read_form.post_id))
 166       .filter(user_id.eq(post_read_form.user_id)))
 167       .execute(conn)
 168   }
 169 }
 170
 171 #[cfg(test)]
 172 mod tests {
 173   use super::*;
 174   use super::super::community::*;
 175   use super::super::user::*;
 176  #[test]
 177   fn test_crud() {
 178     let conn = establish_connection();
 179
 180     let new_user = UserForm {
 181       name: "jim".into(),
 182       fedi_name: "rrf".into(),
 183       preferred_username: None,
 184       password_encrypted: "nope".into(),
 185       email: None,
 186       admin: false,
 187       banned: false,
 188       updated: None,
 189       show_nsfw: false,
 190     };
 191
 192     let inserted_user = User_::create(&conn, &new_user).unwrap();
 193
 194     let new_community = CommunityForm {
 195       name: "test community_3".to_string(),
 196       title: "nada".to_owned(),
 197       description: None,
 198       category_id: 1,
 199       creator_id: inserted_user.id,
 200       removed: None,
 201       deleted: None,
 202       updated: None,
 203       nsfw: false,
 204     };
 205
 206     let inserted_community = Community::create(&conn, &new_community).unwrap();
 207
 208     let new_post = PostForm {
 209       name: "A test post".into(),
 210       url: None,
 211       body: None,
 212       creator_id: inserted_user.id,
 213       community_id: inserted_community.id,
 214       removed: None,
 215       deleted: None,
 216       locked: None,
 217       nsfw: false,
 218       updated: None
 219     };
 220
 221     let inserted_post = Post::create(&conn, &new_post).unwrap();
 222
 223     let expected_post = Post {
 224       id: inserted_post.id,
 225       name: "A test post".into(),
 226       url: None,
 227       body: None,
 228       creator_id: inserted_user.id,
 229       community_id: inserted_community.id,
 230       published: inserted_post.published,
 231       removed: false,
 232       locked: false,
 233       nsfw: false,
 234       deleted: false,
 235       updated: None
 236     };
 237
 238     // Post Like
 239     let post_like_form = PostLikeForm {
 240       post_id: inserted_post.id,
 241       user_id: inserted_user.id,
 242       score: 1
 243     };
 244
 245     let inserted_post_like = PostLike::like(&conn, &post_like_form).unwrap();
 246
 247     let expected_post_like = PostLike {
 248       id: inserted_post_like.id,
 249       post_id: inserted_post.id,
 250       user_id: inserted_user.id,
 251       published: inserted_post_like.published,
 252       score: 1
 253     };
 254
 255     // Post Save
 256     let post_saved_form = PostSavedForm {
 257       post_id: inserted_post.id,
 258       user_id: inserted_user.id,
 259     };
 260
 261     let inserted_post_saved = PostSaved::save(&conn, &post_saved_form).unwrap();
 262
 263     let expected_post_saved = PostSaved {
 264       id: inserted_post_saved.id,
 265       post_id: inserted_post.id,
 266       user_id: inserted_user.id,
 267       published: inserted_post_saved.published,
 268     };
 269
 270     // Post Read
 271     let post_read_form = PostReadForm {
 272       post_id: inserted_post.id,
 273       user_id: inserted_user.id,
 274     };
 275
 276     let inserted_post_read = PostRead::mark_as_read(&conn, &post_read_form).unwrap();
 277
 278     let expected_post_read = PostRead {
 279       id: inserted_post_read.id,
 280       post_id: inserted_post.id,
 281       user_id: inserted_user.id,
 282       published: inserted_post_read.published,
 283     };
 284
 285     let read_post = Post::read(&conn, inserted_post.id).unwrap();
 286     let updated_post = Post::update(&conn, inserted_post.id, &new_post).unwrap();
 287     let like_removed = PostLike::remove(&conn, &post_like_form).unwrap();
 288     let saved_removed = PostSaved::unsave(&conn, &post_saved_form).unwrap();
 289     let read_removed = PostRead::mark_as_unread(&conn, &post_read_form).unwrap();
 290     let num_deleted = Post::delete(&conn, inserted_post.id).unwrap();
 291     Community::delete(&conn, inserted_community.id).unwrap();
 292     User_::delete(&conn, inserted_user.id).unwrap();
 293
 294     assert_eq!(expected_post, read_post);
 295     assert_eq!(expected_post, inserted_post);
 296     assert_eq!(expected_post, updated_post);
 297     assert_eq!(expected_post_like, inserted_post_like);
 298     assert_eq!(expected_post_saved, inserted_post_saved);
 299     assert_eq!(expected_post_read, inserted_post_read);
 300     assert_eq!(1, like_removed);
 301     assert_eq!(1, saved_removed);
 302     assert_eq!(1, read_removed);
 303     assert_eq!(1, num_deleted);
 304
 305   }
 306 }