4 chat_server::{ChatServer, SessionInfo},
10 use actix::{Actor, Context, Handler, ResponseFuture};
12 use lemmy_db::naive_now;
13 use lemmy_rate_limit::RateLimit;
14 use lemmy_utils::{ConnectionId, IPAddr, LemmyError};
15 use log::{error, info};
17 use serde::{Deserialize, Serialize};
19 pub(super) struct Args<'a> {
20 pub(super) context: LemmyContext,
21 pub(super) rate_limiter: RateLimit,
22 pub(super) id: ConnectionId,
23 pub(super) ip: IPAddr,
24 pub(super) op: UserOperation,
25 pub(super) data: &'a str,
28 pub(super) async fn do_user_operation<'a, 'b, Data>(args: Args<'b>) -> Result<String, LemmyError>
30 for<'de> Data: Deserialize<'de> + 'a,
42 let data = data.to_string();
45 let fut = async move {
46 let parsed_data: Data = serde_json::from_str(&data)?;
48 .perform(&web::Data::new(context), Some(id))
50 to_json_string(&op, &res)
54 UserOperation::Register => rate_limiter.register().wrap(ip, fut).await,
55 UserOperation::CreatePost => rate_limiter.post().wrap(ip, fut).await,
56 UserOperation::CreateCommunity => rate_limiter.register().wrap(ip, fut).await,
57 _ => rate_limiter.message().wrap(ip, fut).await,
61 /// Make actor from `ChatServer`
62 impl Actor for ChatServer {
63 /// We are going to use simple Context, we just need ability to communicate
64 /// with other actors.
65 type Context = Context<Self>;
68 /// Handler for Connect message.
70 /// Register new session and assign unique id to this session
71 impl Handler<Connect> for ChatServer {
74 fn handle(&mut self, msg: Connect, _ctx: &mut Context<Self>) -> Self::Result {
75 // register session with random id
76 let id = self.rng.gen::<usize>();
77 info!("{} joined", &msg.ip);
91 /// Handler for Disconnect message.
92 impl Handler<Disconnect> for ChatServer {
95 fn handle(&mut self, msg: Disconnect, _: &mut Context<Self>) {
96 // Remove connections from sessions and all 3 scopes
97 if self.sessions.remove(&msg.id).is_some() {
98 for sessions in self.user_rooms.values_mut() {
99 sessions.remove(&msg.id);
102 for sessions in self.post_rooms.values_mut() {
103 sessions.remove(&msg.id);
106 for sessions in self.community_rooms.values_mut() {
107 sessions.remove(&msg.id);
113 /// Handler for Message message.
114 impl Handler<StandardMessage> for ChatServer {
115 type Result = ResponseFuture<Result<String, std::convert::Infallible>>;
117 fn handle(&mut self, msg: StandardMessage, ctx: &mut Context<Self>) -> Self::Result {
118 let fut = self.parse_json_message(msg, ctx);
119 Box::pin(async move {
122 // info!("Message Sent: {}", m);
126 error!("Error during message handling {}", e);
134 impl<Response> Handler<SendAllMessage<Response>> for ChatServer
140 fn handle(&mut self, msg: SendAllMessage<Response>, _: &mut Context<Self>) {
142 .send_all_message(&msg.op, &msg.response, msg.websocket_id)
147 impl<Response> Handler<SendUserRoomMessage<Response>> for ChatServer
153 fn handle(&mut self, msg: SendUserRoomMessage<Response>, _: &mut Context<Self>) {
155 .send_user_room_message(&msg.op, &msg.response, msg.recipient_id, msg.websocket_id)
160 impl<Response> Handler<SendCommunityRoomMessage<Response>> for ChatServer
166 fn handle(&mut self, msg: SendCommunityRoomMessage<Response>, _: &mut Context<Self>) {
168 .send_community_room_message(&msg.op, &msg.response, msg.community_id, msg.websocket_id)
173 impl Handler<SendPost> for ChatServer {
176 fn handle(&mut self, msg: SendPost, _: &mut Context<Self>) {
177 self.send_post(&msg.op, &msg.post, msg.websocket_id).ok();
181 impl Handler<SendComment> for ChatServer {
184 fn handle(&mut self, msg: SendComment, _: &mut Context<Self>) {
186 .send_comment(&msg.op, &msg.comment, msg.websocket_id)
191 impl Handler<JoinUserRoom> for ChatServer {
194 fn handle(&mut self, msg: JoinUserRoom, _: &mut Context<Self>) {
195 self.join_user_room(msg.user_id, msg.id).ok();
199 impl Handler<JoinCommunityRoom> for ChatServer {
202 fn handle(&mut self, msg: JoinCommunityRoom, _: &mut Context<Self>) {
203 self.join_community_room(msg.community_id, msg.id).ok();
207 impl Handler<JoinPostRoom> for ChatServer {
210 fn handle(&mut self, msg: JoinPostRoom, _: &mut Context<Self>) {
211 self.join_post_room(msg.post_id, msg.id).ok();
215 impl Handler<GetUsersOnline> for ChatServer {
218 fn handle(&mut self, _msg: GetUsersOnline, _: &mut Context<Self>) -> Self::Result {
223 impl Handler<GetPostUsersOnline> for ChatServer {
226 fn handle(&mut self, msg: GetPostUsersOnline, _: &mut Context<Self>) -> Self::Result {
227 if let Some(users) = self.post_rooms.get(&msg.post_id) {
235 impl Handler<GetCommunityUsersOnline> for ChatServer {
238 fn handle(&mut self, msg: GetCommunityUsersOnline, _: &mut Context<Self>) -> Self::Result {
239 if let Some(users) = self.community_rooms.get(&msg.community_id) {
248 struct WebsocketResponse<T> {
253 pub(super) fn to_json_string<Response>(
256 ) -> Result<String, LemmyError>
260 let response = WebsocketResponse {
264 Ok(serde_json::to_string(&response)?)
267 impl Handler<CaptchaItem> for ChatServer {
270 fn handle(&mut self, msg: CaptchaItem, _: &mut Context<Self>) {
271 self.captchas.push(msg);
275 impl Handler<CheckCaptcha> for ChatServer {
278 fn handle(&mut self, msg: CheckCaptcha, _: &mut Context<Self>) -> Self::Result {
279 // Remove all the ones that are past the expire time
280 self.captchas.retain(|x| x.expires.gt(&naive_now()));
285 .any(|r| r.uuid == msg.uuid && r.answer == msg.answer);
287 // Remove this uuid so it can't be re-checked (Checks only work once)
288 self.captchas.retain(|x| x.uuid != msg.uuid);