zhenyi

Fork 0

Clone

style(chat): rustfmt voice handlers, routes and service

Pure `cargo fmt` reflow: import lists, one-line route registrations and
redis command chains, plus the two cluster branches that a widened line
made explicit. No behaviour change.

ZhenYi committed 1 month ago

parent 2f95ed4 commit 4c94523 Browse files

lib/chat/src/handlers/voice.rs +9 −4 View

@@ -12,8 +12,9 @@

1212use crate::errors::ApiError;

1313use crate::services::service::ChatService;

1414use crate::services::voice::{

15 HandDto, VoiceConfigDto, VoiceHandsDto, VoiceLayoutDto, VoiceLayoutPatchDto, VoiceLayoutSavedDto,

16 VoiceModerationDto, VoiceParticipantDto, VoiceRecordingDto, VoiceSpaceStatesDto, VoiceTokenDto,

15 HandDto, VoiceConfigDto, VoiceHandsDto, VoiceLayoutDto, VoiceLayoutPatchDto,

16 VoiceLayoutSavedDto, VoiceModerationDto, VoiceParticipantDto, VoiceRecordingDto,

17 VoiceSpaceStatesDto, VoiceTokenDto,

1718};

1819

1920#[utoipa::path(

@@ -54,7 +55,9 @@

5455 Path(room_id): Path<Uuid>,

5556) -> Result<AppResponseData<VoiceTokenDto>, ApiError> {

5657 let uid = require_uid(&session)?;

57 Ok(AppResponseData::ok(service.voice_token(uid, room_id).await?))

58 Ok(AppResponseData::ok(

59 service.voice_token(uid, room_id).await?,

60 ))

5861}

5962

6063#[utoipa::path(

@@ -140,7 +143,9 @@

140143 Path(room_id): Path<Uuid>,

141144) -> Result<AppResponseData<VoiceLayoutDto>, ApiError> {

142145 let uid = require_uid(&session)?;

143 Ok(AppResponseData::ok(service.voice_layout(uid, room_id).await?))

146 Ok(AppResponseData::ok(

147 service.voice_layout(uid, room_id).await?,

148 ))

144149}

145150

146151#[utoipa::path(

lib/chat/src/services/voice.rs +79 −47 View

@@ -261,7 +261,9 @@

261261 ctx.room.kind,

262262 models::room::rooms::RoomKind::Voice | models::room::rooms::RoomKind::Stage

263263 ) {

264 return Err(ChatError::BadRequest("room is not a voice channel".to_string()));

264 return Err(ChatError::BadRequest(

265 "room is not a voice channel".to_string(),

266 ));

265267 }

266268 Ok(ctx.room)

267269}

@@ -364,11 +366,8 @@

364366 .query_async(c)

365367 .await;

366368 if written.is_ok() {

367 let _: Result<i64, redis::RedisError> = redis::cmd("EXPIRE")

368 .arg(&key)

369 .arg(ttl)

370 .query_async(c)

371 .await;

369 let _: Result<i64, redis::RedisError> =

370 redis::cmd("EXPIRE").arg(&key).arg(ttl).query_async(c).await;

372371 }

373372 written

374373 }

@@ -380,11 +379,8 @@

380379 .query_async(c)

381380 .await;

382381 if written.is_ok() {

383 let _: Result<i64, redis::RedisError> = redis::cmd("EXPIRE")

384 .arg(&key)

385 .arg(ttl)

386 .query_async(c)

387 .await;

382 let _: Result<i64, redis::RedisError> =

383 redis::cmd("EXPIRE").arg(&key).arg(ttl).query_async(c).await;

388384 }

389385 written

390386 }

@@ -403,17 +399,35 @@

403399 let field = uid.to_string();

404400 let _: Result<i64, redis::RedisError> = match &mut conn {

405401 RedisConnection::Standalone(c) => {

406 redis::cmd("HDEL").arg(&key).arg(&field).query_async(c).await

402 redis::cmd("HDEL")

403 .arg(&key)

404 .arg(&field)

405 .query_async(c)

406 .await

407 }

408 RedisConnection::Cluster(c) => {

409 redis::cmd("HDEL")

410 .arg(&key)

411 .arg(&field)

412 .query_async(c)

413 .await

407414 }

408 RedisConnection::Cluster(c) => redis::cmd("HDEL").arg(&key).arg(&field).query_async(c).await,

409415 };

410416 let hkey = hands_key(room_id);

411417 let _: Result<i64, redis::RedisError> = match &mut conn {

412418 RedisConnection::Standalone(c) => {

413 redis::cmd("HDEL").arg(&hkey).arg(&field).query_async(c).await

419 redis::cmd("HDEL")

420 .arg(&hkey)

421 .arg(&field)

422 .query_async(c)

423 .await

414424 }

415425 RedisConnection::Cluster(c) => {

416 redis::cmd("HDEL").arg(&hkey).arg(&field).query_async(c).await

426 redis::cmd("HDEL")

427 .arg(&hkey)

428 .arg(&field)

429 .query_async(c)

430 .await

417431 }

418432 };

419433 Ok(())

@@ -463,13 +477,24 @@

463477 let field = uid.to_string();

464478 let raw: Result<Option<String>, redis::RedisError> = match &mut conn {

465479 RedisConnection::Standalone(c) => {

466 redis::cmd("HGET").arg(&key).arg(&field).query_async(c).await

480 redis::cmd("HGET")

481 .arg(&key)

482 .arg(&field)

483 .query_async(c)

484 .await

467485 }

468486 RedisConnection::Cluster(c) => {

469 redis::cmd("HGET").arg(&key).arg(&field).query_async(c).await

487 redis::cmd("HGET")

488 .arg(&key)

489 .arg(&field)

490 .query_async(c)

491 .await

470492 }

471493 };

472 Ok(raw.ok().flatten().and_then(|v| serde_json::from_str(&v).ok()))

494 Ok(raw

495 .ok()

496 .flatten()

497 .and_then(|v| serde_json::from_str(&v).ok()))

473498}

474499

475500pub async fn read_hands(

@@ -516,11 +541,8 @@

516541 .query_async(c)

517542 .await;

518543 if written.is_ok() {

519 let _: Result<i64, redis::RedisError> = redis::cmd("EXPIRE")

520 .arg(&key)

521 .arg(ttl)

522 .query_async(c)

523 .await;

544 let _: Result<i64, redis::RedisError> =

545 redis::cmd("EXPIRE").arg(&key).arg(ttl).query_async(c).await;

524546 }

525547 written

526548 }

@@ -532,11 +554,8 @@

532554 .query_async(c)

533555 .await;

534556 if written.is_ok() {

535 let _: Result<i64, redis::RedisError> = redis::cmd("EXPIRE")

536 .arg(&key)

537 .arg(ttl)

538 .query_async(c)

539 .await;

557 let _: Result<i64, redis::RedisError> =

558 redis::cmd("EXPIRE").arg(&key).arg(ttl).query_async(c).await;

540559 }

541560 written

542561 }

@@ -680,10 +699,7 @@

680699 .as_ref()

681700 .map(|p| p.can_publish)

682701 .unwrap_or(true);

683 let moderator_muted = stored

684 .get(&uid)

685 .map(|m| m.moderator_muted)

686 .unwrap_or(false);

702 let moderator_muted = stored.get(&uid).map(|m| m.moderator_muted).unwrap_or(false);

687703 let tracks: Vec<VoiceTrackDto> = participant

688704 .tracks

689705 .iter()

@@ -739,12 +755,10 @@

739755 let rooms = models::room::rooms::Entity::find()

740756 .filter(models::room::rooms::Column::SpaceId.eq(space.id))

741757 .filter(models::room::rooms::Column::IsActive.eq(true))

742 .filter(

743 models::room::rooms::Column::Kind.is_in([

744 models::room::rooms::RoomKind::Voice,

745 models::room::rooms::RoomKind::Stage,

746 ]),

747 )

758 .filter(models::room::rooms::Column::Kind.is_in([

759 models::room::rooms::RoomKind::Voice,

760 models::room::rooms::RoomKind::Stage,

761 ]))

748762 .all(self.db().read())

749763 .await?;

750764 let mut out = Vec::with_capacity(rooms.len());

@@ -759,7 +773,11 @@

759773 }

760774

761775 /// 读取房间共享的窗口布局；没有存过就是空布局（前端回落到自动网格）。

762 pub async fn voice_layout(&self, caller: Uuid, room_id: Uuid) -> Result<VoiceLayoutDto, ChatError> {

776 pub async fn voice_layout(

777 &self,

778 caller: Uuid,

779 room_id: Uuid,

780 ) -> Result<VoiceLayoutDto, ChatError> {

763781 require_voice_room(self, room_id, caller).await?;

764782 self.voice_layout_raw(room_id).await

765783 }

@@ -819,15 +837,17 @@

819837 Ok(updated_at) => Ok(updated_at),

820838 // The script signals a full map with an error reply; turn it back into

821839 // the same 400 the previous whole-map write produced.

822 Err(error) if error.to_string().contains("too many tiles") => Err(ChatError::BadRequest(

823 format!("at most {MAX_LAYOUT_TILES} windows can be placed"),

824 )),

840 Err(error) if error.to_string().contains("too many tiles") => Err(

841 ChatError::BadRequest(format!("at most {MAX_LAYOUT_TILES} windows can be placed")),

842 ),

825843 Err(error) => Err(ChatError::from(error)),

826844 }?;

827845 self.realtime

828846 .publish_room(&RoomEvent::VoiceLayout { room_id })

829847 .await;

830 Ok(VoiceLayoutSavedDto { updated_at: written })

848 Ok(VoiceLayoutSavedDto {

849 updated_at: written,

850 })

831851 }

832852

833853 /// 举手。Stage 频道之外、已有发言权都不允许。

@@ -878,10 +898,18 @@

878898 let field = caller.to_string();

879899 let _: Result<i64, redis::RedisError> = match &mut conn {

880900 RedisConnection::Standalone(c) => {

881 redis::cmd("HDEL").arg(&key).arg(&field).query_async(c).await

901 redis::cmd("HDEL")

902 .arg(&key)

903 .arg(&field)

904 .query_async(c)

905 .await

882906 }

883907 RedisConnection::Cluster(c) => {

884 redis::cmd("HDEL").arg(&key).arg(&field).query_async(c).await

908 redis::cmd("HDEL")

909 .arg(&key)

910 .arg(&field)

911 .query_async(c)

912 .await

885913 }

886914 };

887915 self.realtime

@@ -1204,7 +1232,9 @@

12041232 return Err(ChatError::Forbidden);

12051233 }

12061234 if !self.config().livekit.recording_enabled {

1207 return Err(ChatError::BadRequest("recording is not enabled".to_string()));

1235 return Err(ChatError::BadRequest(

1236 "recording is not enabled".to_string(),

1237 ));

12081238 }

12091239 Err(ChatError::BadRequest(

12101240 "recording requires the livekit egress component".to_string(),

@@ -1221,7 +1251,9 @@

12211251 return Err(ChatError::Forbidden);

12221252 }

12231253 if !self.config().livekit.recording_enabled {

1224 return Err(ChatError::BadRequest("recording is not enabled".to_string()));

1254 return Err(ChatError::BadRequest(

1255 "recording is not enabled".to_string(),

1256 ));

12251257 }

12261258 Err(ChatError::BadRequest(

12271259 "recording requires the livekit egress component".to_string(),

lib/chat/src/routes.rs +5 −12 View

@@ -31,10 +31,9 @@

3131 update_thread,

3232};

3333use crate::handlers::voice::{

34 approve_hand, cancel_hand, deny_hand, kick_participant, list_hands, livekit_webhook,

35 get_voice_layout, moderate_mute, raise_hand, revoke_hand, save_voice_layout, start_recording,

36 stop_recording, voice_config,

37 voice_participants, voice_space_states, voice_token,

34 approve_hand, cancel_hand, deny_hand, get_voice_layout, kick_participant, list_hands,

35 livekit_webhook, moderate_mute, raise_hand, revoke_hand, save_voice_layout, start_recording,

36 stop_recording, voice_config, voice_participants, voice_space_states, voice_token,

3837};

3938use crate::handlers::webhooks::{create_webhook, delete_webhook, list_webhooks, post_via_webhook};

4039use crate::services::service::ChatService;

@@ -242,10 +241,7 @@

242241 .delete(crate::handlers::webhooks::delete_outbound_webhook),

243242 )

244243 .route("/chat/voice/config", get(voice_config))

245 .route(

246 "/chat/rooms/{room_id}/voice/token",

247 post(voice_token),

248 )

244 .route("/chat/rooms/{room_id}/voice/token", post(voice_token))

249245 .route(

250246 "/chat/rooms/{room_id}/voice/participants",

251247 get(voice_participants),

@@ -269,11 +265,8 @@

269265 .route(

270266 "/chat/rooms/{room_id}/voice/hands",

271267 get(list_hands).post(raise_hand),

272 )

273 .route(

274 "/chat/rooms/{room_id}/voice/hands/@me",

275 delete(cancel_hand),

276268 )

269 .route("/chat/rooms/{room_id}/voice/hands/@me", delete(cancel_hand))

277270 .route(

278271 "/chat/rooms/{room_id}/voice/hands/{user_id}/approve",

279272 post(approve_hand),