add: channels, messages

crates/app/src/routes/api/v1/channels/channels.rs

@@ -0,0 +1,204 @@
+use axum::{Extension, Json, extract::Path, response::IntoResponse};
+use axum_extra::extract::CookieJar;
+use tetratto_core::model::{channels::Channel, ApiReturn, Error};
+use crate::{
+    get_user_from_token,
+    routes::api::v1::{
+        CreateChannel, CreateGroupChannel, KickMember, UpdateChannelPosition, UpdateChannelTitle,
+    },
+    State,
+};
+
+pub async fn create_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Json(req): Json<CreateChannel>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data
+        .create_channel(Channel::new(
+            match req.community.parse::<usize>() {
+                Ok(c) => c,
+                Err(e) => return Json(Error::MiscError(e.to_string()).into()),
+            },
+            user.id,
+            0,
+            req.title,
+        ))
+        .await
+    {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Channel created".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn create_group_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Json(req): Json<CreateGroupChannel>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    let mut members: Vec<usize> = Vec::new();
+
+    for member in req.members {
+        members.push(match member.parse::<usize>() {
+            Ok(c) => c,
+            Err(e) => return Json(Error::MiscError(e.to_string()).into()),
+        })
+    }
+
+    // check for existing
+    if members.len() == 1 {
+        let other_user = members.get(0).unwrap().to_owned();
+        if let Ok(channel) = data.get_channel_by_owner_member(user.id, other_user).await {
+            return Json(ApiReturn {
+                ok: true,
+                message: "Channel exists".to_string(),
+                payload: Some(channel.id.to_string()),
+            });
+        }
+    }
+
+    // check member permissions
+    for member in &members {
+        let other_user = match data.get_user_by_id(member.to_owned()).await {
+            Ok(ua) => ua,
+            Err(e) => return Json(e.into()),
+        };
+
+        if other_user.settings.private_chats {
+            if data
+                .get_userfollow_by_initiator_receiver(other_user.id, user.id)
+                .await
+                .is_err()
+            {
+                return Json(Error::NotAllowed.into());
+            }
+        }
+    }
+
+    // ...
+    let mut props = Channel::new(0, user.id, 0, req.title);
+    props.members = members;
+    let id = props.id.clone();
+
+    match data.create_channel(props).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Channel created".to_string(),
+            payload: Some(id.to_string()),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn delete_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.delete_channel(id, &user).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Channel deleted".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn update_title_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(req): Json<UpdateChannelTitle>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.update_channel_title(id, user, &req.title).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Channel updated".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn update_position_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(req): Json<UpdateChannelPosition>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.update_channel_position(id, user, req.position).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Channel updated".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn kick_member_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+    Json(req): Json<KickMember>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data
+        .remove_channel_member(
+            id,
+            user,
+            match req.member.parse::<usize>() {
+                Ok(c) => c,
+                Err(e) => return Json(Error::MiscError(e.to_string()).into()),
+            },
+        )
+        .await
+    {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Member removed".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}

crates/app/src/routes/api/v1/channels/messages.rs

@@ -0,0 +1,236 @@
+use axum::{
+    extract::{
+        ws::{Message as WsMessage, WebSocket, WebSocketUpgrade},
+        Path,
+    },
+    response::{IntoResponse, Response},
+    Extension, Json,
+};
+use axum_extra::extract::CookieJar;
+use tetratto_core::{
+    cache::Cache,
+    model::{
+        auth::User,
+        channels::Message,
+        socket::{SocketMessage, SocketMethod},
+        ApiReturn, Error,
+    },
+};
+use std::sync::mpsc;
+use crate::{get_user_from_token, routes::api::v1::CreateMessage, State};
+use serde::Deserialize;
+use futures_util::{sink::SinkExt, stream::StreamExt};
+
+#[derive(Deserialize)]
+pub struct SocketHeaders {
+    pub channel: String,
+    pub user: String,
+}
+
+/// Handle a subscription to the websocket.
+pub async fn subscription_handler(
+    ws: WebSocketUpgrade,
+    Extension(data): Extension<State>,
+    Path(channel_id): Path<usize>,
+) -> Response {
+    ws.on_upgrade(move |socket| handle_socket(socket, data, channel_id))
+}
+
+pub async fn handle_socket(socket: WebSocket, state: State, channel_id: usize) {
+    let db = &(state.read().await).0;
+    let db = db.clone();
+
+    let (mut sink, mut stream) = socket.split();
+    let (sender, receiver) = mpsc::channel::<String>();
+
+    // forward messages from mpsc to the sink
+    tokio::spawn(async move {
+        while let Ok(message) = receiver.recv() {
+            if message == "Close" {
+                sink.close().await.unwrap();
+                drop(receiver);
+                break;
+            }
+
+            if sink.send(message.into()).await.is_err() {
+                break;
+            }
+        }
+    });
+
+    // ...
+    let mut user: Option<User> = None;
+    let mut con = db.2.clone().get_con().await;
+
+    // handle incoming messages on socket
+    let dbc = db.clone();
+    let recv_sender = sender.clone();
+    let mut recv_task = tokio::spawn(async move {
+        while let Some(Ok(WsMessage::Text(text))) = stream.next().await {
+            if text == "Pong" {
+                continue;
+            }
+
+            if text == "Close" {
+                recv_sender.send("Close".to_string()).unwrap();
+                break;
+            }
+
+            let data: SocketMessage = match serde_json::from_str(&text.to_string()) {
+                Ok(t) => t,
+                Err(_) => {
+                    recv_sender.send("Close".to_string()).unwrap();
+                    break;
+                }
+            };
+
+            if data.method != SocketMethod::Headers && user.is_none() {
+                // we've sent something else before authenticating... that's not right
+                recv_sender.send("Close".to_string()).unwrap();
+                break;
+            }
+
+            match data.method {
+                SocketMethod::Headers => {
+                    let data: SocketHeaders = data.data();
+
+                    user = Some(
+                        match dbc
+                            .get_user_by_id(match data.user.parse::<usize>() {
+                                Ok(c) => c,
+                                Err(_) => {
+                                    recv_sender.send("Close".to_string()).unwrap();
+                                    break;
+                                }
+                            })
+                            .await
+                        {
+                            Ok(ua) => ua,
+                            Err(_) => {
+                                recv_sender.send("Close".to_string()).unwrap();
+                                break;
+                            }
+                        },
+                    );
+
+                    let channel = match dbc
+                        .get_channel_by_id(match data.channel.parse::<usize>() {
+                            Ok(c) => c,
+                            Err(_) => {
+                                recv_sender.send("Close".to_string()).unwrap();
+                                break;
+                            }
+                        })
+                        .await
+                    {
+                        Ok(c) => c,
+                        Err(_) => {
+                            recv_sender.send("Close".to_string()).unwrap();
+                            break;
+                        }
+                    };
+
+                    let user = user.as_ref().unwrap();
+
+                    let membership = match dbc
+                        .get_membership_by_owner_community(user.id, channel.id)
+                        .await
+                    {
+                        Ok(ua) => ua,
+                        Err(_) => {
+                            recv_sender.send("Close".to_string()).unwrap();
+                            break;
+                        }
+                    };
+
+                    if !channel.check_read(user.id, Some(membership.role)) {
+                        recv_sender.send("Close".to_string()).unwrap();
+                        break;
+                    }
+                }
+                _ => {
+                    recv_sender.send("Close".to_string()).unwrap();
+                    break;
+                }
+            }
+        }
+    });
+
+    // forward messages from redis to the mpsc
+    let send_task_sender = sender.clone();
+    let mut send_task = tokio::spawn(async move {
+        let mut pubsub = con.as_pubsub();
+        pubsub.subscribe(channel_id).unwrap();
+
+        loop {
+            while let Ok(msg) = pubsub.get_message() {
+                // payload is a stringified SocketMessage
+                if send_task_sender.send(msg.get_payload().unwrap()).is_err() {
+                    break;
+                }
+            }
+        }
+    });
+
+    // ...
+    let close_sender = sender.clone();
+    tokio::select! {
+        _ = (&mut send_task) => recv_task.abort(),
+        _ = (&mut recv_task) => {
+            let _ = close_sender.send("Close".to_string());
+            send_task.abort()
+        },
+    };
+}
+
+pub async fn create_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Json(req): Json<CreateMessage>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data
+        .create_message(Message::new(
+            match req.channel.parse::<usize>() {
+                Ok(c) => c,
+                Err(e) => return Json(Error::MiscError(e.to_string()).into()),
+            },
+            user.id,
+            req.content,
+        ))
+        .await
+    {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Message created".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}
+
+pub async fn delete_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path(id): Path<usize>,
+) -> impl IntoResponse {
+    let data = &(data.read().await).0;
+    let user = match get_user_from_token!(jar, data) {
+        Some(ua) => ua,
+        None => return Json(Error::NotAllowed.into()),
+    };
+
+    match data.delete_message(id, user).await {
+        Ok(_) => Json(ApiReturn {
+            ok: true,
+            message: "Message deleted".to_string(),
+            payload: (),
+        }),
+        Err(e) => Json(e.into()),
+    }
+}

crates/app/src/routes/api/v1/channels/mod.rs

@@ -0,0 +1,2 @@
+pub mod channels;
+pub mod messages;

crates/app/src/routes/api/v1/mod.rs

@@ -6,9 +6,12 @@ pub mod reports;
 pub mod requests;
 pub mod util;
 
+#[cfg(feature = "redis")]
+pub mod channels;
+
 use axum::{
+    routing::{any, delete, get, post},
     Router,
-    routing::{delete, get, post},
 };
 use serde::Deserialize;
 use tetratto_core::model::{
@@ -266,6 +269,32 @@ pub fn routes() -> Router {
             "/auth/user/connections/last_fm/api_proxy",
             post(auth::connections::last_fm::proxy_request),
         )
+        // channels
+        .route("/channels", post(channels::channels::create_request))
+        .route(
+            "/channels/group",
+            post(channels::channels::create_group_request),
+        )
+        .route(
+            "/channels/{id}/title",
+            post(channels::channels::update_title_request),
+        )
+        .route(
+            "/channels/{id}/move",
+            post(channels::channels::update_position_request),
+        )
+        .route("/channels/{id}", delete(channels::channels::delete_request))
+        .route(
+            "/channels/{id}/kick",
+            post(channels::channels::kick_member_request),
+        )
+        // messages
+        .route(
+            "/channels/{id}/ws",
+            any(channels::messages::subscription_handler),
+        )
+        .route("/messages", post(channels::messages::create_request))
+        .route("/messages/{id}", delete(channels::messages::delete_request))
 }
 
 #[derive(Deserialize)]
@@ -419,3 +448,36 @@ pub struct CreateQuestion {
     #[serde(default)]
     pub community: String,
 }
+
+#[derive(Deserialize)]
+pub struct CreateChannel {
+    pub title: String,
+    pub community: String,
+}
+
+#[derive(Deserialize)]
+pub struct CreateGroupChannel {
+    pub title: String,
+    pub members: Vec<String>,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateChannelTitle {
+    pub title: String,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateChannelPosition {
+    pub position: i32,
+}
+
+#[derive(Deserialize)]
+pub struct CreateMessage {
+    pub content: String,
+    pub channel: String,
+}
+
+#[derive(Deserialize)]
+pub struct KickMember {
+    pub member: String,
+}

crates/app/src/routes/pages/chats.rs

@@ -0,0 +1,249 @@
+use super::{render_error, PaginatedQuery};
+use crate::{State, assets::initial_context, get_lang, get_user_from_token};
+use axum::{
+    extract::{Path, Query},
+    response::{Html, IntoResponse, Redirect},
+    Extension, Json,
+};
+use axum_extra::extract::CookieJar;
+use tetratto_core::model::{
+    channels::Message, communities_permissions::CommunityPermission, permissions::FinePermission,
+    Error,
+};
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct RenderMessage {
+    pub data: String,
+}
+
+pub async fn redirect_request() -> impl IntoResponse {
+    Redirect::to("/chats/0/0")
+}
+
+/// `/chats/{community}/{channel}`
+///
+/// `/chats/0` is for channels the user is part of (not in a community)
+pub async fn app_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path((selected_community, selected_channel)): Path<(usize, usize)>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
+    let data = data.read().await;
+    let user = match get_user_from_token!(jar, data.0) {
+        Some(ua) => ua,
+        None => {
+            return Err(Html(
+                render_error(Error::NotAllowed, &jar, &data, &None).await,
+            ));
+        }
+    };
+
+    let membership = match data
+        .0
+        .get_membership_by_owner_community(user.id, selected_community)
+        .await
+    {
+        Ok(m) => m,
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let can_manage_channels = membership.role.check(CommunityPermission::MANAGE_CHANNELS)
+        | user.permissions.check(FinePermission::MANAGE_CHANNELS);
+
+    let communities = match data.0.get_memberships_by_owner(user.id).await {
+        Ok(p) => match data.0.fill_communities(p).await {
+            Ok(p) => p,
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        },
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let channels = if selected_community == 0 {
+        match data.0.get_channels_by_user(user.id).await {
+            Ok(p) => p,
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        }
+    } else {
+        match data.0.get_channels_by_community(selected_community).await {
+            Ok(p) => p,
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        }
+    };
+
+    let community = if selected_community != 0 {
+        match data.0.get_community_by_id(selected_community).await {
+            Ok(p) => Some(p),
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        }
+    } else {
+        None
+    };
+
+    let channel = if selected_channel != 0 {
+        match data.0.get_channel_by_id(selected_channel).await {
+            Ok(p) => {
+                if !p.check_read(user.id, Some(membership.role)) {
+                    return Err(Html(
+                        render_error(Error::NotAllowed, &jar, &data, &Some(user)).await,
+                    ));
+                }
+
+                Some(p)
+            }
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        }
+    } else {
+        None
+    };
+
+    let lang = get_lang!(jar, data.0);
+    let mut context = initial_context(&data.0.0, lang, &Some(user.clone())).await;
+
+    context.insert("selected_community", &selected_community);
+    context.insert("selected_channel", &selected_channel);
+    context.insert("membership_role", &membership.role.bits());
+    context.insert("page", &props.page);
+
+    context.insert(
+        "can_manage_channels",
+        &if selected_community == 0 {
+            false
+        } else {
+            can_manage_channels
+        },
+    );
+
+    context.insert(
+        "can_manage_channel",
+        &if selected_community == 0 {
+            if let Some(ref channel) = channel {
+                channel.members.contains(&user.id) | (channel.owner == user.id)
+            } else {
+                false
+            }
+        } else {
+            can_manage_channels
+        },
+    );
+
+    context.insert("community", &community);
+    context.insert("channel", &channel);
+
+    context.insert("communities", &communities);
+    context.insert("channels", &channels);
+
+    // return
+    Ok(Html(data.1.render("chats/app.html", &context).unwrap()))
+}
+
+/// `/chats/{community}/{channel}/_stream`
+pub async fn stream_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path((community, channel)): Path<(usize, usize)>,
+    Query(props): Query<PaginatedQuery>,
+) -> impl IntoResponse {
+    let data = data.read().await;
+    let user = match get_user_from_token!(jar, data.0) {
+        Some(ua) => ua,
+        None => {
+            return Err(Html(
+                render_error(Error::NotAllowed, &jar, &data, &None).await,
+            ));
+        }
+    };
+
+    let ignore_users = data.0.get_userblocks_receivers(user.id).await;
+    let messages = match data
+        .0
+        .get_messages_by_channel(channel, 12, props.page)
+        .await
+    {
+        Ok(p) => match data.0.fill_messages(p, &ignore_users).await {
+            Ok(p) => p,
+            Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+        },
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let membership = match data
+        .0
+        .get_membership_by_owner_community(user.id, community)
+        .await
+    {
+        Ok(m) => m,
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let can_manage_messages = membership.role.check(CommunityPermission::MANAGE_MESSAGES)
+        | user.permissions.check(FinePermission::MANAGE_MESSAGES);
+
+    let lang = get_lang!(jar, data.0);
+    let mut context = initial_context(&data.0.0, lang, &Some(user)).await;
+
+    context.insert("messages", &messages);
+    context.insert("can_manage_messages", &can_manage_messages);
+
+    context.insert("page", &props.page);
+    context.insert("community", &community);
+    context.insert("channel", &channel);
+
+    // return
+    Ok(Html(data.1.render("chats/stream.html", &context).unwrap()))
+}
+
+/// `/chats/{community}/{channel}/_render`
+pub async fn message_request(
+    jar: CookieJar,
+    Extension(data): Extension<State>,
+    Path((community, _)): Path<(usize, usize)>,
+    Json(req): Json<RenderMessage>,
+) -> impl IntoResponse {
+    let data = data.read().await;
+    let user = match get_user_from_token!(jar, data.0) {
+        Some(ua) => ua,
+        None => {
+            return Err(Html(
+                render_error(Error::NotAllowed, &jar, &data, &None).await,
+            ));
+        }
+    };
+
+    let message: Message = match serde_json::from_str(&req.data) {
+        Ok(m) => m,
+        Err(e) => {
+            return Err(Html(
+                render_error(Error::MiscError(e.to_string()), &jar, &data, &Some(user)).await,
+            ));
+        }
+    };
+
+    let membership = match data
+        .0
+        .get_membership_by_owner_community(user.id, community)
+        .await
+    {
+        Ok(m) => m,
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let can_manage_messages = membership.role.check(CommunityPermission::MANAGE_MESSAGES)
+        | user.permissions.check(FinePermission::MANAGE_MESSAGES);
+
+    let owner = match data.0.get_user_by_id(message.owner).await {
+        Ok(p) => p,
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let lang = get_lang!(jar, data.0);
+    let mut context = initial_context(&data.0.0, lang, &Some(user)).await;
+
+    context.insert("can_manage_messages", &can_manage_messages);
+    context.insert("message", &message);
+    context.insert("user", &owner);
+
+    // return
+    Ok(Html(data.1.render("chats/message.html", &context).unwrap()))
+}

crates/app/src/routes/pages/communities.rs

@@ -525,6 +525,14 @@ pub async fn settings_request(
         ));
     }
 
+    let channels = match data.0.get_channels_by_community(community.id).await {
+        Ok(p) => p,
+        Err(e) => return Err(Html(render_error(e, &jar, &data, &Some(user)).await)),
+    };
+
+    let can_manage_channels = membership.role.check(CommunityPermission::MANAGE_CHANNELS)
+        | user.permissions.check(FinePermission::MANAGE_CHANNELS);
+
     // init context
     let lang = get_lang!(jar, data.0);
     let mut context = initial_context(&data.0.0, lang, &Some(user)).await;
@@ -535,6 +543,9 @@ pub async fn settings_request(
         &clean_context(&community.context),
     );
 
+    context.insert("can_manage_channels", &can_manage_channels);
+    context.insert("channels", &channels);
+
     // return
     Ok(Html(
         data.1

crates/app/src/routes/pages/mod.rs

@@ -4,7 +4,13 @@ pub mod misc;
 pub mod mod_panel;
 pub mod profile;
 
-use axum::{Router, routing::get};
+#[cfg(feature = "redis")]
+pub mod chats;
+
+use axum::{
+    routing::{get, post},
+    Router,
+};
 use axum_extra::extract::CookieJar;
 use serde::Deserialize;
 use tetratto_core::{
@@ -82,6 +88,17 @@ pub fn routes() -> Router {
         .route("/post/{id}", get(communities::post_request))
         .route("/post/{id}/reposts", get(communities::reposts_request))
         .route("/question/{id}", get(communities::question_request))
+        // chats
+        .route("/chats", get(chats::redirect_request))
+        .route("/chats/{community}/{channel}", get(chats::app_request))
+        .route(
+            "/chats/{community}/{channel}/_stream",
+            get(chats::stream_request),
+        )
+        .route(
+            "/chats/{community}/{channel}/_render",
+            post(chats::message_request),
+        )
 }
 
 pub async fn render_error(