oxpanel/oxspeak_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Nell
2026-08-29 14:05:43 +02:00
parent 5e97e9c223
commit 88ad3c389f
15 changed files with 423 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/routes/conversation/handlers.rs
+151 -30
View File
@@ -6,70 +6,178 @@ use crate::domain::dto::conversation::{
use crate::http::context::CurrentUser;
use crate::http::error::HTTPError;
use crate::models::{channel, channel_user, message, user};
use axum::{Json, extract::{Path, State}};
use axum::{
Json,
extract::{Path, State},
};
use chrono::Utc;
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder, Set, TransactionTrait};
use sea_orm::{
ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder, Set, TransactionTrait,
};
use std::collections::HashSet;
use uuid::Uuid;
async fn member_ids(state: &AppState, channel_id: Uuid) -> Result<Vec<Uuid>, HTTPError> {
Ok(channel_user::Entity::find()
.filter(channel_user::Column::ChannelId.eq(channel_id))
.all(&state.db).await?.into_iter().map(|m| m.user_id).collect())
.all(&state.db)
.await?
.into_iter()
.map(|m| m.user_id)
.collect())
}
async fn response(state: &AppState, current_user_id: Uuid, channel: channel::Model) -> Result<ConversationResponse, HTTPError> {
async fn response(
state: &AppState,
current_user_id: Uuid,
channel: channel::Model,
) -> Result<ConversationResponse, HTTPError> {
let ids = member_ids(state, channel.id).await?;
let users = user::Entity::find().filter(user::Column::Id.is_in(ids.clone())).all(&state.db).await?;
let mut participants: Vec<_> = users.into_iter().map(|u| ConversationParticipantResponse { id: u.id, username: u.username }).collect();
let users = user::Entity::find()
.filter(user::Column::Id.is_in(ids.clone()))
.all(&state.db)
.await?;
let mut participants: Vec<_> = users
.into_iter()
.map(|u| ConversationParticipantResponse {
id: u.id,
username: u.username,
})
.collect();
participants.sort_by(|a, b| a.username.to_lowercase().cmp(&b.username.to_lowercase()));
let title = participants.iter().filter(|p| p.id != current_user_id).map(|p| p.username.clone()).collect::<Vec<_>>().join(", ");
let last_message = message::Entity::find().filter(message::Column::ChannelId.eq(channel.id)).order_by_desc(message::Column::Id).one(&state.db).await?.map(|m| m.content);
let unread_count = state.repositories.read_state.unread_counts(&[channel.id], current_user_id).await?.get(&channel.id).copied().unwrap_or(0);
Ok(ConversationResponse { id: channel.id, title: if title.is_empty() { "Discussion".into() } else { title }, participants, last_message, unread_count, created_at: channel.created_at, updated_at: channel.updated_at })
let title = participants
.iter()
.filter(|p| p.id != current_user_id)
.map(|p| p.username.clone())
.collect::<Vec<_>>()
.join(", ");
let last_message = message::Entity::find()
.filter(message::Column::ChannelId.eq(channel.id))
.order_by_desc(message::Column::Id)
.one(&state.db)
.await?
.map(|m| m.content);
let unread_count = state
.repositories
.read_state
.unread_counts(&[channel.id], current_user_id)
.await?
.get(&channel.id)
.copied()
.unwrap_or(0);
Ok(ConversationResponse {
id: channel.id,
title: if title.is_empty() {
"Discussion".into()
} else {
title
},
participants,
last_message,
unread_count,
created_at: channel.created_at,
updated_at: channel.updated_at,
})
}
async fn create_channel(state: &AppState, ids: &[Uuid]) -> Result<channel::Model, HTTPError> {
let txn = state.db.begin().await?;
let channel = channel::ActiveModel { server_id: Set(None), category_id: Set(None), channel_type: Set(channel::ChannelType::DM), name: Set(None), ..Default::default() }.insert(&txn).await?;
let channel = channel::ActiveModel {
server_id: Set(None),
category_id: Set(None),
channel_type: Set(channel::ChannelType::DM),
name: Set(None),
..Default::default()
}
.insert(&txn)
.await?;
for user_id in ids {
channel_user::ActiveModel { channel_id: Set(channel.id), user_id: Set(*user_id), role: Set("member".into()), joined_at: Set(Utc::now()), ..Default::default() }.insert(&txn).await?;
channel_user::ActiveModel {
channel_id: Set(channel.id),
user_id: Set(*user_id),
role: Set("member".into()),
joined_at: Set(Utc::now()),
..Default::default()
}
.insert(&txn)
.await?;
}
txn.commit().await?;
state.services.realtime_registry.set_channel_users(channel.id, ids.iter().copied());
state
.services
.realtime_registry
.set_channel_users(channel.id, ids.iter().copied());
state.event_bus.emit("channel_created", channel.clone());
Ok(channel)
}
async fn validate_ids(state: &AppState, ids: &[Uuid]) -> Result<(), HTTPError> {
if ids.is_empty() { return Err(HTTPError::BadRequest("At least one participant is required".into())); }
let found = user::Entity::find().filter(user::Column::Id.is_in(ids.to_vec())).all(&state.db).await?;
if found.len() != ids.iter().collect::<HashSet<_>>().len() { return Err(HTTPError::BadRequest("Unknown participant".into())); }
if ids.is_empty() {
return Err(HTTPError::BadRequest(
"At least one participant is required".into(),
));
}
let found = user::Entity::find()
.filter(user::Column::Id.is_in(ids.to_vec()))
.all(&state.db)
.await?;
if found.len() != ids.iter().collect::<HashSet<_>>().len() {
return Err(HTTPError::BadRequest("Unknown participant".into()));
}
Ok(())
}
#[utoipa::path(get, path = "/conversations", responses((status = 200, body = [ConversationResponse])), tag = "Conversations", security(("bearerAuth" = [])))]
pub async fn list(user: CurrentUser, State(state): State<AppState>) -> Result<Json<Vec<ConversationResponse>>, HTTPError> {
let memberships = channel_user::Entity::find().filter(channel_user::Column::UserId.eq(user.id)).all(&state.db).await?;
pub async fn list(
user: CurrentUser,
State(state): State<AppState>,
) -> Result<Json<Vec<ConversationResponse>>, HTTPError> {
let memberships = channel_user::Entity::find()
.filter(channel_user::Column::UserId.eq(user.id))
.all(&state.db)
.await?;
let ids: Vec<_> = memberships.into_iter().map(|m| m.channel_id).collect();
if ids.is_empty() { return Ok(Json(Vec::new())); }
let channels = channel::Entity::find().filter(channel::Column::Id.is_in(ids)).filter(channel::Column::ChannelType.eq(channel::ChannelType::DM)).order_by_desc(channel::Column::UpdatedAt).all(&state.db).await?;
if ids.is_empty() {
return Ok(Json(Vec::new()));
}
let channels = channel::Entity::find()
.filter(channel::Column::Id.is_in(ids))
.filter(channel::Column::ChannelType.eq(channel::ChannelType::DM))
.order_by_desc(channel::Column::UpdatedAt)
.all(&state.db)
.await?;
let mut result = Vec::with_capacity(channels.len());
for channel in channels { result.push(response(&state, user.id, channel).await?); }
for channel in channels {
result.push(response(&state, user.id, channel).await?);
}
Ok(Json(result))
}
#[utoipa::path(post, path = "/conversations", request_body = CreateConversationRequest, responses((status = 200, body = ConversationResponse)), tag = "Conversations", security(("bearerAuth" = [])))]
pub async fn create(user: CurrentUser, State(state): State<AppState>, Json(payload): Json<CreateConversationRequest>) -> Result<Json<ConversationResponse>, HTTPError> {
pub async fn create(
user: CurrentUser,
State(state): State<AppState>,
Json(payload): Json<CreateConversationRequest>,
) -> Result<Json<ConversationResponse>, HTTPError> {
let mut ids = payload.user_ids;
ids.push(user.id);
ids.sort_unstable(); ids.dedup();
ids.sort_unstable();
ids.dedup();
validate_ids(&state, &ids).await?;
let channels = channel_user::Entity::find().filter(channel_user::Column::UserId.eq(user.id)).all(&state.db).await?;
let channels = channel_user::Entity::find()
.filter(channel_user::Column::UserId.eq(user.id))
.all(&state.db)
.await?;
for membership in channels {
if let Some(channel) = channel::Entity::find_by_id(membership.channel_id).filter(channel::Column::ChannelType.eq(channel::ChannelType::DM)).one(&state.db).await? {
if let Some(channel) = channel::Entity::find_by_id(membership.channel_id)
.filter(channel::Column::ChannelType.eq(channel::ChannelType::DM))
.one(&state.db)
.await?
{
let existing: HashSet<_> = member_ids(&state, channel.id).await?.into_iter().collect();
if existing == ids.iter().copied().collect() { return Ok(Json(response(&state, user.id, channel).await?)); }
if existing == ids.iter().copied().collect() {
return Ok(Json(response(&state, user.id, channel).await?));
}
}
}
let channel = create_channel(&state, &ids).await?;
@@ -77,12 +185,25 @@ pub async fn create(user: CurrentUser, State(state): State<AppState>, Json(paylo
}
#[utoipa::path(post, path = "/conversations/{id}/fork", request_body = ForkConversationRequest, params(("id" = Uuid, Path)), responses((status = 200, body = ConversationResponse)), tag = "Conversations", security(("bearerAuth" = [])))]
pub async fn fork(user: CurrentUser, State(state): State<AppState>, Path(id): Path<Uuid>, Json(payload): Json<ForkConversationRequest>) -> Result<Json<ConversationResponse>, HTTPError> {
let source = channel::Entity::find_by_id(id).one(&state.db).await?.ok_or(HTTPError::NotFound)?;
if source.channel_type != channel::ChannelType::DM || !member_ids(&state, id).await?.contains(&user.id) { return Err(HTTPError::Forbidden); }
pub async fn fork(
user: CurrentUser,
State(state): State<AppState>,
Path(id): Path<Uuid>,
Json(payload): Json<ForkConversationRequest>,
) -> Result<Json<ConversationResponse>, HTTPError> {
let source = channel::Entity::find_by_id(id)
.one(&state.db)
.await?
.ok_or(HTTPError::NotFound)?;
if source.channel_type != channel::ChannelType::DM
|| !member_ids(&state, id).await?.contains(&user.id)
{
return Err(HTTPError::Forbidden);
}
let mut ids = member_ids(&state, id).await?;
ids.extend(payload.user_ids);
ids.sort_unstable(); ids.dedup();
ids.sort_unstable();
ids.dedup();
validate_ids(&state, &ids).await?;
let channel = create_channel(&state, &ids).await?;
Ok(Json(response(&state, user.id, channel).await?))