server/src/db/moderator.rs

   1 use super::*;
   2 use crate::schema::{
   3   mod_add, mod_add_community, mod_ban, mod_ban_from_community, mod_lock_post, mod_remove_comment,
   4   mod_remove_community, mod_remove_post, mod_sticky_post,
   5 };
   6
   7 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
   8 #[table_name = "mod_remove_post"]
   9 pub struct ModRemovePost {
  10   pub id: i32,
  11   pub mod_user_id: i32,
  12   pub post_id: i32,
  13   pub reason: Option<String>,
  14   pub removed: Option<bool>,
  15   pub when_: chrono::NaiveDateTime,
  16 }
  17
  18 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
  19 #[table_name = "mod_remove_post"]
  20 pub struct ModRemovePostForm {
  21   pub mod_user_id: i32,
  22   pub post_id: i32,
  23   pub reason: Option<String>,
  24   pub removed: Option<bool>,
  25 }
  26
  27 impl Crud<ModRemovePostForm> for ModRemovePost {
  28   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
  29     use crate::schema::mod_remove_post::dsl::*;
  30     mod_remove_post.find(from_id).first::<Self>(conn)
  31   }
  32
  33   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
  34     use crate::schema::mod_remove_post::dsl::*;
  35     diesel::delete(mod_remove_post.find(from_id)).execute(conn)
  36   }
  37
  38   fn create(conn: &PgConnection, form: &ModRemovePostForm) -> Result<Self, Error> {
  39     use crate::schema::mod_remove_post::dsl::*;
  40     insert_into(mod_remove_post)
  41       .values(form)
  42       .get_result::<Self>(conn)
  43   }
  44
  45   fn update(conn: &PgConnection, from_id: i32, form: &ModRemovePostForm) -> Result<Self, Error> {
  46     use crate::schema::mod_remove_post::dsl::*;
  47     diesel::update(mod_remove_post.find(from_id))
  48       .set(form)
  49       .get_result::<Self>(conn)
  50   }
  51 }
  52
  53 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
  54 #[table_name = "mod_lock_post"]
  55 pub struct ModLockPost {
  56   pub id: i32,
  57   pub mod_user_id: i32,
  58   pub post_id: i32,
  59   pub locked: Option<bool>,
  60   pub when_: chrono::NaiveDateTime,
  61 }
  62
  63 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
  64 #[table_name = "mod_lock_post"]
  65 pub struct ModLockPostForm {
  66   pub mod_user_id: i32,
  67   pub post_id: i32,
  68   pub locked: Option<bool>,
  69 }
  70
  71 impl Crud<ModLockPostForm> for ModLockPost {
  72   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
  73     use crate::schema::mod_lock_post::dsl::*;
  74     mod_lock_post.find(from_id).first::<Self>(conn)
  75   }
  76
  77   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
  78     use crate::schema::mod_lock_post::dsl::*;
  79     diesel::delete(mod_lock_post.find(from_id)).execute(conn)
  80   }
  81
  82   fn create(conn: &PgConnection, form: &ModLockPostForm) -> Result<Self, Error> {
  83     use crate::schema::mod_lock_post::dsl::*;
  84     insert_into(mod_lock_post)
  85       .values(form)
  86       .get_result::<Self>(conn)
  87   }
  88
  89   fn update(conn: &PgConnection, from_id: i32, form: &ModLockPostForm) -> Result<Self, Error> {
  90     use crate::schema::mod_lock_post::dsl::*;
  91     diesel::update(mod_lock_post.find(from_id))
  92       .set(form)
  93       .get_result::<Self>(conn)
  94   }
  95 }
  96
  97 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
  98 #[table_name = "mod_sticky_post"]
  99 pub struct ModStickyPost {
 100   pub id: i32,
 101   pub mod_user_id: i32,
 102   pub post_id: i32,
 103   pub stickied: Option<bool>,
 104   pub when_: chrono::NaiveDateTime,
 105 }
 106
 107 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
 108 #[table_name = "mod_sticky_post"]
 109 pub struct ModStickyPostForm {
 110   pub mod_user_id: i32,
 111   pub post_id: i32,
 112   pub stickied: Option<bool>,
 113 }
 114
 115 impl Crud<ModStickyPostForm> for ModStickyPost {
 116   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 117     use crate::schema::mod_sticky_post::dsl::*;
 118     mod_sticky_post.find(from_id).first::<Self>(conn)
 119   }
 120
 121   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
 122     use crate::schema::mod_sticky_post::dsl::*;
 123     diesel::delete(mod_sticky_post.find(from_id)).execute(conn)
 124   }
 125
 126   fn create(conn: &PgConnection, form: &ModStickyPostForm) -> Result<Self, Error> {
 127     use crate::schema::mod_sticky_post::dsl::*;
 128     insert_into(mod_sticky_post)
 129       .values(form)
 130       .get_result::<Self>(conn)
 131   }
 132
 133   fn update(conn: &PgConnection, from_id: i32, form: &ModStickyPostForm) -> Result<Self, Error> {
 134     use crate::schema::mod_sticky_post::dsl::*;
 135     diesel::update(mod_sticky_post.find(from_id))
 136       .set(form)
 137       .get_result::<Self>(conn)
 138   }
 139 }
 140
 141 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
 142 #[table_name = "mod_remove_comment"]
 143 pub struct ModRemoveComment {
 144   pub id: i32,
 145   pub mod_user_id: i32,
 146   pub comment_id: i32,
 147   pub reason: Option<String>,
 148   pub removed: Option<bool>,
 149   pub when_: chrono::NaiveDateTime,
 150 }
 151
 152 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
 153 #[table_name = "mod_remove_comment"]
 154 pub struct ModRemoveCommentForm {
 155   pub mod_user_id: i32,
 156   pub comment_id: i32,
 157   pub reason: Option<String>,
 158   pub removed: Option<bool>,
 159 }
 160
 161 impl Crud<ModRemoveCommentForm> for ModRemoveComment {
 162   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 163     use crate::schema::mod_remove_comment::dsl::*;
 164     mod_remove_comment.find(from_id).first::<Self>(conn)
 165   }
 166
 167   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
 168     use crate::schema::mod_remove_comment::dsl::*;
 169     diesel::delete(mod_remove_comment.find(from_id)).execute(conn)
 170   }
 171
 172   fn create(conn: &PgConnection, form: &ModRemoveCommentForm) -> Result<Self, Error> {
 173     use crate::schema::mod_remove_comment::dsl::*;
 174     insert_into(mod_remove_comment)
 175       .values(form)
 176       .get_result::<Self>(conn)
 177   }
 178
 179   fn update(conn: &PgConnection, from_id: i32, form: &ModRemoveCommentForm) -> Result<Self, Error> {
 180     use crate::schema::mod_remove_comment::dsl::*;
 181     diesel::update(mod_remove_comment.find(from_id))
 182       .set(form)
 183       .get_result::<Self>(conn)
 184   }
 185 }
 186
 187 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
 188 #[table_name = "mod_remove_community"]
 189 pub struct ModRemoveCommunity {
 190   pub id: i32,
 191   pub mod_user_id: i32,
 192   pub community_id: i32,
 193   pub reason: Option<String>,
 194   pub removed: Option<bool>,
 195   pub expires: Option<chrono::NaiveDateTime>,
 196   pub when_: chrono::NaiveDateTime,
 197 }
 198
 199 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
 200 #[table_name = "mod_remove_community"]
 201 pub struct ModRemoveCommunityForm {
 202   pub mod_user_id: i32,
 203   pub community_id: i32,
 204   pub reason: Option<String>,
 205   pub removed: Option<bool>,
 206   pub expires: Option<chrono::NaiveDateTime>,
 207 }
 208
 209 impl Crud<ModRemoveCommunityForm> for ModRemoveCommunity {
 210   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 211     use crate::schema::mod_remove_community::dsl::*;
 212     mod_remove_community.find(from_id).first::<Self>(conn)
 213   }
 214
 215   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
 216     use crate::schema::mod_remove_community::dsl::*;
 217     diesel::delete(mod_remove_community.find(from_id)).execute(conn)
 218   }
 219
 220   fn create(conn: &PgConnection, form: &ModRemoveCommunityForm) -> Result<Self, Error> {
 221     use crate::schema::mod_remove_community::dsl::*;
 222     insert_into(mod_remove_community)
 223       .values(form)
 224       .get_result::<Self>(conn)
 225   }
 226
 227   fn update(
 228     conn: &PgConnection,
 229     from_id: i32,
 230     form: &ModRemoveCommunityForm,
 231   ) -> Result<Self, Error> {
 232     use crate::schema::mod_remove_community::dsl::*;
 233     diesel::update(mod_remove_community.find(from_id))
 234       .set(form)
 235       .get_result::<Self>(conn)
 236   }
 237 }
 238
 239 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
 240 #[table_name = "mod_ban_from_community"]
 241 pub struct ModBanFromCommunity {
 242   pub id: i32,
 243   pub mod_user_id: i32,
 244   pub other_user_id: i32,
 245   pub community_id: i32,
 246   pub reason: Option<String>,
 247   pub banned: Option<bool>,
 248   pub expires: Option<chrono::NaiveDateTime>,
 249   pub when_: chrono::NaiveDateTime,
 250 }
 251
 252 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
 253 #[table_name = "mod_ban_from_community"]
 254 pub struct ModBanFromCommunityForm {
 255   pub mod_user_id: i32,
 256   pub other_user_id: i32,
 257   pub community_id: i32,
 258   pub reason: Option<String>,
 259   pub banned: Option<bool>,
 260   pub expires: Option<chrono::NaiveDateTime>,
 261 }
 262
 263 impl Crud<ModBanFromCommunityForm> for ModBanFromCommunity {
 264   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 265     use crate::schema::mod_ban_from_community::dsl::*;
 266     mod_ban_from_community.find(from_id).first::<Self>(conn)
 267   }
 268
 269   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
 270     use crate::schema::mod_ban_from_community::dsl::*;
 271     diesel::delete(mod_ban_from_community.find(from_id)).execute(conn)
 272   }
 273
 274   fn create(conn: &PgConnection, form: &ModBanFromCommunityForm) -> Result<Self, Error> {
 275     use crate::schema::mod_ban_from_community::dsl::*;
 276     insert_into(mod_ban_from_community)
 277       .values(form)
 278       .get_result::<Self>(conn)
 279   }
 280
 281   fn update(
 282     conn: &PgConnection,
 283     from_id: i32,
 284     form: &ModBanFromCommunityForm,
 285   ) -> Result<Self, Error> {
 286     use crate::schema::mod_ban_from_community::dsl::*;
 287     diesel::update(mod_ban_from_community.find(from_id))
 288       .set(form)
 289       .get_result::<Self>(conn)
 290   }
 291 }
 292
 293 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
 294 #[table_name = "mod_ban"]
 295 pub struct ModBan {
 296   pub id: i32,
 297   pub mod_user_id: i32,
 298   pub other_user_id: i32,
 299   pub reason: Option<String>,
 300   pub banned: Option<bool>,
 301   pub expires: Option<chrono::NaiveDateTime>,
 302   pub when_: chrono::NaiveDateTime,
 303 }
 304
 305 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
 306 #[table_name = "mod_ban"]
 307 pub struct ModBanForm {
 308   pub mod_user_id: i32,
 309   pub other_user_id: i32,
 310   pub reason: Option<String>,
 311   pub banned: Option<bool>,
 312   pub expires: Option<chrono::NaiveDateTime>,
 313 }
 314
 315 impl Crud<ModBanForm> for ModBan {
 316   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 317     use crate::schema::mod_ban::dsl::*;
 318     mod_ban.find(from_id).first::<Self>(conn)
 319   }
 320
 321   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
 322     use crate::schema::mod_ban::dsl::*;
 323     diesel::delete(mod_ban.find(from_id)).execute(conn)
 324   }
 325
 326   fn create(conn: &PgConnection, form: &ModBanForm) -> Result<Self, Error> {
 327     use crate::schema::mod_ban::dsl::*;
 328     insert_into(mod_ban).values(form).get_result::<Self>(conn)
 329   }
 330
 331   fn update(conn: &PgConnection, from_id: i32, form: &ModBanForm) -> Result<Self, Error> {
 332     use crate::schema::mod_ban::dsl::*;
 333     diesel::update(mod_ban.find(from_id))
 334       .set(form)
 335       .get_result::<Self>(conn)
 336   }
 337 }
 338
 339 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
 340 #[table_name = "mod_add_community"]
 341 pub struct ModAddCommunity {
 342   pub id: i32,
 343   pub mod_user_id: i32,
 344   pub other_user_id: i32,
 345   pub community_id: i32,
 346   pub removed: Option<bool>,
 347   pub when_: chrono::NaiveDateTime,
 348 }
 349
 350 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
 351 #[table_name = "mod_add_community"]
 352 pub struct ModAddCommunityForm {
 353   pub mod_user_id: i32,
 354   pub other_user_id: i32,
 355   pub community_id: i32,
 356   pub removed: Option<bool>,
 357 }
 358
 359 impl Crud<ModAddCommunityForm> for ModAddCommunity {
 360   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 361     use crate::schema::mod_add_community::dsl::*;
 362     mod_add_community.find(from_id).first::<Self>(conn)
 363   }
 364
 365   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
 366     use crate::schema::mod_add_community::dsl::*;
 367     diesel::delete(mod_add_community.find(from_id)).execute(conn)
 368   }
 369
 370   fn create(conn: &PgConnection, form: &ModAddCommunityForm) -> Result<Self, Error> {
 371     use crate::schema::mod_add_community::dsl::*;
 372     insert_into(mod_add_community)
 373       .values(form)
 374       .get_result::<Self>(conn)
 375   }
 376
 377   fn update(conn: &PgConnection, from_id: i32, form: &ModAddCommunityForm) -> Result<Self, Error> {
 378     use crate::schema::mod_add_community::dsl::*;
 379     diesel::update(mod_add_community.find(from_id))
 380       .set(form)
 381       .get_result::<Self>(conn)
 382   }
 383 }
 384
 385 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
 386 #[table_name = "mod_add"]
 387 pub struct ModAdd {
 388   pub id: i32,
 389   pub mod_user_id: i32,
 390   pub other_user_id: i32,
 391   pub removed: Option<bool>,
 392   pub when_: chrono::NaiveDateTime,
 393 }
 394
 395 #[derive(Insertable, AsChangeset, Clone, Serialize, Deserialize)]
 396 #[table_name = "mod_add"]
 397 pub struct ModAddForm {
 398   pub mod_user_id: i32,
 399   pub other_user_id: i32,
 400   pub removed: Option<bool>,
 401 }
 402
 403 impl Crud<ModAddForm> for ModAdd {
 404   fn read(conn: &PgConnection, from_id: i32) -> Result<Self, Error> {
 405     use crate::schema::mod_add::dsl::*;
 406     mod_add.find(from_id).first::<Self>(conn)
 407   }
 408
 409   fn delete(conn: &PgConnection, from_id: i32) -> Result<usize, Error> {
 410     use crate::schema::mod_add::dsl::*;
 411     diesel::delete(mod_add.find(from_id)).execute(conn)
 412   }
 413
 414   fn create(conn: &PgConnection, form: &ModAddForm) -> Result<Self, Error> {
 415     use crate::schema::mod_add::dsl::*;
 416     insert_into(mod_add).values(form).get_result::<Self>(conn)
 417   }
 418
 419   fn update(conn: &PgConnection, from_id: i32, form: &ModAddForm) -> Result<Self, Error> {
 420     use crate::schema::mod_add::dsl::*;
 421     diesel::update(mod_add.find(from_id))
 422       .set(form)
 423       .get_result::<Self>(conn)
 424   }
 425 }
 426
 427 #[cfg(test)]
 428 mod tests {
 429   use super::super::comment::*;
 430   use super::super::community::*;
 431   use super::super::post::*;
 432   use super::super::user::*;
 433   use super::*;
 434   // use Crud;
 435   #[test]
 436   fn test_crud() {
 437     let conn = establish_connection();
 438
 439     let new_mod = UserForm {
 440       name: "the mod".into(),
 441       fedi_name: "rrf".into(),
 442       preferred_username: None,
 443       password_encrypted: "nope".into(),
 444       email: None,
 445       admin: false,
 446       banned: false,
 447       updated: None,
 448       show_nsfw: false,
 449       theme: "darkly".into(),
 450     };
 451
 452     let inserted_mod = User_::create(&conn, &new_mod).unwrap();
 453
 454     let new_user = UserForm {
 455       name: "jim2".into(),
 456       fedi_name: "rrf".into(),
 457       preferred_username: None,
 458       password_encrypted: "nope".into(),
 459       email: None,
 460       admin: false,
 461       banned: false,
 462       updated: None,
 463       show_nsfw: false,
 464       theme: "darkly".into(),
 465     };
 466
 467     let inserted_user = User_::create(&conn, &new_user).unwrap();
 468
 469     let new_community = CommunityForm {
 470       name: "mod_community".to_string(),
 471       title: "nada".to_owned(),
 472       description: None,
 473       category_id: 1,
 474       creator_id: inserted_user.id,
 475       removed: None,
 476       deleted: None,
 477       updated: None,
 478       nsfw: false,
 479     };
 480
 481     let inserted_community = Community::create(&conn, &new_community).unwrap();
 482
 483     let new_post = PostForm {
 484       name: "A test post thweep".into(),
 485       url: None,
 486       body: None,
 487       creator_id: inserted_user.id,
 488       community_id: inserted_community.id,
 489       removed: None,
 490       deleted: None,
 491       locked: None,
 492       stickied: None,
 493       updated: None,
 494       nsfw: false,
 495     };
 496
 497     let inserted_post = Post::create(&conn, &new_post).unwrap();
 498
 499     let comment_form = CommentForm {
 500       content: "A test comment".into(),
 501       creator_id: inserted_user.id,
 502       post_id: inserted_post.id,
 503       removed: None,
 504       deleted: None,
 505       read: None,
 506       parent_id: None,
 507       updated: None,
 508     };
 509
 510     let inserted_comment = Comment::create(&conn, &comment_form).unwrap();
 511
 512     // Now the actual tests
 513
 514     // remove post
 515     let mod_remove_post_form = ModRemovePostForm {
 516       mod_user_id: inserted_mod.id,
 517       post_id: inserted_post.id,
 518       reason: None,
 519       removed: None,
 520     };
 521     let inserted_mod_remove_post = ModRemovePost::create(&conn, &mod_remove_post_form).unwrap();
 522     let read_mod_remove_post = ModRemovePost::read(&conn, inserted_mod_remove_post.id).unwrap();
 523     let expected_mod_remove_post = ModRemovePost {
 524       id: inserted_mod_remove_post.id,
 525       post_id: inserted_post.id,
 526       mod_user_id: inserted_mod.id,
 527       reason: None,
 528       removed: Some(true),
 529       when_: inserted_mod_remove_post.when_,
 530     };
 531
 532     // lock post
 533
 534     let mod_lock_post_form = ModLockPostForm {
 535       mod_user_id: inserted_mod.id,
 536       post_id: inserted_post.id,
 537       locked: None,
 538     };
 539     let inserted_mod_lock_post = ModLockPost::create(&conn, &mod_lock_post_form).unwrap();
 540     let read_mod_lock_post = ModLockPost::read(&conn, inserted_mod_lock_post.id).unwrap();
 541     let expected_mod_lock_post = ModLockPost {
 542       id: inserted_mod_lock_post.id,
 543       post_id: inserted_post.id,
 544       mod_user_id: inserted_mod.id,
 545       locked: Some(true),
 546       when_: inserted_mod_lock_post.when_,
 547     };
 548
 549     // sticky post
 550
 551     let mod_sticky_post_form = ModStickyPostForm {
 552       mod_user_id: inserted_mod.id,
 553       post_id: inserted_post.id,
 554       stickied: None,
 555     };
 556     let inserted_mod_sticky_post = ModStickyPost::create(&conn, &mod_sticky_post_form).unwrap();
 557     let read_mod_sticky_post = ModStickyPost::read(&conn, inserted_mod_sticky_post.id).unwrap();
 558     let expected_mod_sticky_post = ModStickyPost {
 559       id: inserted_mod_sticky_post.id,
 560       post_id: inserted_post.id,
 561       mod_user_id: inserted_mod.id,
 562       stickied: Some(true),
 563       when_: inserted_mod_sticky_post.when_,
 564     };
 565
 566     // comment
 567
 568     let mod_remove_comment_form = ModRemoveCommentForm {
 569       mod_user_id: inserted_mod.id,
 570       comment_id: inserted_comment.id,
 571       reason: None,
 572       removed: None,
 573     };
 574     let inserted_mod_remove_comment =
 575       ModRemoveComment::create(&conn, &mod_remove_comment_form).unwrap();
 576     let read_mod_remove_comment =
 577       ModRemoveComment::read(&conn, inserted_mod_remove_comment.id).unwrap();
 578     let expected_mod_remove_comment = ModRemoveComment {
 579       id: inserted_mod_remove_comment.id,
 580       comment_id: inserted_comment.id,
 581       mod_user_id: inserted_mod.id,
 582       reason: None,
 583       removed: Some(true),
 584       when_: inserted_mod_remove_comment.when_,
 585     };
 586
 587     // community
 588
 589     let mod_remove_community_form = ModRemoveCommunityForm {
 590       mod_user_id: inserted_mod.id,
 591       community_id: inserted_community.id,
 592       reason: None,
 593       removed: None,
 594       expires: None,
 595     };
 596     let inserted_mod_remove_community =
 597       ModRemoveCommunity::create(&conn, &mod_remove_community_form).unwrap();
 598     let read_mod_remove_community =
 599       ModRemoveCommunity::read(&conn, inserted_mod_remove_community.id).unwrap();
 600     let expected_mod_remove_community = ModRemoveCommunity {
 601       id: inserted_mod_remove_community.id,
 602       community_id: inserted_community.id,
 603       mod_user_id: inserted_mod.id,
 604       reason: None,
 605       removed: Some(true),
 606       expires: None,
 607       when_: inserted_mod_remove_community.when_,
 608     };
 609
 610     // ban from community
 611
 612     let mod_ban_from_community_form = ModBanFromCommunityForm {
 613       mod_user_id: inserted_mod.id,
 614       other_user_id: inserted_user.id,
 615       community_id: inserted_community.id,
 616       reason: None,
 617       banned: None,
 618       expires: None,
 619     };
 620     let inserted_mod_ban_from_community =
 621       ModBanFromCommunity::create(&conn, &mod_ban_from_community_form).unwrap();
 622     let read_mod_ban_from_community =
 623       ModBanFromCommunity::read(&conn, inserted_mod_ban_from_community.id).unwrap();
 624     let expected_mod_ban_from_community = ModBanFromCommunity {
 625       id: inserted_mod_ban_from_community.id,
 626       community_id: inserted_community.id,
 627       mod_user_id: inserted_mod.id,
 628       other_user_id: inserted_user.id,
 629       reason: None,
 630       banned: Some(true),
 631       expires: None,
 632       when_: inserted_mod_ban_from_community.when_,
 633     };
 634
 635     // ban
 636
 637     let mod_ban_form = ModBanForm {
 638       mod_user_id: inserted_mod.id,
 639       other_user_id: inserted_user.id,
 640       reason: None,
 641       banned: None,
 642       expires: None,
 643     };
 644     let inserted_mod_ban = ModBan::create(&conn, &mod_ban_form).unwrap();
 645     let read_mod_ban = ModBan::read(&conn, inserted_mod_ban.id).unwrap();
 646     let expected_mod_ban = ModBan {
 647       id: inserted_mod_ban.id,
 648       mod_user_id: inserted_mod.id,
 649       other_user_id: inserted_user.id,
 650       reason: None,
 651       banned: Some(true),
 652       expires: None,
 653       when_: inserted_mod_ban.when_,
 654     };
 655
 656     // mod add community
 657
 658     let mod_add_community_form = ModAddCommunityForm {
 659       mod_user_id: inserted_mod.id,
 660       other_user_id: inserted_user.id,
 661       community_id: inserted_community.id,
 662       removed: None,
 663     };
 664     let inserted_mod_add_community =
 665       ModAddCommunity::create(&conn, &mod_add_community_form).unwrap();
 666     let read_mod_add_community =
 667       ModAddCommunity::read(&conn, inserted_mod_add_community.id).unwrap();
 668     let expected_mod_add_community = ModAddCommunity {
 669       id: inserted_mod_add_community.id,
 670       community_id: inserted_community.id,
 671       mod_user_id: inserted_mod.id,
 672       other_user_id: inserted_user.id,
 673       removed: Some(false),
 674       when_: inserted_mod_add_community.when_,
 675     };
 676
 677     // mod add
 678
 679     let mod_add_form = ModAddForm {
 680       mod_user_id: inserted_mod.id,
 681       other_user_id: inserted_user.id,
 682       removed: None,
 683     };
 684     let inserted_mod_add = ModAdd::create(&conn, &mod_add_form).unwrap();
 685     let read_mod_add = ModAdd::read(&conn, inserted_mod_add.id).unwrap();
 686     let expected_mod_add = ModAdd {
 687       id: inserted_mod_add.id,
 688       mod_user_id: inserted_mod.id,
 689       other_user_id: inserted_user.id,
 690       removed: Some(false),
 691       when_: inserted_mod_add.when_,
 692     };
 693
 694     ModRemovePost::delete(&conn, inserted_mod_remove_post.id).unwrap();
 695     ModLockPost::delete(&conn, inserted_mod_lock_post.id).unwrap();
 696     ModStickyPost::delete(&conn, inserted_mod_sticky_post.id).unwrap();
 697     ModRemoveComment::delete(&conn, inserted_mod_remove_comment.id).unwrap();
 698     ModRemoveCommunity::delete(&conn, inserted_mod_remove_community.id).unwrap();
 699     ModBanFromCommunity::delete(&conn, inserted_mod_ban_from_community.id).unwrap();
 700     ModBan::delete(&conn, inserted_mod_ban.id).unwrap();
 701     ModAddCommunity::delete(&conn, inserted_mod_add_community.id).unwrap();
 702     ModAdd::delete(&conn, inserted_mod_add.id).unwrap();
 703
 704     Comment::delete(&conn, inserted_comment.id).unwrap();
 705     Post::delete(&conn, inserted_post.id).unwrap();
 706     Community::delete(&conn, inserted_community.id).unwrap();
 707     User_::delete(&conn, inserted_user.id).unwrap();
 708     User_::delete(&conn, inserted_mod.id).unwrap();
 709
 710     assert_eq!(expected_mod_remove_post, read_mod_remove_post);
 711     assert_eq!(expected_mod_lock_post, read_mod_lock_post);
 712     assert_eq!(expected_mod_sticky_post, read_mod_sticky_post);
 713     assert_eq!(expected_mod_remove_comment, read_mod_remove_comment);
 714     assert_eq!(expected_mod_remove_community, read_mod_remove_community);
 715     assert_eq!(expected_mod_ban_from_community, read_mod_ban_from_community);
 716     assert_eq!(expected_mod_ban, read_mod_ban);
 717     assert_eq!(expected_mod_add_community, read_mod_add_community);
 718     assert_eq!(expected_mod_add, read_mod_add);
 719   }
 720 }