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_unpooled_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       matrix_user_id: None,
 446       avatar: None,
 447       admin: false,
 448       banned: false,
 449       updated: None,
 450       show_nsfw: false,
 451       theme: "darkly".into(),
 452       default_sort_type: SortType::Hot as i16,
 453       default_listing_type: ListingType::Subscribed as i16,
 454       lang: "browser".into(),
 455       show_avatars: true,
 456       send_notifications_to_email: false,
 457     };
 458
 459     let inserted_mod = User_::create(&conn, &new_mod).unwrap();
 460
 461     let new_user = UserForm {
 462       name: "jim2".into(),
 463       fedi_name: "rrf".into(),
 464       preferred_username: None,
 465       password_encrypted: "nope".into(),
 466       email: None,
 467       matrix_user_id: None,
 468       avatar: None,
 469       admin: false,
 470       banned: false,
 471       updated: None,
 472       show_nsfw: false,
 473       theme: "darkly".into(),
 474       default_sort_type: SortType::Hot as i16,
 475       default_listing_type: ListingType::Subscribed as i16,
 476       lang: "browser".into(),
 477       show_avatars: true,
 478       send_notifications_to_email: false,
 479     };
 480
 481     let inserted_user = User_::create(&conn, &new_user).unwrap();
 482
 483     let new_community = CommunityForm {
 484       name: "mod_community".to_string(),
 485       title: "nada".to_owned(),
 486       description: None,
 487       category_id: 1,
 488       creator_id: inserted_user.id,
 489       removed: None,
 490       deleted: None,
 491       updated: None,
 492       nsfw: false,
 493     };
 494
 495     let inserted_community = Community::create(&conn, &new_community).unwrap();
 496
 497     let new_post = PostForm {
 498       name: "A test post thweep".into(),
 499       url: None,
 500       body: None,
 501       creator_id: inserted_user.id,
 502       community_id: inserted_community.id,
 503       removed: None,
 504       deleted: None,
 505       locked: None,
 506       stickied: None,
 507       updated: None,
 508       nsfw: false,
 509     };
 510
 511     let inserted_post = Post::create(&conn, &new_post).unwrap();
 512
 513     let comment_form = CommentForm {
 514       content: "A test comment".into(),
 515       creator_id: inserted_user.id,
 516       post_id: inserted_post.id,
 517       removed: None,
 518       deleted: None,
 519       read: None,
 520       parent_id: None,
 521       updated: None,
 522     };
 523
 524     let inserted_comment = Comment::create(&conn, &comment_form).unwrap();
 525
 526     // Now the actual tests
 527
 528     // remove post
 529     let mod_remove_post_form = ModRemovePostForm {
 530       mod_user_id: inserted_mod.id,
 531       post_id: inserted_post.id,
 532       reason: None,
 533       removed: None,
 534     };
 535     let inserted_mod_remove_post = ModRemovePost::create(&conn, &mod_remove_post_form).unwrap();
 536     let read_mod_remove_post = ModRemovePost::read(&conn, inserted_mod_remove_post.id).unwrap();
 537     let expected_mod_remove_post = ModRemovePost {
 538       id: inserted_mod_remove_post.id,
 539       post_id: inserted_post.id,
 540       mod_user_id: inserted_mod.id,
 541       reason: None,
 542       removed: Some(true),
 543       when_: inserted_mod_remove_post.when_,
 544     };
 545
 546     // lock post
 547
 548     let mod_lock_post_form = ModLockPostForm {
 549       mod_user_id: inserted_mod.id,
 550       post_id: inserted_post.id,
 551       locked: None,
 552     };
 553     let inserted_mod_lock_post = ModLockPost::create(&conn, &mod_lock_post_form).unwrap();
 554     let read_mod_lock_post = ModLockPost::read(&conn, inserted_mod_lock_post.id).unwrap();
 555     let expected_mod_lock_post = ModLockPost {
 556       id: inserted_mod_lock_post.id,
 557       post_id: inserted_post.id,
 558       mod_user_id: inserted_mod.id,
 559       locked: Some(true),
 560       when_: inserted_mod_lock_post.when_,
 561     };
 562
 563     // sticky post
 564
 565     let mod_sticky_post_form = ModStickyPostForm {
 566       mod_user_id: inserted_mod.id,
 567       post_id: inserted_post.id,
 568       stickied: None,
 569     };
 570     let inserted_mod_sticky_post = ModStickyPost::create(&conn, &mod_sticky_post_form).unwrap();
 571     let read_mod_sticky_post = ModStickyPost::read(&conn, inserted_mod_sticky_post.id).unwrap();
 572     let expected_mod_sticky_post = ModStickyPost {
 573       id: inserted_mod_sticky_post.id,
 574       post_id: inserted_post.id,
 575       mod_user_id: inserted_mod.id,
 576       stickied: Some(true),
 577       when_: inserted_mod_sticky_post.when_,
 578     };
 579
 580     // comment
 581
 582     let mod_remove_comment_form = ModRemoveCommentForm {
 583       mod_user_id: inserted_mod.id,
 584       comment_id: inserted_comment.id,
 585       reason: None,
 586       removed: None,
 587     };
 588     let inserted_mod_remove_comment =
 589       ModRemoveComment::create(&conn, &mod_remove_comment_form).unwrap();
 590     let read_mod_remove_comment =
 591       ModRemoveComment::read(&conn, inserted_mod_remove_comment.id).unwrap();
 592     let expected_mod_remove_comment = ModRemoveComment {
 593       id: inserted_mod_remove_comment.id,
 594       comment_id: inserted_comment.id,
 595       mod_user_id: inserted_mod.id,
 596       reason: None,
 597       removed: Some(true),
 598       when_: inserted_mod_remove_comment.when_,
 599     };
 600
 601     // community
 602
 603     let mod_remove_community_form = ModRemoveCommunityForm {
 604       mod_user_id: inserted_mod.id,
 605       community_id: inserted_community.id,
 606       reason: None,
 607       removed: None,
 608       expires: None,
 609     };
 610     let inserted_mod_remove_community =
 611       ModRemoveCommunity::create(&conn, &mod_remove_community_form).unwrap();
 612     let read_mod_remove_community =
 613       ModRemoveCommunity::read(&conn, inserted_mod_remove_community.id).unwrap();
 614     let expected_mod_remove_community = ModRemoveCommunity {
 615       id: inserted_mod_remove_community.id,
 616       community_id: inserted_community.id,
 617       mod_user_id: inserted_mod.id,
 618       reason: None,
 619       removed: Some(true),
 620       expires: None,
 621       when_: inserted_mod_remove_community.when_,
 622     };
 623
 624     // ban from community
 625
 626     let mod_ban_from_community_form = ModBanFromCommunityForm {
 627       mod_user_id: inserted_mod.id,
 628       other_user_id: inserted_user.id,
 629       community_id: inserted_community.id,
 630       reason: None,
 631       banned: None,
 632       expires: None,
 633     };
 634     let inserted_mod_ban_from_community =
 635       ModBanFromCommunity::create(&conn, &mod_ban_from_community_form).unwrap();
 636     let read_mod_ban_from_community =
 637       ModBanFromCommunity::read(&conn, inserted_mod_ban_from_community.id).unwrap();
 638     let expected_mod_ban_from_community = ModBanFromCommunity {
 639       id: inserted_mod_ban_from_community.id,
 640       community_id: inserted_community.id,
 641       mod_user_id: inserted_mod.id,
 642       other_user_id: inserted_user.id,
 643       reason: None,
 644       banned: Some(true),
 645       expires: None,
 646       when_: inserted_mod_ban_from_community.when_,
 647     };
 648
 649     // ban
 650
 651     let mod_ban_form = ModBanForm {
 652       mod_user_id: inserted_mod.id,
 653       other_user_id: inserted_user.id,
 654       reason: None,
 655       banned: None,
 656       expires: None,
 657     };
 658     let inserted_mod_ban = ModBan::create(&conn, &mod_ban_form).unwrap();
 659     let read_mod_ban = ModBan::read(&conn, inserted_mod_ban.id).unwrap();
 660     let expected_mod_ban = ModBan {
 661       id: inserted_mod_ban.id,
 662       mod_user_id: inserted_mod.id,
 663       other_user_id: inserted_user.id,
 664       reason: None,
 665       banned: Some(true),
 666       expires: None,
 667       when_: inserted_mod_ban.when_,
 668     };
 669
 670     // mod add community
 671
 672     let mod_add_community_form = ModAddCommunityForm {
 673       mod_user_id: inserted_mod.id,
 674       other_user_id: inserted_user.id,
 675       community_id: inserted_community.id,
 676       removed: None,
 677     };
 678     let inserted_mod_add_community =
 679       ModAddCommunity::create(&conn, &mod_add_community_form).unwrap();
 680     let read_mod_add_community =
 681       ModAddCommunity::read(&conn, inserted_mod_add_community.id).unwrap();
 682     let expected_mod_add_community = ModAddCommunity {
 683       id: inserted_mod_add_community.id,
 684       community_id: inserted_community.id,
 685       mod_user_id: inserted_mod.id,
 686       other_user_id: inserted_user.id,
 687       removed: Some(false),
 688       when_: inserted_mod_add_community.when_,
 689     };
 690
 691     // mod add
 692
 693     let mod_add_form = ModAddForm {
 694       mod_user_id: inserted_mod.id,
 695       other_user_id: inserted_user.id,
 696       removed: None,
 697     };
 698     let inserted_mod_add = ModAdd::create(&conn, &mod_add_form).unwrap();
 699     let read_mod_add = ModAdd::read(&conn, inserted_mod_add.id).unwrap();
 700     let expected_mod_add = ModAdd {
 701       id: inserted_mod_add.id,
 702       mod_user_id: inserted_mod.id,
 703       other_user_id: inserted_user.id,
 704       removed: Some(false),
 705       when_: inserted_mod_add.when_,
 706     };
 707
 708     ModRemovePost::delete(&conn, inserted_mod_remove_post.id).unwrap();
 709     ModLockPost::delete(&conn, inserted_mod_lock_post.id).unwrap();
 710     ModStickyPost::delete(&conn, inserted_mod_sticky_post.id).unwrap();
 711     ModRemoveComment::delete(&conn, inserted_mod_remove_comment.id).unwrap();
 712     ModRemoveCommunity::delete(&conn, inserted_mod_remove_community.id).unwrap();
 713     ModBanFromCommunity::delete(&conn, inserted_mod_ban_from_community.id).unwrap();
 714     ModBan::delete(&conn, inserted_mod_ban.id).unwrap();
 715     ModAddCommunity::delete(&conn, inserted_mod_add_community.id).unwrap();
 716     ModAdd::delete(&conn, inserted_mod_add.id).unwrap();
 717
 718     Comment::delete(&conn, inserted_comment.id).unwrap();
 719     Post::delete(&conn, inserted_post.id).unwrap();
 720     Community::delete(&conn, inserted_community.id).unwrap();
 721     User_::delete(&conn, inserted_user.id).unwrap();
 722     User_::delete(&conn, inserted_mod.id).unwrap();
 723
 724     assert_eq!(expected_mod_remove_post, read_mod_remove_post);
 725     assert_eq!(expected_mod_lock_post, read_mod_lock_post);
 726     assert_eq!(expected_mod_sticky_post, read_mod_sticky_post);
 727     assert_eq!(expected_mod_remove_comment, read_mod_remove_comment);
 728     assert_eq!(expected_mod_remove_community, read_mod_remove_community);
 729     assert_eq!(expected_mod_ban_from_community, read_mod_ban_from_community);
 730     assert_eq!(expected_mod_ban, read_mod_ban);
 731     assert_eq!(expected_mod_add_community, read_mod_add_community);
 732     assert_eq!(expected_mod_add, read_mod_add);
 733   }
 734 }