lemmy/server/src/websocket/server.rs

//! `ChatServer` is an actor. It maintains list of connection client session.
//! And manages available rooms. Peers send messages to other peers in same
//! room through `ChatServer`.

use actix::prelude::*;
use rand::{rngs::ThreadRng, Rng};
use std::collections::{HashMap, HashSet};
use serde::{Deserialize, Serialize};
use serde_json::{Value};
use bcrypt::{verify};
use std::str::FromStr;
use diesel::PgConnection;
use failure::Error;
use std::time::{SystemTime};

use {Crud, Joinable, Likeable, Followable, Bannable, Saveable, establish_connection, naive_now, naive_from_unix, SortType, SearchType, has_slurs, remove_slurs, Settings};
use db::community::*;
use db::user::*;
use db::post::*;
use db::comment::*;
use db::post_view::*;
use db::comment_view::*;
use db::category::*;
use db::community_view::*;
use db::user_view::*;
use db::moderator_views::*;
use db::moderator::*;

const RATE_LIMIT_MESSAGES: i32 = 30;
const RATE_LIMIT_PER_SECOND: i32 = 60;
const RATE_LIMIT_REGISTER_MESSAGES: i32 = 1;
const RATE_LIMIT_REGISTER_PER_SECOND: i32 = 60;

#[derive(EnumString,ToString,Debug)]
pub enum UserOperation {
  Login, Register, CreateCommunity, CreatePost, ListCommunities, ListCategories, GetPost, GetCommunity, CreateComment, EditComment, SaveComment, CreateCommentLike, GetPosts, CreatePostLike, EditPost, SavePost, EditCommunity, FollowCommunity, GetFollowedCommunities, GetUserDetails, GetReplies, GetModlog, BanFromCommunity, AddModToCommunity, CreateSite, EditSite, GetSite, AddAdmin, BanUser, Search, MarkAllAsRead
}

#[derive(Fail, Debug)]
#[fail(display = "{{\"op\":\"{}\", \"error\":\"{}\"}}", op, message)]
pub struct ErrorMessage {
  op: String,
  message: String
}

/// Chat server sends this messages to session
#[derive(Message)]
pub struct WSMessage(pub String);

/// Message for chat server communications

/// New chat session is created
#[derive(Message)]
#[rtype(usize)]
pub struct Connect {
  pub addr: Recipient<WSMessage>,
  pub ip: String,
}

/// Session is disconnected
#[derive(Message)]
pub struct Disconnect {
  pub id: usize,
  pub ip: String,
}

/// Send message to specific room
#[derive(Message)]
pub struct ClientMessage {
  /// Id of the client session
  pub id: usize,
  /// Peer message
  pub msg: String,
  /// Room name
  pub room: String,
}

#[derive(Serialize, Deserialize)]
pub struct StandardMessage {
  /// Id of the client session
  pub id: usize,
  /// Peer message
  pub msg: String,
}

impl actix::Message for StandardMessage {
  type Result = String;
}

#[derive(Serialize, Deserialize)]
pub struct Login {
  pub username_or_email: String,
  pub password: String
}

#[derive(Serialize, Deserialize)]
pub struct Register {
  username: String,
  email: Option<String>,
  password: String,
  password_verify: String,
  admin: bool,
  spam_timeri: i64,
}

#[derive(Serialize, Deserialize)]
pub struct LoginResponse {
  op: String,
  jwt: String
}

#[derive(Serialize, Deserialize)]
pub struct CreateCommunity {
  name: String,
  title: String,
  description: Option<String>,
  category_id: i32 ,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct CommunityResponse {
  op: String,
  community: CommunityView
}

#[derive(Serialize, Deserialize)]
pub struct ListCommunities {
  sort: String,
  page: Option<i64>,
  limit: Option<i64>,
  auth: Option<String>
}

#[derive(Serialize, Deserialize)]
pub struct ListCommunitiesResponse {
  op: String,
  communities: Vec<CommunityView>
}

#[derive(Serialize, Deserialize)]
pub struct ListCategories;

#[derive(Serialize, Deserialize)]
pub struct ListCategoriesResponse {
  op: String,
  categories: Vec<Category>
}

#[derive(Serialize, Deserialize)]
pub struct CreatePost {
  name: String,
  url: Option<String>,
  body: Option<String>,
  community_id: i32,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct PostResponse {
  op: String,
  post: PostView
}


#[derive(Serialize, Deserialize)]
pub struct GetPost {
  id: i32,
  auth: Option<String>
}

#[derive(Serialize, Deserialize)]
pub struct GetPostResponse {
  op: String,
  post: PostView,
  comments: Vec<CommentView>,
  community: CommunityView,
  moderators: Vec<CommunityModeratorView>,
  admins: Vec<UserView>,
}

#[derive(Serialize, Deserialize)]
pub struct GetPosts {
  type_: String,
  sort: String,
  page: Option<i64>,
  limit: Option<i64>,
  community_id: Option<i32>,
  auth: Option<String>
}

#[derive(Serialize, Deserialize)]
pub struct GetPostsResponse {
  op: String,
  posts: Vec<PostView>,
}

#[derive(Serialize, Deserialize)]
pub struct GetCommunity {
  id: Option<i32>,
  name: Option<String>,
  auth: Option<String>
}

#[derive(Serialize, Deserialize)]
pub struct GetCommunityResponse {
  op: String,
  community: CommunityView,
  moderators: Vec<CommunityModeratorView>,
  admins: Vec<UserView>,
}

#[derive(Serialize, Deserialize)]
pub struct CreateComment {
  content: String,
  parent_id: Option<i32>,
  edit_id: Option<i32>,
  post_id: i32,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct EditComment {
  content: String,
  parent_id: Option<i32>,
  edit_id: i32,
  creator_id: i32,
  post_id: i32,
  removed: Option<bool>,
  deleted: Option<bool>,
  reason: Option<String>,
  read: Option<bool>,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct SaveComment {
  comment_id: i32,
  save: bool,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct CommentResponse {
  op: String,
  comment: CommentView
}

#[derive(Serialize, Deserialize)]
pub struct CreateCommentLike {
  comment_id: i32,
  post_id: i32,
  score: i16,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct CreatePostLike {
  post_id: i32,
  score: i16,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct CreatePostLikeResponse {
  op: String,
  post: PostView
}


#[derive(Serialize, Deserialize)]
pub struct EditPost {
  edit_id: i32,
  creator_id: i32,
  community_id: i32,
  name: String,
  url: Option<String>,
  body: Option<String>,
  removed: Option<bool>,
  deleted: Option<bool>,
  locked: Option<bool>,
  reason: Option<String>,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct SavePost {
  post_id: i32,
  save: bool,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct EditCommunity {
  edit_id: i32,
  name: String,
  title: String,
  description: Option<String>,
  category_id: i32,
  removed: Option<bool>,
  deleted: Option<bool>,
  reason: Option<String>,
  expires: Option<i64>,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct FollowCommunity {
  community_id: i32,
  follow: bool,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct GetFollowedCommunities {
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct GetFollowedCommunitiesResponse {
  op: String,
  communities: Vec<CommunityFollowerView>
}

#[derive(Serialize, Deserialize)]
pub struct GetUserDetails {
  user_id: Option<i32>,
  username: Option<String>,
  sort: String,
  page: Option<i64>,
  limit: Option<i64>,
  community_id: Option<i32>,
  saved_only: bool,
  auth: Option<String>,
}

#[derive(Serialize, Deserialize)]
pub struct GetUserDetailsResponse {
  op: String,
  user: UserView,
  follows: Vec<CommunityFollowerView>,
  moderates: Vec<CommunityModeratorView>,
  comments: Vec<CommentView>,
  posts: Vec<PostView>,
}

#[derive(Serialize, Deserialize)]
pub struct GetModlog {
  mod_user_id: Option<i32>,
  community_id: Option<i32>,
  page: Option<i64>,
  limit: Option<i64>,
}

#[derive(Serialize, Deserialize)]
pub struct GetModlogResponse {
  op: String,
  removed_posts: Vec<ModRemovePostView>,
  locked_posts: Vec<ModLockPostView>,
  removed_comments: Vec<ModRemoveCommentView>,
  removed_communities: Vec<ModRemoveCommunityView>,
  banned_from_community: Vec<ModBanFromCommunityView>,
  banned: Vec<ModBanView>,
  added_to_community: Vec<ModAddCommunityView>,
  added: Vec<ModAddView>,
}

#[derive(Serialize, Deserialize)]
pub struct BanFromCommunity {
  community_id: i32,
  user_id: i32,
  ban: bool,
  reason: Option<String>,
  expires: Option<i64>,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct BanFromCommunityResponse {
  op: String,
  user: UserView,
  banned: bool,
}


#[derive(Serialize, Deserialize)]
pub struct AddModToCommunity {
  community_id: i32,
  user_id: i32,
  added: bool,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct AddModToCommunityResponse {
  op: String,
  moderators: Vec<CommunityModeratorView>,
}

#[derive(Serialize, Deserialize)]
pub struct CreateSite {
  name: String,
  description: Option<String>,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct EditSite {
  name: String,
  description: Option<String>,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct GetSite {
}

#[derive(Serialize, Deserialize)]
pub struct SiteResponse {
  op: String,
  site: SiteView,
}

#[derive(Serialize, Deserialize)]
pub struct GetSiteResponse {
  op: String,
  site: Option<SiteView>,
  admins: Vec<UserView>,
  banned: Vec<UserView>,
}

#[derive(Serialize, Deserialize)]
pub struct AddAdmin {
  user_id: i32,
  added: bool,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct AddAdminResponse {
  op: String,
  admins: Vec<UserView>,
}

#[derive(Serialize, Deserialize)]
pub struct BanUser {
  user_id: i32,
  ban: bool,
  reason: Option<String>,
  expires: Option<i64>,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct BanUserResponse {
  op: String,
  user: UserView,
  banned: bool,
}

#[derive(Serialize, Deserialize)]
pub struct GetReplies {
  sort: String,
  page: Option<i64>,
  limit: Option<i64>,
  unread_only: bool,
  auth: String
}

#[derive(Serialize, Deserialize)]
pub struct GetRepliesResponse {
  op: String,
  replies: Vec<ReplyView>,
}

#[derive(Serialize, Deserialize)]
pub struct Search {
  q: String,
  type_: String,
  community_id: Option<i32>,
  sort: String,
  page: Option<i64>,
  limit: Option<i64>,
}

#[derive(Serialize, Deserialize)]
pub struct SearchResponse {
  op: String,
  comments: Vec<CommentView>,
  posts: Vec<PostView>,
}

#[derive(Serialize, Deserialize)]
pub struct MarkAllAsRead {
  auth: String
}

#[derive(Debug)]
pub struct RateLimitBucket {
  last_checked: SystemTime,
  allowance: f64
}

pub struct SessionInfo {
  pub addr: Recipient<WSMessage>,
  pub ip: String,
}

/// `ChatServer` manages chat rooms and responsible for coordinating chat
/// session. implementation is super primitive
pub struct ChatServer {
  sessions: HashMap<usize, SessionInfo>, // A map from generated random ID to session addr
  rate_limits: HashMap<String, RateLimitBucket>,
  rooms: HashMap<i32, HashSet<usize>>, // A map from room / post name to set of connectionIDs
  rng: ThreadRng,
}

impl Default for ChatServer {
  fn default() -> ChatServer {
    // default room
    let rooms = HashMap::new();

    ChatServer {
      sessions: HashMap::new(),
      rate_limits: HashMap::new(),
      rooms: rooms,
      rng: rand::thread_rng(),
    }
  }
}

impl ChatServer {
  /// Send message to all users in the room
  fn send_room_message(&self, room: i32, message: &str, skip_id: usize) {
    if let Some(sessions) = self.rooms.get(&room) {
      for id in sessions {
        if *id != skip_id {
          if let Some(info) = self.sessions.get(id) {
            let _ = info.addr.do_send(WSMessage(message.to_owned()));
          }
        }
      }
    }
  }

  fn send_community_message(&self, conn: &PgConnection, community_id: i32, message: &str, skip_id: usize) -> Result<(), Error> {
    let posts = PostView::list(conn,
                               PostListingType::Community, 
                               &SortType::New, 
                               Some(community_id), 
                               None,
                               None, 
                               None,
                               false,
                               false,
                               None,
                               Some(9999))?;
    for post in posts {
      self.send_room_message(post.id, message, skip_id);
    }

    Ok(())
  }

  fn check_rate_limit_register(&mut self, addr: usize) -> Result<(), Error> {
    self.check_rate_limit_full(addr, RATE_LIMIT_REGISTER_MESSAGES, RATE_LIMIT_REGISTER_PER_SECOND)
  }

  fn check_rate_limit(&mut self, addr: usize) -> Result<(), Error> {
    self.check_rate_limit_full(addr, RATE_LIMIT_MESSAGES, RATE_LIMIT_PER_SECOND)
  }

  fn check_rate_limit_full(&mut self, addr: usize, rate: i32, per: i32) -> Result<(), Error> {
    if let Some(info) = self.sessions.get(&addr) {
      if let Some(rate_limit) = self.rate_limits.get_mut(&info.ip) {
        // The initial value
        if rate_limit.allowance == -2f64 {
          rate_limit.allowance = rate as f64;
        };

        let current = SystemTime::now();
        let time_passed = current.duration_since(rate_limit.last_checked)?.as_secs() as f64;
        rate_limit.last_checked = current;
        rate_limit.allowance += time_passed * (rate as f64 / per as f64);
        if rate_limit.allowance > rate as f64 {
          rate_limit.allowance = rate as f64;
        }

        if rate_limit.allowance < 1.0 {
          println!("Rate limited IP: {}, time_passed: {}, allowance: {}", &info.ip, time_passed, rate_limit.allowance);
          Err(ErrorMessage {
            op: "Rate Limit".to_string(), 
            message: format!("Too many requests. {} per {} seconds", rate, per),
          })?
        } else {
          rate_limit.allowance -= 1.0;
          Ok(())
        }
      } else {
        Ok(())
      }
    } else {
      Ok(())
    }
  }
}


/// Make actor from `ChatServer`
impl Actor for ChatServer {
  /// We are going to use simple Context, we just need ability to communicate
  /// with other actors.
  type Context = Context<Self>;
}

/// Handler for Connect message.
///
/// Register new session and assign unique id to this session
impl Handler<Connect> for ChatServer {
  type Result = usize;

  fn handle(&mut self, msg: Connect, _ctx: &mut Context<Self>) -> Self::Result {

    // notify all users in same room
    // self.send_room_message(&"Main".to_owned(), "Someone joined", 0);

    // register session with random id
    let id = self.rng.gen::<usize>();
    println!("{} joined", &msg.ip);

    self.sessions.insert(id, SessionInfo {
      addr: msg.addr,
      ip: msg.ip.to_owned(),
    });

    if self.rate_limits.get(&msg.ip).is_none() {
      self.rate_limits.insert(msg.ip, RateLimitBucket {
        last_checked: SystemTime::now(),
        allowance: -2f64,
      });
    }

    // for (k,v) in &self.rate_limits {
    //   println!("{}: {:?}", k,v);
    // }

    // auto join session to Main room
    // self.rooms.get_mut(&"Main".to_owned()).unwrap().insert(id);

    // send id back
    id
  }
}


/// Handler for Disconnect message.
impl Handler<Disconnect> for ChatServer {
  type Result = ();

  fn handle(&mut self, msg: Disconnect, _: &mut Context<Self>) {

    // let mut rooms: Vec<i32> = Vec::new();

    // remove address
    if self.sessions.remove(&msg.id).is_some() {
      // remove session from all rooms
      for (_id, sessions) in &mut self.rooms {
        if sessions.remove(&msg.id) {
          // rooms.push(*id);
        }
      }
    }
  }
}

/// Handler for Message message.
impl Handler<StandardMessage> for ChatServer {
  type Result = MessageResult<StandardMessage>;


  fn handle(&mut self, msg: StandardMessage, _: &mut Context<Self>) -> Self::Result {

    let msg_out = match parse_json_message(self, msg) {
      Ok(m) => m,
      Err(e) => e.to_string()
    };

    MessageResult(msg_out)
  }
}

fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result<String, Error> {

  let json: Value = serde_json::from_str(&msg.msg)?;
  let data = &json["data"].to_string();
  let op = &json["op"].as_str().unwrap();

  let user_operation: UserOperation = UserOperation::from_str(&op)?;

  match user_operation {
    UserOperation::Login => {
      let login: Login = serde_json::from_str(data)?;
      login.perform(chat, msg.id)
    },
    UserOperation::Register => {
      let register: Register = serde_json::from_str(data)?;
      register.perform(chat, msg.id)
    },
    UserOperation::CreateCommunity => {
      let create_community: CreateCommunity = serde_json::from_str(data)?;
      create_community.perform(chat, msg.id)
    },
    UserOperation::ListCommunities => {
      let list_communities: ListCommunities = serde_json::from_str(data)?;
      list_communities.perform(chat, msg.id)
    },
    UserOperation::ListCategories => {
      let list_categories: ListCategories = ListCategories;
      list_categories.perform(chat, msg.id)
    },
    UserOperation::CreatePost => {
      let create_post: CreatePost = serde_json::from_str(data)?;
      create_post.perform(chat, msg.id)
    },
    UserOperation::GetPost => {
      let get_post: GetPost = serde_json::from_str(data)?;
      get_post.perform(chat, msg.id)
    },
    UserOperation::GetCommunity => {
      let get_community: GetCommunity = serde_json::from_str(data)?;
      get_community.perform(chat, msg.id)
    },
    UserOperation::CreateComment => {
      let create_comment: CreateComment = serde_json::from_str(data)?;
      create_comment.perform(chat, msg.id)
    },
    UserOperation::EditComment => {
      let edit_comment: EditComment = serde_json::from_str(data)?;
      edit_comment.perform(chat, msg.id)
    },
    UserOperation::SaveComment => {
      let save_post: SaveComment = serde_json::from_str(data)?;
      save_post.perform(chat, msg.id)
    },
    UserOperation::CreateCommentLike => {
      let create_comment_like: CreateCommentLike = serde_json::from_str(data)?;
      create_comment_like.perform(chat, msg.id)
    },
    UserOperation::GetPosts => {
      let get_posts: GetPosts = serde_json::from_str(data)?;
      get_posts.perform(chat, msg.id)
    },
    UserOperation::CreatePostLike => {
      let create_post_like: CreatePostLike = serde_json::from_str(data)?;
      create_post_like.perform(chat, msg.id)
    },
    UserOperation::EditPost => {
      let edit_post: EditPost = serde_json::from_str(data)?;
      edit_post.perform(chat, msg.id)
    },
    UserOperation::SavePost => {
      let save_post: SavePost = serde_json::from_str(data)?;
      save_post.perform(chat, msg.id)
    },
    UserOperation::EditCommunity => {
      let edit_community: EditCommunity = serde_json::from_str(data)?;
      edit_community.perform(chat, msg.id)
    },
    UserOperation::FollowCommunity => {
      let follow_community: FollowCommunity = serde_json::from_str(data)?;
      follow_community.perform(chat, msg.id)
    },
    UserOperation::GetFollowedCommunities => {
      let followed_communities: GetFollowedCommunities = serde_json::from_str(data)?;
      followed_communities.perform(chat, msg.id)
    },
    UserOperation::GetUserDetails => {
      let get_user_details: GetUserDetails = serde_json::from_str(data)?;
      get_user_details.perform(chat, msg.id)
    },
    UserOperation::GetModlog => {
      let get_modlog: GetModlog = serde_json::from_str(data)?;
      get_modlog.perform(chat, msg.id)
    },
    UserOperation::BanFromCommunity => {
      let ban_from_community: BanFromCommunity = serde_json::from_str(data)?;
      ban_from_community.perform(chat, msg.id)
    },
    UserOperation::AddModToCommunity => {
      let mod_add_to_community: AddModToCommunity = serde_json::from_str(data)?;
      mod_add_to_community.perform(chat, msg.id)
    },
    UserOperation::CreateSite => {
      let create_site: CreateSite = serde_json::from_str(data)?;
      create_site.perform(chat, msg.id)
    },
    UserOperation::EditSite => {
      let edit_site: EditSite = serde_json::from_str(data)?;
      edit_site.perform(chat, msg.id)
    },
    UserOperation::GetSite => {
      let get_site: GetSite = serde_json::from_str(data)?;
      get_site.perform(chat, msg.id)
    },
    UserOperation::AddAdmin => {
      let add_admin: AddAdmin = serde_json::from_str(data)?;
      add_admin.perform(chat, msg.id)
    },
    UserOperation::BanUser => {
      let ban_user: BanUser = serde_json::from_str(data)?;
      ban_user.perform(chat, msg.id)
    },
    UserOperation::GetReplies => {
      let get_replies: GetReplies = serde_json::from_str(data)?;
      get_replies.perform(chat, msg.id)
    },
    UserOperation::Search => {
      let search: Search = serde_json::from_str(data)?;
      search.perform(chat, msg.id)
    },
    UserOperation::MarkAllAsRead => {
      let mark_all_as_read: MarkAllAsRead = serde_json::from_str(data)?;
      mark_all_as_read.perform(chat, msg.id)
    },
  }
}

pub trait Perform {
  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error>;
  fn op_type(&self) -> UserOperation;
  fn error(&self, error_msg: &str) -> ErrorMessage {
    ErrorMessage {
      op: self.op_type().to_string(), 
      message: error_msg.to_string()
    }
  }
}

impl Perform for Login {

  fn op_type(&self) -> UserOperation {
    UserOperation::Login
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    // Fetch that username / email
    let user: User_ = match User_::find_by_email_or_username(&conn, &self.username_or_email) {
      Ok(user) => user,
      Err(_e) => return Err(self.error("Couldn't find that username or email"))?
    };

    // Verify the password
    let valid: bool = verify(&self.password, &user.password_encrypted).unwrap_or(false);
    if !valid {
      return Err(self.error("Password incorrect"))?
    }

    // Return the jwt
    Ok(
      serde_json::to_string(
        &LoginResponse {
          op: self.op_type().to_string(),
          jwt: user.jwt()
        }
        )?
      )
  }

}

impl Perform for Register {
  fn op_type(&self) -> UserOperation {
    UserOperation::Register
  }
  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    chat.check_rate_limit_register(addr)?;

    // Make sure passwords match
    if &self.password != &self.password_verify {
      return Err(self.error("Passwords do not match."))?
    }

    if self.spam_timeri < 1142 {
      return Err(self.error("Too fast"))?
    }

    if has_slurs(&self.username) {
      return Err(self.error("No slurs"))?
    }

    // Make sure there are no admins
    if self.admin && UserView::admins(&conn)?.len() > 0 {
      return Err(self.error("Sorry, there's already an admin."))?
    }

    // Register the new user
    let user_form = UserForm {
      name: self.username.to_owned(),
      fedi_name: Settings::get().hostname.into(),
      email: self.email.to_owned(),
      password_encrypted: self.password.to_owned(),
      preferred_username: None,
      updated: None,
      admin: self.admin,
      banned: false,
    };

    // Create the user
    let inserted_user = match User_::register(&conn, &user_form) {
      Ok(user) => user,
      Err(_e) => {
        return Err(self.error("User already exists."))?
      }
    };

    // Sign them up for main community no matter what
    let community_follower_form = CommunityFollowerForm {
      community_id: 1,
      user_id: inserted_user.id,
    };

    let _inserted_community_follower = match CommunityFollower::follow(&conn, &community_follower_form) {
      Ok(user) => user,
      Err(_e) => {
        return Err(self.error("Community follower already exists."))?
      }
    };

    // If its an admin, add them as a mod and follower to main
    if self.admin {
      let community_moderator_form = CommunityModeratorForm {
        community_id: 1,
        user_id: inserted_user.id,
      };

      let _inserted_community_moderator = match CommunityModerator::join(&conn, &community_moderator_form) {
        Ok(user) => user,
        Err(_e) => {
          return Err(self.error("Community moderator already exists."))?
        }
      };

    }


    // Return the jwt
    Ok(
      serde_json::to_string(
        &LoginResponse {
          op: self.op_type().to_string(), 
          jwt: inserted_user.jwt()
        }
        )?
      )

  }
}

impl Perform for CreateCommunity {
  fn op_type(&self) -> UserOperation {
    UserOperation::CreateCommunity
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    chat.check_rate_limit_register(addr)?;

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    if has_slurs(&self.name) || 
      has_slurs(&self.title) || 
        (self.description.is_some() && has_slurs(&self.description.to_owned().unwrap())) {
          return Err(self.error("No slurs"))?
        }

    let user_id = claims.id;

    // Check for a site ban
    if UserView::read(&conn, user_id)?.banned {
      return Err(self.error("You have been banned from the site"))?
    }

    // When you create a community, make sure the user becomes a moderator and a follower
    let community_form = CommunityForm {
      name: self.name.to_owned(),
      title: self.title.to_owned(),
      description: self.description.to_owned(),
      category_id: self.category_id,
      creator_id: user_id,
      removed: None,
      deleted: None,
      updated: None,
    };

    let inserted_community = match Community::create(&conn, &community_form) {
      Ok(community) => community,
      Err(_e) => {
        return Err(self.error("Community already exists."))?
      }
    };

    let community_moderator_form = CommunityModeratorForm {
      community_id: inserted_community.id,
      user_id: user_id
    };

    let _inserted_community_moderator = match CommunityModerator::join(&conn, &community_moderator_form) {
      Ok(user) => user,
      Err(_e) => {
        return Err(self.error("Community moderator already exists."))?
      }
    };

    let community_follower_form = CommunityFollowerForm {
      community_id: inserted_community.id,
      user_id: user_id
    };

    let _inserted_community_follower = match CommunityFollower::follow(&conn, &community_follower_form) {
      Ok(user) => user,
      Err(_e) => {
        return Err(self.error("Community follower already exists."))?
      }
    };

    let community_view = CommunityView::read(&conn, inserted_community.id, Some(user_id))?;

    Ok(
      serde_json::to_string(
        &CommunityResponse {
          op: self.op_type().to_string(), 
          community: community_view
        }
        )?
      )
  }
}

impl Perform for ListCommunities {
  fn op_type(&self) -> UserOperation {
    UserOperation::ListCommunities
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let user_id: Option<i32> = match &self.auth {
      Some(auth) => {
        match Claims::decode(&auth) {
          Ok(claims) => {
            let user_id = claims.claims.id;
            Some(user_id)
          }
          Err(_e) => None
        }
      }
      None => None
    };

    let sort = SortType::from_str(&self.sort)?;

    let communities: Vec<CommunityView> = CommunityView::list(&conn, user_id, sort, self.page, self.limit)?;

    // Return the jwt
    Ok(
      serde_json::to_string(
        &ListCommunitiesResponse {
          op: self.op_type().to_string(),
          communities: communities
        }
        )?
      )
  }
}

impl Perform for ListCategories {
  fn op_type(&self) -> UserOperation {
    UserOperation::ListCategories
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let categories: Vec<Category> = Category::list_all(&conn)?;

    // Return the jwt
    Ok(
      serde_json::to_string(
        &ListCategoriesResponse {
          op: self.op_type().to_string(),
          categories: categories
        }
        )?
      )
  }
}

impl Perform for CreatePost {
  fn op_type(&self) -> UserOperation {
    UserOperation::CreatePost
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    chat.check_rate_limit_register(addr)?;

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    if has_slurs(&self.name) || 
      (self.body.is_some() && has_slurs(&self.body.to_owned().unwrap())) {
        return Err(self.error("No slurs"))?
      }

    let user_id = claims.id;

    // Check for a community ban
    if CommunityUserBanView::get(&conn, user_id, self.community_id).is_ok() {
      return Err(self.error("You have been banned from this community"))?
    }

    // Check for a site ban
    if UserView::read(&conn, user_id)?.banned {
      return Err(self.error("You have been banned from the site"))?
    }

    let post_form = PostForm {
      name: self.name.to_owned(),
      url: self.url.to_owned(),
      body: self.body.to_owned(),
      community_id: self.community_id,
      creator_id: user_id,
      removed: None,
      deleted: None,
      locked: None,
      updated: None
    };

    let inserted_post = match Post::create(&conn, &post_form) {
      Ok(post) => post,
      Err(_e) => {
        return Err(self.error("Couldn't create Post"))?
      }
    };

    // They like their own post by default
    let like_form = PostLikeForm {
      post_id: inserted_post.id,
      user_id: user_id,
      score: 1
    };

    // Only add the like if the score isnt 0
    let _inserted_like = match PostLike::like(&conn, &like_form) {
      Ok(like) => like,
      Err(_e) => {
        return Err(self.error("Couldn't like post."))?
      }
    };

    // Refetch the view
    let post_view = match PostView::read(&conn, inserted_post.id, Some(user_id)) {
      Ok(post) => post,
      Err(_e) => {
        return Err(self.error("Couldn't find Post"))?
      }
    };

    Ok(
      serde_json::to_string(
        &PostResponse {
          op: self.op_type().to_string(), 
          post: post_view
        }
        )?
      )
  }
}


impl Perform for GetPost {
  fn op_type(&self) -> UserOperation {
    UserOperation::GetPost
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let user_id: Option<i32> = match &self.auth {
      Some(auth) => {
        match Claims::decode(&auth) {
          Ok(claims) => {
            let user_id = claims.claims.id;
            Some(user_id)
          }
          Err(_e) => None
        }
      }
      None => None
    };

    let post_view = match PostView::read(&conn, self.id, user_id) {
      Ok(post) => post,
      Err(_e) => {
        return Err(self.error("Couldn't find Post"))?
      }
    };

    // remove session from all rooms
    for (_n, sessions) in &mut chat.rooms {
      sessions.remove(&addr);
    }

    // If the room doesn't exist yet
    if chat.rooms.get_mut(&self.id).is_none() {
      chat.rooms.insert(self.id, HashSet::new());
    }

    chat.rooms.get_mut(&self.id).unwrap().insert(addr);

    let comments = CommentView::list(&conn, &SortType::New, Some(self.id), None, None, user_id, false, None, Some(9999))?;

    let community = CommunityView::read(&conn, post_view.community_id, user_id)?;

    let moderators = CommunityModeratorView::for_community(&conn, post_view.community_id)?;

    let admins = UserView::admins(&conn)?;

    // Return the jwt
    Ok(
      serde_json::to_string(
        &GetPostResponse {
          op: self.op_type().to_string(),
          post: post_view,
          comments: comments,
          community: community,
          moderators: moderators,
          admins: admins,
        }
        )?
      )
  }
}

impl Perform for GetCommunity {
  fn op_type(&self) -> UserOperation {
    UserOperation::GetCommunity
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let user_id: Option<i32> = match &self.auth {
      Some(auth) => {
        match Claims::decode(&auth) {
          Ok(claims) => {
            let user_id = claims.claims.id;
            Some(user_id)
          }
          Err(_e) => None
        }
      }
      None => None
    };

    let community_id = match self.id {
      Some(id) => id,
      None => Community::read_from_name(&conn, self.name.to_owned().unwrap_or("main".to_string()))?.id
    };

    let community_view = match CommunityView::read(&conn, community_id, user_id) {
      Ok(community) => community,
      Err(_e) => {
        return Err(self.error("Couldn't find Community"))?
      }
    };

    let moderators = match CommunityModeratorView::for_community(&conn, community_id) {
      Ok(moderators) => moderators,
      Err(_e) => {
        return Err(self.error("Couldn't find Community"))?
      }
    };

    let admins = UserView::admins(&conn)?;

    // Return the jwt
    Ok(
      serde_json::to_string(
        &GetCommunityResponse {
          op: self.op_type().to_string(),
          community: community_view,
          moderators: moderators,
          admins: admins,
        }
        )?
      )
  }
}

impl Perform for CreateComment {
  fn op_type(&self) -> UserOperation {
    UserOperation::CreateComment
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    chat.check_rate_limit(addr)?;

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    // Check for a community ban
    let post = Post::read(&conn, self.post_id)?;
    if CommunityUserBanView::get(&conn, user_id, post.community_id).is_ok() {
      return Err(self.error("You have been banned from this community"))?
    }

    // Check for a site ban
    if UserView::read(&conn, user_id)?.banned {
      return Err(self.error("You have been banned from the site"))?
    }

    let content_slurs_removed = remove_slurs(&self.content.to_owned());

    let comment_form = CommentForm {
      content: content_slurs_removed,
      parent_id: self.parent_id.to_owned(),
      post_id: self.post_id,
      creator_id: user_id,
      removed: None,
      deleted: None,
      read: None,
      updated: None
    };

    let inserted_comment = match Comment::create(&conn, &comment_form) {
      Ok(comment) => comment,
      Err(_e) => {
        return Err(self.error("Couldn't create Comment"))?
      }
    };

    // You like your own comment by default
    let like_form = CommentLikeForm {
      comment_id: inserted_comment.id,
      post_id: self.post_id,
      user_id: user_id,
      score: 1
    };

    let _inserted_like = match CommentLike::like(&conn, &like_form) {
      Ok(like) => like,
      Err(_e) => {
        return Err(self.error("Couldn't like comment."))?
      }
    };

    let comment_view = CommentView::read(&conn, inserted_comment.id, Some(user_id))?;

    let mut comment_sent = comment_view.clone();
    comment_sent.my_vote = None;
    comment_sent.user_id = None;

    let comment_out = serde_json::to_string(
      &CommentResponse {
        op: self.op_type().to_string(), 
        comment: comment_view
      }
      )?;

    let comment_sent_out = serde_json::to_string(
      &CommentResponse {
        op: self.op_type().to_string(), 
        comment: comment_sent
      }
      )?;

    chat.send_room_message(self.post_id, &comment_sent_out, addr);

    Ok(comment_out)
  }
}

impl Perform for EditComment {
  fn op_type(&self) -> UserOperation {
    UserOperation::EditComment
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let orig_comment = CommentView::read(&conn, self.edit_id, None)?;

    // You are allowed to mark the comment as read even if you're banned.
    if self.read.is_none() {

      // Verify its the creator or a mod, or an admin
      let mut editors: Vec<i32> = vec![self.creator_id];
      editors.append(
        &mut CommunityModeratorView::for_community(&conn, orig_comment.community_id)
        ?
        .into_iter()
        .map(|m| m.user_id)
        .collect()
        );
      editors.append(
        &mut UserView::admins(&conn)
        ?
        .into_iter()
        .map(|a| a.id)
        .collect()
        );

      if !editors.contains(&user_id) {
        return Err(self.error("Not allowed to edit comment."))?
      }

      // Check for a community ban
      if CommunityUserBanView::get(&conn, user_id, orig_comment.community_id).is_ok() {
        return Err(self.error("You have been banned from this community"))?
      }

      // Check for a site ban
      if UserView::read(&conn, user_id)?.banned {
        return Err(self.error("You have been banned from the site"))?
      }

    }

    let content_slurs_removed = remove_slurs(&self.content.to_owned());

    let comment_form = CommentForm {
      content: content_slurs_removed,
      parent_id: self.parent_id,
      post_id: self.post_id,
      creator_id: self.creator_id,
      removed: self.removed.to_owned(),
      deleted: self.deleted.to_owned(),
      read: self.read.to_owned(),
      updated: if self.read.is_some() { orig_comment.updated } else {Some(naive_now())}
    };

    let _updated_comment = match Comment::update(&conn, self.edit_id, &comment_form) {
      Ok(comment) => comment,
      Err(_e) => {
        return Err(self.error("Couldn't update Comment"))?
      }
    };

    // Mod tables
    if let Some(removed) = self.removed.to_owned() {
      let form = ModRemoveCommentForm {
        mod_user_id: user_id,
        comment_id: self.edit_id,
        removed: Some(removed),
        reason: self.reason.to_owned(),
      };
      ModRemoveComment::create(&conn, &form)?;
    }


    let comment_view = CommentView::read(&conn, self.edit_id, Some(user_id))?;

    let mut comment_sent = comment_view.clone();
    comment_sent.my_vote = None;
    comment_sent.user_id = None;

    let comment_out = serde_json::to_string(
      &CommentResponse {
        op: self.op_type().to_string(), 
        comment: comment_view
      }
      )?;

    let comment_sent_out = serde_json::to_string(
      &CommentResponse {
        op: self.op_type().to_string(), 
        comment: comment_sent
      }
      )?;

    chat.send_room_message(self.post_id, &comment_sent_out, addr);

    Ok(comment_out)
  }
}

impl Perform for SaveComment {
  fn op_type(&self) -> UserOperation {
    UserOperation::SaveComment
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let comment_saved_form = CommentSavedForm {
      comment_id: self.comment_id,
      user_id: user_id,
    };

    if self.save {
      match CommentSaved::save(&conn, &comment_saved_form) {
        Ok(comment) => comment,
        Err(_e) => {
          return Err(self.error("Couldnt do comment save"))?
        }
      };
    } else {
      match CommentSaved::unsave(&conn, &comment_saved_form) {
        Ok(comment) => comment,
        Err(_e) => {
          return Err(self.error("Couldnt do comment save"))?
        }
      };
    }

    let comment_view = CommentView::read(&conn, self.comment_id, Some(user_id))?;

    let comment_out = serde_json::to_string(
      &CommentResponse {
        op: self.op_type().to_string(), 
        comment: comment_view
      }
      )
      ?;

    Ok(comment_out)
  }
}


impl Perform for CreateCommentLike {
  fn op_type(&self) -> UserOperation {
    UserOperation::CreateCommentLike
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    chat.check_rate_limit(addr)?;

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    // Check for a community ban
    let post = Post::read(&conn, self.post_id)?;
    if CommunityUserBanView::get(&conn, user_id, post.community_id).is_ok() {
      return Err(self.error("You have been banned from this community"))?
    }

    // Check for a site ban
    if UserView::read(&conn, user_id)?.banned {
      return Err(self.error("You have been banned from the site"))?
    }

    let like_form = CommentLikeForm {
      comment_id: self.comment_id,
      post_id: self.post_id,
      user_id: user_id,
      score: self.score
    };

    // Remove any likes first
    CommentLike::remove(&conn, &like_form)?;

    // Only add the like if the score isnt 0
    if &like_form.score != &0 {
      let _inserted_like = match CommentLike::like(&conn, &like_form) {
        Ok(like) => like,
        Err(_e) => {
          return Err(self.error("Couldn't like comment."))?
        }
      };
    }

    // Have to refetch the comment to get the current state
    let liked_comment = CommentView::read(&conn, self.comment_id, Some(user_id))?;

    let mut liked_comment_sent = liked_comment.clone();
    liked_comment_sent.my_vote = None;
    liked_comment_sent.user_id = None;

    let like_out = serde_json::to_string(
      &CommentResponse {
        op: self.op_type().to_string(), 
        comment: liked_comment
      }
      )?;

    let like_sent_out = serde_json::to_string(
      &CommentResponse {
        op: self.op_type().to_string(), 
        comment: liked_comment_sent
      }
      )?;

    chat.send_room_message(self.post_id, &like_sent_out, addr);

    Ok(like_out)
  }
}


impl Perform for GetPosts {
  fn op_type(&self) -> UserOperation {
    UserOperation::GetPosts
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let user_id: Option<i32> = match &self.auth {
      Some(auth) => {
        match Claims::decode(&auth) {
          Ok(claims) => {
            let user_id = claims.claims.id;
            Some(user_id)
          }
          Err(_e) => None
        }
      }
      None => None
    };

    let type_ = PostListingType::from_str(&self.type_)?;
    let sort = SortType::from_str(&self.sort)?;

    let posts = match PostView::list(&conn, 
                                     type_, 
                                     &sort, 
                                     self.community_id, 
                                     None,
                                     None,
                                     user_id, 
                                     false, 
                                     false, 
                                     self.page, 
                                     self.limit) {
      Ok(posts) => posts,
      Err(_e) => {
        return Err(self.error("Couldn't get posts"))?
      }
    };

    // Return the jwt
    Ok(
      serde_json::to_string(
        &GetPostsResponse {
          op: self.op_type().to_string(),
          posts: posts
        }
        )?
      )
  }
}


impl Perform for CreatePostLike {
  fn op_type(&self) -> UserOperation {
    UserOperation::CreatePostLike
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    chat.check_rate_limit(addr)?;

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    // Check for a community ban
    let post = Post::read(&conn, self.post_id)?;
    if CommunityUserBanView::get(&conn, user_id, post.community_id).is_ok() {
      return Err(self.error("You have been banned from this community"))?
    }

    // Check for a site ban
    if UserView::read(&conn, user_id)?.banned {
      return Err(self.error("You have been banned from the site"))?
    }

    let like_form = PostLikeForm {
      post_id: self.post_id,
      user_id: user_id,
      score: self.score
    };

    // Remove any likes first
    PostLike::remove(&conn, &like_form)?;

    // Only add the like if the score isnt 0
    if &like_form.score != &0 {
      let _inserted_like = match PostLike::like(&conn, &like_form) {
        Ok(like) => like,
        Err(_e) => {
          return Err(self.error("Couldn't like post."))?
        }
      };
    }

    let post_view = match PostView::read(&conn, self.post_id, Some(user_id)) {
      Ok(post) => post,
      Err(_e) => {
        return Err(self.error("Couldn't find Post"))?
      }
    };

    // just output the score

    let like_out = serde_json::to_string(
      &CreatePostLikeResponse {
        op: self.op_type().to_string(), 
        post: post_view
      }
      )?;

    Ok(like_out)
  }
}

impl Perform for EditPost {
  fn op_type(&self) -> UserOperation {
    UserOperation::EditPost
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    if has_slurs(&self.name) || 
      (self.body.is_some() && has_slurs(&self.body.to_owned().unwrap())) {
        return Err(self.error("No slurs"))?
      }

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    // Verify its the creator or a mod or admin
    let mut editors: Vec<i32> = vec![self.creator_id];
    editors.append(
      &mut CommunityModeratorView::for_community(&conn, self.community_id)
      ?
      .into_iter()
      .map(|m| m.user_id)
      .collect()
      );
    editors.append(
      &mut UserView::admins(&conn)
      ?
      .into_iter()
      .map(|a| a.id)
      .collect()
      );
    if !editors.contains(&user_id) {
      return Err(self.error("Not allowed to edit post."))?
    }

    // Check for a community ban
    if CommunityUserBanView::get(&conn, user_id, self.community_id).is_ok() {
      return Err(self.error("You have been banned from this community"))?
    }

    // Check for a site ban
    if UserView::read(&conn, user_id)?.banned {
      return Err(self.error("You have been banned from the site"))?
    }

    let post_form = PostForm {
      name: self.name.to_owned(),
      url: self.url.to_owned(),
      body: self.body.to_owned(),
      creator_id: self.creator_id.to_owned(),
      community_id: self.community_id,
      removed: self.removed.to_owned(),
      deleted: self.deleted.to_owned(),
      locked: self.locked.to_owned(),
      updated: Some(naive_now())
    };

    let _updated_post = match Post::update(&conn, self.edit_id, &post_form) {
      Ok(post) => post,
      Err(_e) => {
        return Err(self.error("Couldn't update Post"))?
      }
    };

    // Mod tables
    if let Some(removed) = self.removed.to_owned() {
      let form = ModRemovePostForm {
        mod_user_id: user_id,
        post_id: self.edit_id,
        removed: Some(removed),
        reason: self.reason.to_owned(),
      };
      ModRemovePost::create(&conn, &form)?;
    }

    if let Some(locked) = self.locked.to_owned() {
      let form = ModLockPostForm {
        mod_user_id: user_id,
        post_id: self.edit_id,
        locked: Some(locked),
      };
      ModLockPost::create(&conn, &form)?;
    }

    let post_view = PostView::read(&conn, self.edit_id, Some(user_id))?;

    let mut post_sent = post_view.clone();
    post_sent.my_vote = None;

    let post_out = serde_json::to_string(
      &PostResponse {
        op: self.op_type().to_string(), 
        post: post_view
      }
      )
      ?;

    let post_sent_out = serde_json::to_string(
      &PostResponse {
        op: self.op_type().to_string(), 
        post: post_sent
      }
      )
      ?;

    chat.send_room_message(self.edit_id, &post_sent_out, addr);

    Ok(post_out)
  }
}

impl Perform for SavePost {
  fn op_type(&self) -> UserOperation {
    UserOperation::SavePost
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let post_saved_form = PostSavedForm {
      post_id: self.post_id,
      user_id: user_id,
    };

    if self.save {
      match PostSaved::save(&conn, &post_saved_form) {
        Ok(post) => post,
        Err(_e) => {
          return Err(self.error("Couldnt do post save"))?
        }
      };
    } else {
      match PostSaved::unsave(&conn, &post_saved_form) {
        Ok(post) => post,
        Err(_e) => {
          return Err(self.error("Couldnt do post save"))?
        }
      };
    }

    let post_view = PostView::read(&conn, self.post_id, Some(user_id))?;

    let post_out = serde_json::to_string(
      &PostResponse {
        op: self.op_type().to_string(), 
        post: post_view
      }
      )
      ?;

    Ok(post_out)
  }
}

impl Perform for EditCommunity {
  fn op_type(&self) -> UserOperation {
    UserOperation::EditCommunity
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    if has_slurs(&self.name) || has_slurs(&self.title) {
      return Err(self.error("No slurs"))?
    }

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    // Check for a site ban
    if UserView::read(&conn, user_id)?.banned {
      return Err(self.error("You have been banned from the site"))?
    }

    // Verify its a mod
    let mut editors: Vec<i32> = Vec::new();
    editors.append(
      &mut CommunityModeratorView::for_community(&conn, self.edit_id)
      ?
      .into_iter()
      .map(|m| m.user_id)
      .collect()
      );
    editors.append(
      &mut UserView::admins(&conn)
      ?
      .into_iter()
      .map(|a| a.id)
      .collect()
      );
    if !editors.contains(&user_id) {
      return Err(self.error("Not allowed to edit community"))?
    }

    let community_form = CommunityForm {
      name: self.name.to_owned(),
      title: self.title.to_owned(),
      description: self.description.to_owned(),
      category_id: self.category_id.to_owned(),
      creator_id: user_id,
      removed: self.removed.to_owned(),
      deleted: self.deleted.to_owned(),
      updated: Some(naive_now())
    };

    let _updated_community = match Community::update(&conn, self.edit_id, &community_form) {
      Ok(community) => community,
      Err(_e) => {
        return Err(self.error("Couldn't update Community"))?
      }
    };

    // Mod tables
    if let Some(removed) = self.removed.to_owned() {
      let expires = match self.expires {
        Some(time) => Some(naive_from_unix(time)),
        None => None
      };
      let form = ModRemoveCommunityForm {
        mod_user_id: user_id,
        community_id: self.edit_id,
        removed: Some(removed),
        reason: self.reason.to_owned(),
        expires: expires
      };
      ModRemoveCommunity::create(&conn, &form)?;
    }

    let community_view = CommunityView::read(&conn, self.edit_id, Some(user_id))?;

    let community_out = serde_json::to_string(
      &CommunityResponse {
        op: self.op_type().to_string(), 
        community: community_view
      }
      )
      ?;

    let community_view_sent = CommunityView::read(&conn, self.edit_id, None)?;

    let community_sent = serde_json::to_string(
      &CommunityResponse {
        op: self.op_type().to_string(), 
        community: community_view_sent
      }
      )
      ?;

    chat.send_community_message(&conn, self.edit_id, &community_sent, addr)?;

    Ok(community_out)
  }
}


impl Perform for FollowCommunity {
  fn op_type(&self) -> UserOperation {
    UserOperation::FollowCommunity
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let community_follower_form = CommunityFollowerForm {
      community_id: self.community_id,
      user_id: user_id
    };

    if self.follow {

      match CommunityFollower::follow(&conn, &community_follower_form) {
        Ok(user) => user,
        Err(_e) => {
          return Err(self.error("Community follower already exists."))?
        }
      };
    } else {
      match CommunityFollower::ignore(&conn, &community_follower_form) {
        Ok(user) => user,
        Err(_e) => {
          return Err(self.error("Community follower already exists."))?
        }
      };
    }

    let community_view = CommunityView::read(&conn, self.community_id, Some(user_id))?;

    Ok(
      serde_json::to_string(
        &CommunityResponse {
          op: self.op_type().to_string(), 
          community: community_view
        }
        )?
      )
  }
}

impl Perform for GetFollowedCommunities {
  fn op_type(&self) -> UserOperation {
    UserOperation::GetFollowedCommunities
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let communities: Vec<CommunityFollowerView> = match CommunityFollowerView::for_user(&conn, user_id) {
      Ok(communities) => communities,
      Err(_e) => {
        return Err(self.error("System error, try logging out and back in."))?
      }
    };

    // Return the jwt
    Ok(
      serde_json::to_string(
        &GetFollowedCommunitiesResponse {
          op: self.op_type().to_string(),
          communities: communities
        }
        )?
      )
  }
}

impl Perform for GetUserDetails {
  fn op_type(&self) -> UserOperation {
    UserOperation::GetUserDetails
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let user_id: Option<i32> = match &self.auth {
      Some(auth) => {
        match Claims::decode(&auth) {
          Ok(claims) => {
            let user_id = claims.claims.id;
            Some(user_id)
          }
          Err(_e) => None
        }
      }
      None => None
    };

    //TODO add save
    let sort = SortType::from_str(&self.sort)?;

    let user_details_id = match self.user_id {
      Some(id) => id,
      None => User_::read_from_name(&conn, self.username.to_owned().unwrap_or("admin".to_string()))?.id
    };

    let user_view = UserView::read(&conn, user_details_id)?;

    // If its saved only, you don't care what creator it was
    let posts = if self.saved_only {
      PostView::list(&conn, 
                     PostListingType::All, 
                     &sort, 
                     self.community_id, 
                     None, 
                     None,
                     Some(user_details_id), 
                     self.saved_only, 
                     false, 
                     self.page, 
                     self.limit)?
    } else {
      PostView::list(&conn, 
                     PostListingType::All, 
                     &sort, 
                     self.community_id, 
                     Some(user_details_id), 
                     None, 
                     user_id, 
                     self.saved_only, 
                     false, 
                     self.page, 
                     self.limit)?
    };
    let comments = if self.saved_only {
      CommentView::list(&conn, 
                        &sort, 
                        None, 
                        None, 
                        None, 
                        Some(user_details_id), 
                        self.saved_only, 
                        self.page, 
                        self.limit)?
    } else {
      CommentView::list(&conn, 
                        &sort, 
                        None, 
                        Some(user_details_id), 
                        None, 
                        user_id, 
                        self.saved_only, 
                        self.page, 
                        self.limit)?
    };

    let follows = CommunityFollowerView::for_user(&conn, user_details_id)?;
    let moderates = CommunityModeratorView::for_user(&conn, user_details_id)?;

    // Return the jwt
    Ok(
      serde_json::to_string(
        &GetUserDetailsResponse {
          op: self.op_type().to_string(),
          user: user_view,
          follows: follows,
          moderates: moderates, 
          comments: comments,
          posts: posts,
        }
        )?
      )
  }
}

impl Perform for GetModlog {
  fn op_type(&self) -> UserOperation {
    UserOperation::GetModlog
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let removed_posts = ModRemovePostView::list(&conn, self.community_id, self.mod_user_id, self.page, self.limit)?;
    let locked_posts = ModLockPostView::list(&conn, self.community_id, self.mod_user_id, self.page, self.limit)?;
    let removed_comments = ModRemoveCommentView::list(&conn, self.community_id, self.mod_user_id, self.page, self.limit)?;
    let banned_from_community = ModBanFromCommunityView::list(&conn, self.community_id, self.mod_user_id, self.page, self.limit)?;
    let added_to_community = ModAddCommunityView::list(&conn, self.community_id, self.mod_user_id, self.page, self.limit)?;

    // These arrays are only for the full modlog, when a community isn't given
    let mut removed_communities = Vec::new();
    let mut banned = Vec::new();
    let mut added = Vec::new();

    if self.community_id.is_none() {
      removed_communities = ModRemoveCommunityView::list(&conn, self.mod_user_id, self.page, self.limit)?;
      banned = ModBanView::list(&conn, self.mod_user_id, self.page, self.limit)?;
      added = ModAddView::list(&conn, self.mod_user_id, self.page, self.limit)?;
    }

    // Return the jwt
    Ok(
      serde_json::to_string(
        &GetModlogResponse {
          op: self.op_type().to_string(),
          removed_posts: removed_posts,
          locked_posts: locked_posts,
          removed_comments: removed_comments,
          removed_communities: removed_communities,
          banned_from_community: banned_from_community,
          banned: banned,
          added_to_community: added_to_community,
          added: added,
        }
        )?
      )
  }
}

impl Perform for GetReplies {
  fn op_type(&self) -> UserOperation {
    UserOperation::GetReplies
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let sort = SortType::from_str(&self.sort)?;

    let replies = ReplyView::get_replies(&conn, user_id, &sort, self.unread_only, self.page, self.limit)?;

    // Return the jwt
    Ok(
      serde_json::to_string(
        &GetRepliesResponse {
          op: self.op_type().to_string(),
          replies: replies,
        }
        )?
      )
  }
}

impl Perform for BanFromCommunity {
  fn op_type(&self) -> UserOperation {
    UserOperation::BanFromCommunity
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let community_user_ban_form = CommunityUserBanForm {
      community_id: self.community_id,
      user_id: self.user_id,
    };

    if self.ban {
      match CommunityUserBan::ban(&conn, &community_user_ban_form) {
        Ok(user) => user,
        Err(_e) => {
          return Err(self.error("Community user ban already exists"))?
        }
      };
    } else {
      match CommunityUserBan::unban(&conn, &community_user_ban_form) {
        Ok(user) => user,
        Err(_e) => {
          return Err(self.error("Community user ban already exists"))?
        }
      };
    }

    // Mod tables
    let expires = match self.expires {
      Some(time) => Some(naive_from_unix(time)),
      None => None
    };

    let form = ModBanFromCommunityForm {
      mod_user_id: user_id,
      other_user_id: self.user_id,
      community_id: self.community_id,
      reason: self.reason.to_owned(),
      banned: Some(self.ban),
      expires: expires,
    };
    ModBanFromCommunity::create(&conn, &form)?;

    let user_view = UserView::read(&conn, self.user_id)?;

    let res = serde_json::to_string(
      &BanFromCommunityResponse {
        op: self.op_type().to_string(), 
        user: user_view,
        banned: self.ban
      }
      )
      ?;


    chat.send_community_message(&conn, self.community_id, &res, addr)?;

    Ok(res)
  }
}

impl Perform for AddModToCommunity {
  fn op_type(&self) -> UserOperation {
    UserOperation::AddModToCommunity
  }

  fn perform(&self, chat: &mut ChatServer, addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let community_moderator_form = CommunityModeratorForm {
      community_id: self.community_id,
      user_id: self.user_id
    };

    if self.added {
      match CommunityModerator::join(&conn, &community_moderator_form) {
        Ok(user) => user,
        Err(_e) => {
          return Err(self.error("Community moderator already exists."))?
        }
      };
    } else {
      match CommunityModerator::leave(&conn, &community_moderator_form) {
        Ok(user) => user,
        Err(_e) => {
          return Err(self.error("Community moderator already exists."))?
        }
      };
    }

    // Mod tables
    let form = ModAddCommunityForm {
      mod_user_id: user_id,
      other_user_id: self.user_id,
      community_id: self.community_id,
      removed: Some(!self.added),
    };
    ModAddCommunity::create(&conn, &form)?;

    let moderators = CommunityModeratorView::for_community(&conn, self.community_id)?;

    let res = serde_json::to_string(
      &AddModToCommunityResponse {
        op: self.op_type().to_string(), 
        moderators: moderators,
      }
      )
      ?;


    chat.send_community_message(&conn, self.community_id, &res, addr)?;

    Ok(res)

  }
}

impl Perform for CreateSite {
  fn op_type(&self) -> UserOperation {
    UserOperation::CreateSite
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    if has_slurs(&self.name) || 
      (self.description.is_some() && has_slurs(&self.description.to_owned().unwrap())) {
        return Err(self.error("No slurs"))?
      }

    let user_id = claims.id;

    // Make sure user is an admin
    if !UserView::read(&conn, user_id)?.admin {
      return Err(self.error("Not an admin."))?
    }

    let site_form = SiteForm {
      name: self.name.to_owned(),
      description: self.description.to_owned(),
      creator_id: user_id,
      updated: None,
    };

    match Site::create(&conn, &site_form) {
      Ok(site) => site,
      Err(_e) => {
        return Err(self.error("Site exists already"))?
      }
    };

    let site_view = SiteView::read(&conn)?;

    Ok(
      serde_json::to_string(
        &SiteResponse {
          op: self.op_type().to_string(), 
          site: site_view,
        }
        )?
      )
  }
}

impl Perform for EditSite {
  fn op_type(&self) -> UserOperation {
    UserOperation::EditSite
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    if has_slurs(&self.name) || 
      (self.description.is_some() && has_slurs(&self.description.to_owned().unwrap())) {
        return Err(self.error("No slurs"))?
      }

    let user_id = claims.id;

    // Make sure user is an admin
    if UserView::read(&conn, user_id)?.admin == false {
      return Err(self.error("Not an admin."))?
    }

    let found_site = Site::read(&conn, 1)?;

    let site_form = SiteForm {
      name: self.name.to_owned(),
      description: self.description.to_owned(),
      creator_id: found_site.creator_id,
      updated: Some(naive_now()),
    };

    match Site::update(&conn, 1, &site_form) {
      Ok(site) => site,
      Err(_e) => {
        return Err(self.error("Couldn't update site."))?
      }
    };

    let site_view = SiteView::read(&conn)?;

    Ok(
      serde_json::to_string(
        &SiteResponse {
          op: self.op_type().to_string(), 
          site: site_view,
        }
        )?
      )
  }
}

impl Perform for GetSite {
  fn op_type(&self) -> UserOperation {
    UserOperation::GetSite
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    // It can return a null site in order to redirect
    let site_view = match Site::read(&conn, 1) {
      Ok(_site) => Some(SiteView::read(&conn)?),
      Err(_e) => None
    };

    let admins = UserView::admins(&conn)?;
    let banned = UserView::banned(&conn)?;

    Ok(
      serde_json::to_string(
        &GetSiteResponse {
          op: self.op_type().to_string(), 
          site: site_view,
          admins: admins,
          banned: banned,
        }
        )?    
      )
  }
}

impl Perform for AddAdmin {
  fn op_type(&self) -> UserOperation {
    UserOperation::AddAdmin
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    // Make sure user is an admin
    if UserView::read(&conn, user_id)?.admin == false {
      return Err(self.error("Not an admin."))?
    }

    let read_user = User_::read(&conn, self.user_id)?;

    let user_form = UserForm {
      name: read_user.name,
      fedi_name: read_user.fedi_name,
      email: read_user.email,
      password_encrypted: read_user.password_encrypted,
      preferred_username: read_user.preferred_username,
      updated: Some(naive_now()),
      admin: self.added,
      banned: read_user.banned,
    };

    match User_::update(&conn, self.user_id, &user_form) {
      Ok(user) => user,
      Err(_e) => {
        return Err(self.error("Couldn't update user"))?
      }
    };

    // Mod tables
    let form = ModAddForm {
      mod_user_id: user_id,
      other_user_id: self.user_id,
      removed: Some(!self.added),
    };

    ModAdd::create(&conn, &form)?;

    let admins = UserView::admins(&conn)?;

    let res = serde_json::to_string(
      &AddAdminResponse {
        op: self.op_type().to_string(), 
        admins: admins,
      }
      )
      ?;


    Ok(res)

  }
}

impl Perform for BanUser {
  fn op_type(&self) -> UserOperation {
    UserOperation::BanUser
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    // Make sure user is an admin
    if UserView::read(&conn, user_id)?.admin == false {
      return Err(self.error("Not an admin."))?
    }

    let read_user = User_::read(&conn, self.user_id)?;

    let user_form = UserForm {
      name: read_user.name,
      fedi_name: read_user.fedi_name,
      email: read_user.email,
      password_encrypted: read_user.password_encrypted,
      preferred_username: read_user.preferred_username,
      updated: Some(naive_now()),
      admin: read_user.admin,
      banned: self.ban,
    };

    match User_::update(&conn, self.user_id, &user_form) {
      Ok(user) => user,
      Err(_e) => {
        return Err(self.error("Couldn't update user"))?
      }
    };

    // Mod tables
    let expires = match self.expires {
      Some(time) => Some(naive_from_unix(time)),
      None => None
    };

    let form = ModBanForm {
      mod_user_id: user_id,
      other_user_id: self.user_id,
      reason: self.reason.to_owned(),
      banned: Some(self.ban),
      expires: expires,
    };

    ModBan::create(&conn, &form)?;

    let user_view = UserView::read(&conn, self.user_id)?;

    let res = serde_json::to_string(
      &BanUserResponse {
        op: self.op_type().to_string(), 
        user: user_view,
        banned: self.ban
      }
      )
      ?;

    Ok(res)

  }
}

impl Perform for Search {
  fn op_type(&self) -> UserOperation {
    UserOperation::Search
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let sort = SortType::from_str(&self.sort)?;
    let type_ = SearchType::from_str(&self.type_)?;

    let mut posts = Vec::new();
    let mut comments = Vec::new();

    match type_ {
      SearchType::Posts => {
        posts = PostView::list(&conn, 
                               PostListingType::All, 
                               &sort, 
                               self.community_id, 
                               None,
                               Some(self.q.to_owned()),
                               None, 
                               false, 
                               false, 
                               self.page, 
                               self.limit)?;
      },
      SearchType::Comments => {
        comments = CommentView::list(&conn, 
                                     &sort, 
                                     None, 
                                     None, 
                                     Some(self.q.to_owned()),
                                     None,
                                     false, 
                                     self.page,
                                     self.limit)?;
      }, 
      SearchType::Both => {
        posts = PostView::list(&conn, 
                               PostListingType::All, 
                               &sort, 
                               self.community_id, 
                               None,
                               Some(self.q.to_owned()),
                               None, 
                               false, 
                               false, 
                               self.page, 
                               self.limit)?;
        comments = CommentView::list(&conn, 
                                     &sort, 
                                     None, 
                                     None, 
                                     Some(self.q.to_owned()),
                                     None,
                                     false, 
                                     self.page,
                                     self.limit)?;
      }
    };


    // Return the jwt
    Ok(
      serde_json::to_string(
        &SearchResponse {
          op: self.op_type().to_string(),
          comments: comments,
          posts: posts,
        }
        )?
      )
  }
}


impl Perform for MarkAllAsRead {
  fn op_type(&self) -> UserOperation {
    UserOperation::MarkAllAsRead
  }

  fn perform(&self, _chat: &mut ChatServer, _addr: usize) -> Result<String, Error> {

    let conn = establish_connection();

    let claims = match Claims::decode(&self.auth) {
      Ok(claims) => claims.claims,
      Err(_e) => {
        return Err(self.error("Not logged in."))?
      }
    };

    let user_id = claims.id;

    let replies = ReplyView::get_replies(&conn, user_id, &SortType::New, true, Some(1), Some(999))?;

    for reply in &replies {
      let comment_form = CommentForm {
        content: reply.to_owned().content,
        parent_id: reply.to_owned().parent_id,
        post_id: reply.to_owned().post_id,
        creator_id: reply.to_owned().creator_id,
        removed: None,
        deleted: None,
        read: Some(true),
        updated: reply.to_owned().updated 
      };

      let _updated_comment = match Comment::update(&conn, reply.id, &comment_form) {
        Ok(comment) => comment,
        Err(_e) => {
          return Err(self.error("Couldn't update Comment"))?
        }
      };
    }

    let replies = ReplyView::get_replies(&conn, user_id, &SortType::New, true, Some(1), Some(999))?;

    Ok(
      serde_json::to_string(
        &GetRepliesResponse {
          op: self.op_type().to_string(),
          replies: replies,
        }
        )?
      )
  }
}