//! room through `ChatServer`.
use actix::prelude::*;
+use diesel::r2d2::{ConnectionManager, Pool, PooledConnection};
+use diesel::PgConnection;
+use failure::Error;
use rand::{rngs::ThreadRng, Rng};
-use std::collections::{HashMap, HashSet};
use serde::{Deserialize, Serialize};
-use serde_json::{Value};
-use bcrypt::{verify};
+use serde_json::Value;
+use std::collections::{HashMap, HashSet};
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
-}
+use std::time::SystemTime;
+
+use crate::api::comment::*;
+use crate::api::community::*;
+use crate::api::post::*;
+use crate::api::site::*;
+use crate::api::user::*;
+use crate::api::*;
+use crate::apub::puller::*;
+use crate::websocket::UserOperation;
+use crate::Settings;
+
+type ConnectionId = usize;
+type PostId = i32;
+type CommunityId = i32;
+type UserId = i32;
+type IPAddr = String;
/// Chat server sends this messages to session
#[derive(Message)]
+#[rtype(result = "()")]
pub struct WSMessage(pub String);
/// Message for chat server communications
#[rtype(usize)]
pub struct Connect {
pub addr: Recipient<WSMessage>,
- pub ip: String,
+ pub ip: IPAddr,
}
/// Session is disconnected
#[derive(Message)]
+#[rtype(result = "()")]
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,
+ pub id: ConnectionId,
+ pub ip: IPAddr,
}
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Message)]
+#[rtype(String)]
pub struct StandardMessage {
/// Id of the client session
- pub id: usize,
+ pub id: ConnectionId,
/// 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(Debug)]
+pub struct RateLimitBucket {
+ last_checked: SystemTime,
+ allowance: f64,
}
-#[derive(Serialize, Deserialize)]
-pub struct CreateSite {
- name: String,
- description: Option<String>,
- auth: String
+pub struct SessionInfo {
+ pub addr: Recipient<WSMessage>,
+ pub ip: IPAddr,
}
-#[derive(Serialize, Deserialize)]
-pub struct EditSite {
- name: String,
- description: Option<String>,
- auth: String
-}
+/// `ChatServer` manages chat rooms and responsible for coordinating chat
+/// session.
+pub struct ChatServer {
+ /// A map from generated random ID to session addr
+ sessions: HashMap<ConnectionId, SessionInfo>,
-#[derive(Serialize, Deserialize)]
-pub struct GetSite {
-}
+ /// A map from post_id to set of connectionIDs
+ post_rooms: HashMap<PostId, HashSet<ConnectionId>>,
-#[derive(Serialize, Deserialize)]
-pub struct SiteResponse {
- op: String,
- site: SiteView,
-}
+ /// A map from community to set of connectionIDs
+ community_rooms: HashMap<CommunityId, HashSet<ConnectionId>>,
-#[derive(Serialize, Deserialize)]
-pub struct GetSiteResponse {
- op: String,
- site: Option<SiteView>,
- admins: Vec<UserView>,
- banned: Vec<UserView>,
-}
+ /// A map from user id to its connection ID for joined users. Remember a user can have multiple
+ /// sessions (IE clients)
+ user_rooms: HashMap<UserId, HashSet<ConnectionId>>,
-#[derive(Serialize, Deserialize)]
-pub struct AddAdmin {
- user_id: i32,
- added: bool,
- auth: String
-}
+ /// Rate limiting based on IP addr
+ rate_limits: HashMap<IPAddr, RateLimitBucket>,
-#[derive(Serialize, Deserialize)]
-pub struct AddAdminResponse {
- op: String,
- admins: Vec<UserView>,
+ rng: ThreadRng,
+ db: Pool<ConnectionManager<PgConnection>>,
}
-#[derive(Serialize, Deserialize)]
-pub struct BanUser {
- user_id: i32,
- ban: bool,
- reason: Option<String>,
- expires: Option<i64>,
- auth: String
-}
+impl ChatServer {
+ pub fn startup(db: Pool<ConnectionManager<PgConnection>>) -> ChatServer {
+ ChatServer {
+ sessions: HashMap::new(),
+ rate_limits: HashMap::new(),
+ post_rooms: HashMap::new(),
+ community_rooms: HashMap::new(),
+ user_rooms: HashMap::new(),
+ rng: rand::thread_rng(),
+ db,
+ }
+ }
-#[derive(Serialize, Deserialize)]
-pub struct BanUserResponse {
- op: String,
- user: UserView,
- banned: bool,
-}
+ fn join_community_room(&mut self, community_id: CommunityId, id: ConnectionId) {
+ // remove session from all rooms
+ for sessions in self.community_rooms.values_mut() {
+ sessions.remove(&id);
+ }
-#[derive(Serialize, Deserialize)]
-pub struct GetReplies {
- sort: String,
- page: Option<i64>,
- limit: Option<i64>,
- unread_only: bool,
- auth: String
-}
+ // If the room doesn't exist yet
+ if self.community_rooms.get_mut(&community_id).is_none() {
+ self.community_rooms.insert(community_id, HashSet::new());
+ }
-#[derive(Serialize, Deserialize)]
-pub struct GetRepliesResponse {
- op: String,
- replies: Vec<ReplyView>,
-}
+ self
+ .community_rooms
+ .get_mut(&community_id)
+ .unwrap()
+ .insert(id);
+ }
-#[derive(Serialize, Deserialize)]
-pub struct Search {
- q: String,
- type_: String,
- community_id: Option<i32>,
- sort: String,
- page: Option<i64>,
- limit: Option<i64>,
-}
+ fn join_post_room(&mut self, post_id: PostId, id: ConnectionId) {
+ // remove session from all rooms
+ for sessions in self.post_rooms.values_mut() {
+ sessions.remove(&id);
+ }
-#[derive(Serialize, Deserialize)]
-pub struct SearchResponse {
- op: String,
- comments: Vec<CommentView>,
- posts: Vec<PostView>,
-}
+ // If the room doesn't exist yet
+ if self.post_rooms.get_mut(&post_id).is_none() {
+ self.post_rooms.insert(post_id, HashSet::new());
+ }
-#[derive(Serialize, Deserialize)]
-pub struct MarkAllAsRead {
- auth: String
-}
+ self.post_rooms.get_mut(&post_id).unwrap().insert(id);
+ }
-#[derive(Debug)]
-pub struct RateLimitBucket {
- last_checked: SystemTime,
- allowance: f64
-}
+ fn join_user_room(&mut self, user_id: UserId, id: ConnectionId) {
+ // remove session from all rooms
+ for sessions in self.user_rooms.values_mut() {
+ sessions.remove(&id);
+ }
-pub struct SessionInfo {
- pub addr: Recipient<WSMessage>,
- pub ip: String,
-}
+ // If the room doesn't exist yet
+ if self.user_rooms.get_mut(&user_id).is_none() {
+ self.user_rooms.insert(user_id, HashSet::new());
+ }
-/// `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,
-}
+ self.user_rooms.get_mut(&user_id).unwrap().insert(id);
+ }
-impl Default for ChatServer {
- fn default() -> ChatServer {
- // default room
- let rooms = HashMap::new();
+ fn send_post_room_message(&self, post_id: PostId, message: &str, skip_id: ConnectionId) {
+ if let Some(sessions) = self.post_rooms.get(&post_id) {
+ 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()));
+ }
+ }
+ }
+ }
+ }
- ChatServer {
- sessions: HashMap::new(),
- rate_limits: HashMap::new(),
- rooms: rooms,
- rng: rand::thread_rng(),
+ fn send_community_room_message(
+ &self,
+ community_id: CommunityId,
+ message: &str,
+ skip_id: ConnectionId,
+ ) {
+ if let Some(sessions) = self.community_rooms.get(&community_id) {
+ 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()));
+ }
+ }
+ }
}
}
-}
-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) {
+ fn send_user_room_message(&self, user_id: UserId, message: &str, skip_id: ConnectionId) {
+ if let Some(sessions) = self.user_rooms.get(&user_id) {
for id in sessions {
if *id != skip_id {
if let Some(info) = self.sessions.get(id) {
}
}
- 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);
+ fn send_all_message(&self, message: &str, skip_id: ConnectionId) {
+ for id in self.sessions.keys() {
+ if *id != skip_id {
+ if let Some(info) = self.sessions.get(id) {
+ let _ = info.addr.do_send(WSMessage(message.to_owned()));
+ }
+ }
+ }
+ }
+
+ fn comment_sends(
+ &self,
+ user_operation: UserOperation,
+ comment: CommentResponse,
+ id: ConnectionId,
+ ) -> Result<String, Error> {
+ let mut comment_reply_sent = comment.clone();
+ comment_reply_sent.comment.my_vote = None;
+ comment_reply_sent.comment.user_id = None;
+
+ // For the post room ones, and the directs back to the user
+ // strip out the recipient_ids, so that
+ // users don't get double notifs
+ let mut comment_user_sent = comment.clone();
+ comment_user_sent.recipient_ids = Vec::new();
+
+ let mut comment_post_sent = comment_reply_sent.clone();
+ comment_post_sent.recipient_ids = Vec::new();
+
+ let comment_reply_sent_str = to_json_string(&user_operation, &comment_reply_sent)?;
+ let comment_post_sent_str = to_json_string(&user_operation, &comment_post_sent)?;
+ let comment_user_sent_str = to_json_string(&user_operation, &comment_user_sent)?;
+
+ // Send it to the post room
+ self.send_post_room_message(comment.comment.post_id, &comment_post_sent_str, id);
+
+ // Send it to the recipient(s) including the mentioned users
+ for recipient_id in comment_reply_sent.recipient_ids {
+ self.send_user_room_message(recipient_id, &comment_reply_sent_str, id);
}
- Ok(())
+ Ok(comment_user_sent_str)
+ }
+
+ fn post_sends(
+ &self,
+ user_operation: UserOperation,
+ post: PostResponse,
+ id: ConnectionId,
+ ) -> Result<String, Error> {
+ let community_id = post.post.community_id;
+
+ // Don't send my data with it
+ let mut post_sent = post.clone();
+ post_sent.post.my_vote = None;
+ post_sent.post.user_id = None;
+ let post_sent_str = to_json_string(&user_operation, &post_sent)?;
+
+ // Send it to /c/all and that community
+ self.send_community_room_message(0, &post_sent_str, id);
+ self.send_community_room_message(community_id, &post_sent_str, id);
+
+ to_json_string(&user_operation, post)
+ }
+
+ fn check_rate_limit_register(&mut self, id: usize) -> Result<(), Error> {
+ self.check_rate_limit_full(
+ id,
+ Settings::get().rate_limit.register,
+ Settings::get().rate_limit.register_per_second,
+ )
}
- 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_post(&mut self, id: usize) -> Result<(), Error> {
+ self.check_rate_limit_full(
+ id,
+ Settings::get().rate_limit.post,
+ Settings::get().rate_limit.post_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_message(&mut self, id: usize) -> Result<(), Error> {
+ self.check_rate_limit_full(
+ id,
+ Settings::get().rate_limit.message,
+ Settings::get().rate_limit.message_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) {
+ #[allow(clippy::float_cmp)]
+ fn check_rate_limit_full(&mut self, id: usize, rate: i32, per: i32) -> Result<(), Error> {
+ if let Some(info) = self.sessions.get(&id) {
if let Some(rate_limit) = self.rate_limits.get_mut(&info.ip) {
// The initial value
if rate_limit.allowance == -2f64 {
}
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),
- })?
+ println!(
+ "Rate limited IP: {}, time_passed: {}, allowance: {}",
+ &info.ip, time_passed, rate_limit.allowance
+ );
+ Err(
+ APIError {
+ message: format!("Too many requests. {} per {} seconds", rate, per),
+ }
+ .into(),
+ )
} else {
rate_limit.allowance -= 1.0;
Ok(())
}
}
-
/// Make actor from `ChatServer`
impl Actor for ChatServer {
/// We are going to use simple Context, we just need ability to communicate
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(),
- });
+ 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,
- });
+ 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>) {
+ // Remove connections from sessions and all 3 scopes
+ if self.sessions.remove(&msg.id).is_some() {
+ for sessions in self.user_rooms.values_mut() {
+ sessions.remove(&msg.id);
+ }
- // let mut rooms: Vec<i32> = Vec::new();
+ for sessions in self.post_rooms.values_mut() {
+ sessions.remove(&msg.id);
+ }
- // 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);
- }
+ for sessions in self.community_rooms.values_mut() {
+ sessions.remove(&msg.id);
}
}
}
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()
+ Err(e) => e.to_string(),
};
+ println!("Message Sent: {}", msg_out);
MessageResult(msg_out)
}
}
-fn parse_json_message(chat: &mut ChatServer, msg: StandardMessage) -> Result<String, Error> {
+#[derive(Serialize)]
+struct WebsocketResponse<T> {
+ op: String,
+ data: T,
+}
+
+fn to_json_string<T>(op: &UserOperation, data: T) -> Result<String, Error>
+where
+ T: Serialize,
+{
+ let response = WebsocketResponse {
+ op: op.to_string(),
+ data,
+ };
+ Ok(serde_json::to_string(&response)?)
+}
+
+fn do_user_operation<'a, Data, Response>(
+ op: UserOperation,
+ data: &str,
+ conn: &PooledConnection<ConnectionManager<PgConnection>>,
+) -> Result<String, Error>
+where
+ for<'de> Data: Deserialize<'de> + 'a,
+ Response: Serialize,
+ Oper<Data>: Perform<Response>,
+{
+ let parsed_data: Data = serde_json::from_str(data)?;
+ let res = Oper::new(parsed_data).perform(&conn)?;
+ to_json_string(&op, &res)
+}
+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 op = &json["op"].as_str().ok_or(APIError {
+ message: "Unknown op type".to_string(),
+ })?;
+
+ let conn = chat.db.get()?;
let user_operation: UserOperation = UserOperation::from_str(&op)?;
+ // TODO: none of the chat messages are going to work if stuff is submitted via http api,
+ // need to move that handling elsewhere
match user_operation {
- UserOperation::Login => {
- let login: Login = serde_json::from_str(data)?;
- login.perform(chat, msg.id)
- },
+ UserOperation::Login => do_user_operation::<Login, LoginResponse>(user_operation, data, &conn),
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)
- },
+ chat.check_rate_limit_register(msg.id)?;
+ do_user_operation::<Register, LoginResponse>(user_operation, data, &conn)
+ }
+ UserOperation::GetUserDetails => {
+ do_user_operation::<GetUserDetails, GetUserDetailsResponse>(user_operation, data, &conn)
+ }
+ UserOperation::SaveUserSettings => {
+ do_user_operation::<SaveUserSettings, LoginResponse>(user_operation, data, &conn)
+ }
+ UserOperation::AddAdmin => {
+ let add_admin: AddAdmin = serde_json::from_str(data)?;
+ let res = Oper::new(add_admin).perform(&conn)?;
+ let res_str = to_json_string(&user_operation, &res)?;
+ chat.send_all_message(&res_str, msg.id);
+ Ok(res_str)
+ }
+ UserOperation::BanUser => {
+ let ban_user: BanUser = serde_json::from_str(data)?;
+ let res = Oper::new(ban_user).perform(&conn)?;
+ let res_str = to_json_string(&user_operation, &res)?;
+ chat.send_all_message(&res_str, msg.id);
+ Ok(res_str)
+ }
+ UserOperation::GetReplies => {
+ do_user_operation::<GetReplies, GetRepliesResponse>(user_operation, data, &conn)
+ }
+ UserOperation::GetUserMentions => {
+ do_user_operation::<GetUserMentions, GetUserMentionsResponse>(user_operation, data, &conn)
+ }
+ UserOperation::EditUserMention => {
+ do_user_operation::<EditUserMention, UserMentionResponse>(user_operation, data, &conn)
+ }
+ UserOperation::MarkAllAsRead => {
+ do_user_operation::<MarkAllAsRead, GetRepliesResponse>(user_operation, data, &conn)
+ }
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)
- },
+
+ let mut res = if Settings::get().federation_enabled {
+ if let Some(community_name) = get_community.name.to_owned() {
+ if community_name.contains('@') {
+ // TODO: need to support sort, filter etc for remote communities
+ get_remote_community(community_name)?
+ // TODO what is this about
+ // get_community.name = Some(name.replace("!", ""));
+ } else {
+ Oper::new(get_community).perform(&conn)?
+ }
+ } else {
+ Oper::new(get_community).perform(&conn)?
+ }
+ } else {
+ Oper::new(get_community).perform(&conn)?
+ };
+
+ let community_id = res.community.id;
+
+ chat.join_community_room(community_id, msg.id);
+
+ res.online = if let Some(community_users) = chat.community_rooms.get(&community_id) {
+ community_users.len()
+ } else {
+ 0
+ };
+
+ to_json_string(&user_operation, &res)
+ }
+ UserOperation::ListCommunities => {
+ if Settings::get().federation_enabled {
+ let res = get_all_communities()?;
+ let val = ListCommunitiesResponse { communities: res };
+ to_json_string(&user_operation, &val)
+ } else {
+ do_user_operation::<ListCommunities, ListCommunitiesResponse>(user_operation, data, &conn)
+ }
+ }
+ UserOperation::CreateCommunity => {
+ chat.check_rate_limit_register(msg.id)?;
+ do_user_operation::<CreateCommunity, CommunityResponse>(user_operation, data, &conn)
+ }
UserOperation::EditCommunity => {
let edit_community: EditCommunity = serde_json::from_str(data)?;
- edit_community.perform(chat, msg.id)
- },
+ let res = Oper::new(edit_community).perform(&conn)?;
+ let mut community_sent: CommunityResponse = res.clone();
+ community_sent.community.user_id = None;
+ community_sent.community.subscribed = None;
+ let community_sent_str = to_json_string(&user_operation, &community_sent)?;
+ chat.send_community_room_message(community_sent.community.id, &community_sent_str, msg.id);
+ to_json_string(&user_operation, &res)
+ }
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)
- },
+ do_user_operation::<FollowCommunity, CommunityResponse>(user_operation, data, &conn)
+ }
+ UserOperation::GetFollowedCommunities => do_user_operation::<
+ GetFollowedCommunities,
+ GetFollowedCommunitiesResponse,
+ >(user_operation, data, &conn),
UserOperation::BanFromCommunity => {
let ban_from_community: BanFromCommunity = serde_json::from_str(data)?;
- ban_from_community.perform(chat, msg.id)
- },
+ let community_id = ban_from_community.community_id;
+ let res = Oper::new(ban_from_community).perform(&conn)?;
+ let res_str = to_json_string(&user_operation, &res)?;
+ chat.send_community_room_message(community_id, &res_str, msg.id);
+ Ok(res_str)
+ }
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()
+ let community_id = mod_add_to_community.community_id;
+ let res = Oper::new(mod_add_to_community).perform(&conn)?;
+ let res_str = to_json_string(&user_operation, &res)?;
+ chat.send_community_room_message(community_id, &res_str, msg.id);
+ Ok(res_str)
}
- }
-}
-
-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"))?
+ UserOperation::ListCategories => {
+ do_user_operation::<ListCategories, ListCategoriesResponse>(user_operation, data, &conn)
}
+ UserOperation::GetPost => {
+ let get_post: GetPost = serde_json::from_str(data)?;
+ let post_id = get_post.id;
+ chat.join_post_room(post_id, msg.id);
+ let mut res = Oper::new(get_post).perform(&conn)?;
- // 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)?;
+ res.online = if let Some(post_users) = chat.post_rooms.get(&post_id) {
+ post_users.len()
+ } else {
+ 0
+ };
- // Make sure passwords match
- if &self.password != &self.password_verify {
- return Err(self.error("Passwords do not match."))?
+ to_json_string(&user_operation, &res)
}
-
- if self.spam_timeri < 1142 {
- return Err(self.error("Too fast"))?
+ UserOperation::GetPosts => {
+ let get_posts: GetPosts = serde_json::from_str(data)?;
+ if get_posts.community_id.is_none() {
+ // 0 is the "all" community
+ chat.join_community_room(0, msg.id);
+ }
+ let res = Oper::new(get_posts).perform(&conn)?;
+ to_json_string(&user_operation, &res)
}
+ UserOperation::CreatePost => {
+ chat.check_rate_limit_post(msg.id)?;
+ let create_post: CreatePost = serde_json::from_str(data)?;
+ let res = Oper::new(create_post).perform(&conn)?;
- if has_slurs(&self.username) {
- return Err(self.error("No slurs"))?
+ chat.post_sends(UserOperation::CreatePost, res, msg.id)
}
+ UserOperation::CreatePostLike => {
+ chat.check_rate_limit_message(msg.id)?;
+ let create_post_like: CreatePostLike = serde_json::from_str(data)?;
+ let res = Oper::new(create_post_like).perform(&conn)?;
- // Make sure there are no admins
- if self.admin && UserView::admins(&conn)?.len() > 0 {
- return Err(self.error("Sorry, there's already an admin."))?
+ chat.post_sends(UserOperation::CreatePostLike, res, msg.id)
}
+ UserOperation::EditPost => {
+ let edit_post: EditPost = serde_json::from_str(data)?;
+ let res = Oper::new(edit_post).perform(&conn)?;
- // 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."))?
- }
- };
-
+ chat.post_sends(UserOperation::EditPost, res, msg.id)
}
-
-
- // 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"))?
+ UserOperation::SavePost => {
+ do_user_operation::<SavePost, PostResponse>(user_operation, data, &conn)
}
+ UserOperation::CreateComment => {
+ chat.check_rate_limit_message(msg.id)?;
+ let create_comment: CreateComment = serde_json::from_str(data)?;
+ let res = Oper::new(create_comment).perform(&conn)?;
- // 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"))?
+ chat.comment_sends(UserOperation::CreateComment, res, msg.id)
}
+ UserOperation::EditComment => {
+ let edit_comment: EditComment = serde_json::from_str(data)?;
+ let res = Oper::new(edit_comment).perform(&conn)?;
- // Check for a site ban
- if UserView::read(&conn, user_id)?.banned {
- return Err(self.error("You have been banned from the site"))?
+ chat.comment_sends(UserOperation::EditComment, res, msg.id)
}
-
- 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);
+ UserOperation::SaveComment => {
+ do_user_operation::<SaveComment, CommentResponse>(user_operation, data, &conn)
}
+ UserOperation::CreateCommentLike => {
+ chat.check_rate_limit_message(msg.id)?;
+ let create_comment_like: CreateCommentLike = serde_json::from_str(data)?;
+ let res = Oper::new(create_comment_like).perform(&conn)?;
- if chat.rooms.get_mut(&self.id).is_none() {
- chat.rooms.insert(self.id, HashSet::new());
+ chat.comment_sends(UserOperation::CreateCommentLike, res, msg.id)
}
-
- 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"))?
+ UserOperation::GetModlog => {
+ do_user_operation::<GetModlog, GetModlogResponse>(user_operation, data, &conn)
}
-
- // Check for a site ban
- if UserView::read(&conn, user_id)?.banned {
- return Err(self.error("You have been banned from the site"))?
+ UserOperation::CreateSite => {
+ do_user_operation::<CreateSite, SiteResponse>(user_operation, data, &conn)
}
-
- 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."))?
- }
- };
+ UserOperation::EditSite => {
+ let edit_site: EditSite = serde_json::from_str(data)?;
+ let res = Oper::new(edit_site).perform(&conn)?;
+ let res_str = to_json_string(&user_operation, &res)?;
+ chat.send_all_message(&res_str, msg.id);
+ Ok(res_str)
}
-
- 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."))?
+ UserOperation::GetSite => {
+ let get_site: GetSite = serde_json::from_str(data)?;
+ let mut res = Oper::new(get_site).perform(&conn)?;
+ res.online = chat.sessions.len();
+ to_json_string(&user_operation, &res)
}
-
- // 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"))?
+ UserOperation::Search => {
+ do_user_operation::<Search, SearchResponse>(user_operation, data, &conn)
}
-
- // Check for a site ban
- if UserView::read(&conn, user_id)?.banned {
- return Err(self.error("You have been banned from the site"))?
+ UserOperation::TransferCommunity => {
+ do_user_operation::<TransferCommunity, GetCommunityResponse>(user_operation, data, &conn)
}
-
- 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)?;
+ UserOperation::TransferSite => {
+ do_user_operation::<TransferSite, GetSiteResponse>(user_operation, data, &conn)
}
-
- 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)?;
+ UserOperation::DeleteAccount => {
+ do_user_operation::<DeleteAccount, LoginResponse>(user_operation, data, &conn)
}
-
- 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"))?
- }
- };
+ UserOperation::PasswordReset => {
+ do_user_operation::<PasswordReset, PasswordResetResponse>(user_operation, data, &conn)
}
-
- 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"))?
+ UserOperation::PasswordChange => {
+ do_user_operation::<PasswordChange, LoginResponse>(user_operation, data, &conn)
}
+ UserOperation::CreatePrivateMessage => {
+ chat.check_rate_limit_message(msg.id)?;
+ let create_private_message: CreatePrivateMessage = serde_json::from_str(data)?;
+ let recipient_id = create_private_message.recipient_id;
+ let res = Oper::new(create_private_message).perform(&conn)?;
+ let res_str = to_json_string(&user_operation, &res)?;
- 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"))?
+ chat.send_user_room_message(recipient_id, &res_str, msg.id);
+ Ok(res_str)
}
-
- // 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"))?
+ UserOperation::EditPrivateMessage => {
+ do_user_operation::<EditPrivateMessage, PrivateMessageResponse>(user_operation, data, &conn)
}
-
- 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)?;
+ UserOperation::GetPrivateMessages => {
+ do_user_operation::<GetPrivateMessages, PrivateMessagesResponse>(user_operation, data, &conn)
}
-
- 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."))?
- }
- };
+ UserOperation::UserJoin => {
+ let user_join: UserJoin = serde_json::from_str(data)?;
+ let res = Oper::new(user_join).perform(&conn)?;
+ chat.join_user_room(res.user_id, msg.id);
+ to_json_string(&user_operation, &res)
}
-
- 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,
- }
- )?
- )
}
}
projects / lemmy.git / blobdiff