refactor(mod): remove unused guard module and update imports

Modified lib/infra/api/src/http.rs +32 −12 View lib/infra/api/src/http.rs

@@ -389,12 +389,18 @@

389389 self

390390 }

391391

392 pub fn nest(mut self, prefix: &str, router: Router<S>) -> Self {

392 pub fn nest(mut self, prefix: &str, mut router: Router<S>) -> Self {

393 for guard in &self.pending_guards {

394 router.apply_guard(*guard);

395 }

393396 self.nests.push((prefix.to_string(), router.erase()));

394397 self

395398 }

396399

397 pub fn merge<S2>(mut self, other: Router<S2>) -> Self {

400 pub fn merge<S2>(mut self, mut other: Router<S2>) -> Self {

401 for guard in &self.pending_guards {

402 other.apply_guard(*guard);

403 }

398404 self.routes.extend(other.routes);

399405 self.nests.extend(other.nests);

400406 self.setups.extend(other.setups);

@@ -413,11 +419,20 @@

413419 }

414420

415421 pub fn wrap(mut self, guard: Guard) -> Self {

422 self.apply_guard(guard);

423 self.pending_guards.push(guard);

424 self

425 }

426

427 fn apply_guard(&mut self, guard: Guard) {

416428 for route in &mut self.routes {

417 route.guards.push(guard);

429 if !route.guards.contains(&guard) {

430 route.guards.push(guard);

431 }

432 }

433 for (_, child) in &mut self.nests {

434 child.apply_guard(guard);

418435 }

419 self.pending_guards.push(guard);

420 self

421436 }

422437

423438 fn erase(self) -> Router<()> {

@@ -453,13 +468,18 @@

453468 grouped.sort_by(|left, right| compare_specificity(&left.0, &right.0));

454469 for (path, guards, methods) in grouped {

455470 let resource = methods.apply(web::resource(path));

456 scope = 'inline_register_resource: {

457 let guards = &guards;

458 let Some(guard) = guards.first().copied() else {

459 break 'inline_register_resource scope.service(resource);

460 };

461 let middleware = guard_middleware(guard);

462 scope.service(resource.wrap(actix_web::middleware::from_fn(middleware)))

471 scope = match guards.as_slice() {

472 [] => scope.service(resource),

473 [guard] => scope.service(

474 resource.wrap(actix_web::middleware::from_fn(guard_middleware(*guard))),

475 ),

476 [first, second, ..] => {

477 let resource =

478 resource.wrap(actix_web::middleware::from_fn(guard_middleware(*second)));

479 scope.service(

480 resource.wrap(actix_web::middleware::from_fn(guard_middleware(*first))),

481 )

482 }

463483 };

464484 }

465485 for (prefix, child) in self.nests {

Modified lib/infra/session/src/error.rs +1 −1 View lib/infra/session/src/error.rs

@@ -129,7 +129,7 @@

129129 }

130130

131131 fn error_response(&self) -> HttpResponse {

132 self.response("")

132 self.response(&envelope::context::request_id().unwrap_or_default())

133133 }

134134}

135135

Modified lib/infra/session/src/extract.rs +36 −0 View lib/infra/session/src/extract.rs

@@ -3,8 +3,44 @@

33use actix_web::dev::Payload;

44use actix_web::{FromRequest, HttpMessage, HttpRequest};

55

6use crate::error::SessionError;

67use crate::state::Session;

78

9pub struct AuthedUser(pub i64);

10

11impl FromRequest for AuthedUser {

12 type Error = actix_web::Error;

13 type Future = Ready<Result<Self, Self::Error>>;

14

15 fn from_request(req: &HttpRequest, _payload: &mut Payload) -> Self::Future {

16 let Some(session) = req.extensions().get::<Session>().cloned() else {

17 return ready(Err(actix_web::error::ErrorInternalServerError(

18 "session is not initialized",

19 )));

20 };

21 match session.uid() {

22 Some(uid) => ready(Ok(Self(uid))),

23 None => ready(Err(SessionError::Unauthorized.into())),

24 }

25 }

26}

27

28pub struct OptionalUser(pub Option<i64>);

29

30impl FromRequest for OptionalUser {

31 type Error = actix_web::Error;

32 type Future = Ready<Result<Self, Self::Error>>;

33

34 fn from_request(req: &HttpRequest, _payload: &mut Payload) -> Self::Future {

35 match req.extensions().get::<Session>() {

36 Some(session) => ready(Ok(Self(session.uid()))),

37 None => ready(Err(actix_web::error::ErrorInternalServerError(

38 "session is not initialized",

39 ))),

40 }

41 }

42}

43

844impl FromRequest for Session {

945 type Error = actix_web::Error;

1046 type Future = Ready<Result<Self, Self::Error>>;

Modified lib/infra/session/src/guard.rs +0 −4 View lib/infra/session/src/guard.rs

@@ -6,10 +6,6 @@

66use crate::error::SessionError;

77use crate::state::Session;

88

9pub fn require_uid(session: &Session) -> Result<i64, SessionError> {

10 session.uid().ok_or(SessionError::Unauthorized)

11}

12

139pub async fn session_guard<B>(

1410 request: ServiceRequest,

1511 next: Next<B>,

Modified lib/infra/session/src/lib.rs +2 −5 View lib/infra/session/src/lib.rs

@@ -10,7 +10,8 @@

1010

1111pub use cookie::{clear_session_cookie, read_cookie, session_cookie};

1212pub use error::SessionError;

13pub use guard::{require_uid, session_guard};

13pub use extract::{AuthedUser, OptionalUser};

14pub use guard::session_guard;

1415pub use key::{MAX_SESSION_KEY_LEN, SESSION_KEY_LEN, SessionKey};

1516pub use middleware::SessionMiddleware;

1617pub use redis::RedisStore;

@@ -23,9 +24,5 @@

2324pub mod share {

2425 pub mod guard {

2526 pub use crate::guard::session_guard;

26 }

27

28 pub mod session {

29 pub use crate::guard::require_uid;

3027 }

3128}

Modified lib/service/auth/src/handlers/accept_agreement.rs +2 −4 View lib/service/auth/src/handlers/accept_agreement.rs

@@ -1,6 +1,6 @@

11use api::http::{Json, Path, State};

22

3use ::session::Session;

3use ::session::AuthedUser;

44use api::rest::{AppResponseData, NoData};

55use serde::{Deserialize, Serialize};

66use utoipa::ToSchema;

@@ -8,7 +8,6 @@

88use crate::AuthService;

99use crate::errors::ApiError;

1010use crate::services::agreements::AcceptAgreementResp;

11use ::session::share::session;

1211

1312#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)]

1413pub struct AcceptAgreementCmd {

@@ -32,11 +31,10 @@

3231)]

3332pub async fn accept_agreement(

3433 State(service): State<AuthService>,

35 session: Session,

34 AuthedUser(uid): AuthedUser,

3635 Path(key): Path<String>,

3736 Json(cmd): Json<AcceptAgreementCmd>,

3837) -> Result<AppResponseData<AcceptAgreementResp>, ApiError> {

39 let uid = session::require_uid(&session)?;

4038 let resp = service

4139 .accept_agreement(uid, &key, &cmd.version)

4240 .await

Modified lib/service/auth/src/handlers/create_report.rs +2 −4 View lib/service/auth/src/handlers/create_report.rs

@@ -1,12 +1,11 @@

11use api::http::{Json, State};

22

3use ::session::Session;

3use ::session::AuthedUser;

44use api::rest::{AppResponseData, NoData};

55

66use crate::AuthService;

77use crate::errors::ApiError;

88use crate::services::reports::{CreateReportCmd, ReportDto};

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn create_report(

2524 State(service): State<AuthService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Json(cmd): Json<CreateReportCmd>,

2827) -> Result<AppResponseData<ReportDto>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let resp = service

3129 .create_report(uid, cmd)

3230 .await

Modified lib/service/auth/src/handlers/delete_notification.rs +2 −4 View lib/service/auth/src/handlers/delete_notification.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44use uuid::Uuid;

55

66use crate::AuthService;

77use crate::errors::ApiError;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_notification(

2423 State(service): State<AuthService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(notification_id): Path<Uuid>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .delete_notification(uid, notification_id)

3129 .await

Modified lib/service/auth/src/handlers/devices.rs +2 −4 View lib/service/auth/src/handlers/devices.rs

@@ -1,6 +1,5 @@

11use crate::protos::auth::common::v1::PageRequest;

2use ::session::Session;

3use ::session::share::session;

2use ::session::AuthedUser;

43use api::http::{Query, State};

54use api::pagination::PageQuery;

65use api::rest::AppResponseData;

@@ -66,10 +65,9 @@

6665)]

6766pub async fn list_devices(

6867 State(service): State<AuthService>,

69 session: Session,

68 AuthedUser(uid): AuthedUser,

7069 Query(query): Query<PageQuery>,

7170) -> Result<AppResponseData<api::pagination::Page<DeviceDto>>, ApiError> {

72 let uid = session::require_uid(&session)?;

7371 let listed = service

7472 .accounts

7573 .list_user_sessions(

Modified lib/service/auth/src/handlers/get_preferences.rs +2 −4 View lib/service/auth/src/handlers/get_preferences.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::State;

33use api::rest::{AppResponseData, NoData};

44

55use crate::AuthService;

66use crate::errors::ApiError;

77use crate::services::preferences::UserPreferencesDto;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -20,9 +19,8 @@

2019)]

2120pub async fn get_preferences(

2221 State(service): State<AuthService>,

23 session: Session,

22 AuthedUser(uid): AuthedUser,

2423) -> Result<AppResponseData<UserPreferencesDto>, ApiError> {

25 let uid = session::require_uid(&session)?;

2624 let resp = service.preferences(uid).await.map_err(ApiError::from)?;

2725 Ok(AppResponseData::ok(resp))

2826}

Modified lib/service/auth/src/handlers/get_user.rs +2 −4 View lib/service/auth/src/handlers/get_user.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Path, State};

43use api::rest::{AppResponseData, NoData};

54

@@ -22,10 +21,9 @@

2221)]

2322pub async fn get_user(

2423 State(service): State<AuthService>,

25 session: Session,

24 AuthedUser(caller): AuthedUser,

2625 Path(user_id): Path<i64>,

2726) -> Result<AppResponseData<UserPublic>, ApiError> {

28 let caller = session::require_uid(&session)?;

2927 let user = service

3028 .public_user(caller, user_id)

3129 .await

Modified lib/service/auth/src/handlers/list_notifications.rs +2 −4 View lib/service/auth/src/handlers/list_notifications.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Query, State};

33use api::rest::{AppResponseData, NoData};

44use serde::Deserialize;

@@ -7,7 +7,6 @@

77use crate::AuthService;

88use crate::errors::ApiError;

99use crate::services::notifications::NotificationDto;

10use ::session::share::session;

1110

1211#[derive(Debug, Clone, Copy, Default, Deserialize, IntoParams)]

1312#[serde(deny_unknown_fields)]

@@ -42,10 +41,9 @@

4241)]

4342pub async fn list_notifications(

4443 State(service): State<AuthService>,

45 session: Session,

44 AuthedUser(uid): AuthedUser,

4645 Query(query): Query<ListNotificationsQuery>,

4746) -> Result<AppResponseData<api::pagination::Page<NotificationDto>>, ApiError> {

48 let uid = session::require_uid(&session)?;

4947 let notification_type = query.notification_type;

5048 let unread = query.unread;

5149 let page = service

Modified lib/service/auth/src/handlers/mark_notifications_read.rs +2 −4 View lib/service/auth/src/handlers/mark_notifications_read.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, State};

33use api::rest::{AppResponseData, NoData};

44use serde::Deserialize;

@@ -6,7 +6,6 @@

66

77use crate::AuthService;

88use crate::errors::ApiError;

9use ::session::share::session;

109

1110#[derive(Debug, Deserialize, utoipa::ToSchema)]

1211pub struct MarkNotificationsReadCmd {

@@ -35,10 +34,9 @@

3534)]

3635pub async fn mark_notifications_read(

3736 State(service): State<AuthService>,

38 session: Session,

37 AuthedUser(uid): AuthedUser,

3938 Json(cmd): Json<MarkNotificationsReadCmd>,

4039) -> Result<AppResponseData<MarkedCountResp>, ApiError> {

41 let uid = session::require_uid(&session)?;

4240 let marked = if cmd.all {

4341 service

4442 .mark_all_notifications_read(uid)

Modified lib/service/auth/src/handlers/me.rs +2 −4 View lib/service/auth/src/handlers/me.rs

@@ -6,8 +6,7 @@

66use crate::AuthService;

77use crate::errors::ApiError;

88use crate::services::profile::{ProfileDto, UserMeDto};

9use ::session::Session;

10use ::session::share::session;

9use ::session::AuthedUser;

1110

1211#[derive(Debug, Clone, Serialize, ToSchema)]

1312pub struct MeResp {

@@ -28,9 +27,8 @@

2827)]

2928pub async fn me(

3029 State(service): State<AuthService>,

31 session: Session,

30 AuthedUser(uid): AuthedUser,

3231) -> Result<AppResponseData<MeResp>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let (user, profile) = service.account_me(uid).await.map_err(ApiError::from)?;

3533 Ok(AppResponseData::ok(MeResp { user, profile }))

3634}

Modified lib/service/auth/src/handlers/password.rs +2 −3 View lib/service/auth/src/handlers/password.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::{AuthedUser, Session};

32use api::http::{HeaderMap, Json, State};

43use api::rest::{AppResponseData, NoData};

54use serde::Deserialize;

@@ -30,10 +29,10 @@

3029pub async fn change_password(

3130 State(service): State<AuthService>,

3231 session: Session,

32 AuthedUser(uid): AuthedUser,

3333 headers: HeaderMap,

3434 Json(cmd): Json<ChangePasswordCmd>,

3535) -> Result<AppResponseData<NoData>, ApiError> {

36 let uid = session::require_uid(&session)?;

3736 let keep = session.session_id().unwrap_or_default();

3837 service

3938 .change_password(

Modified lib/service/auth/src/handlers/sessions.rs +4 −6 View lib/service/auth/src/handlers/sessions.rs

@@ -1,7 +1,6 @@

11use crate::protos::auth::common::v1::{PageRequest, SessionInfo};

22use crate::protos::auth::v1::ListUserSessionsResponse;

3use ::session::Session;

4use ::session::share::session;

3use ::session::{AuthedUser, Session};

54use api::http::{Path, Query, State};

65use api::pagination::{Page, PageQuery, paginate};

76use api::rest::{AppResponseData, NoData};

@@ -124,9 +123,9 @@

124123pub async fn list_sessions(

125124 State(service): State<AuthService>,

126125 session: Session,

126 AuthedUser(uid): AuthedUser,

127127 Query(query): Query<SessionQuery>,

128128) -> Result<AppResponseData<Page<SessionDto>>, ApiError> {

129 let uid = session::require_uid(&session)?;

130129 let listed = service

131130 .accounts

132131 .list_user_sessions(

@@ -158,8 +157,8 @@

158157pub async fn revoke_all_sessions(

159158 State(service): State<AuthService>,

160159 session: Session,

160 AuthedUser(uid): AuthedUser,

161161) -> Result<AppResponseData<CountResp>, ApiError> {

162 let uid = session::require_uid(&session)?;

163162 let keep = session.session_id().unwrap_or_default();

164163 let revoked = service

165164 .accounts

@@ -185,10 +184,9 @@

185184)]

186185pub async fn revoke_session(

187186 State(service): State<AuthService>,

188 session: Session,

187 AuthedUser(uid): AuthedUser,

189188 Path(session_id): Path<Uuid>,

190189) -> Result<AppResponseData<NoData>, ApiError> {

191 let uid = session::require_uid(&session)?;

192190 let revoked = service

193191 .accounts

194192 .revoke_session(uid, &session_id.to_string(), "user_revoked")

Modified lib/service/auth/src/handlers/two_factor.rs +7 −14 View lib/service/auth/src/handlers/two_factor.rs

@@ -1,6 +1,5 @@

11use crate::protos::auth::common::v1::MfaStatus;

2use ::session::Session;

3use ::session::share::session;

2use ::session::AuthedUser;

43use api::http::{HeaderMap, Json, State};

54use api::rest::{AppResponseData, NoData};

65use serde::{Deserialize, Serialize};

@@ -56,9 +55,8 @@

5655)]

5756pub async fn totp_status(

5857 State(service): State<AuthService>,

59 session: Session,

58 AuthedUser(uid): AuthedUser,

6059) -> Result<AppResponseData<TotpStatusResp>, ApiError> {

61 let uid = session::require_uid(&session)?;

6260 let status = service

6361 .get_mfa_status(uid)

6462 .await

@@ -83,10 +81,9 @@

8381)]

8482pub async fn totp_setup(

8583 State(service): State<AuthService>,

86 session: Session,

84 AuthedUser(uid): AuthedUser,

8785 headers: HeaderMap,

8886) -> Result<AppResponseData<TotpSetupResp>, ApiError> {

89 let uid = session::require_uid(&session)?;

9087 let configured = service

9188 .configure_totp(uid, "TOTP", &account_helpers::client_ip(&headers))

9289 .await

@@ -111,11 +108,10 @@

111108)]

112109pub async fn totp_enable(

113110 State(service): State<AuthService>,

114 session: Session,

111 AuthedUser(uid): AuthedUser,

115112 headers: HeaderMap,

116113 Json(cmd): Json<TotpEnableCmd>,

117114) -> Result<AppResponseData<RecoveryCodesResp>, ApiError> {

118 let uid = session::require_uid(&session)?;

119115 let enabled = service

120116 .enable_totp(

121117 uid,

@@ -147,11 +143,10 @@

147143)]

148144pub async fn totp_disable(

149145 State(service): State<AuthService>,

150 session: Session,

146 AuthedUser(uid): AuthedUser,

151147 headers: HeaderMap,

152148 Json(cmd): Json<TotpCodeCmd>,

153149) -> Result<AppResponseData<NoData>, ApiError> {

154 let uid = session::require_uid(&session)?;

155150 service

156151 .disable_totp(uid, cmd.code.trim(), &account_helpers::client_ip(&headers))

157152 .await

@@ -171,9 +166,8 @@

171166)]

172167pub async fn recovery_codes(

173168 State(service): State<AuthService>,

174 session: Session,

169 AuthedUser(uid): AuthedUser,

175170) -> Result<AppResponseData<RecoveryCodesResp>, ApiError> {

176 let uid = session::require_uid(&session)?;

177171 let status = service

178172 .get_mfa_status(uid)

179173 .await

@@ -199,11 +193,10 @@

199193)]

200194pub async fn regenerate_recovery_codes(

201195 State(service): State<AuthService>,

202 session: Session,

196 AuthedUser(uid): AuthedUser,

203197 headers: HeaderMap,

204198 Json(cmd): Json<RegenerateRecoveryCodesCmd>,

205199) -> Result<AppResponseData<RecoveryCodesResp>, ApiError> {

206 let uid = session::require_uid(&session)?;

207200 let regenerated = service

208201 .regenerate_recovery_codes(

209202 uid,

Modified lib/service/auth/src/handlers/unread_notifications_count.rs +2 −4 View lib/service/auth/src/handlers/unread_notifications_count.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::State;

33use api::rest::{AppResponseData, NoData};

44use serde::Serialize;

@@ -6,7 +6,6 @@

66

77use crate::AuthService;

88use crate::errors::ApiError;

9use ::session::share::session;

109

1110#[derive(Debug, Clone, Serialize, ToSchema)]

1211pub struct UnreadCountResp {

@@ -26,9 +25,8 @@

2625)]

2726pub async fn unread_notifications_count(

2827 State(service): State<AuthService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029) -> Result<AppResponseData<UnreadCountResp>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let count = service

3331 .unread_notifications_count(uid)

3432 .await

Modified lib/service/auth/src/handlers/update_preferences.rs +2 −4 View lib/service/auth/src/handlers/update_preferences.rs

@@ -1,12 +1,11 @@

11use api::http::{Json, State};

22

3use ::session::Session;

3use ::session::AuthedUser;

44use api::rest::{AppResponseData, NoData};

55

66use crate::AuthService;

77use crate::errors::ApiError;

88use crate::services::preferences::{UpdatePreferencesCmd, UserPreferencesDto};

9use ::session::share::session;

109

1110#[utoipa::path(

1211 patch,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn update_preferences(

2423 State(service): State<AuthService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Json(cmd): Json<UpdatePreferencesCmd>,

2726) -> Result<AppResponseData<UserPreferencesDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let prefs = service

3028 .update_preferences(uid, cmd)

3129 .await

Modified lib/service/auth/src/handlers/update_profile.rs +2 −4 View lib/service/auth/src/handlers/update_profile.rs

@@ -1,12 +1,11 @@

11use api::http::{Json, State};

22

3use ::session::Session;

3use ::session::AuthedUser;

44use api::rest::{AppResponseData, NoData};

55

66use crate::AuthService;

77use crate::errors::ApiError;

88use crate::services::profile::UpdateProfileCmd;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 patch,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn update_profile(

2423 State(service): State<AuthService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Json(cmd): Json<UpdateProfileCmd>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .update_profile(uid, cmd)

3129 .await

Modified lib/service/auth/src/handlers/users.rs +4 −8 View lib/service/auth/src/handlers/users.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Query, State};

43use api::rest::{AppResponseData, NoData};

54use serde::Deserialize;

@@ -28,10 +27,9 @@

2827)]

2928pub async fn list_users_batch(

3029 State(service): State<AuthService>,

31 session: Session,

30 AuthedUser(caller): AuthedUser,

3231 Query(query): Query<UsersBatchQuery>,

3332) -> Result<AppResponseData<Vec<UserPublic>>, ApiError> {

34 let caller = session::require_uid(&session)?;

3533 let users = service

3634 .public_users(caller, query.ids)

3735 .await

@@ -53,10 +51,9 @@

5351)]

5452pub async fn get_user_by_username(

5553 State(service): State<AuthService>,

56 session: Session,

54 AuthedUser(caller): AuthedUser,

5755 Path(username): Path<String>,

5856) -> Result<AppResponseData<UserPublic>, ApiError> {

59 let caller = session::require_uid(&session)?;

6057 let user = service

6158 .public_user_by_name(caller, &username)

6259 .await

@@ -83,10 +80,9 @@

8380)]

8481pub async fn update_username(

8582 State(service): State<AuthService>,

86 session: Session,

83 AuthedUser(uid): AuthedUser,

8784 Json(cmd): Json<UpdateUsernameCmd>,

8885) -> Result<AppResponseData<UserPublic>, ApiError> {

89 let uid = session::require_uid(&session)?;

9086 let user = service

9187 .update_username(uid, &cmd.username)

9288 .await

Modified lib/service/auth/src/share/mod.rs +0 −1 View lib/service/auth/src/share/mod.rs

@@ -3,7 +3,6 @@

33pub mod audit;

44pub mod codes;

55pub mod crypto;

6pub mod guard;

76pub mod identity_error;

87pub mod mfa;

98pub mod net;

Modified lib/service/auth/src/routes.rs +6 −7 View lib/service/auth/src/routes.rs

@@ -16,8 +16,8 @@

1616use crate::handlers::update_profile::update_profile;

1717use crate::handlers::users;

1818

19pub fn router(_service: AuthService) -> Router<AuthService> {

20 let public = Router::<AuthService>::new()

19pub fn public(_service: AuthService) -> Router<AuthService> {

20 Router::<AuthService>::new()

2121 .route(

2222 "/auth/challenge",

2323 post(crate::handlers::challenge::challenge),

@@ -47,9 +47,11 @@

4747 "/auth/password/reset/confirm",

4848 post(crate::handlers::password_reset::password_reset),

4949 )

50 .route("/auth/agreements", get(list_agreements));

50 .route("/auth/agreements", get(list_agreements))

51}

5152

52 let authed = Router::<AuthService>::new()

53pub fn protected(_service: AuthService) -> Router<AuthService> {

54 Router::<AuthService>::new()

5355 .route("/users", get(users::list_users_batch))

5456 .route(

5557 "/users/by-username/{username}",

@@ -112,9 +114,6 @@

112114 delete(crate::handlers::sessions::revoke_session),

113115 )

114116 .route("/me/devices", get(crate::handlers::devices::list_devices))

115 .wrap(api::http::Guard::Session);

116

117 public.merge(authed)

118117}

119118

120119pub fn pages_router(service: AuthService) -> Router {

Modified lib/service/chat/src/handlers/attachments.rs +5 −10 View lib/service/chat/src/handlers/attachments.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Query, Response, State};

43use api::rest::{AppResponseData, NoData};

54use imaging::layout::ImageVariant;

@@ -28,10 +27,9 @@

2827)]

2928pub async fn create_attachment(

3029 State(service): State<ChatService>,

31 session: Session,

30 AuthedUser(uid): AuthedUser,

3231 Json(cmd): Json<CreateAttachmentCmd>,

3332) -> Result<AppResponseData<UploadIntentDto>, ApiError> {

34 let uid = session::require_uid(&session)?;

3533 let intent = service.create_attachment(uid, cmd).await?;

3634 Ok(AppResponseData::ok(intent))

3735}

@@ -52,11 +50,10 @@

5250)]

5351pub async fn finalize_attachment(

5452 State(service): State<ChatService>,

55 session: Session,

53 AuthedUser(uid): AuthedUser,

5654 Path(attachment_id): Path<Uuid>,

5755 Json(cmd): Json<FinalizeAttachmentCmd>,

5856) -> Result<AppResponseData<AttachmentDto>, ApiError> {

59 let uid = session::require_uid(&session)?;

6057 let dto = service.finalize_attachment(uid, attachment_id, cmd).await?;

6158 Ok(AppResponseData::ok(dto))

6259}

@@ -75,10 +72,9 @@

7572)]

7673pub async fn get_attachment(

7774 State(service): State<ChatService>,

78 session: Session,

75 AuthedUser(uid): AuthedUser,

7976 Path(attachment_id): Path<Uuid>,

8077) -> Result<AppResponseData<AttachmentDto>, ApiError> {

81 let uid = session::require_uid(&session)?;

8278 let dto = service.get_attachment_meta(uid, attachment_id).await?;

8379 Ok(AppResponseData::ok(dto))

8480}

@@ -106,11 +102,10 @@

106102)]

107103pub async fn download_attachment(

108104 State(service): State<ChatService>,

109 session: Session,

105 AuthedUser(uid): AuthedUser,

110106 Path(attachment_id): Path<Uuid>,

111107 Query(query): Query<AttachmentVariantQuery>,

112108) -> Result<Response, ApiError> {

113 let uid = session::require_uid(&session)?;

114109 let (row, body, content_type) = service

115110 .download_attachment(

116111 uid,

Modified lib/service/chat/src/handlers/bookmarks.rs +5 −10 View lib/service/chat/src/handlers/bookmarks.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Query, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -22,11 +21,10 @@

2221)]

2322pub async fn list_bookmarks(

2423 State(service): State<ChatService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(room_id): Path<Uuid>,

2726 Query(page): Query<api::pagination::PageQuery>,

2827) -> Result<AppResponseData<api::pagination::Page<BookmarkDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let bookmarks = service.list_bookmarks(uid, room_id).await?;

3129 Ok(AppResponseData::ok(api::pagination::paginate(

3230 bookmarks, &page,

@@ -49,11 +47,10 @@

4947)]

5048pub async fn create_bookmark(

5149 State(service): State<ChatService>,

52 session: Session,

50 AuthedUser(uid): AuthedUser,

5351 Path(room_id): Path<Uuid>,

5452 Json(cmd): Json<CreateBookmarkCmd>,

5553) -> Result<AppResponseData<BookmarkDto>, ApiError> {

56 let uid = session::require_uid(&session)?;

5754 let dto = service.create_bookmark(uid, room_id, cmd).await?;

5855 Ok(AppResponseData::ok(dto))

5956}

@@ -77,11 +74,10 @@

7774)]

7875pub async fn update_bookmark(

7976 State(service): State<ChatService>,

80 session: Session,

77 AuthedUser(uid): AuthedUser,

8178 Path((room_id, bookmark_id)): Path<(Uuid, Uuid)>,

8279 Json(cmd): Json<UpdateBookmarkCmd>,

8380) -> Result<AppResponseData<BookmarkDto>, ApiError> {

84 let uid = session::require_uid(&session)?;

8581 let dto = service

8682 .update_bookmark(uid, room_id, bookmark_id, cmd)

8783 .await?;

@@ -105,10 +101,9 @@

105101)]

106102pub async fn delete_bookmark(

107103 State(service): State<ChatService>,

108 session: Session,

104 AuthedUser(uid): AuthedUser,

109105 Path((room_id, bookmark_id)): Path<(Uuid, Uuid)>,

110106) -> Result<AppResponseData<NoData>, ApiError> {

111 let uid = session::require_uid(&session)?;

112107 service.delete_bookmark(uid, room_id, bookmark_id).await?;

113108 Ok(AppResponseData::empty())

114109}

Modified lib/service/chat/src/handlers/dms.rs +4 −8 View lib/service/chat/src/handlers/dms.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Query, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -25,10 +24,9 @@

2524)]

2625pub async fn open_dm(

2726 State(service): State<ChatService>,

28 session: Session,

27 AuthedUser(uid): AuthedUser,

2928 Json(cmd): Json<OpenDmCmd>,

3029) -> Result<AppResponseData<DmDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let dto = service.open_dm(uid, cmd).await?;

3331 Ok(AppResponseData::ok(dto))

3432}

@@ -47,10 +45,9 @@

4745)]

4846pub async fn list_dms(

4947 State(service): State<ChatService>,

50 session: Session,

48 AuthedUser(uid): AuthedUser,

5149 Query(page): Query<api::pagination::PageQuery>,

5250) -> Result<AppResponseData<api::pagination::Page<DmDto>>, ApiError> {

53 let uid = session::require_uid(&session)?;

5451 let dms = service.list_dms(uid).await?;

5552 Ok(AppResponseData::ok(api::pagination::paginate(dms, &page)?))

5653}

@@ -69,10 +66,9 @@

6966)]

7067pub async fn close_dm(

7168 State(service): State<ChatService>,

72 session: Session,

69 AuthedUser(uid): AuthedUser,

7370 Path(room_id): Path<Uuid>,

7471) -> Result<AppResponseData<NoData>, ApiError> {

75 let uid = session::require_uid(&session)?;

7672 service.close_dm(uid, room_id).await?;

7773 Ok(AppResponseData::empty())

7874}

Modified lib/service/chat/src/handlers/drafts.rs +5 −10 View lib/service/chat/src/handlers/drafts.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Query, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -28,11 +27,10 @@

2827)]

2928pub async fn upsert_draft(

3029 State(service): State<ChatService>,

31 session: Session,

30 AuthedUser(uid): AuthedUser,

3231 Path(room_id): Path<Uuid>,

3332 Json(cmd): Json<UpsertDraftCmd>,

3433) -> Result<AppResponseData<DraftDto>, ApiError> {

35 let uid = session::require_uid(&session)?;

3634 let dto = service.upsert_draft(uid, room_id, cmd).await?;

3735 Ok(AppResponseData::ok(dto))

3836}

@@ -51,11 +49,10 @@

5149)]

5250pub async fn get_draft(

5351 State(service): State<ChatService>,

54 session: Session,

52 AuthedUser(uid): AuthedUser,

5553 Path(room_id): Path<Uuid>,

5654 Query(q): Query<DraftQuery>,

5755) -> Result<AppResponseData<Option<DraftDto>>, ApiError> {

58 let uid = session::require_uid(&session)?;

5956 let dto = service.get_draft(uid, room_id, q.thread_id).await?;

6057 Ok(AppResponseData::ok(dto))

6158}

@@ -73,10 +70,9 @@

7370)]

7471pub async fn list_my_drafts(

7572 State(service): State<ChatService>,

76 session: Session,

73 AuthedUser(uid): AuthedUser,

7774 Query(page): Query<api::pagination::PageQuery>,

7875) -> Result<AppResponseData<api::pagination::Page<DraftDto>>, ApiError> {

79 let uid = session::require_uid(&session)?;

8076 let drafts = service.list_my_drafts(uid).await?;

8177 Ok(AppResponseData::ok(api::pagination::paginate(

8278 drafts, &page,

@@ -97,11 +93,10 @@

9793)]

9894pub async fn delete_draft(

9995 State(service): State<ChatService>,

100 session: Session,

96 AuthedUser(uid): AuthedUser,

10197 Path(room_id): Path<Uuid>,

10298 Query(q): Query<DraftQuery>,

10399) -> Result<AppResponseData<NoData>, ApiError> {

104 let uid = session::require_uid(&session)?;

105100 service.delete_draft(uid, room_id, q.thread_id).await?;

106101 Ok(AppResponseData::empty())

107102}

Modified lib/service/chat/src/handlers/emojis.rs +6 −12 View lib/service/chat/src/handlers/emojis.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Response, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_emojis(

2524 State(service): State<ChatService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(space_name): Path<String>,

2827) -> Result<AppResponseData<Vec<EmojiDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let emojis = service.list_emojis(uid, &space_name).await?;

3129 Ok(AppResponseData::ok(emojis))

3230}

@@ -48,11 +46,10 @@

4846)]

4947pub async fn upload_emoji(

5048 State(service): State<ChatService>,

51 session: Session,

49 AuthedUser(uid): AuthedUser,

5250 Path(space_name): Path<String>,

5351 Json(cmd): Json<UploadEmojiCmd>,

5452) -> Result<AppResponseData<EmojiDto>, ApiError> {

55 let uid = session::require_uid(&session)?;

5653 let dto = service.upload_emoji(uid, &space_name, cmd).await?;

5754 Ok(AppResponseData::ok(dto))

5855}

@@ -74,10 +71,9 @@

7471)]

7572pub async fn delete_emoji(

7673 State(service): State<ChatService>,

77 session: Session,

74 AuthedUser(uid): AuthedUser,

7875 Path((space_name, emoji_id)): Path<(String, Uuid)>,

7976) -> Result<AppResponseData<NoData>, ApiError> {

80 let uid = session::require_uid(&session)?;

8177 service.delete_emoji(uid, &space_name, emoji_id).await?;

8278 Ok(AppResponseData::empty())

8379}

@@ -99,10 +95,9 @@

9995)]

10096pub async fn emoji_image(

10197 State(service): State<ChatService>,

102 session: Session,

98 AuthedUser(uid): AuthedUser,

10399 Path((space_name, emoji_id)): Path<(String, Uuid)>,

104100) -> Result<Response, ApiError> {

105 let uid = session::require_uid(&session)?;

106101 let space = lookup_space_by_name(&service, &space_name).await?;

107102 require_space_member(&service, &space, uid).await?;

108103 let bytes = service.emoji_image(&space, emoji_id).await?;

@@ -123,10 +118,9 @@

123118)]

124119pub async fn get_emoji(

125120 State(service): State<ChatService>,

126 session: Session,

121 AuthedUser(uid): AuthedUser,

127122 Path((space_name, emoji_id)): Path<(String, Uuid)>,

128123) -> Result<AppResponseData<EmojiDto>, ApiError> {

129 let uid = session::require_uid(&session)?;

130124 let dto = service.get_emoji(uid, &space_name, emoji_id).await?;

131125 Ok(AppResponseData::ok(dto))

132126}

Modified lib/service/chat/src/handlers/messages.rs +11 −22 View lib/service/chat/src/handlers/messages.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Query, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -28,11 +27,10 @@

2827)]

2928pub async fn send_message(

3029 State(service): State<ChatService>,

31 session: Session,

30 AuthedUser(uid): AuthedUser,

3231 Path(room_id): Path<Uuid>,

3332 Json(cmd): Json<SendMessageCmd>,

3433) -> Result<AppResponseData<MessageDto>, ApiError> {

35 let uid = session::require_uid(&session)?;

3634 let dto = service.send_message(uid, room_id, cmd).await?;

3735 Ok(AppResponseData::ok(dto))

3836}

@@ -51,11 +49,10 @@

5149)]

5250pub async fn list_messages(

5351 State(service): State<ChatService>,

54 session: Session,

52 AuthedUser(uid): AuthedUser,

5553 Path(room_id): Path<Uuid>,

5654 Query(q): Query<ListMessageQuery>,

5755) -> Result<AppResponseData<MessagePage>, ApiError> {

58 let uid = session::require_uid(&session)?;

5956 let page = service.list_messages(uid, room_id, q).await?;

6057 Ok(AppResponseData::ok(page))

6158}

@@ -74,10 +71,9 @@

7471)]

7572pub async fn get_message(

7673 State(service): State<ChatService>,

77 session: Session,

74 AuthedUser(uid): AuthedUser,

7875 Path(path): Path<MessagePath>,

7976) -> Result<AppResponseData<MessageDto>, ApiError> {

80 let uid = session::require_uid(&session)?;

8177 let dto = service

8278 .get_message(uid, path.room_id, path.message_id)

8379 .await?;

@@ -100,11 +96,10 @@

10096)]

10197pub async fn update_message(

10298 State(service): State<ChatService>,

103 session: Session,

99 AuthedUser(uid): AuthedUser,

104100 Path(path): Path<MessagePath>,

105101 Json(cmd): Json<UpdateMessageCmd>,

106102) -> Result<AppResponseData<MessageDto>, ApiError> {

107 let uid = session::require_uid(&session)?;

108103 let dto = service

109104 .update_message(uid, path.room_id, path.message_id, cmd)

110105 .await?;

@@ -125,10 +120,9 @@

125120)]

126121pub async fn delete_message(

127122 State(service): State<ChatService>,

128 session: Session,

123 AuthedUser(uid): AuthedUser,

129124 Path(path): Path<MessagePath>,

130125) -> Result<AppResponseData<NoData>, ApiError> {

131 let uid = session::require_uid(&session)?;

132126 service

133127 .delete_message(uid, path.room_id, path.message_id)

134128 .await?;

@@ -152,11 +146,10 @@

152146)]

153147pub async fn bulk_delete_messages(

154148 State(service): State<ChatService>,

155 session: Session,

149 AuthedUser(uid): AuthedUser,

156150 Path(room_id): Path<Uuid>,

157151 Json(cmd): Json<BulkDeleteCmd>,

158152) -> Result<AppResponseData<NoData>, ApiError> {

159 let uid = session::require_uid(&session)?;

160153 service.bulk_delete_messages(uid, room_id, cmd).await?;

161154 Ok(AppResponseData::empty())

162155}

@@ -177,11 +170,10 @@

177170)]

178171pub async fn set_message_pin(

179172 State(service): State<ChatService>,

180 session: Session,

173 AuthedUser(uid): AuthedUser,

181174 Path(path): Path<MessagePath>,

182175 Json(cmd): Json<PinCmd>,

183176) -> Result<AppResponseData<MessageDto>, ApiError> {

184 let uid = session::require_uid(&session)?;

185177 let dto = service

186178 .set_message_pin(uid, path.room_id, path.message_id, cmd)

187179 .await?;

@@ -202,10 +194,9 @@

202194)]

203195pub async fn list_pins(

204196 State(service): State<ChatService>,

205 session: Session,

197 AuthedUser(uid): AuthedUser,

206198 Path(room_id): Path<Uuid>,

207199) -> Result<AppResponseData<Vec<MessageDto>>, ApiError> {

208 let uid = session::require_uid(&session)?;

209200 let pins = service.list_pins(uid, room_id).await?;

210201 Ok(AppResponseData::ok(pins))

211202}

@@ -227,11 +218,10 @@

227218)]

228219pub async fn forward_message(

229220 State(service): State<ChatService>,

230 session: Session,

221 AuthedUser(uid): AuthedUser,

231222 Path(path): Path<MessagePath>,

232223 Json(cmd): Json<ForwardMessageCmd>,

233224) -> Result<AppResponseData<MessageDto>, ApiError> {

234 let uid = session::require_uid(&session)?;

235225 let dto = service

236226 .forward_message(uid, path.room_id, path.message_id, cmd)

237227 .await?;

@@ -252,10 +242,9 @@

252242)]

253243pub async fn list_message_history(

254244 State(service): State<ChatService>,

255 session: Session,

245 AuthedUser(uid): AuthedUser,

256246 Path(path): Path<MessagePath>,

257247) -> Result<AppResponseData<Vec<MessageEditDto>>, ApiError> {

258 let uid = session::require_uid(&session)?;

259248 let history = service

260249 .list_message_history(uid, path.room_id, path.message_id)

261250 .await?;

Modified lib/service/chat/src/handlers/presence.rs +4 −8 View lib/service/chat/src/handlers/presence.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, State};

43use api::rest::{AppResponseData, NoData};

54

@@ -21,10 +20,9 @@

2120)]

2221pub async fn set_presence(

2322 State(service): State<ChatService>,

24 session: Session,

23 AuthedUser(uid): AuthedUser,

2524 Json(cmd): Json<SetPresenceCmd>,

2625) -> Result<AppResponseData<PresenceDto>, ApiError> {

27 let uid = session::require_uid(&session)?;

2826 let dto = service.participants.set_presence(uid, cmd).await?;

2927 Ok(AppResponseData::ok(dto))

3028}

@@ -42,10 +40,9 @@

4240)]

4341pub async fn get_presence(

4442 State(service): State<ChatService>,

45 session: Session,

43 AuthedUser(uid): AuthedUser,

4644 Path(user_id): Path<i64>,

4745) -> Result<AppResponseData<PresenceDto>, ApiError> {

48 let uid = session::require_uid(&session)?;

4946 let dto = service.participants.get_presence_for(uid, user_id).await?;

5047 Ok(AppResponseData::ok(dto))

5148}

@@ -64,10 +61,9 @@

6461)]

6562pub async fn list_space_presences(

6663 State(service): State<ChatService>,

67 session: Session,

64 AuthedUser(uid): AuthedUser,

6865 Path(space_name): Path<String>,

6966) -> Result<AppResponseData<Vec<PresenceDto>>, ApiError> {

70 let uid = session::require_uid(&session)?;

7167 let presences = service

7268 .participants

7369 .list_space_presences(uid, &space_name)

Modified lib/service/chat/src/handlers/reactions.rs +4 −8 View lib/service/chat/src/handlers/reactions.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -27,11 +26,10 @@

2726)]

2827pub async fn add_reaction(

2928 State(service): State<ChatService>,

30 session: Session,

29 AuthedUser(uid): AuthedUser,

3130 Path((room_id, message_id)): Path<(Uuid, Uuid)>,

3231 Json(cmd): Json<ReactionCmd>,

3332) -> Result<AppResponseData<Vec<ReactionAggDto>>, ApiError> {

34 let uid = session::require_uid(&session)?;

3533 let agg = service.add_reaction(uid, room_id, message_id, cmd).await?;

3634 Ok(AppResponseData::ok(agg))

3735}

@@ -55,11 +53,10 @@

5553)]

5654pub async fn remove_reaction(

5755 State(service): State<ChatService>,

58 session: Session,

56 AuthedUser(uid): AuthedUser,

5957 Path((room_id, message_id)): Path<(Uuid, Uuid)>,

6058 Json(cmd): Json<ReactionCmd>,

6159) -> Result<AppResponseData<Vec<ReactionAggDto>>, ApiError> {

62 let uid = session::require_uid(&session)?;

6360 let agg = service

6461 .remove_reaction(uid, room_id, message_id, cmd)

6562 .await?;

@@ -83,10 +80,9 @@

8380)]

8481pub async fn list_reactions(

8582 State(service): State<ChatService>,

86 session: Session,

83 AuthedUser(uid): AuthedUser,

8784 Path((room_id, message_id)): Path<(Uuid, Uuid)>,

8885) -> Result<AppResponseData<Vec<ReactionUserDto>>, ApiError> {

89 let uid = session::require_uid(&session)?;

9086 let rows = service

9187 .list_message_reactions(uid, room_id, message_id)

9288 .await?;

Modified lib/service/chat/src/handlers/read_state.rs +5 −10 View lib/service/chat/src/handlers/read_state.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -24,11 +23,10 @@

2423)]

2524pub async fn mark_read(

2625 State(service): State<ChatService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(room_id): Path<Uuid>,

2928 Json(cmd): Json<MarkReadCmd>,

3029) -> Result<AppResponseData<ReadStateDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let dto = service.mark_read(uid, room_id, cmd).await?;

3331 Ok(AppResponseData::ok(dto))

3432}

@@ -47,10 +45,9 @@

4745)]

4846pub async fn get_read_state(

4947 State(service): State<ChatService>,

50 session: Session,

48 AuthedUser(uid): AuthedUser,

5149 Path(room_id): Path<Uuid>,

5250) -> Result<AppResponseData<ReadStateDto>, ApiError> {

53 let uid = session::require_uid(&session)?;

5451 let dto = service.get_read_state(uid, room_id).await?;

5552 Ok(AppResponseData::ok(dto))

5653}

@@ -69,10 +66,9 @@

6966)]

7067pub async fn list_space_read_states(

7168 State(service): State<ChatService>,

72 session: Session,

69 AuthedUser(uid): AuthedUser,

7370 Path(space_name): Path<String>,

7471) -> Result<AppResponseData<SpaceReadStates>, ApiError> {

75 let uid = session::require_uid(&session)?;

7672 let page = service.list_space_read_states(uid, &space_name).await?;

7773 Ok(AppResponseData::ok(page))

7874}

@@ -99,11 +95,10 @@

9995)]

10096pub async fn mark_thread_read(

10197 State(service): State<ChatService>,

102 session: Session,

98 AuthedUser(uid): AuthedUser,

10399 Path(thread_id): Path<Uuid>,

104100 Json(q): Json<MarkThreadReadCmd>,

105101) -> Result<AppResponseData<NoData>, ApiError> {

106 let uid = session::require_uid(&session)?;

107102 service

108103 .mark_thread_read(uid, thread_id, q.message_id)

109104 .await?;

Modified lib/service/chat/src/handlers/reminders.rs +5 −10 View lib/service/chat/src/handlers/reminders.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -28,11 +27,10 @@

2827)]

2928pub async fn create_reminder(

3029 State(service): State<ChatService>,

31 session: Session,

30 AuthedUser(uid): AuthedUser,

3231 Path((room_id, message_id)): Path<(Uuid, Uuid)>,

3332 Json(cmd): Json<CreateReminderCmd>,

3433) -> Result<AppResponseData<ReminderDto>, ApiError> {

35 let uid = session::require_uid(&session)?;

3634 let dto = service

3735 .create_reminder(uid, room_id, message_id, cmd)

3836 .await?;

@@ -52,9 +50,8 @@

5250)]

5351pub async fn list_reminders(

5452 State(service): State<ChatService>,

55 session: Session,

53 AuthedUser(uid): AuthedUser,

5654) -> Result<AppResponseData<Vec<ReminderDto>>, ApiError> {

57 let uid = session::require_uid(&session)?;

5855 let reminders = service.list_reminders(uid).await?;

5956 Ok(AppResponseData::ok(reminders))

6057}

@@ -73,10 +70,9 @@

7370)]

7471pub async fn cancel_reminder(

7572 State(service): State<ChatService>,

76 session: Session,

73 AuthedUser(uid): AuthedUser,

7774 Path(reminder_id): Path<Uuid>,

7875) -> Result<AppResponseData<NoData>, ApiError> {

79 let uid = session::require_uid(&session)?;

8076 service.cancel_reminder(uid, reminder_id).await?;

8177 Ok(AppResponseData::empty())

8278}

@@ -97,11 +93,10 @@

9793)]

9894pub async fn update_reminder(

9995 State(service): State<ChatService>,

100 session: Session,

96 AuthedUser(uid): AuthedUser,

10197 Path(reminder_id): Path<Uuid>,

10298 Json(cmd): Json<UpdateReminderCmd>,

10399) -> Result<AppResponseData<ReminderDto>, ApiError> {

104 let uid = session::require_uid(&session)?;

105100 let dto = service.update_reminder(uid, reminder_id, cmd).await?;

106101 Ok(AppResponseData::ok(dto))

107102}

Modified lib/service/chat/src/handlers/rooms.rs +6 −12 View lib/service/chat/src/handlers/rooms.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -24,10 +23,9 @@

2423)]

2524pub async fn list_space_rooms(

2625 State(service): State<ChatService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(space_name): Path<String>,

2928) -> Result<AppResponseData<Vec<RoomBriefDto>>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let rooms = service.list_space_rooms(uid, &space_name).await?;

3230 Ok(AppResponseData::ok(rooms))

3331}

@@ -46,10 +44,9 @@

4644)]

4745pub async fn get_room(

4846 State(service): State<ChatService>,

49 session: Session,

47 AuthedUser(uid): AuthedUser,

5048 Path(room_id): Path<Uuid>,

5149) -> Result<AppResponseData<RoomBriefDto>, ApiError> {

52 let uid = session::require_uid(&session)?;

5350 let room = service.get_room(uid, room_id).await?;

5451 Ok(AppResponseData::ok(room))

5552}

@@ -70,11 +67,10 @@

7067)]

7168pub async fn update_room(

7269 State(service): State<ChatService>,

73 session: Session,

70 AuthedUser(uid): AuthedUser,

7471 Path(room_id): Path<Uuid>,

7572 Json(cmd): Json<UpdateRoomCmd>,

7673) -> Result<AppResponseData<RoomBriefDto>, ApiError> {

77 let uid = session::require_uid(&session)?;

7874 let room = service.update_room(uid, room_id, cmd).await?;

7975 Ok(AppResponseData::ok(room))

8076}

@@ -98,11 +94,10 @@

9894)]

9995pub async fn create_room(

10096 State(service): State<ChatService>,

101 session: Session,

97 AuthedUser(uid): AuthedUser,

10298 Path(path): Path<SpacePath>,

10399 Json(cmd): Json<CreateRoomCmd>,

104100) -> Result<AppResponseData<RoomDto>, ApiError> {

105 let uid = session::require_uid(&session)?;

106101 let room = service.create_room(uid, &path.space_name, cmd).await?;

107102 Ok(AppResponseData::ok(room))

108103}

@@ -124,10 +119,9 @@

124119)]

125120pub async fn delete_room(

126121 State(service): State<ChatService>,

127 session: Session,

122 AuthedUser(uid): AuthedUser,

128123 Path(room_id): Path<Uuid>,

129124) -> Result<AppResponseData<NoData>, ApiError> {

130 let uid = session::require_uid(&session)?;

131125 service.delete_room(uid, room_id).await?;

132126 Ok(AppResponseData::empty())

133127}

Modified lib/service/chat/src/handlers/settings.rs +3 −6 View lib/service/chat/src/handlers/settings.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -22,10 +21,9 @@

2221)]

2322pub async fn get_room_setting(

2423 State(service): State<ChatService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(room_id): Path<Uuid>,

2726) -> Result<AppResponseData<RoomSettingDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let dto = service.get_room_setting(uid, room_id).await?;

3028 Ok(AppResponseData::ok(dto))

3129}

@@ -46,11 +44,10 @@

4644)]

4745pub async fn update_room_setting(

4846 State(service): State<ChatService>,

49 session: Session,

47 AuthedUser(uid): AuthedUser,

5048 Path(room_id): Path<Uuid>,

5149 Json(cmd): Json<UpdateRoomSettingCmd>,

5250) -> Result<AppResponseData<RoomSettingDto>, ApiError> {

53 let uid = session::require_uid(&session)?;

5451 let dto = service.update_room_setting(uid, room_id, cmd).await?;

5552 Ok(AppResponseData::ok(dto))

5653}

Modified lib/service/chat/src/handlers/threads.rs +8 −16 View lib/service/chat/src/handlers/threads.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Query, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -30,11 +29,10 @@

3029)]

3130pub async fn create_thread(

3231 State(service): State<ChatService>,

33 session: Session,

32 AuthedUser(uid): AuthedUser,

3433 Path((room_id, message_id)): Path<(Uuid, Uuid)>,

3534 Json(cmd): Json<CreateThreadCmd>,

3635) -> Result<AppResponseData<ThreadDto>, ApiError> {

37 let uid = session::require_uid(&session)?;

3836 let dto = service.create_thread(uid, room_id, message_id, cmd).await?;

3937 Ok(AppResponseData::ok(dto))

4038}

@@ -53,11 +51,10 @@

5351)]

5452pub async fn list_threads(

5553 State(service): State<ChatService>,

56 session: Session,

54 AuthedUser(uid): AuthedUser,

5755 Path(room_id): Path<Uuid>,

5856 Query(q): Query<ListThreadQuery>,

5957) -> Result<AppResponseData<ThreadPage>, ApiError> {

60 let uid = session::require_uid(&session)?;

6158 let page = service.list_threads(uid, room_id, q).await?;

6259 Ok(AppResponseData::ok(page))

6360}

@@ -76,10 +73,9 @@

7673)]

7774pub async fn list_my_threads(

7875 State(service): State<ChatService>,

79 session: Session,

76 AuthedUser(uid): AuthedUser,

8077 Query(page): Query<api::pagination::PageQuery>,

8178) -> Result<AppResponseData<api::pagination::Page<ThreadDto>>, ApiError> {

82 let uid = session::require_uid(&session)?;

8379 let threads = service.list_my_threads(uid).await?;

8480 Ok(AppResponseData::ok(api::pagination::paginate(

8581 threads, &page,

@@ -100,10 +96,9 @@

10096)]

10197pub async fn get_thread(

10298 State(service): State<ChatService>,

103 session: Session,

99 AuthedUser(uid): AuthedUser,

104100 Path(thread_id): Path<Uuid>,

105101) -> Result<AppResponseData<ThreadDto>, ApiError> {

106 let uid = session::require_uid(&session)?;

107102 let dto = service.get_thread(uid, thread_id).await?;

108103 Ok(AppResponseData::ok(dto))

109104}

@@ -124,11 +119,10 @@

124119)]

125120pub async fn update_thread(

126121 State(service): State<ChatService>,

127 session: Session,

122 AuthedUser(uid): AuthedUser,

128123 Path(thread_id): Path<Uuid>,

129124 Json(cmd): Json<UpdateThreadCmd>,

130125) -> Result<AppResponseData<ThreadDto>, ApiError> {

131 let uid = session::require_uid(&session)?;

132126 let dto = service.update_thread(uid, thread_id, cmd).await?;

133127 Ok(AppResponseData::ok(dto))

134128}

@@ -149,11 +143,10 @@

149143)]

150144pub async fn follow_thread(

151145 State(service): State<ChatService>,

152 session: Session,

146 AuthedUser(uid): AuthedUser,

153147 Path(thread_id): Path<Uuid>,

154148 Json(cmd): Json<ThreadMemberCmd>,

155149) -> Result<AppResponseData<NoData>, ApiError> {

156 let uid = session::require_uid(&session)?;

157150 service.set_thread_membership(uid, thread_id, cmd).await?;

158151 Ok(AppResponseData::empty())

159152}

@@ -172,10 +165,9 @@

172165)]

173166pub async fn unfollow_thread(

174167 State(service): State<ChatService>,

175 session: Session,

168 AuthedUser(uid): AuthedUser,

176169 Path(thread_id): Path<Uuid>,

177170) -> Result<AppResponseData<NoData>, ApiError> {

178 let uid = session::require_uid(&session)?;

179171 service.leave_thread(uid, thread_id).await?;

180172 Ok(AppResponseData::empty())

181173}

Modified lib/service/chat/src/handlers/voice.rs +17 −34 View lib/service/chat/src/handlers/voice.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{HeaderMap, Json, Path, Query, State};

43use api::rest::{AppResponseData, NoData};

54use livekit_api::access_token::TokenVerifier;

@@ -27,9 +26,8 @@

2726)]

2827pub async fn voice_config(

2928 State(service): State<ChatService>,

30 session: Session,

29 AuthedUser(_uid): AuthedUser,

3130) -> Result<AppResponseData<VoiceConfigDto>, ApiError> {

32 let _uid = session::require_uid(&session)?;

3331 Ok(AppResponseData::ok(service.voice_config()))

3432}

3533

@@ -49,10 +47,9 @@

4947)]

5048pub async fn voice_token(

5149 State(service): State<ChatService>,

52 session: Session,

50 AuthedUser(uid): AuthedUser,

5351 Path(room_id): Path<Uuid>,

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

55 let uid = session::require_uid(&session)?;

5653 Ok(AppResponseData::ok(

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

5855 ))

@@ -72,10 +69,9 @@

7269)]

7370pub async fn voice_participants(

7471 State(service): State<ChatService>,

75 session: Session,

72 AuthedUser(uid): AuthedUser,

7673 Path(room_id): Path<Uuid>,

7774) -> Result<AppResponseData<Vec<VoiceParticipantDto>>, ApiError> {

78 let uid = session::require_uid(&session)?;

7975 Ok(AppResponseData::ok(

8076 service.voice_participants(uid, room_id).await?,

8177 ))

@@ -94,10 +90,9 @@

9490)]

9591pub async fn voice_space_states(

9692 State(service): State<ChatService>,

97 session: Session,

93 AuthedUser(uid): AuthedUser,

9894 Path(space_name): Path<String>,

9995) -> Result<AppResponseData<VoiceSpaceStatesDto>, ApiError> {

100 let uid = session::require_uid(&session)?;

10196 Ok(AppResponseData::ok(

10297 service.voice_space_states(uid, &space_name).await?,

10398 ))

@@ -116,10 +111,9 @@

116111)]

117112pub async fn list_hands(

118113 State(service): State<ChatService>,

119 session: Session,

114 AuthedUser(uid): AuthedUser,

120115 Path(room_id): Path<Uuid>,

121116) -> Result<AppResponseData<VoiceHandsDto>, ApiError> {

122 let uid = session::require_uid(&session)?;

123117 Ok(AppResponseData::ok(service.list_hands(uid, room_id).await?))

124118}

125119

@@ -137,10 +131,9 @@

137131)]

138132pub async fn get_voice_layout(

139133 State(service): State<ChatService>,

140 session: Session,

134 AuthedUser(uid): AuthedUser,

141135 Path(room_id): Path<Uuid>,

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

143 let uid = session::require_uid(&session)?;

144137 Ok(AppResponseData::ok(

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

146139 ))

@@ -162,11 +155,10 @@

162155)]

163156pub async fn save_voice_layout(

164157 State(service): State<ChatService>,

165 session: Session,

158 AuthedUser(uid): AuthedUser,

166159 Path(room_id): Path<Uuid>,

167160 Json(patch): Json<VoiceLayoutPatchDto>,

168161) -> Result<AppResponseData<VoiceLayoutSavedDto>, ApiError> {

169 let uid = session::require_uid(&session)?;

170162 Ok(AppResponseData::ok(

171163 service.save_voice_layout(uid, room_id, patch).await?,

172164 ))

@@ -186,10 +178,9 @@

186178)]

187179pub async fn raise_hand(

188180 State(service): State<ChatService>,

189 session: Session,

181 AuthedUser(uid): AuthedUser,

190182 Path(room_id): Path<Uuid>,

191183) -> Result<AppResponseData<HandDto>, ApiError> {

192 let uid = session::require_uid(&session)?;

193184 Ok(AppResponseData::ok(service.raise_hand(uid, room_id).await?))

194185}

195186

@@ -207,10 +198,9 @@

207198)]

208199pub async fn cancel_hand(

209200 State(service): State<ChatService>,

210 session: Session,

201 AuthedUser(uid): AuthedUser,

211202 Path(room_id): Path<Uuid>,

212203) -> Result<AppResponseData<NoData>, ApiError> {

213 let uid = session::require_uid(&session)?;

214204 service.cancel_hand(uid, room_id).await?;

215205 Ok(AppResponseData::empty())

216206}

@@ -232,10 +222,9 @@

232222)]

233223pub async fn approve_hand(

234224 State(service): State<ChatService>,

235 session: Session,

225 AuthedUser(uid): AuthedUser,

236226 Path((room_id, user_id)): Path<(Uuid, i64)>,

237227) -> Result<AppResponseData<VoiceModerationDto>, ApiError> {

238 let uid = session::require_uid(&session)?;

239228 Ok(AppResponseData::ok(

240229 service.approve_hand(uid, room_id, user_id).await?,

241230 ))

@@ -257,10 +246,9 @@

257246)]

258247pub async fn deny_hand(

259248 State(service): State<ChatService>,

260 session: Session,

249 AuthedUser(uid): AuthedUser,

261250 Path((room_id, user_id)): Path<(Uuid, i64)>,

262251) -> Result<AppResponseData<VoiceModerationDto>, ApiError> {

263 let uid = session::require_uid(&session)?;

264252 Ok(AppResponseData::ok(

265253 service.deny_hand(uid, room_id, user_id).await?,

266254 ))

@@ -282,10 +270,9 @@

282270)]

283271pub async fn revoke_hand(

284272 State(service): State<ChatService>,

285 session: Session,

273 AuthedUser(uid): AuthedUser,

286274 Path((room_id, user_id)): Path<(Uuid, i64)>,

287275) -> Result<AppResponseData<VoiceModerationDto>, ApiError> {

288 let uid = session::require_uid(&session)?;

289276 Ok(AppResponseData::ok(

290277 service.revoke_hand(uid, room_id, user_id).await?,

291278 ))

@@ -314,11 +301,10 @@

314301)]

315302pub async fn moderate_mute(

316303 State(service): State<ChatService>,

317 session: Session,

304 AuthedUser(uid): AuthedUser,

318305 Path((room_id, user_id)): Path<(Uuid, i64)>,

319306 Query(query): Query<ModerateQuery>,

320307) -> Result<AppResponseData<VoiceModerationDto>, ApiError> {

321 let uid = session::require_uid(&session)?;

322308 Ok(AppResponseData::ok(

323309 service

324310 .moderate_mute(uid, room_id, user_id, query.muted)

@@ -342,10 +328,9 @@

342328)]

343329pub async fn kick_participant(

344330 State(service): State<ChatService>,

345 session: Session,

331 AuthedUser(uid): AuthedUser,

346332 Path((room_id, user_id)): Path<(Uuid, i64)>,

347333) -> Result<AppResponseData<VoiceModerationDto>, ApiError> {

348 let uid = session::require_uid(&session)?;

349334 Ok(AppResponseData::ok(

350335 service.kick_participant(uid, room_id, user_id).await?,

351336 ))

@@ -365,10 +350,9 @@

365350)]

366351pub async fn start_recording(

367352 State(service): State<ChatService>,

368 session: Session,

353 AuthedUser(uid): AuthedUser,

369354 Path(room_id): Path<Uuid>,

370355) -> Result<AppResponseData<VoiceRecordingDto>, ApiError> {

371 let uid = session::require_uid(&session)?;

372356 Ok(AppResponseData::ok(

373357 service.start_recording(uid, room_id).await?,

374358 ))

@@ -388,10 +372,9 @@

388372)]

389373pub async fn stop_recording(

390374 State(service): State<ChatService>,

391 session: Session,

375 AuthedUser(uid): AuthedUser,

392376 Path(room_id): Path<Uuid>,

393377) -> Result<AppResponseData<VoiceRecordingDto>, ApiError> {

394 let uid = session::require_uid(&session)?;

395378 Ok(AppResponseData::ok(

396379 service.stop_recording(uid, room_id).await?,

397380 ))

Modified lib/service/chat/src/handlers/webhooks.rs +9 −18 View lib/service/chat/src/handlers/webhooks.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, Path, Query, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -28,11 +27,10 @@

2827)]

2928pub async fn create_webhook(

3029 State(service): State<ChatService>,

31 session: Session,

30 AuthedUser(uid): AuthedUser,

3231 Path(room_id): Path<Uuid>,

3332 Json(cmd): Json<CreateWebhookCmd>,

3433) -> Result<AppResponseData<WebhookSecretDto>, ApiError> {

35 let uid = session::require_uid(&session)?;

3634 let dto = service.create_webhook(uid, room_id, cmd).await?;

3735 Ok(AppResponseData::ok(dto))

3836}

@@ -51,11 +49,10 @@

5149)]

5250pub async fn list_webhooks(

5351 State(service): State<ChatService>,

54 session: Session,

52 AuthedUser(uid): AuthedUser,

5553 Path(room_id): Path<Uuid>,

5654 Query(page): Query<api::pagination::PageQuery>,

5755) -> Result<AppResponseData<api::pagination::Page<WebhookDto>>, ApiError> {

58 let uid = session::require_uid(&session)?;

5956 let rows = service.list_webhooks(uid, room_id).await?;

6057 Ok(AppResponseData::ok(api::pagination::paginate(rows, &page)?))

6158}

@@ -77,10 +74,9 @@

7774)]

7875pub async fn delete_webhook(

7976 State(service): State<ChatService>,

80 session: Session,

77 AuthedUser(uid): AuthedUser,

8178 Path((room_id, webhook_id)): Path<(Uuid, Uuid)>,

8279) -> Result<AppResponseData<NoData>, ApiError> {

83 let uid = session::require_uid(&session)?;

8480 service.delete_webhook(uid, room_id, webhook_id).await?;

8581 Ok(AppResponseData::empty())

8682}

@@ -124,11 +120,10 @@

124120)]

125121pub async fn update_webhook(

126122 State(service): State<ChatService>,

127 session: Session,

123 AuthedUser(uid): AuthedUser,

128124 Path((room_id, webhook_id)): Path<(Uuid, Uuid)>,

129125 Json(cmd): Json<UpdateWebhookCmd>,

130126) -> Result<AppResponseData<WebhookDto>, ApiError> {

131 let uid = session::require_uid(&session)?;

132127 let dto = service

133128 .update_webhook(uid, room_id, webhook_id, cmd)

134129 .await?;

@@ -156,11 +151,10 @@

156151)]

157152pub async fn create_outbound_webhook(

158153 State(service): State<ChatService>,

159 session: Session,

154 AuthedUser(uid): AuthedUser,

160155 Path(room_id): Path<Uuid>,

161156 Json(cmd): Json<CreateOutboundWebhookCmd>,

162157) -> Result<AppResponseData<OutboundWebhookSecretDto>, ApiError> {

163 let uid = session::require_uid(&session)?;

164158 let dto = service.create_outbound_webhook(uid, room_id, cmd).await?;

165159 Ok(AppResponseData::ok(dto))

166160}

@@ -179,10 +173,9 @@

179173)]

180174pub async fn list_outbound_webhooks(

181175 State(service): State<ChatService>,

182 session: Session,

176 AuthedUser(uid): AuthedUser,

183177 Path(room_id): Path<Uuid>,

184178) -> Result<AppResponseData<Vec<OutboundWebhookDto>>, ApiError> {

185 let uid = session::require_uid(&session)?;

186179 let rows = service.list_outbound_webhooks(uid, room_id).await?;

187180 Ok(AppResponseData::ok(rows))

188181}

@@ -203,11 +196,10 @@

203196)]

204197pub async fn update_outbound_webhook(

205198 State(service): State<ChatService>,

206 session: Session,

199 AuthedUser(uid): AuthedUser,

207200 Path((room_id, webhook_id)): Path<(Uuid, Uuid)>,

208201 Json(cmd): Json<UpdateOutboundWebhookCmd>,

209202) -> Result<AppResponseData<OutboundWebhookDto>, ApiError> {

210 let uid = session::require_uid(&session)?;

211203 let dto = service

212204 .update_outbound_webhook(uid, room_id, webhook_id, cmd)

213205 .await?;

@@ -228,10 +220,9 @@

228220)]

229221pub async fn delete_outbound_webhook(

230222 State(service): State<ChatService>,

231 session: Session,

223 AuthedUser(uid): AuthedUser,

232224 Path((room_id, webhook_id)): Path<(Uuid, Uuid)>,

233225) -> Result<AppResponseData<NoData>, ApiError> {

234 let uid = session::require_uid(&session)?;

235226 service

236227 .delete_outbound_webhook(uid, room_id, webhook_id)

237228 .await?;

Modified lib/service/chat/src/share/mod.rs +0 −1 View lib/service/chat/src/share/mod.rs

@@ -1,7 +1,6 @@

11pub mod authz;

22pub mod events;

33pub mod fanout;

4pub mod guard;

54pub mod lookup;

65pub mod mention;

76pub mod notify;

Modified lib/service/chat/src/routes.rs +6 −7 View lib/service/chat/src/routes.rs

@@ -34,8 +34,8 @@

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

3535use crate::services::service::ChatService;

3636

37pub fn router(_service: ChatService) -> Router<ChatService> {

38 let guarded = Router::<ChatService>::new()

37pub fn protected(_service: ChatService) -> Router<ChatService> {

38 Router::<ChatService>::new()

3939 .route(

4040 "/chat/spaces/{space_name}/rooms",

4141 get(list_space_rooms).post(create_room),

@@ -230,13 +230,12 @@

230230 "/chat/rooms/{room_id}/voice/recording/stop",

231231 post(stop_recording),

232232 )

233 .wrap(api::http::Guard::Session);

233}

234234

235 let open = Router::<ChatService>::new()

235pub fn public(_service: ChatService) -> Router<ChatService> {

236 Router::<ChatService>::new()

236237 .route("/chat/hooks/{token}", post(post_via_webhook))

237 .route("/chat/livekit/webhook", post(livekit_webhook));

238

239 guarded.merge(open)

238 .route("/chat/livekit/webhook", post(livekit_webhook))

240239}

241240

242241/// 内部路由：只由服务间调用（`x-gitdata-service-key` 校验），不暴露给浏览器。

Modified lib/service/git/src/handler/analysis/code_activity.rs +3 −3 View lib/service/git/src/handler/analysis/code_activity.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -25,13 +25,13 @@

2525)]

2626pub async fn code_activity(

2727 State(service): State<GitService>,

28 session: Session,

28 OptionalUser(viewer): OptionalUser,

2929 Path(path): Path<crate::handler::RepoPath>,

3030 Query(q): Query<CodeActivityQuery>,

3131) -> Result<AppResponseData<CodeActivityDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/analysis/contributors.rs +3 −3 View lib/service/git/src/handler/analysis/contributors.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn contributors(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424) -> Result<AppResponseData<Vec<ContributorStatDto>>, ApiError> {

2525 let (ctx, _) = handler::resolve_reader(

2626 &service,

27 &session,

27 viewer,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/analysis/languages.rs +3 −3 View lib/service/git/src/handler/analysis/languages.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn languages(

2121 State(service): State<GitService>,

22 session: Session,

22 AuthedUser(uid): AuthedUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424) -> Result<AppResponseData<Vec<LanguageStatDto>>, ApiError> {

2525 let (ctx, _uid) = handler::require_writer(

2626 &service,

27 &session,

27 uid,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/analysis/languages_read.rs +3 −3 View lib/service/git/src/handler/analysis/languages_read.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn languages_read(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424) -> Result<AppResponseData<Vec<LanguageStatDto>>, ApiError> {

2525 let (ctx, _) = handler::resolve_reader(

2626 &service,

27 &session,

27 viewer,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/archives/create.rs +3 −3 View lib/service/git/src/handler/archives/create.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -48,13 +48,13 @@

4848)]

4949pub async fn create_archive(

5050 State(service): State<GitService>,

51 session: Session,

51 AuthedUser(uid): AuthedUser,

5252 Path(path): Path<RepoPath>,

5353 Json(cmd): Json<ArchiveCreateCmd>,

5454) -> Result<AppResponseData<ArchiveResultDto>, ApiError> {

5555 let (ctx, _) = require_writer(

5656 &service,

57 &session,

57 uid,

5858 path.space_name.clone(),

5959 path.repo_name.clone(),

6060 )

Modified lib/service/git/src/handler/archives/create_bundle.rs +3 −3 View lib/service/git/src/handler/archives/create_bundle.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn create_bundle(

2121 State(service): State<GitService>,

22 session: Session,

22 AuthedUser(uid): AuthedUser,

2323 Path(path): Path<RepoPath>,

2424) -> Result<AppResponseData<ArchiveResultDto>, ApiError> {

2525 let (ctx, _) = require_writer(

2626 &service,

27 &session,

27 uid,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/archives/download.rs +3 −3 View lib/service/git/src/handler/archives/download.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -23,13 +23,13 @@

2323)]

2424pub async fn get_archive(

2525 State(service): State<GitService>,

26 session: Session,

26 OptionalUser(viewer): OptionalUser,

2727 Path(path): Path<RepoPathRev>,

2828 Query(opts): Query<ArchiveOptionsDto>,

2929) -> Result<AppResponseData<ArchiveResultDto>, ApiError> {

3030 let (ctx, _) = resolve_reader(

3131 &service,

32 &session,

32 viewer,

3333 path.space_name.clone(),

3434 path.repo_name.clone(),

3535 )

Modified lib/service/git/src/handler/blobs/content.rs +3 −3 View lib/service/git/src/handler/blobs/content.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -26,12 +26,12 @@

2626)]

2727pub async fn blob_content(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<BlobPath>,

3131) -> Result<AppResponseData<BlobContentDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/blobs/list_lfs_pointers.rs +3 −3 View lib/service/git/src/handler/blobs/list_lfs_pointers.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -35,13 +35,13 @@

3535)]

3636pub async fn list_lfs_pointers(

3737 State(service): State<GitService>,

38 session: Session,

38 OptionalUser(viewer): OptionalUser,

3939 Path(path): Path<RepoQuery>,

4040 Query(q): Query<LfsPointerQuery>,

4141) -> Result<AppResponseData<Vec<LfsPointerDto>>, ApiError> {

4242 let (ctx, _) = handler::resolve_reader(

4343 &service,

44 &session,

44 viewer,

4545 path.space_name.clone(),

4646 path.repo_name.clone(),

4747 )

Modified lib/service/git/src/handler/blobs/metadata.rs +3 −3 View lib/service/git/src/handler/blobs/metadata.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -26,12 +26,12 @@

2626)]

2727pub async fn blob_metadata(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<BlobPath>,

3131) -> Result<AppResponseData<BlobMetaDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/branch_protection/create_policy.rs +3 −3 View lib/service/git/src/handler/branch_protection/create_policy.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -20,13 +20,13 @@

2020)]

2121pub async fn create_policy(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<RepoPath>,

2525 Json(cmd): Json<CreateBranchPolicyCmd>,

2626) -> Result<AppResponseData<BranchPolicyDto>, ApiError> {

2727 let (ctx, _) = require_repo_admin(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

Modified lib/service/git/src/handler/branch_protection/delete_policy.rs +3 −3 View lib/service/git/src/handler/branch_protection/delete_policy.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn delete_policy(

2121 State(service): State<GitService>,

22 session: Session,

22 AuthedUser(uid): AuthedUser,

2323 Path(path): Path<PolicyPath>,

2424) -> Result<AppResponseData<NoData>, ApiError> {

2525 let (ctx, _) = handler::require_repo_admin(

2626 &service,

27 &session,

27 uid,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/branch_protection/get_policy.rs +3 −3 View lib/service/git/src/handler/branch_protection/get_policy.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -20,12 +20,12 @@

2020)]

2121pub async fn get_policy(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<PolicyPath>,

2525) -> Result<AppResponseData<BranchPolicyDto>, ApiError> {

2626 let (ctx, _) = handler::require_repo_admin(

2727 &service,

28 &session,

28 uid,

2929 path.space_name.clone(),

3030 path.repo_name.clone(),

3131 )

Modified lib/service/git/src/handler/branch_protection/list_policies.rs +3 −3 View lib/service/git/src/handler/branch_protection/list_policies.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn list_policies(

2121 State(service): State<GitService>,

22 session: Session,

22 AuthedUser(uid): AuthedUser,

2323 Path(path): Path<RepoPath>,

2424) -> Result<AppResponseData<Vec<BranchPolicyDto>>, ApiError> {

2525 let (ctx, _) = require_repo_admin(

2626 &service,

27 &session,

27 uid,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/branch_protection/update_policy.rs +3 −3 View lib/service/git/src/handler/branch_protection/update_policy.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -21,13 +21,13 @@

2121)]

2222pub async fn update_policy(

2323 State(service): State<GitService>,

24 session: Session,

24 AuthedUser(uid): AuthedUser,

2525 Path(path): Path<PolicyPath>,

2626 Json(cmd): Json<UpdateBranchPolicyCmd>,

2727) -> Result<AppResponseData<BranchPolicyDto>, ApiError> {

2828 let (ctx, _) = handler::require_repo_admin(

2929 &service,

30 &session,

30 uid,

3131 path.space_name.clone(),

3232 path.repo_name.clone(),

3333 )

Modified lib/service/git/src/handler/branches/create.rs +3 −3 View lib/service/git/src/handler/branches/create.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -20,13 +20,13 @@

2020)]

2121pub async fn create_branch(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<crate::handler::RepoPath>,

2525 Json(cmd): Json<CreateBranchCmd>,

2626) -> Result<AppResponseData<BranchDto>, ApiError> {

2727 let (ctx, _) = handler::require_writer(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

Modified lib/service/git/src/handler/branches/delete.rs +3 −3 View lib/service/git/src/handler/branches/delete.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -31,13 +31,13 @@

3131)]

3232pub async fn delete_branch(

3333 State(service): State<GitService>,

34 session: Session,

34 AuthedUser(uid): AuthedUser,

3535 Path(path): Path<BranchPath>,

3636 Query(query): Query<DeleteBranchQuery>,

3737) -> Result<AppResponseData<NoData>, ApiError> {

3838 let (ctx, _) = handler::require_writer(

3939 &service,

40 &session,

40 uid,

4141 path.space_name.clone(),

4242 path.repo_name.clone(),

4343 )

Modified lib/service/git/src/handler/branches/get.rs +3 −3 View lib/service/git/src/handler/branches/get.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -26,12 +26,12 @@

2626)]

2727pub async fn get_branch(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<BranchPath>,

3131) -> Result<AppResponseData<BranchDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/branches/list.rs +3 −3 View lib/service/git/src/handler/branches/list.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -19,13 +19,13 @@

1919)]

2020pub async fn list_branches(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424 Query(page): Query<api::pagination::PageQuery>,

2525) -> Result<AppResponseData<api::pagination::Page<BranchDto>>, ApiError> {

2626 let (ctx, _) = handler::resolve_reader(

2727 &service,

28 &session,

28 viewer,

2929 path.space_name.clone(),

3030 path.repo_name.clone(),

3131 )

Modified lib/service/git/src/handler/branches/rename.rs +3 −3 View lib/service/git/src/handler/branches/rename.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -31,13 +31,13 @@

3131)]

3232pub async fn rename_branch(

3333 State(service): State<GitService>,

34 session: Session,

34 AuthedUser(uid): AuthedUser,

3535 Path(path): Path<BranchPath>,

3636 Json(cmd): Json<RenameBranchCmd>,

3737) -> Result<AppResponseData<NoData>, ApiError> {

3838 let (ctx, _) = handler::require_writer(

3939 &service,

40 &session,

40 uid,

4141 path.space_name.clone(),

4242 path.repo_name.clone(),

4343 )

Modified lib/service/git/src/handler/branches/set_default.rs +3 −3 View lib/service/git/src/handler/branches/set_default.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -25,12 +25,12 @@

2525)]

2626pub async fn set_default_branch(

2727 State(service): State<GitService>,

28 session: Session,

28 AuthedUser(uid): AuthedUser,

2929 Path(path): Path<BranchPath>,

3030) -> Result<AppResponseData<NoData>, ApiError> {

3131 let (ctx, _) = handler::require_writer(

3232 &service,

33 &session,

33 uid,

3434 path.space_name.clone(),

3535 path.repo_name.clone(),

3636 )

Modified lib/service/git/src/handler/code_comments/create_code_comment.rs +3 −3 View lib/service/git/src/handler/code_comments/create_code_comment.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -20,13 +20,13 @@

2020)]

2121pub async fn create_code_comment(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<crate::handler::RepoPath>,

2525 Json(cmd): Json<CreateCodeCommentCmd>,

2626) -> Result<AppResponseData<CodeCommentDto>, ApiError> {

2727 let (ctx, uid) = handler::require_writer(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

Modified lib/service/git/src/handler/code_comments/list_code_comments.rs +3 −3 View lib/service/git/src/handler/code_comments/list_code_comments.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -19,13 +19,13 @@

1919)]

2020pub async fn list_code_comments(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424 Query(query): Query<ListCodeCommentsQuery>,

2525) -> Result<AppResponseData<CodeCommentPage>, ApiError> {

2626 let (ctx, _) = handler::resolve_reader(

2727 &service,

28 &session,

28 viewer,

2929 path.space_name.clone(),

3030 path.repo_name.clone(),

3131 )

Modified lib/service/git/src/handler/code_comments/modify.rs +7 −7 View lib/service/git/src/handler/code_comments/modify.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44use uuid::Uuid;

@@ -28,20 +28,20 @@

2828)]

2929pub async fn update_code_comment(

3030 State(service): State<GitService>,

31 session: Session,

31 AuthedUser(uid): AuthedUser,

3232 Path(path): Path<CodeCommentPath>,

3333 Json(cmd): Json<UpdateCodeCommentCmd>,

3434) -> Result<AppResponseData<CodeCommentDto>, ApiError> {

3535 let (ctx, uid) = require_writer(

3636 &service,

37 &session,

37 uid,

3838 path.space_name.clone(),

3939 path.repo_name.clone(),

4040 )

4141 .await?;

4242 let admin = require_repo_admin(

4343 &service,

44 &session,

44 uid,

4545 path.space_name.clone(),

4646 path.repo_name.clone(),

4747 )

@@ -66,19 +66,19 @@

6666)]

6767pub async fn delete_code_comment(

6868 State(service): State<GitService>,

69 session: Session,

69 AuthedUser(uid): AuthedUser,

7070 Path(path): Path<CodeCommentPath>,

7171) -> Result<AppResponseData<NoData>, ApiError> {

7272 let (ctx, uid) = require_writer(

7373 &service,

74 &session,

74 uid,

7575 path.space_name.clone(),

7676 path.repo_name.clone(),

7777 )

7878 .await?;

7979 let admin = require_repo_admin(

8080 &service,

81 &session,

81 uid,

8282 path.space_name.clone(),

8383 path.repo_name.clone(),

8484 )

Modified lib/service/git/src/handler/code_comments/resolve_code_comment.rs +5 −5 View lib/service/git/src/handler/code_comments/resolve_code_comment.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn resolve_code_comment(

2121 State(service): State<GitService>,

22 session: Session,

22 AuthedUser(uid): AuthedUser,

2323 Path(path): Path<super::modify::CodeCommentPath>,

2424) -> Result<AppResponseData<CodeCommentDto>, ApiError> {

2525 let (ctx, uid) = handler::require_writer(

2626 &service,

27 &session,

27 uid,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

@@ -48,12 +48,12 @@

4848)]

4949pub async fn unresolve_code_comment(

5050 State(service): State<GitService>,

51 session: Session,

51 AuthedUser(uid): AuthedUser,

5252 Path(path): Path<super::modify::CodeCommentPath>,

5353) -> Result<AppResponseData<CodeCommentDto>, ApiError> {

5454 let (ctx, uid) = handler::require_writer(

5555 &service,

56 &session,

56 uid,

5757 path.space_name.clone(),

5858 path.repo_name.clone(),

5959 )

Modified lib/service/git/src/handler/commits/get.rs +3 −3 View lib/service/git/src/handler/commits/get.rs

@@ -1,5 +1,5 @@

11use crate::rpcgit::commit::types::CommitInfo;

2use ::session::Session;

2use ::session::OptionalUser;

33use api::http::{Path, State};

44use api::rest::AppResponseData;

55

@@ -26,12 +26,12 @@

2626)]

2727pub async fn get_commit(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<CommitPath>,

3131) -> Result<AppResponseData<CommitInfo>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/commits/is_ancestor.rs +3 −3 View lib/service/git/src/handler/commits/is_ancestor.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44use serde::Serialize;

@@ -30,13 +30,13 @@

3030)]

3131pub async fn is_ancestor(

3232 State(service): State<GitService>,

33 session: Session,

33 OptionalUser(viewer): OptionalUser,

3434 Path(path): Path<crate::handler::RepoPath>,

3535 Query(query): Query<AncestorQuery>,

3636) -> Result<AppResponseData<IsAncestorResponse>, ApiError> {

3737 let (ctx, _) = handler::resolve_reader(

3838 &service,

39 &session,

39 viewer,

4040 path.space_name.clone(),

4141 path.repo_name.clone(),

4242 )

Modified lib/service/git/src/handler/commits/list.rs +3 −3 View lib/service/git/src/handler/commits/list.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -28,13 +28,13 @@

2828)]

2929pub async fn list_commits(

3030 State(service): State<GitService>,

31 session: Session,

31 OptionalUser(viewer): OptionalUser,

3232 Path(path): Path<crate::handler::RepoPath>,

3333 Query(cmd): Query<ListCommitsCmd>,

3434) -> Result<AppResponseData<api::pagination::Page<CommitDto>>, ApiError> {

3535 let (ctx, _viewer) = handler::resolve_reader(

3636 &service,

37 &session,

37 viewer,

3838 path.space_name.clone(),

3939 path.repo_name.clone(),

4040 )

Modified lib/service/git/src/handler/commits/list_commit_statuses.rs +3 −3 View lib/service/git/src/handler/commits/list_commit_statuses.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -26,12 +26,12 @@

2626)]

2727pub async fn list_commit_statuses(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<StatusPath>,

3131) -> Result<AppResponseData<Vec<CommitStatusDto>>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/commits/rev_parse.rs +3 −3 View lib/service/git/src/handler/commits/rev_parse.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -25,12 +25,12 @@

2525)]

2626pub async fn rev_parse(

2727 State(service): State<GitService>,

28 session: Session,

28 OptionalUser(viewer): OptionalUser,

2929 Path(path): Path<RevPath>,

3030) -> Result<AppResponseData<String>, ApiError> {

3131 let (ctx, _) = handler::resolve_reader(

3232 &service,

33 &session,

33 viewer,

3434 path.space_name.clone(),

3535 path.repo_name.clone(),

3636 )

Modified lib/service/git/src/handler/commits/set_commit_status.rs +3 −3 View lib/service/git/src/handler/commits/set_commit_status.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -20,13 +20,13 @@

2020)]

2121pub async fn set_commit_status(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<crate::handler::RepoPath>,

2525 Json(cmd): Json<SetCommitStatusCmd>,

2626) -> Result<AppResponseData<CommitStatusDto>, ApiError> {

2727 let (ctx, uid) = handler::require_writer(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

Modified lib/service/git/src/handler/commits/stats.rs +3 −3 View lib/service/git/src/handler/commits/stats.rs

@@ -1,7 +1,7 @@

11use std::path::PathBuf;

22

33use crate::rpcgit::commit::types::CommitStats;

4use ::session::Session;

4use ::session::OptionalUser;

55use api::http::{Path, Query, State};

66use api::rest::AppResponseData;

77

@@ -28,13 +28,13 @@

2828)]

2929pub async fn commit_stats(

3030 State(service): State<GitService>,

31 session: Session,

31 OptionalUser(viewer): OptionalUser,

3232 Path(path): Path<crate::handler::RepoPath>,

3333 Query(query): Query<StatsQuery>,

3434) -> Result<AppResponseData<CommitStats>, ApiError> {

3535 let (ctx, _) = handler::resolve_reader(

3636 &service,

37 &session,

37 viewer,

3838 path.space_name.clone(),

3939 path.repo_name.clone(),

4040 )

Modified lib/service/git/src/handler/commits/sync_commit.rs +3 −3 View lib/service/git/src/handler/commits/sync_commit.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44use serde::Serialize;

@@ -32,12 +32,12 @@

3232)]

3333pub async fn sync_commit(

3434 State(service): State<GitService>,

35 session: Session,

35 AuthedUser(uid): AuthedUser,

3636 Path(path): Path<CommitPath>,

3737) -> Result<AppResponseData<CommitSyncResponse>, ApiError> {

3838 let (ctx, _uid) = handler::require_writer(

3939 &service,

40 &session,

40 uid,

4141 path.space_name.clone(),

4242 path.repo_name.clone(),

4343 )

Modified lib/service/git/src/handler/conflicts/detail.rs +3 −3 View lib/service/git/src/handler/conflicts/detail.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -26,13 +26,13 @@

2626)]

2727pub async fn conflict_detail(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<crate::handler::RepoPath>,

3131 Query(q): Query<ConflictDetailQuery>,

3232) -> Result<AppResponseData<ConflictDetailDto>, ApiError> {

3333 let (ctx, _) = handler::resolve_reader(

3434 &service,

35 &session,

35 viewer,

3636 path.space_name.clone(),

3737 path.repo_name.clone(),

3838 )

Modified lib/service/git/src/handler/conflicts/get_conflicts.rs +3 −3 View lib/service/git/src/handler/conflicts/get_conflicts.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -27,13 +27,13 @@

2727)]

2828pub async fn get_conflicts(

2929 State(service): State<GitService>,

30 session: Session,

30 OptionalUser(viewer): OptionalUser,

3131 Path(path): Path<crate::handler::RepoPath>,

3232 Query(q): Query<GetConflictsQuery>,

3333) -> Result<AppResponseData<MergeStatusDto>, ApiError> {

3434 let (ctx, _) = handler::resolve_reader(

3535 &service,

36 &session,

36 viewer,

3737 path.space_name.clone(),

3838 path.repo_name.clone(),

3939 )

Modified lib/service/git/src/handler/content/caller_signature.rs +3 −4 View lib/service/git/src/handler/content/caller_signature.rs

@@ -1,10 +1,9 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, State};

33use api::rest::AppResponseData;

44use time::OffsetDateTime;

55

66use crate::errors::{ApiError, GitApiError};

7use crate::handler;

87use crate::service::GitService;

98use crate::service::content::SignatureDto;

109

@@ -26,10 +25,10 @@

2625)]

2726pub async fn caller_signature(

2827 State(service): State<GitService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Json(_body): Json<CallerSignatureBody>,

3130) -> Result<AppResponseData<SignatureDto>, ApiError> {

32 let caller = handler::ensure_caller(&session)?;

31 let caller = uid;

3332 let out = service

3433 .caller_signature(caller, OffsetDateTime::now_utc())

3534 .await

Modified lib/service/git/src/handler/content/commit_object.rs +3 −3 View lib/service/git/src/handler/content/commit_object.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -30,13 +30,13 @@

3030)]

3131pub async fn commit_object(

3232 State(service): State<GitService>,

33 session: Session,

33 AuthedUser(uid): AuthedUser,

3434 Path(path): Path<RepoPath>,

3535 Json(body): Json<CommitObjectBody>,

3636) -> Result<AppResponseData<WriteObjectResultDto>, ApiError> {

3737 require_writer(

3838 &service,

39 &session,

39 uid,

4040 path.space_name.clone(),

4141 path.repo_name.clone(),

4242 )

Modified lib/service/git/src/handler/content/write_blob.rs +3 −3 View lib/service/git/src/handler/content/write_blob.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -25,13 +25,13 @@

2525)]

2626pub async fn write_blob(

2727 State(service): State<GitService>,

28 session: Session,

28 AuthedUser(uid): AuthedUser,

2929 Path(path): Path<RepoPath>,

3030 Json(body): Json<WriteBlobBody>,

3131) -> Result<AppResponseData<WriteObjectResultDto>, ApiError> {

3232 require_writer(

3333 &service,

34 &session,

34 uid,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/content/write_tree_from_files.rs +3 −3 View lib/service/git/src/handler/content/write_tree_from_files.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -25,13 +25,13 @@

2525)]

2626pub async fn write_tree_from_files(

2727 State(service): State<GitService>,

28 session: Session,

28 AuthedUser(uid): AuthedUser,

2929 Path(path): Path<RepoPath>,

3030 Json(body): Json<WriteTreeBody>,

3131) -> Result<AppResponseData<WriteObjectResultDto>, ApiError> {

3232 require_writer(

3333 &service,

34 &session,

34 uid,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/diffs/for_commit.rs +3 −3 View lib/service/git/src/handler/diffs/for_commit.rs

@@ -1,5 +1,5 @@

11use crate::rpcgit::diff::types::ChangedPath;

2use ::session::Session;

2use ::session::OptionalUser;

33use api::http::{Path, State};

44use api::rest::AppResponseData;

55

@@ -26,12 +26,12 @@

2626)]

2727pub async fn diff_for_commit(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<CommitPath>,

3131) -> Result<AppResponseData<Vec<ChangedPath>>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/diffs/get_diff.rs +3 −3 View lib/service/git/src/handler/diffs/get_diff.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44use serde::Deserialize;

@@ -51,13 +51,13 @@

5151)]

5252pub async fn get_diff(

5353 State(service): State<GitService>,

54 session: Session,

54 OptionalUser(viewer): OptionalUser,

5555 Path(path): Path<crate::handler::RepoPath>,

5656 Query(q): Query<GetDiffQuery>,

5757) -> Result<AppResponseData<serde_json::Value>, ApiError> {

5858 let (ctx, _) = handler::resolve_reader(

5959 &service,

60 &session,

60 viewer,

6161 path.space_name.clone(),

6262 path.repo_name.clone(),

6363 )

Modified lib/service/git/src/handler/diffs/range_diff.rs +3 −3 View lib/service/git/src/handler/diffs/range_diff.rs

@@ -1,5 +1,5 @@

11use crate::rpcgit::diff::types::RangeDiffSpec;

2use ::session::Session;

2use ::session::OptionalUser;

33use api::http::{Path, Query, State};

44use api::rest::AppResponseData;

55

@@ -27,7 +27,7 @@

2727)]

2828pub async fn range_diff(

2929 State(service): State<GitService>,

30 session: Session,

30 OptionalUser(viewer): OptionalUser,

3131 Path(path): Path<crate::handler::RepoPath>,

3232 Query(q): Query<RangeDiffQuery>,

3333) -> Result<AppResponseData<String>, ApiError> {

@@ -37,7 +37,7 @@

3737 };

3838 let (ctx, _) = handler::resolve_reader(

3939 &service,

40 &session,

40 viewer,

4141 path.space_name.clone(),

4242 path.repo_name.clone(),

4343 )

Modified lib/service/git/src/handler/diffs/raw.rs +3 −3 View lib/service/git/src/handler/diffs/raw.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -27,13 +27,13 @@

2727)]

2828pub async fn diff_raw(

2929 State(service): State<GitService>,

30 session: Session,

30 OptionalUser(viewer): OptionalUser,

3131 Path(path): Path<crate::handler::RepoPath>,

3232 Query(q): Query<DiffBaseHeadQuery>,

3333) -> Result<AppResponseData<String>, ApiError> {

3434 let (ctx, _) = handler::resolve_reader(

3535 &service,

36 &session,

36 viewer,

3737 path.space_name.clone(),

3838 path.repo_name.clone(),

3939 )

Modified lib/service/git/src/handler/hooks/execute_script.rs +3 −3 View lib/service/git/src/handler/hooks/execute_script.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -33,13 +33,13 @@

3333)]

3434pub async fn execute_script(

3535 State(service): State<GitService>,

36 session: Session,

36 AuthedUser(uid): AuthedUser,

3737 Path(path): Path<HookScriptPath>,

3838 Json(body): Json<HookExecBody>,

3939) -> Result<AppResponseData<ScriptOutputDto>, ApiError> {

4040 let (ctx, _) = handler::require_writer(

4141 &service,

42 &session,

42 uid,

4343 path.space_name.clone(),

4444 path.repo_name.clone(),

4545 )

Modified lib/service/git/src/handler/html/badge.rs +3 −3 View lib/service/git/src/handler/html/badge.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, archived_class, format_size, resolve, response_html};

55use crate::service::GitService;

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[utoipa::path(

99 get,

@@ -20,9 +20,9 @@

2020pub async fn render_badge(

2121 State(service): State<GitService>,

2222 Path(path): Path<HtmlRepoPath>,

23 session: Session,

23 OptionalUser(viewer): OptionalUser,

2424) -> Response {

25 let ctx = match resolve(service, path, session).await {

25 let ctx = match resolve(service, path, viewer).await {

2626 Ok(c) => c,

2727 Err(resp) => return resp,

2828 };

Modified lib/service/git/src/handler/html/blame.rs +3 −3 View lib/service/git/src/handler/html/blame.rs

@@ -8,7 +8,7 @@

88 HtmlRepoPath, archived_class, error, resolve_view, response_html, short_sha,

99};

1010use crate::service::GitService;

11use ::session::Session;

11use ::session::OptionalUser;

1212

1313#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

1414pub struct BlameQuery {

@@ -34,9 +34,9 @@

3434 State(service): State<GitService>,

3535 Path(path): Path<HtmlRepoPath>,

3636 Query(q): Query<BlameQuery>,

37 session: Session,

37 OptionalUser(viewer): OptionalUser,

3838) -> Response {

39 let view = match resolve_view(service.clone(), path, session, q.revision, q.path, true).await {

39 let view = match resolve_view(service.clone(), path, viewer, q.revision, q.path, true).await {

4040 Ok(v) => v,

4141 Err(resp) => return resp,

4242 };

Modified lib/service/git/src/handler/html/blob_content.rs +3 −3 View lib/service/git/src/handler/html/blob_content.rs

@@ -6,7 +6,7 @@

66 HtmlRepoPath, archived_class, error, format_size, resolve_view, response_html,

77};

88use crate::service::GitService;

9use ::session::Session;

9use ::session::OptionalUser;

1010

1111#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

1212pub struct BlobContentQuery {

@@ -32,9 +32,9 @@

3232 State(service): State<GitService>,

3333 Path(path): Path<HtmlRepoPath>,

3434 Query(q): Query<BlobContentQuery>,

35 session: Session,

35 OptionalUser(viewer): OptionalUser,

3636) -> Response {

37 let view = match resolve_view(service.clone(), path, session, q.revision, q.path, true).await {

37 let view = match resolve_view(service.clone(), path, viewer, q.revision, q.path, true).await {

3838 Ok(v) => v,

3939 Err(resp) => return resp,

4040 };

Modified lib/service/git/src/handler/html/blob_header.rs +3 −3 View lib/service/git/src/handler/html/blob_header.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, archived_class, resolve_view, response_html};

55use crate::service::GitService;

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

99pub struct BlobHeaderQuery {

@@ -29,9 +29,9 @@

2929 State(service): State<GitService>,

3030 Path(path): Path<HtmlRepoPath>,

3131 Query(q): Query<BlobHeaderQuery>,

32 session: Session,

32 OptionalUser(viewer): OptionalUser,

3333) -> Response {

34 let view = match resolve_view(service.clone(), path, session, q.revision, q.path, true).await {

34 let view = match resolve_view(service.clone(), path, viewer, q.revision, q.path, true).await {

3535 Ok(v) => v,

3636 Err(resp) => return resp,

3737 };

Modified lib/service/git/src/handler/html/blob_pages.rs +3 −3 View lib/service/git/src/handler/html/blob_pages.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, error, resolve_view};

55use crate::service::{GitService, pdf};

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

99pub struct BlobPagesQuery {

@@ -41,9 +41,9 @@

4141 State(service): State<GitService>,

4242 Path(path): Path<HtmlRepoPath>,

4343 Query(q): Query<BlobPagesQuery>,

44 session: Session,

44 OptionalUser(viewer): OptionalUser,

4545) -> Response {

46 let view = match resolve_view(service.clone(), path, session, q.revision, q.path, true).await {

46 let view = match resolve_view(service.clone(), path, viewer, q.revision, q.path, true).await {

4747 Ok(v) => v,

4848 Err(resp) => return resp,

4949 };

Modified lib/service/git/src/handler/html/breadcrumbs.rs +3 −3 View lib/service/git/src/handler/html/breadcrumbs.rs

@@ -4,7 +4,7 @@

44use crate::handler::html::{HtmlRepoPath, archived_class, error, resolve, response_html};

55use crate::service::GitService;

66use crate::share::validate;

7use ::session::Session;

7use ::session::OptionalUser;

88

99#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

1010pub struct BreadcrumbsQuery {

@@ -30,9 +30,9 @@

3030 State(service): State<GitService>,

3131 Path(path): Path<HtmlRepoPath>,

3232 Query(q): Query<BreadcrumbsQuery>,

33 session: Session,

33 OptionalUser(viewer): OptionalUser,

3434) -> Response {

35 let ctx = match resolve(service, path, session).await {

35 let ctx = match resolve(service, path, viewer).await {

3636 Ok(c) => c,

3737 Err(resp) => return resp,

3838 };

Modified lib/service/git/src/handler/html/clone_buttons.rs +3 −3 View lib/service/git/src/handler/html/clone_buttons.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, clone_https_url, clone_ssh_url, resolve, response_html};

55use crate::service::GitService;

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[utoipa::path(

99 get,

@@ -20,9 +20,9 @@

2020pub async fn render_clone_buttons(

2121 State(service): State<GitService>,

2222 Path(path): Path<HtmlRepoPath>,

23 session: Session,

23 OptionalUser(viewer): OptionalUser,

2424) -> Response {

25 let ctx = match resolve(service.clone(), path.clone(), session).await {

25 let ctx = match resolve(service.clone(), path.clone(), viewer).await {

2626 Ok(c) => c,

2727 Err(resp) => return resp,

2828 };

Modified lib/service/git/src/handler/html/commit_diff.rs +3 −3 View lib/service/git/src/handler/html/commit_diff.rs

@@ -6,7 +6,7 @@

66};

77use crate::service::GitService;

88use crate::service::diffs::ChangedPathDiffDto;

9use ::session::Session;

9use ::session::OptionalUser;

1010

1111const MAX_FILES: usize = 50;

1212const MAX_LINES_PER_FILE: usize = 2000;

@@ -35,9 +35,9 @@

3535 State(service): State<GitService>,

3636 Path(path): Path<HtmlRepoPath>,

3737 Query(q): Query<CommitDiffQuery>,

38 session: Session,

38 OptionalUser(viewer): OptionalUser,

3939) -> Response {

40 let ctx = match resolve(service.clone(), path, session).await {

40 let ctx = match resolve(service.clone(), path, viewer).await {

4141 Ok(c) => c,

4242 Err(resp) => return resp,

4343 };

Modified lib/service/git/src/handler/html/commits.rs +3 −3 View lib/service/git/src/handler/html/commits.rs

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

99};

1010use crate::service::GitService;

1111use crate::service::commits::ListCommitsCmd;

12use ::session::Session;

12use ::session::OptionalUser;

1313

1414#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

1515pub struct CommitsQuery {

@@ -39,9 +39,9 @@

3939 State(service): State<GitService>,

4040 Path(path): Path<HtmlRepoPath>,

4141 Query(q): Query<CommitsQuery>,

42 session: Session,

42 OptionalUser(viewer): OptionalUser,

4343) -> Response {

44 let view = match resolve_view(service.clone(), path, session, q.revision, q.path, false).await {

44 let view = match resolve_view(service.clone(), path, viewer, q.revision, q.path, false).await {

4545 Ok(v) => v,

4646 Err(resp) => return resp,

4747 };

Modified lib/service/git/src/handler/html/header.rs +3 −3 View lib/service/git/src/handler/html/header.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, archived_class, resolve, response_html};

55use crate::service::GitService;

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[utoipa::path(

99 get,

@@ -20,9 +20,9 @@

2020pub async fn render_header(

2121 State(service): State<GitService>,

2222 Path(path): Path<HtmlRepoPath>,

23 session: Session,

23 OptionalUser(viewer): OptionalUser,

2424) -> Response {

25 let ctx = match resolve(service, path, session).await {

25 let ctx = match resolve(service, path, viewer).await {

2626 Ok(c) => c,

2727 Err(resp) => return resp,

2828 };

Modified lib/service/git/src/handler/html/languages.rs +3 −3 View lib/service/git/src/handler/html/languages.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, archived_class, resolve, response_html};

55use crate::service::GitService;

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[utoipa::path(

99 get,

@@ -20,9 +20,9 @@

2020pub async fn render_languages(

2121 State(service): State<GitService>,

2222 Path(path): Path<HtmlRepoPath>,

23 session: Session,

23 OptionalUser(viewer): OptionalUser,

2424) -> Response {

25 let ctx = match resolve(service.clone(), path, session).await {

25 let ctx = match resolve(service.clone(), path, viewer).await {

2626 Ok(c) => c,

2727 Err(resp) => return resp,

2828 };

Modified lib/service/git/src/handler/html/last_commit.rs +3 −3 View lib/service/git/src/handler/html/last_commit.rs

@@ -7,7 +7,7 @@

77};

88use crate::service::GitService;

99use crate::share::validate;

10use ::session::Session;

10use ::session::OptionalUser;

1111

1212#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

1313pub struct LastCommitQuery {

@@ -33,9 +33,9 @@

3333 State(service): State<GitService>,

3434 Path(path): Path<HtmlRepoPath>,

3535 Query(q): Query<LastCommitQuery>,

36 session: Session,

36 OptionalUser(viewer): OptionalUser,

3737) -> Response {

38 let ctx = match resolve(service.clone(), path.clone(), session).await {

38 let ctx = match resolve(service.clone(), path.clone(), viewer).await {

3939 Ok(c) => c,

4040 Err(resp) => return resp,

4141 };

Modified lib/service/git/src/handler/html/mod.rs +4 −4 View lib/service/git/src/handler/html/mod.rs

@@ -144,7 +144,7 @@

144144pub async fn resolve(

145145 service: GitService,

146146 path: HtmlRepoPath,

147 session: ::session::Session,

147 viewer: Option<i64>,

148148) -> Result<HtmlCtx, Response> {

149149 if path.space_name.chars().count() > MAX_NAME_LEN

150150 || path.repo_name.chars().count() > MAX_NAME_LEN

@@ -162,7 +162,7 @@

162162 return Err(html_err(500, "internal"));

163163 }

164164 };

165 let uid = match ensure_read_access(&service, &session, &ctx).await {

165 let uid = match ensure_read_access(&service, viewer, &ctx).await {

166166 Ok(uid) => uid,

167167 Err(error) => return Err(html_err(error_status(&error), "")),

168168 };

@@ -195,12 +195,12 @@

195195pub async fn resolve_view(

196196 service: GitService,

197197 path: HtmlRepoPath,

198 session: ::session::Session,

198 viewer: Option<i64>,

199199 revision: Option<String>,

200200 raw_path: Option<String>,

201201 require_path: bool,

202202) -> Result<HtmlView, Response> {

203 let ctx = resolve(service, path, session).await?;

203 let ctx = resolve(service, path, viewer).await?;

204204 let revision = revision

205205 .as_deref()

206206 .unwrap_or(ctx.dto.default_branch.as_str())

Modified lib/service/git/src/handler/html/quickstart.rs +3 −3 View lib/service/git/src/handler/html/quickstart.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, clone_https_url, clone_ssh_url, resolve, response_html};

55use crate::service::GitService;

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[utoipa::path(

99 get,

@@ -20,9 +20,9 @@

2020pub async fn render_quickstart(

2121 State(service): State<GitService>,

2222 Path(path): Path<HtmlRepoPath>,

23 session: Session,

23 OptionalUser(viewer): OptionalUser,

2424) -> Response {

25 let ctx = match resolve(service.clone(), path.clone(), session).await {

25 let ctx = match resolve(service.clone(), path.clone(), viewer).await {

2626 Ok(c) => c,

2727 Err(resp) => return resp,

2828 };

Modified lib/service/git/src/handler/html/readme.rs +3 −3 View lib/service/git/src/handler/html/readme.rs

@@ -6,7 +6,7 @@

66 HtmlRepoPath, archived_class, error, format_size, resolve_view, response_html,

77};

88use crate::service::GitService;

9use ::session::Session;

9use ::session::OptionalUser;

1010

1111const README_CANDIDATES: &[&str] = &[

1212 "README.md",

@@ -45,9 +45,9 @@

4545 State(service): State<GitService>,

4646 Path(path): Path<HtmlRepoPath>,

4747 Query(q): Query<ReadmeQuery>,

48 session: Session,

48 OptionalUser(viewer): OptionalUser,

4949) -> Response {

50 let view = match resolve_view(service.clone(), path, session, q.revision, q.path, false).await {

50 let view = match resolve_view(service.clone(), path, viewer, q.revision, q.path, false).await {

5151 Ok(v) => v,

5252 Err(resp) => return resp,

5353 };

Modified lib/service/git/src/handler/html/refs_dropdown.rs +3 −3 View lib/service/git/src/handler/html/refs_dropdown.rs

@@ -4,7 +4,7 @@

44use crate::handler::html::{HtmlRepoPath, archived_class, resolve, response_html};

55use crate::service::GitService;

66use crate::share::validate;

7use ::session::Session;

7use ::session::OptionalUser;

88

99#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

1010pub struct RefsDropdownQuery {

@@ -28,9 +28,9 @@

2828 State(service): State<GitService>,

2929 Path(path): Path<HtmlRepoPath>,

3030 Query(q): Query<RefsDropdownQuery>,

31 session: Session,

31 OptionalUser(viewer): OptionalUser,

3232) -> Response {

33 let ctx = match resolve(service.clone(), path, session).await {

33 let ctx = match resolve(service.clone(), path, viewer).await {

3434 Ok(c) => c,

3535 Err(resp) => return resp,

3636 };

Modified lib/service/git/src/handler/html/refs_summary.rs +3 −3 View lib/service/git/src/handler/html/refs_summary.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, archived_class, resolve, response_html};

55use crate::service::GitService;

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[utoipa::path(

99 get,

@@ -20,9 +20,9 @@

2020pub async fn render_refs_summary(

2121 State(service): State<GitService>,

2222 Path(path): Path<HtmlRepoPath>,

23 session: Session,

23 OptionalUser(viewer): OptionalUser,

2424) -> Response {

25 let ctx = match resolve(service, path, session).await {

25 let ctx = match resolve(service, path, viewer).await {

2626 Ok(c) => c,

2727 Err(resp) => return resp,

2828 };

Modified lib/service/git/src/handler/html/star_button.rs +3 −3 View lib/service/git/src/handler/html/star_button.rs

@@ -3,7 +3,7 @@

33

44use crate::handler::html::{HtmlRepoPath, archived_class, resolve, response_html};

55use crate::service::GitService;

6use ::session::Session;

6use ::session::OptionalUser;

77

88#[utoipa::path(

99 get,

@@ -20,9 +20,9 @@

2020pub async fn render_star_button(

2121 State(service): State<GitService>,

2222 Path(path): Path<HtmlRepoPath>,

23 session: Session,

23 OptionalUser(viewer): OptionalUser,

2424) -> Response {

25 let ctx = match resolve(service.clone(), path, session).await {

25 let ctx = match resolve(service.clone(), path, viewer).await {

2626 Ok(c) => c,

2727 Err(resp) => return resp,

2828 };

Modified lib/service/git/src/handler/html/tree.rs +3 −3 View lib/service/git/src/handler/html/tree.rs

@@ -8,7 +8,7 @@

88 resolve_view, response_html, short_sha,

99};

1010use crate::service::GitService;

11use ::session::Session;

11use ::session::OptionalUser;

1212

1313#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

1414pub struct TreeQuery {

@@ -36,9 +36,9 @@

3636 State(service): State<GitService>,

3737 Path(path): Path<HtmlRepoPath>,

3838 Query(q): Query<TreeQuery>,

39 session: Session,

39 OptionalUser(viewer): OptionalUser,

4040) -> Response {

41 let view = match resolve_view(service.clone(), path, session, q.revision, q.path, false).await {

41 let view = match resolve_view(service.clone(), path, viewer, q.revision, q.path, false).await {

4242 Ok(v) => v,

4343 Err(resp) => return resp,

4444 };

Modified lib/service/git/src/handler/html/tree_row.rs +3 −3 View lib/service/git/src/handler/html/tree_row.rs

@@ -7,7 +7,7 @@

77 short_sha,

88};

99use crate::service::GitService;

10use ::session::Session;

10use ::session::OptionalUser;

1111

1212#[derive(Debug, Clone, serde::Deserialize, utoipa::IntoParams)]

1313pub struct TreeRowQuery {

@@ -35,9 +35,9 @@

3535 State(service): State<GitService>,

3636 Path(path): Path<HtmlRepoPath>,

3737 Query(q): Query<TreeRowQuery>,

38 session: Session,

38 OptionalUser(viewer): OptionalUser,

3939) -> Response {

40 let view = match resolve_view(service.clone(), path, session, q.revision, q.path, false).await {

40 let view = match resolve_view(service.clone(), path, viewer, q.revision, q.path, false).await {

4141 Ok(v) => v,

4242 Err(resp) => return resp,

4343 };

Modified lib/service/git/src/handler/html/watch_button.rs +3 −3 View lib/service/git/src/handler/html/watch_button.rs

@@ -4,7 +4,7 @@

44

55use crate::handler::html::{HtmlRepoPath, archived_class, resolve, response_html};

66use crate::service::GitService;

7use ::session::Session;

7use ::session::OptionalUser;

88

99#[utoipa::path(

1010 get,

@@ -21,9 +21,9 @@

2121pub async fn render_watch_button(

2222 State(service): State<GitService>,

2323 Path(path): Path<HtmlRepoPath>,

24 session: Session,

24 OptionalUser(viewer): OptionalUser,

2525) -> Response {

26 let ctx = match resolve(service.clone(), path, session).await {

26 let ctx = match resolve(service.clone(), path, viewer).await {

2727 Ok(c) => c,

2828 Err(resp) => return resp,

2929 };

Modified lib/service/git/src/handler/lfs/cleanup_unreferenced.rs +3 −3 View lib/service/git/src/handler/lfs/cleanup_unreferenced.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -23,12 +23,12 @@

2323)]

2424pub async fn cleanup_unreferenced(

2525 State(service): State<GitService>,

26 session: Session,

26 AuthedUser(uid): AuthedUser,

2727 Path(path): Path<RepoPath>,

2828) -> Result<AppResponseData<LfsCleanupResponse>, ApiError> {

2929 let (ctx, _) = require_writer(

3030 &service,

31 &session,

31 uid,

3232 path.space_name.clone(),

3333 path.repo_name.clone(),

3434 )

Modified lib/service/git/src/handler/lfs/list_locks.rs +3 −3 View lib/service/git/src/handler/lfs/list_locks.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -27,13 +27,13 @@

2727)]

2828pub async fn list_locks(

2929 State(service): State<GitService>,

30 session: Session,

30 OptionalUser(viewer): OptionalUser,

3131 Path(path): Path<RepoPath>,

3232 Query(query): Query<LfsListLocksQuery>,

3333) -> Result<AppResponseData<LfsLockListResponse>, ApiError> {

3434 let (ctx, _) = resolve_reader(

3535 &service,

36 &session,

36 viewer,

3737 path.space_name.clone(),

3838 path.repo_name.clone(),

3939 )

Modified lib/service/git/src/handler/lfs/lock.rs +3 −3 View lib/service/git/src/handler/lfs/lock.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -27,13 +27,13 @@

2727)]

2828pub async fn lock(

2929 State(service): State<GitService>,

30 session: Session,

30 AuthedUser(uid): AuthedUser,

3131 Path(path): Path<RepoPath>,

3232 Json(body): Json<LfsLockBody>,

3333) -> Result<AppResponseData<LfsLock>, ApiError> {

3434 let (ctx, uid) = require_writer(

3535 &service,

36 &session,

36 uid,

3737 path.space_name.clone(),

3838 path.repo_name.clone(),

3939 )

Modified lib/service/git/src/handler/lfs/mod.rs +3 −5 View lib/service/git/src/handler/lfs/mod.rs

@@ -1,5 +1,3 @@

1use ::session::Session;

2

31use crate::errors::ApiError;

42use crate::handler::{require_repo_admin, require_writer};

53use crate::service::GitService;

@@ -13,14 +11,14 @@

1311

1412pub(crate) async fn unlock_actor(

1513 service: &GitService,

16 session: &Session,

14 uid: i64,

1715 space_name: String,

1816 repo_name: String,

1917 force: bool,

2018) -> Result<(crate::context::facade::GitContext, i64), ApiError> {

2119 if force {

22 require_repo_admin(service, session, space_name, repo_name).await

20 require_repo_admin(service, uid, space_name, repo_name).await

2321 } else {

24 require_writer(service, session, space_name, repo_name).await

22 require_writer(service, uid, space_name, repo_name).await

2523 }

2624}

Modified lib/service/git/src/handler/lfs/unlock.rs +3 −3 View lib/service/git/src/handler/lfs/unlock.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -25,14 +25,14 @@

2525)]

2626pub async fn unlock(

2727 State(service): State<GitService>,

28 session: Session,

28 AuthedUser(uid): AuthedUser,

2929 Path(path): Path<RepoPath>,

3030 Query(q): Query<LfsUnlockPathQuery>,

3131) -> Result<AppResponseData<NoData>, ApiError> {

3232 let force = q.force.unwrap_or(false);

3333 let (ctx, uid) = lfs::unlock_actor(

3434 &service,

35 &session,

35 uid,

3636 path.space_name.clone(),

3737 path.repo_name.clone(),

3838 force,

Modified lib/service/git/src/handler/lfs/unlock_by_id.rs +3 −3 View lib/service/git/src/handler/lfs/unlock_by_id.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -31,14 +31,14 @@

3131)]

3232pub async fn unlock_by_id(

3333 State(service): State<GitService>,

34 session: Session,

34 AuthedUser(uid): AuthedUser,

3535 Path(path): Path<LfsLockIdPath>,

3636 Query(q): Query<LfsUnlockQuery>,

3737) -> Result<AppResponseData<NoData>, ApiError> {

3838 let force = q.force.unwrap_or(false);

3939 let (ctx, uid) = lfs::unlock_actor(

4040 &service,

41 &session,

41 uid,

4242 path.space_name.clone(),

4343 path.repo_name.clone(),

4444 force,

Modified lib/service/git/src/handler/lfs/verify_locks.rs +3 −3 View lib/service/git/src/handler/lfs/verify_locks.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -25,13 +25,13 @@

2525)]

2626pub async fn verify_locks(

2727 State(service): State<GitService>,

28 session: Session,

28 AuthedUser(uid): AuthedUser,

2929 Path(path): Path<RepoPath>,

3030 Query(query): Query<LfsVerifyLocksQuery>,

3131) -> Result<AppResponseData<LfsVerifyLocksResponse>, ApiError> {

3232 let (ctx, uid) = require_writer(

3333 &service,

34 &session,

34 uid,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/maintenance/fsck.rs +3 −3 View lib/service/git/src/handler/maintenance/fsck.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn fsck(

2121 State(service): State<GitService>,

22 session: Session,

22 AuthedUser(uid): AuthedUser,

2323 Path(path): Path<RepoPath>,

2424) -> Result<AppResponseData<FsckDto>, ApiError> {

2525 let (ctx, _) = require_writer(

2626 &service,

27 &session,

27 uid,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/maintenance/prune.rs +3 −3 View lib/service/git/src/handler/maintenance/prune.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn prune(

2121 State(service): State<GitService>,

22 session: Session,

22 AuthedUser(uid): AuthedUser,

2323 Path(path): Path<RepoPath>,

2424) -> Result<AppResponseData<PruneResultDto>, ApiError> {

2525 let (ctx, _) = require_writer(

2626 &service,

27 &session,

27 uid,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/packs/ingest.rs +3 −3 View lib/service/git/src/handler/packs/ingest.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Bytes, Path, State};

33use api::rest::AppResponseData;

44

@@ -20,13 +20,13 @@

2020)]

2121pub async fn ingest(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<RepoPath>,

2525 body: Bytes,

2626) -> Result<AppResponseData<IngestPackDto>, ApiError> {

2727 let (ctx, _) = require_writer(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

Modified lib/service/git/src/handler/packs/repack.rs +3 −3 View lib/service/git/src/handler/packs/repack.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -18,12 +18,12 @@

1818)]

1919pub async fn repack(

2020 State(service): State<GitService>,

21 session: Session,

21 AuthedUser(uid): AuthedUser,

2222 Path(path): Path<RepoPath>,

2323) -> Result<AppResponseData<NoData>, ApiError> {

2424 let (ctx, _) = require_writer(

2525 &service,

26 &session,

26 uid,

2727 path.space_name.clone(),

2828 path.repo_name.clone(),

2929 )

Modified lib/service/git/src/handler/packs/stats.rs +3 −3 View lib/service/git/src/handler/packs/stats.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn stats(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<RepoPath>,

2424) -> Result<AppResponseData<PackStatsDto>, ApiError> {

2525 let (ctx, _) = resolve_reader(

2626 &service,

27 &session,

27 viewer,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/patches/apply.rs +3 −3 View lib/service/git/src/handler/patches/apply.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -26,13 +26,13 @@

2626)]

2727pub async fn patch_apply(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<crate::handler::RepoPath>,

3131 Json(body): Json<PatchApplyBody>,

3232) -> Result<AppResponseData<AppliedPatchDto>, ApiError> {

3333 let (ctx, _) = handler::resolve_reader(

3434 &service,

35 &session,

35 viewer,

3636 path.space_name.clone(),

3737 path.repo_name.clone(),

3838 )

Modified lib/service/git/src/handler/patches/generate.rs +3 −3 View lib/service/git/src/handler/patches/generate.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -25,13 +25,13 @@

2525)]

2626pub async fn patch_generate(

2727 State(service): State<GitService>,

28 session: Session,

28 OptionalUser(viewer): OptionalUser,

2929 Path(path): Path<crate::handler::RepoPath>,

3030 Query(q): Query<PatchGenerateQuery>,

3131) -> Result<AppResponseData<PatchDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/patches/parse.rs +2 −4 View lib/service/git/src/handler/patches/parse.rs

@@ -1,9 +1,8 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, State};

33use api::rest::AppResponseData;

44

55use crate::errors::{ApiError, GitApiError};

6use crate::handler;

76use crate::service::GitService;

87use crate::service::patches::ParsedPatchDto;

98

@@ -19,10 +18,9 @@

1918)]

2019pub async fn patch_parse(

2120 State(service): State<GitService>,

22 session: Session,

21 AuthedUser(_uid): AuthedUser,

2322 Json(content): Json<String>,

2423) -> Result<AppResponseData<ParsedPatchDto>, ApiError> {

25 handler::ensure_caller(&session)?;

2624 let out = service

2725 .patch_parse(content)

2826 .await

Modified lib/service/git/src/handler/refs/branches.rs +3 −3 View lib/service/git/src/handler/refs/branches.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -19,13 +19,13 @@

1919)]

2020pub async fn refs_branches(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424 Query(query): Query<api::pagination::PageQuery>,

2525) -> Result<AppResponseData<api::pagination::Page<BranchInfoDto>>, ApiError> {

2626 let (ctx, _) = handler::resolve_reader(

2727 &service,

28 &session,

28 viewer,

2929 path.space_name.clone(),

3030 path.repo_name.clone(),

3131 )

Modified lib/service/git/src/handler/refs/delete.rs +3 −3 View lib/service/git/src/handler/refs/delete.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -25,12 +25,12 @@

2525)]

2626pub async fn refs_delete(

2727 State(service): State<GitService>,

28 session: Session,

28 AuthedUser(uid): AuthedUser,

2929 Path(path): Path<RefPath>,

3030) -> Result<AppResponseData<NoData>, ApiError> {

3131 let (ctx, _) = handler::require_writer(

3232 &service,

33 &session,

33 uid,

3434 path.space_name.clone(),

3535 path.repo_name.clone(),

3636 )

Modified lib/service/git/src/handler/refs/filtered.rs +3 −3 View lib/service/git/src/handler/refs/filtered.rs

@@ -1,5 +1,5 @@

11use crate::rpcgit::refs::types::RefInfo;

2use ::session::Session;

2use ::session::OptionalUser;

33use api::http::{Path, Query, State};

44use api::rest::AppResponseData;

55

@@ -24,13 +24,13 @@

2424)]

2525pub async fn refs_list_filtered(

2626 State(service): State<GitService>,

27 session: Session,

27 OptionalUser(viewer): OptionalUser,

2828 Path(path): Path<crate::handler::RepoPath>,

2929 Query(query): Query<RefsFilteredQuery>,

3030) -> Result<AppResponseData<Vec<RefInfo>>, ApiError> {

3131 let (ctx, _) = handler::resolve_reader(

3232 &service,

33 &session,

33 viewer,

3434 path.space_name.clone(),

3535 path.repo_name.clone(),

3636 )

Modified lib/service/git/src/handler/refs/get.rs +3 −3 View lib/service/git/src/handler/refs/get.rs

@@ -1,5 +1,5 @@

11use crate::rpcgit::refs::types::RefInfo;

2use ::session::Session;

2use ::session::OptionalUser;

33use api::http::{Path, State};

44use api::rest::AppResponseData;

55

@@ -26,12 +26,12 @@

2626)]

2727pub async fn refs_get(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<RefPath>,

3131) -> Result<AppResponseData<RefInfo>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/refs/head.rs +3 −3 View lib/service/git/src/handler/refs/head.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn refs_head(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424) -> Result<AppResponseData<HeadInfoDto>, ApiError> {

2525 let (ctx, _) = handler::resolve_reader(

2626 &service,

27 &session,

27 viewer,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/refs/is_object_in_ref.rs +3 −3 View lib/service/git/src/handler/refs/is_object_in_ref.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44use serde::Serialize;

@@ -30,13 +30,13 @@

3030)]

3131pub async fn refs_is_object_in_ref(

3232 State(service): State<GitService>,

33 session: Session,

33 OptionalUser(viewer): OptionalUser,

3434 Path(path): Path<crate::handler::RepoPath>,

3535 Query(query): Query<ContainsQuery>,

3636) -> Result<AppResponseData<IsObjectInRefResponse>, ApiError> {

3737 let (ctx, _) = handler::resolve_reader(

3838 &service,

39 &session,

39 viewer,

4040 path.space_name.clone(),

4141 path.repo_name.clone(),

4242 )

Modified lib/service/git/src/handler/refs/list.rs +3 −3 View lib/service/git/src/handler/refs/list.rs

@@ -1,5 +1,5 @@

11use crate::rpcgit::refs::types::RefInfo;

2use ::session::Session;

2use ::session::OptionalUser;

33use api::http::{Path, State};

44use api::rest::AppResponseData;

55

@@ -19,12 +19,12 @@

1919)]

2020pub async fn refs_list(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424) -> Result<AppResponseData<Vec<RefInfo>>, ApiError> {

2525 let (ctx, _) = handler::resolve_reader(

2626 &service,

27 &session,

27 viewer,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/refs/resolve.rs +3 −3 View lib/service/git/src/handler/refs/resolve.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -25,12 +25,12 @@

2525)]

2626pub async fn refs_resolve(

2727 State(service): State<GitService>,

28 session: Session,

28 OptionalUser(viewer): OptionalUser,

2929 Path(path): Path<RefPath>,

3030) -> Result<AppResponseData<String>, ApiError> {

3131 let (ctx, _) = handler::resolve_reader(

3232 &service,

33 &session,

33 viewer,

3434 path.space_name.clone(),

3535 path.repo_name.clone(),

3636 )

Modified lib/service/git/src/handler/refs/update.rs +3 −3 View lib/service/git/src/handler/refs/update.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44use serde::{Deserialize, Serialize};

@@ -34,13 +34,13 @@

3434)]

3535pub async fn refs_update(

3636 State(service): State<GitService>,

37 session: Session,

37 AuthedUser(uid): AuthedUser,

3838 Path(path): Path<RefPath>,

3939 Json(body): Json<RefUpdateBody>,

4040) -> Result<AppResponseData<UpdateRefResultDto>, ApiError> {

4141 let (ctx, _) = handler::require_writer(

4242 &service,

43 &session,

43 uid,

4444 path.space_name.clone(),

4545 path.repo_name.clone(),

4646 )

Modified lib/service/git/src/handler/releases/create_release.rs +3 −3 View lib/service/git/src/handler/releases/create_release.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -20,13 +20,13 @@

2020)]

2121pub async fn create_release(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<crate::handler::RepoPath>,

2525 Json(cmd): Json<CreateReleaseCmd>,

2626) -> Result<AppResponseData<ReleaseDto>, ApiError> {

2727 let (ctx, uid) = handler::require_writer(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

Modified lib/service/git/src/handler/releases/delete_release.rs +4 −4 View lib/service/git/src/handler/releases/delete_release.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -18,19 +18,19 @@

1818)]

1919pub async fn delete_release(

2020 State(service): State<GitService>,

21 session: Session,

21 AuthedUser(uid): AuthedUser,

2222 Path(path): Path<crate::handler::releases::get_release::ReleasePath>,

2323) -> Result<AppResponseData<NoData>, ApiError> {

2424 let (ctx, uid) = require_writer(

2525 &service,

26 &session,

26 uid,

2727 path.space_name.clone(),

2828 path.repo_name.clone(),

2929 )

3030 .await?;

3131 let admin = require_repo_admin(

3232 &service,

33 &session,

33 uid,

3434 path.space_name.clone(),

3535 path.repo_name.clone(),

3636 )

Modified lib/service/git/src/handler/releases/get_release.rs +3 −3 View lib/service/git/src/handler/releases/get_release.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -26,12 +26,12 @@

2626)]

2727pub async fn get_release(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<ReleasePath>,

3131) -> Result<AppResponseData<ReleaseDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/releases/list_releases.rs +3 −3 View lib/service/git/src/handler/releases/list_releases.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -19,13 +19,13 @@

1919)]

2020pub async fn list_releases(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424 Query(query): Query<ListReleasesQuery>,

2525) -> Result<AppResponseData<ReleasePage>, ApiError> {

2626 let (ctx, _) = handler::resolve_reader(

2727 &service,

28 &session,

28 viewer,

2929 path.space_name.clone(),

3030 path.repo_name.clone(),

3131 )

Modified lib/service/git/src/handler/releases/update_release.rs +4 −4 View lib/service/git/src/handler/releases/update_release.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -20,20 +20,20 @@

2020)]

2121pub async fn update_release(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<crate::handler::releases::get_release::ReleasePath>,

2525 Json(cmd): Json<UpdateReleaseCmd>,

2626) -> Result<AppResponseData<ReleaseDto>, ApiError> {

2727 let (ctx, uid) = require_writer(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

3333 .await?;

3434 let admin = require_repo_admin(

3535 &service,

36 &session,

36 uid,

3737 path.space_name.clone(),

3838 path.repo_name.clone(),

3939 )

Modified lib/service/git/src/handler/remotes/add.rs +3 −3 View lib/service/git/src/handler/remotes/add.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -31,13 +31,13 @@

3131)]

3232pub async fn upsert_remote(

3333 State(service): State<GitService>,

34 session: Session,

34 AuthedUser(uid): AuthedUser,

3535 Path(path): Path<RemotePath>,

3636 Json(body): Json<RemoteAddBody>,

3737) -> Result<AppResponseData<NoData>, ApiError> {

3838 let (ctx, _) = handler::require_writer(

3939 &service,

40 &session,

40 uid,

4141 path.space_name.clone(),

4242 path.repo_name.clone(),

4343 )

Modified lib/service/git/src/handler/remotes/clone_import.rs +3 −3 View lib/service/git/src/handler/remotes/clone_import.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -27,13 +27,13 @@

2727)]

2828pub async fn clone_import(

2929 State(service): State<GitService>,

30 session: Session,

30 AuthedUser(uid): AuthedUser,

3131 Path(path): Path<RepoPath>,

3232 Json(body): Json<RemoteImportBody>,

3333) -> Result<AppResponseData<ImportResultDto>, ApiError> {

3434 let (ctx, _) = require_writer(

3535 &service,

36 &session,

36 uid,

3737 path.space_name.clone(),

3838 path.repo_name.clone(),

3939 )

Modified lib/service/git/src/handler/remotes/fetch.rs +3 −3 View lib/service/git/src/handler/remotes/fetch.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -28,13 +28,13 @@

2828)]

2929pub async fn fetch(

3030 State(service): State<GitService>,

31 session: Session,

31 AuthedUser(uid): AuthedUser,

3232 Path(path): Path<RepoPath>,

3333 Json(body): Json<RemoteFetchBody>,

3434) -> Result<AppResponseData<FetchResultDto>, ApiError> {

3535 let (ctx, _) = require_writer(

3636 &service,

37 &session,

37 uid,

3838 path.space_name.clone(),

3939 path.repo_name.clone(),

4040 )

Modified lib/service/git/src/handler/remotes/list.rs +3 −3 View lib/service/git/src/handler/remotes/list.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,14 +19,14 @@

1919)]

2020pub async fn list_remotes(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<RepoPath>,

2424) -> Result<AppResponseData<Vec<RemoteDto>>, ApiError> {

2525 let ctx = service

2626 .context(path.space_name.clone(), path.repo_name.clone())

2727 .await

2828 .map_err(GitApiError::from)?;

29 ensure_read_access(&service, &session, &ctx).await?;

29 ensure_read_access(&service, viewer, &ctx).await?;

3030 let rows = service.remote_list(&ctx).await.map_err(GitApiError::from)?;

3131 Ok(AppResponseData::ok(rows))

3232}

Modified lib/service/git/src/handler/remotes/push.rs +3 −3 View lib/service/git/src/handler/remotes/push.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -29,13 +29,13 @@

2929)]

3030pub async fn push(

3131 State(service): State<GitService>,

32 session: Session,

32 AuthedUser(uid): AuthedUser,

3333 Path(path): Path<RepoPath>,

3434 Json(body): Json<RemotePushBody>,

3535) -> Result<AppResponseData<PushResultDto>, ApiError> {

3636 let (ctx, _) = require_writer(

3737 &service,

38 &session,

38 uid,

3939 path.space_name.clone(),

4040 path.repo_name.clone(),

4141 )

Modified lib/service/git/src/handler/remotes/remove.rs +3 −3 View lib/service/git/src/handler/remotes/remove.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -25,12 +25,12 @@

2525)]

2626pub async fn remove(

2727 State(service): State<GitService>,

28 session: Session,

28 AuthedUser(uid): AuthedUser,

2929 Path(path): Path<RemotePath>,

3030) -> Result<AppResponseData<NoData>, ApiError> {

3131 let (ctx, _) = handler::require_writer(

3232 &service,

33 &session,

33 uid,

3434 path.space_name.clone(),

3535 path.repo_name.clone(),

3636 )

Modified lib/service/git/src/handler/repos/archive.rs +6 −6 View lib/service/git/src/handler/repos/archive.rs

@@ -1,9 +1,9 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

55use crate::errors::{ApiError, GitApiError};

6use crate::handler::{RepoPath, ensure_caller};

6use crate::handler::RepoPath;

77use crate::service::GitService;

88use crate::service::repos::RepoDto;

99

@@ -19,10 +19,10 @@

1919)]

2020pub async fn archive_repo(

2121 State(service): State<GitService>,

22 session: Session,

22 AuthedUser(uid): AuthedUser,

2323 Path(path): Path<RepoPath>,

2424) -> Result<AppResponseData<RepoDto>, ApiError> {

25 let caller = ensure_caller(&session)?;

25 let caller = uid;

2626 let ctx = service

2727 .context(path.space_name, path.repo_name)

2828 .await

@@ -46,10 +46,10 @@

4646)]

4747pub async fn unarchive_repo(

4848 State(service): State<GitService>,

49 session: Session,

49 AuthedUser(uid): AuthedUser,

5050 Path(path): Path<RepoPath>,

5151) -> Result<AppResponseData<RepoDto>, ApiError> {

52 let caller = ensure_caller(&session)?;

52 let caller = uid;

5353 let ctx = service

5454 .context(path.space_name, path.repo_name)

5555 .await

Modified lib/service/git/src/handler/repos/create.rs +3 −4 View lib/service/git/src/handler/repos/create.rs

@@ -1,9 +1,8 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

55use crate::errors::{ApiError, GitApiError};

6use crate::handler;

76use crate::service::GitService;

87use crate::service::repos::{CreateRepoCmd, RepoDto};

98

@@ -25,11 +24,11 @@

2524)]

2625pub async fn create_repo(

2726 State(service): State<GitService>,

28 session: Session,

27 AuthedUser(uid): AuthedUser,

2928 Path(path): Path<SpacePath>,

3029 Json(cmd): Json<CreateRepoCmd>,

3130) -> Result<AppResponseData<RepoDto>, ApiError> {

32 let caller: i64 = handler::ensure_caller(&session)?;

31 let caller: i64 = uid;

3332 let out = service

3433 .create_repo(path.space_name, caller, cmd)

3534 .await

Modified lib/service/git/src/handler/repos/get.rs +3 −3 View lib/service/git/src/handler/repos/get.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -19,12 +19,12 @@

1919)]

2020pub async fn get_repo(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<RepoPath>,

2424) -> Result<AppResponseData<RepoDto>, ApiError> {

2525 let (ctx, viewer) = resolve_reader(

2626 &service,

27 &session,

27 viewer,

2828 path.space_name.clone(),

2929 path.repo_name.clone(),

3030 )

Modified lib/service/git/src/handler/repos/list.rs +3 −3 View lib/service/git/src/handler/repos/list.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -23,11 +23,11 @@

2323)]

2424pub async fn list_repos(

2525 State(service): State<GitService>,

26 session: Session,

26 OptionalUser(viewer): OptionalUser,

2727 Path(path): Path<SpacePath>,

2828 Query(page): Query<RepoListQuery>,

2929) -> Result<AppResponseData<api::pagination::Page<RepoSummaryDto>>, ApiError> {

30 let caller = session.uid();

30 let caller = viewer;

3131 let out = service

3232 .list_repos(path.space_name, caller, page)

3333 .await

Modified lib/service/git/src/handler/repos/update.rs +4 −4 View lib/service/git/src/handler/repos/update.rs

@@ -1,9 +1,9 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

55use crate::errors::{ApiError, GitApiError};

6use crate::handler::{RepoPath, ensure_caller};

6use crate::handler::RepoPath;

77use crate::service::GitService;

88use crate::service::repos::{RepoDto, UpdateRepoCmd};

99

@@ -20,11 +20,11 @@

2020)]

2121pub async fn update_repo(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<RepoPath>,

2525 Json(cmd): Json<UpdateRepoCmd>,

2626) -> Result<AppResponseData<RepoDto>, ApiError> {

27 let caller = ensure_caller(&session)?;

27 let caller = uid;

2828 let ctx = service

2929 .context(path.space_name, path.repo_name)

3030 .await

Modified lib/service/git/src/handler/signatures/verify_commit.rs +3 −3 View lib/service/git/src/handler/signatures/verify_commit.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -26,12 +26,12 @@

2626)]

2727pub async fn verify_commit(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<CommitShaPath>,

3131) -> Result<AppResponseData<VerifyResultDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/signatures/verify_tag.rs +3 −3 View lib/service/git/src/handler/signatures/verify_tag.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -26,12 +26,12 @@

2626)]

2727pub async fn verify_tag(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<TagNamePath>,

3131) -> Result<AppResponseData<VerifyResultDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/submodules/list.rs +3 −3 View lib/service/git/src/handler/submodules/list.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -27,13 +27,13 @@

2727)]

2828pub async fn submodule_list(

2929 State(service): State<GitService>,

30 session: Session,

30 OptionalUser(viewer): OptionalUser,

3131 Path(path): Path<crate::handler::RepoPath>,

3232 Query(q): Query<SubmoduleListQuery>,

3333) -> Result<AppResponseData<Vec<SubmoduleDto>>, ApiError> {

3434 let (ctx, _) = handler::resolve_reader(

3535 &service,

36 &session,

36 viewer,

3737 path.space_name.clone(),

3838 path.repo_name.clone(),

3939 )

Modified lib/service/git/src/handler/submodules/resolve.rs +3 −3 View lib/service/git/src/handler/submodules/resolve.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -27,13 +27,13 @@

2727)]

2828pub async fn submodule_resolve(

2929 State(service): State<GitService>,

30 session: Session,

30 OptionalUser(viewer): OptionalUser,

3131 Path(path): Path<crate::handler::RepoPath>,

3232 Query(q): Query<SubmoduleResolveQuery>,

3333) -> Result<AppResponseData<String>, ApiError> {

3434 let (ctx, _) = handler::resolve_reader(

3535 &service,

36 &session,

36 viewer,

3737 path.space_name.clone(),

3838 path.repo_name.clone(),

3939 )

Modified lib/service/git/src/handler/tag_protection/create_policy.rs +3 −3 View lib/service/git/src/handler/tag_protection/create_policy.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -21,13 +21,13 @@

2121)]

2222pub async fn create_policy(

2323 State(service): State<GitService>,

24 session: Session,

24 AuthedUser(uid): AuthedUser,

2525 Path(path): Path<RepoPath>,

2626 Json(cmd): Json<CreateTagPolicyCmd>,

2727) -> Result<AppResponseData<TagPolicyDto>, ApiError> {

2828 let (ctx, _) = require_repo_admin(

2929 &service,

30 &session,

30 uid,

3131 path.space_name.clone(),

3232 path.repo_name.clone(),

3333 )

Modified lib/service/git/src/handler/tag_protection/delete_policy.rs +3 −3 View lib/service/git/src/handler/tag_protection/delete_policy.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -20,12 +20,12 @@

2020)]

2121pub async fn delete_policy(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<PolicyPath>,

2525) -> Result<AppResponseData<NoData>, ApiError> {

2626 let (ctx, _) = handler::require_repo_admin(

2727 &service,

28 &session,

28 uid,

2929 path.space_name.clone(),

3030 path.repo_name.clone(),

3131 )

Modified lib/service/git/src/handler/tag_protection/get_policy.rs +3 −3 View lib/service/git/src/handler/tag_protection/get_policy.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -21,12 +21,12 @@

2121)]

2222pub async fn get_policy(

2323 State(service): State<GitService>,

24 session: Session,

24 AuthedUser(uid): AuthedUser,

2525 Path(path): Path<PolicyPath>,

2626) -> Result<AppResponseData<TagPolicyDto>, ApiError> {

2727 let (ctx, _) = handler::require_repo_admin(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

Modified lib/service/git/src/handler/tag_protection/list_policies.rs +3 −3 View lib/service/git/src/handler/tag_protection/list_policies.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -20,12 +20,12 @@

2020)]

2121pub async fn list_policies(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<RepoPath>,

2525) -> Result<AppResponseData<Vec<TagPolicyDto>>, ApiError> {

2626 let (ctx, _) = require_repo_admin(

2727 &service,

28 &session,

28 uid,

2929 path.space_name.clone(),

3030 path.repo_name.clone(),

3131 )

Modified lib/service/git/src/handler/tag_protection/update_policy.rs +3 −3 View lib/service/git/src/handler/tag_protection/update_policy.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -22,13 +22,13 @@

2222)]

2323pub async fn update_policy(

2424 State(service): State<GitService>,

25 session: Session,

25 AuthedUser(uid): AuthedUser,

2626 Path(path): Path<PolicyPath>,

2727 Json(cmd): Json<UpdateTagPolicyCmd>,

2828) -> Result<AppResponseData<TagPolicyDto>, ApiError> {

2929 let (ctx, _) = handler::require_repo_admin(

3030 &service,

31 &session,

31 uid,

3232 path.space_name.clone(),

3333 path.repo_name.clone(),

3434 )

Modified lib/service/git/src/handler/tags/create.rs +3 −3 View lib/service/git/src/handler/tags/create.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::AppResponseData;

44

@@ -20,13 +20,13 @@

2020)]

2121pub async fn create_tag(

2222 State(service): State<GitService>,

23 session: Session,

23 AuthedUser(uid): AuthedUser,

2424 Path(path): Path<crate::handler::RepoPath>,

2525 Json(cmd): Json<CreateTagCmd>,

2626) -> Result<AppResponseData<TagDto>, ApiError> {

2727 let (ctx, _) = handler::require_writer(

2828 &service,

29 &session,

29 uid,

3030 path.space_name.clone(),

3131 path.repo_name.clone(),

3232 )

Modified lib/service/git/src/handler/tags/delete.rs +3 −3 View lib/service/git/src/handler/tags/delete.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -25,12 +25,12 @@

2525)]

2626pub async fn delete_tag(

2727 State(service): State<GitService>,

28 session: Session,

28 AuthedUser(uid): AuthedUser,

2929 Path(path): Path<TagPath>,

3030) -> Result<AppResponseData<NoData>, ApiError> {

3131 let (ctx, _) = handler::require_writer(

3232 &service,

33 &session,

33 uid,

3434 path.space_name.clone(),

3535 path.repo_name.clone(),

3636 )

Modified lib/service/git/src/handler/tags/get.rs +3 −3 View lib/service/git/src/handler/tags/get.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::AppResponseData;

44

@@ -26,12 +26,12 @@

2626)]

2727pub async fn get_tag(

2828 State(service): State<GitService>,

29 session: Session,

29 OptionalUser(viewer): OptionalUser,

3030 Path(path): Path<TagPath>,

3131) -> Result<AppResponseData<TagDto>, ApiError> {

3232 let (ctx, _) = handler::resolve_reader(

3333 &service,

34 &session,

34 viewer,

3535 path.space_name.clone(),

3636 path.repo_name.clone(),

3737 )

Modified lib/service/git/src/handler/tags/list.rs +3 −3 View lib/service/git/src/handler/tags/list.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -19,13 +19,13 @@

1919)]

2020pub async fn list_tags(

2121 State(service): State<GitService>,

22 session: Session,

22 OptionalUser(viewer): OptionalUser,

2323 Path(path): Path<crate::handler::RepoPath>,

2424 Query(page): Query<api::pagination::PageQuery>,

2525) -> Result<AppResponseData<api::pagination::Page<TagDto>>, ApiError> {

2626 let (ctx, _) = handler::resolve_reader(

2727 &service,

28 &session,

28 viewer,

2929 path.space_name.clone(),

3030 path.repo_name.clone(),

3131 )

Modified lib/service/git/src/handler/trees/read.rs +3 −3 View lib/service/git/src/handler/trees/read.rs

@@ -1,6 +1,6 @@

11use std::path::PathBuf;

22

3use ::session::Session;

3use ::session::OptionalUser;

44use api::http::{Path, Query, State};

55use api::rest::AppResponseData;

66use serde::Deserialize;

@@ -46,13 +46,13 @@

4646)]

4747pub async fn get_tree(

4848 State(service): State<GitService>,

49 session: Session,

49 OptionalUser(viewer): OptionalUser,

5050 Path(path): Path<crate::handler::RepoPathRev>,

5151 Query(q): Query<GetTreeQuery>,

5252) -> Result<AppResponseData<serde_json::Value>, ApiError> {

5353 let (ctx, _) = handler::resolve_reader(

5454 &service,

55 &session,

55 viewer,

5656 path.space_name.clone(),

5757 path.repo_name.clone(),

5858 )

Modified lib/service/git/src/handler/blame.rs +3 −3 View lib/service/git/src/handler/blame.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -32,13 +32,13 @@

3232)]

3333pub async fn blame(

3434 State(service): State<GitService>,

35 session: Session,

35 OptionalUser(viewer): OptionalUser,

3636 Path(path): Path<crate::handler::RepoPath>,

3737 Query(q): Query<BlameQuery>,

3838) -> Result<AppResponseData<Vec<BlameRangeDto>>, ApiError> {

3939 let (ctx, _) = handler::resolve_reader(

4040 &service,

41 &session,

41 viewer,

4242 path.space_name.clone(),

4343 path.repo_name.clone(),

4444 )

Modified lib/service/git/src/handler/mod.rs +1 −2 View lib/service/git/src/handler/mod.rs

@@ -33,6 +33,5 @@

3333pub mod whitelists;

3434

3535pub use share::{

36 RepoPath, RepoPathRev, ensure_caller, ensure_read_access, require_repo_admin, require_writer,

37 resolve_reader,

36 RepoPath, RepoPathRev, ensure_read_access, require_repo_admin, require_writer, resolve_reader,

3837};

Modified lib/service/git/src/handler/path_log.rs +3 −3 View lib/service/git/src/handler/path_log.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -28,13 +28,13 @@

2828)]

2929pub async fn path_log(

3030 State(service): State<GitService>,

31 session: Session,

31 OptionalUser(viewer): OptionalUser,

3232 Path(path): Path<crate::handler::RepoPath>,

3333 Query(q): Query<PathLogQuery>,

3434) -> Result<AppResponseData<Vec<PathLogEntryDto>>, ApiError> {

3535 let (ctx, _) = handler::resolve_reader(

3636 &service,

37 &session,

37 viewer,

3838 path.space_name.clone(),

3939 path.repo_name.clone(),

4040 )

Modified lib/service/git/src/handler/share.rs +8 −15 View lib/service/git/src/handler/share.rs

@@ -1,7 +1,6 @@

11use std::future::Future;

22use std::pin::Pin;

33

4use ::session::Session;

54use actix_web::dev::Payload;

65use actix_web::{FromRequest, HttpRequest};

76use serde::Deserialize;

@@ -37,15 +36,11 @@

3736 .map_err(|_| ApiError::bad_request())

3837 })

3938 }

40}

41

42pub fn ensure_caller(session: &Session) -> Result<i64, ApiError> {

43 session.uid().ok_or(ApiError::unauthorized())

4439}

4540

4641pub async fn resolve_reader(

4742 service: &GitService,

48 session: &Session,

43 viewer: Option<i64>,

4944 space_name: String,

5045 repo_name: String,

5146) -> Result<(crate::context::facade::GitContext, Option<i64>), ApiError> {

@@ -54,35 +49,35 @@

5449 .await

5550 .map_err(super::super::errors::GitApiError::from)?;

5651 if ctx.model.is_private {

57 let uid = session.uid().ok_or(ApiError::unauthorized())?;

52 let uid = viewer.ok_or_else(ApiError::unauthorized)?;

5853 access::authorize_repo_access(service, uid, &ctx, false, false)

5954 .await

6055 .map_err(super::super::errors::GitApiError::from)?;

6156 Ok((ctx, Some(uid)))

6257 } else {

63 Ok((ctx, session.uid()))

58 Ok((ctx, viewer))

6459 }

6560}

6661

6762pub async fn ensure_read_access(

6863 service: &GitService,

69 session: &Session,

64 viewer: Option<i64>,

7065 ctx: &crate::context::facade::GitContext,

7166) -> Result<Option<i64>, ApiError> {

7267 if ctx.model.is_private {

73 let uid = session.uid().ok_or(ApiError::unauthorized())?;

68 let uid = viewer.ok_or_else(ApiError::unauthorized)?;

7469 access::authorize_repo_access(service, uid, ctx, false, false)

7570 .await

7671 .map_err(super::super::errors::GitApiError::from)?;

7772 Ok(Some(uid))

7873 } else {

79 Ok(session.uid())

74 Ok(viewer)

8075 }

8176}

8277

8378pub async fn require_writer(

8479 service: &GitService,

85 session: &Session,

80 uid: i64,

8681 space_name: String,

8782 repo_name: String,

8883) -> Result<(crate::context::facade::GitContext, i64), ApiError> {

@@ -90,7 +85,6 @@

9085 .context(space_name, repo_name)

9186 .await

9287 .map_err(super::super::errors::GitApiError::from)?;

93 let uid = session.uid().ok_or(ApiError::unauthorized())?;

9488 access::authorize_repo_access(service, uid, &ctx, true, false)

9589 .await

9690 .map_err(super::super::errors::GitApiError::from)?;

@@ -99,7 +93,7 @@

9993

10094pub async fn require_repo_admin(

10195 service: &GitService,

102 session: &Session,

96 uid: i64,

10397 space_name: String,

10498 repo_name: String,

10599) -> Result<(crate::context::facade::GitContext, i64), ApiError> {

@@ -107,7 +101,6 @@

107101 .context(space_name, repo_name)

108102 .await

109103 .map_err(super::super::errors::GitApiError::from)?;

110 let uid = session.uid().ok_or(ApiError::unauthorized())?;

111104 access::authorize_repo_access(service, uid, &ctx, true, true)

112105 .await

113106 .map_err(super::super::errors::GitApiError::from)?;

Modified lib/service/git/src/handler/stars.rs +9 −11 View lib/service/git/src/handler/stars.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::{AuthedUser, OptionalUser};

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44use serde::Deserialize;

@@ -27,17 +27,16 @@

2727)]

2828pub async fn star_repo(

2929 State(service): State<GitService>,

30 session: Session,

30 AuthedUser(uid): AuthedUser,

3131 Path(path): Path<RepoPath>,

3232) -> Result<AppResponseData<RepoStarResp>, ApiError> {

33 let (ctx, viewer) = resolve_reader(

33 let (ctx, _) = resolve_reader(

3434 &service,

35 &session,

35 Some(uid),

3636 path.space_name.clone(),

3737 path.repo_name.clone(),

3838 )

3939 .await?;

40 let uid = viewer.ok_or_else(|| ApiError::from(GitApiError::Unauthorized))?;

4140 let out = service

4241 .star_repo(&ctx, uid)

4342 .await

@@ -57,17 +56,16 @@

5756)]

5857pub async fn unstar_repo(

5958 State(service): State<GitService>,

60 session: Session,

59 AuthedUser(uid): AuthedUser,

6160 Path(path): Path<RepoPath>,

6261) -> Result<AppResponseData<RepoStarResp>, ApiError> {

63 let (ctx, viewer) = resolve_reader(

62 let (ctx, _) = resolve_reader(

6463 &service,

65 &session,

64 Some(uid),

6665 path.space_name.clone(),

6766 path.repo_name.clone(),

6867 )

6968 .await?;

70 let uid = viewer.ok_or_else(|| ApiError::from(GitApiError::Unauthorized))?;

7169 let out = service

7270 .unstar_repo(&ctx, uid)

7371 .await

@@ -87,13 +85,13 @@

8785)]

8886pub async fn list_stargazers(

8987 State(service): State<GitService>,

90 session: Session,

88 OptionalUser(viewer): OptionalUser,

9189 Path(path): Path<RepoPath>,

9290 Query(q): Query<api::pagination::PageQuery>,

9391) -> Result<AppResponseData<api::pagination::Page<StargazerDto>>, ApiError> {

9492 let ctx = resolve_reader(

9593 &service,

96 &session,

94 viewer,

9795 path.space_name.clone(),

9896 path.repo_name.clone(),

9997 )

Modified lib/service/git/src/handler/topics.rs +9 −19 View lib/service/git/src/handler/topics.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::{AuthedUser, OptionalUser};

22use api::http::{Json, Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44use serde::{Deserialize, Serialize};

@@ -125,16 +125,11 @@

125125)]

126126pub async fn add_topic_to_repo(

127127 State(service): State<GitService>,

128 session: Session,

128 AuthedUser(uid): AuthedUser,

129129 Path(p): Path<RepoTopicPath>,

130130) -> Result<AppResponseData<TopicDto>, ApiError> {

131 let (ctx, _uid) = require_writer(

132 &service,

133 &session,

134 p.space_name.clone(),

135 p.repo_name.clone(),

136 )

137 .await?;

131 let (ctx, _uid) =

132 require_writer(&service, uid, p.space_name.clone(), p.repo_name.clone()).await?;

138133 let out = service

139134 .add_topic_to_repo(&ctx, &p.topic_name)

140135 .await

@@ -154,16 +149,11 @@

154149)]

155150pub async fn remove_topic_from_repo(

156151 State(service): State<GitService>,

157 session: Session,

152 AuthedUser(uid): AuthedUser,

158153 Path(p): Path<RepoTopicPath>,

159154) -> Result<AppResponseData<NoData>, ApiError> {

160 let (ctx, _uid) = require_writer(

161 &service,

162 &session,

163 p.space_name.clone(),

164 p.repo_name.clone(),

165 )

166 .await?;

155 let (ctx, _uid) =

156 require_writer(&service, uid, p.space_name.clone(), p.repo_name.clone()).await?;

167157 service

168158 .remove_topic_from_repo(&ctx, &p.topic_name)

169159 .await

@@ -183,12 +173,12 @@

183173)]

184174pub async fn list_repo_topics(

185175 State(service): State<GitService>,

186 session: Session,

176 OptionalUser(viewer): OptionalUser,

187177 Path(path): Path<RepoPath>,

188178) -> Result<AppResponseData<Vec<TopicDto>>, ApiError> {

189179 let (ctx, _uid) = resolve_reader(

190180 &service,

191 &session,

181 viewer,

192182 path.space_name.clone(),

193183 path.repo_name.clone(),

194184 )

Modified lib/service/git/src/handler/watches.rs +6 −7 View lib/service/git/src/handler/watches.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::{AuthedUser, OptionalUser};

22use api::http::{Json, Path, Query, State};

33use api::rest::AppResponseData;

44use models::common::watch_mode::WatchMode;

@@ -37,18 +37,17 @@

3737)]

3838pub async fn upsert_watch(

3939 State(service): State<GitService>,

40 session: Session,

40 AuthedUser(uid): AuthedUser,

4141 Path(path): Path<RepoPath>,

4242 Json(cmd): Json<UpsertWatchCmd>,

4343) -> Result<AppResponseData<RepoWatchDto>, ApiError> {

44 let (ctx, viewer) = resolve_reader(

44 let (ctx, _) = resolve_reader(

4545 &service,

46 &session,

46 Some(uid),

4747 path.space_name.clone(),

4848 path.repo_name.clone(),

4949 )

5050 .await?;

51 let uid = viewer.ok_or_else(|| ApiError::from(GitApiError::Unauthorized))?;

5251 let out = service

5352 .upsert_watch(&ctx, uid, cmd)

5453 .await

@@ -68,13 +67,13 @@

6867)]

6968pub async fn list_watchers(

7069 State(service): State<GitService>,

71 session: Session,

70 OptionalUser(viewer): OptionalUser,

7271 Path(path): Path<RepoPath>,

7372 Query(q): Query<WatchQuery>,

7473) -> Result<AppResponseData<api::pagination::Page<WatcherDto>>, ApiError> {

7574 let ctx = resolve_reader(

7675 &service,

77 &session,

76 viewer,

7877 path.space_name.clone(),

7978 path.repo_name.clone(),

8079 )

Modified lib/service/git/src/handler/whitelists.rs +25 −49 View lib/service/git/src/handler/whitelists.rs

@@ -4,7 +4,7 @@

44use utoipa::IntoParams;

55use uuid::Uuid;

66

7use ::session::Session;

7use ::session::AuthedUser;

88

99use crate::errors::{ApiError, GitApiError};

1010use crate::handler;

@@ -56,17 +56,13 @@

5656)]

5757pub async fn add_branch_whitelist(

5858 State(service): State<GitService>,

59 session: Session,

59 AuthedUser(uid): AuthedUser,

6060 Path(p): Path<BranchPolicyPath>,

6161 Json(cmd): Json<AddBranchWhitelistCmd>,

6262) -> Result<AppResponseData<BranchWhitelistDto>, ApiError> {

63 let (ctx, _) = handler::require_repo_admin(

64 &service,

65 &session,

66 p.space_name.clone(),

67 p.repo_name.clone(),

68 )

69 .await?;

63 let (ctx, _) =

64 handler::require_repo_admin(&service, uid, p.space_name.clone(), p.repo_name.clone())

65 .await?;

7066 let out = service

7167 .add_branch_whitelist(ctx.model.id, p.policy_id, cmd)

7268 .await

@@ -86,16 +82,12 @@

8682)]

8783pub async fn remove_branch_whitelist(

8884 State(service): State<GitService>,

89 session: Session,

85 AuthedUser(uid): AuthedUser,

9086 Path(p): Path<BranchWhitelistPath>,

9187) -> Result<AppResponseData<NoData>, ApiError> {

92 let (ctx, _) = handler::require_repo_admin(

93 &service,

94 &session,

95 p.space_name.clone(),

96 p.repo_name.clone(),

97 )

98 .await?;

88 let (ctx, _) =

89 handler::require_repo_admin(&service, uid, p.space_name.clone(), p.repo_name.clone())

90 .await?;

9991 service

10092 .remove_branch_whitelist(ctx.model.id, p.policy_id, p.whitelist_id)

10193 .await

@@ -115,16 +107,12 @@

115107)]

116108pub async fn list_branch_whitelists(

117109 State(service): State<GitService>,

118 session: Session,

110 AuthedUser(uid): AuthedUser,

119111 Path(p): Path<BranchPolicyPath>,

120112) -> Result<AppResponseData<Vec<BranchWhitelistDto>>, ApiError> {

121 let (ctx, _) = handler::require_repo_admin(

122 &service,

123 &session,

124 p.space_name.clone(),

125 p.repo_name.clone(),

126 )

127 .await?;

113 let (ctx, _) =

114 handler::require_repo_admin(&service, uid, p.space_name.clone(), p.repo_name.clone())

115 .await?;

128116 let out = service

129117 .list_branch_whitelists(ctx.model.id, p.policy_id)

130118 .await

@@ -145,17 +133,13 @@

145133)]

146134pub async fn add_tag_whitelist(

147135 State(service): State<GitService>,

148 session: Session,

136 AuthedUser(uid): AuthedUser,

149137 Path(p): Path<TagPolicyPath>,

150138 Json(cmd): Json<AddTagWhitelistCmd>,

151139) -> Result<AppResponseData<TagWhitelistDto>, ApiError> {

152 let (ctx, _) = handler::require_repo_admin(

153 &service,

154 &session,

155 p.space_name.clone(),

156 p.repo_name.clone(),

157 )

158 .await?;

140 let (ctx, _) =

141 handler::require_repo_admin(&service, uid, p.space_name.clone(), p.repo_name.clone())

142 .await?;

159143 let out = service

160144 .add_tag_whitelist(ctx.model.id, p.policy_id, cmd)

161145 .await

@@ -175,16 +159,12 @@

175159)]

176160pub async fn remove_tag_whitelist(

177161 State(service): State<GitService>,

178 session: Session,

162 AuthedUser(uid): AuthedUser,

179163 Path(p): Path<TagWhitelistPath>,

180164) -> Result<AppResponseData<NoData>, ApiError> {

181 let (ctx, _) = handler::require_repo_admin(

182 &service,

183 &session,

184 p.space_name.clone(),

185 p.repo_name.clone(),

186 )

187 .await?;

165 let (ctx, _) =

166 handler::require_repo_admin(&service, uid, p.space_name.clone(), p.repo_name.clone())

167 .await?;

188168 service

189169 .remove_tag_whitelist(ctx.model.id, p.policy_id, p.user_id)

190170 .await

@@ -204,16 +184,12 @@

204184)]

205185pub async fn list_tag_whitelists(

206186 State(service): State<GitService>,

207 session: Session,

187 AuthedUser(uid): AuthedUser,

208188 Path(p): Path<TagPolicyPath>,

209189) -> Result<AppResponseData<Vec<TagWhitelistDto>>, ApiError> {

210 let (ctx, _) = handler::require_repo_admin(

211 &service,

212 &session,

213 p.space_name.clone(),

214 p.repo_name.clone(),

215 )

216 .await?;

190 let (ctx, _) =

191 handler::require_repo_admin(&service, uid, p.space_name.clone(), p.repo_name.clone())

192 .await?;

217193 let out = service

218194 .list_tag_whitelists(ctx.model.id, p.policy_id)

219195 .await

Modified lib/service/issues/src/handlers/attachments/create_attachment.rs +2 −4 View lib/service/issues/src/handlers/attachments/create_attachment.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Json, State};

43use api::rest::{AppResponseData, NoData};

54

@@ -22,10 +21,9 @@

2221)]

2322pub async fn create_issue_attachment(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Json(cmd): Json<CreateIssueAttachmentCmd>,

2726) -> Result<AppResponseData<IssueUploadIntentDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let intent = service.create_issue_attachment(uid, cmd).await?;

3028 Ok(AppResponseData::ok(intent))

3129}

Modified lib/service/issues/src/handlers/attachments/delete_attachment.rs +2 −4 View lib/service/issues/src/handlers/attachments/delete_attachment.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Path, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -21,10 +20,9 @@

2120)]

2221pub async fn delete_issue_attachment(

2322 State(service): State<IssueService>,

24 session: Session,

23 AuthedUser(uid): AuthedUser,

2524 Path(attachment_id): Path<Uuid>,

2625) -> Result<AppResponseData<NoData>, ApiError> {

27 let uid = session::require_uid(&session)?;

2826 service.delete_issue_attachment(uid, attachment_id).await?;

2927 Ok(AppResponseData::ok(NoData))

3028}

Modified lib/service/issues/src/handlers/attachments/download_attachment.rs +2 −4 View lib/service/issues/src/handlers/attachments/download_attachment.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use actix_web::http::header;

43use api::http::{Path, Response, State};

54use api::rest::{AppResponseData, NoData};

@@ -22,10 +21,9 @@

2221)]

2322pub async fn download_issue_attachment(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(attachment_id): Path<Uuid>,

2726) -> Result<Response, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let (row, body, content_type) = service

3028 .download_issue_attachment(uid, attachment_id)

3129 .await?;

Modified lib/service/issues/src/handlers/attachments/finalize_attachment.rs +2 −4 View lib/service/issues/src/handlers/attachments/finalize_attachment.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Path, State};

43use api::rest::{AppResponseData, NoData};

54use uuid::Uuid;

@@ -24,10 +23,9 @@

2423)]

2524pub async fn finalize_issue_attachment(

2625 State(service): State<IssueService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(attachment_id): Path<Uuid>,

2928) -> Result<AppResponseData<IssueAttachmentDto>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let dto = service

3230 .finalize_issue_attachment(uid, attachment_id)

3331 .await?;

Modified lib/service/issues/src/handlers/attachments/list_attachments.rs +2 −4 View lib/service/issues/src/handlers/attachments/list_attachments.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Path, State};

43use api::rest::{AppResponseData, NoData};

54

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_issue_attachments(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827) -> Result<AppResponseData<Vec<IssueAttachmentDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let rows = service

3129 .list_issue_attachments(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/boards/create_board.rs +2 −4 View lib/service/issues/src/handlers/boards/create_board.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::boards::{BoardDto, CreateBoardCmd};

77use crate::services::service::IssueService;

8use ::session::share::session;

98use space::services::dto::SpacePath;

109

1110#[utoipa::path(

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_board(

2827 State(service): State<IssueService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<SpacePath>,

3130 Json(cmd): Json<CreateBoardCmd>,

3231) -> Result<AppResponseData<BoardDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let dto = service.create_board(uid, &path.space_name, cmd).await?;

3533 Ok(AppResponseData::ok(dto))

3634}

Modified lib/service/issues/src/handlers/boards/delete_board.rs +2 −4 View lib/service/issues/src/handlers/boards/delete_board.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::boards::BoardPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_board(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<BoardPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .delete_board(uid, &path.space_name, path.board_id)

3129 .await?;

Modified lib/service/issues/src/handlers/boards/get_board.rs +2 −4 View lib/service/issues/src/handlers/boards/get_board.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::boards::{BoardDto, BoardPath};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn get_board(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<BoardPath>,

2726) -> Result<AppResponseData<BoardDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let dto = service

3028 .get_board(uid, &path.space_name, path.board_id)

3129 .await?;

Modified lib/service/issues/src/handlers/boards/list_boards.rs +2 −4 View lib/service/issues/src/handlers/boards/list_boards.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::boards::{BoardPage, ListBoardQuery};

77use crate::services::service::IssueService;

8use ::session::share::session;

98use space::services::dto::SpacePath;

109

1110#[utoipa::path(

@@ -23,11 +22,10 @@

2322)]

2423pub async fn list_boards(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<SpacePath>,

2827 Query(q): Query<ListBoardQuery>,

2928) -> Result<AppResponseData<BoardPage>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let page = service.list_boards(uid, &path.space_name, q).await?;

3230 Ok(AppResponseData::ok(page))

3331}

Modified lib/service/issues/src/handlers/boards/update_board.rs +2 −4 View lib/service/issues/src/handlers/boards/update_board.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::boards::{BoardDto, BoardPath, UpdateBoardCmd};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn update_board(

2625 State(service): State<IssueService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<BoardPath>,

2928 Json(cmd): Json<UpdateBoardCmd>,

3029) -> Result<AppResponseData<BoardDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let dto = service

3331 .update_board(uid, &path.space_name, path.board_id, cmd)

3432 .await?;

Modified lib/service/issues/src/handlers/comments/create_comment.rs +2 −4 View lib/service/issues/src/handlers/comments/create_comment.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::comments::{CommentDto, CreateCommentCmd};

77use crate::services::issues::IssuePath;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -27,11 +26,10 @@

2726)]

2827pub async fn create_comment(

2928 State(service): State<IssueService>,

30 session: Session,

29 AuthedUser(uid): AuthedUser,

3130 Path(path): Path<IssuePath>,

3231 Json(cmd): Json<CreateCommentCmd>,

3332) -> Result<AppResponseData<CommentDto>, ApiError> {

34 let uid = session::require_uid(&session)?;

3533 let issue_id = service

3634 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3735 .await?;

Modified lib/service/issues/src/handlers/comments/delete_comment.rs +2 −4 View lib/service/issues/src/handlers/comments/delete_comment.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::comments::CommentPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_comment(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<CommentPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/comments/get_comment.rs +2 −4 View lib/service/issues/src/handlers/comments/get_comment.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::comments::{CommentDto, CommentPath};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn get_comment(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<CommentPath>,

2726) -> Result<AppResponseData<CommentDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/comments/list_comments.rs +2 −4 View lib/service/issues/src/handlers/comments/list_comments.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::comments::{CommentPage, ListCommentQuery};

77use crate::services::issues::IssuePath;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn list_comments(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827 Query(q): Query<ListCommentQuery>,

2928) -> Result<AppResponseData<CommentPage>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let issue_id = service

3230 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3331 .await?;

Modified lib/service/issues/src/handlers/comments/list_comments_tree.rs +2 −4 View lib/service/issues/src/handlers/comments/list_comments_tree.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::comments::CommentTreeNode;

77use crate::services::issues::IssuePath;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn list_comments_tree(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<IssuePath>,

2726) -> Result<AppResponseData<Vec<CommentTreeNode>>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/comments/update_comment.rs +2 −4 View lib/service/issues/src/handlers/comments/update_comment.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::comments::{CommentDto, CommentPath, UpdateCommentCmd};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn update_comment(

2625 State(service): State<IssueService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<CommentPath>,

2928 Json(cmd): Json<UpdateCommentCmd>,

3029) -> Result<AppResponseData<CommentDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let issue_id = service

3331 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3432 .await?;

Modified lib/service/issues/src/handlers/content_history/list_content_history.rs +2 −4 View lib/service/issues/src/handlers/content_history/list_content_history.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -7,7 +7,6 @@

77 ContentHistoryPage, ContentHistoryPath, ListContentHistoryQuery,

88};

99use crate::services::service::IssueService;

10use ::session::share::session;

1110

1211#[utoipa::path(

1312 get,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn list_content_history(

2625 State(service): State<IssueService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<ContentHistoryPath>,

2928 Query(q): Query<ListContentHistoryQuery>,

3029) -> Result<AppResponseData<ContentHistoryPage>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let issue_id = service

3331 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3432 .await?;

Modified lib/service/issues/src/handlers/dependencies/create_dependency.rs +2 −4 View lib/service/issues/src/handlers/dependencies/create_dependency.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dependencies::{CreateDependencyCmd, DependencyDto};

77use crate::services::issues::IssuePath;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_dependency(

2827 State(service): State<IssueService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<IssuePath>,

3130 Json(cmd): Json<CreateDependencyCmd>,

3231) -> Result<AppResponseData<DependencyDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let issue_id = service

3533 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3634 .await?;

Modified lib/service/issues/src/handlers/dependencies/delete_dependency.rs +2 −4 View lib/service/issues/src/handlers/dependencies/delete_dependency.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::dependencies::DependencyPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_dependency(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<DependencyPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/dependencies/list_dependencies.rs +2 −4 View lib/service/issues/src/handlers/dependencies/list_dependencies.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dependencies::DependencyDto;

77use crate::services::issues::IssuePath;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_dependencies(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827) -> Result<AppResponseData<Vec<DependencyDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/dependencies/list_dependents.rs +2 −4 View lib/service/issues/src/handlers/dependencies/list_dependents.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dependencies::DependencyDto;

77use crate::services::issues::IssuePath;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn list_dependents(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<IssuePath>,

2726) -> Result<AppResponseData<Vec<DependencyDto>>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/events/list_events.rs +2 −4 View lib/service/issues/src/handlers/events/list_events.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::events::{EventPage, EventPath, ListEventQuery};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,11 +21,10 @@

2221)]

2322pub async fn list_events(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<EventPath>,

2726 Query(q): Query<ListEventQuery>,

2827) -> Result<AppResponseData<EventPage>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/issue_users/list_issue_users.rs +2 −4 View lib/service/issues/src/handlers/issue_users/list_issue_users.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issue_users::{IssueUserPage, ListIssueUserQuery};

77use crate::services::issues::IssuePath;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn list_issue_users(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827 Query(q): Query<ListIssueUserQuery>,

2928) -> Result<AppResponseData<IssueUserPage>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let issue_id = service

3230 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3331 .await?;

Modified lib/service/issues/src/handlers/issue_users/mark_issue_read.rs +2 −4 View lib/service/issues/src/handlers/issue_users/mark_issue_read.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issue_users::{IssueUserDto, UpdateIssueUserCmd};

77use crate::services::issues::IssuePath;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[derive(Debug, Clone, serde::Deserialize, utoipa::ToSchema)]

1211pub struct MarkIssueReadCmd {

@@ -30,11 +29,10 @@

3029)]

3130pub async fn mark_issue_read(

3231 State(service): State<IssueService>,

33 session: Session,

32 AuthedUser(caller): AuthedUser,

3433 Path(path): Path<IssuePath>,

3534 Json(body): Json<MarkIssueReadCmd>,

3635) -> Result<AppResponseData<IssueUserDto>, ApiError> {

37 let caller = session::require_uid(&session)?;

3836 let issue_id = service

3937 .resolve_issue_ref(caller, &path.space_name, path.board_id, &path.issue_id)

4038 .await?;

Modified lib/service/issues/src/handlers/issues/bulk_issues.rs +2 −4 View lib/service/issues/src/handlers/issues/bulk_issues.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::issues::{BulkIssuesCmd, BulkResultDto};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn bulk_issues(

2625 State(service): State<IssueService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<BoardPath>,

2928 Json(cmd): Json<BulkIssuesCmd>,

3029) -> Result<AppResponseData<BulkResultDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let result = service

3331 .bulk_update_state(uid, &path.space_name, path.board_id, cmd)

3432 .await?;

Modified lib/service/issues/src/handlers/issues/close_issue.rs +2 −4 View lib/service/issues/src/handlers/issues/close_issue.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::issues::{IssueDto, IssuePath};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn close_issue(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827) -> Result<AppResponseData<IssueDto>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/issues/create_issue.rs +2 −4 View lib/service/issues/src/handlers/issues/create_issue.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::issues::{CreateIssueCmd, IssueDto};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -27,11 +26,10 @@

2726)]

2827pub async fn create_issue(

2928 State(service): State<IssueService>,

30 session: Session,

29 AuthedUser(uid): AuthedUser,

3130 Path(path): Path<BoardPath>,

3231 Json(cmd): Json<CreateIssueCmd>,

3332) -> Result<AppResponseData<IssueDto>, ApiError> {

34 let uid = session::require_uid(&session)?;

3533 let dto = service

3634 .create_issue(uid, &path.space_name, path.board_id, cmd)

3735 .await?;

Modified lib/service/issues/src/handlers/issues/delete_issue.rs +2 −4 View lib/service/issues/src/handlers/issues/delete_issue.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::issues::IssuePath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_issue(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<IssuePath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/issues/get_issue.rs +2 −4 View lib/service/issues/src/handlers/issues/get_issue.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::issues::{IssueDto, IssuePath};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn get_issue(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<IssuePath>,

2726) -> Result<AppResponseData<IssueDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/issues/list_issues.rs +2 −4 View lib/service/issues/src/handlers/issues/list_issues.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::issues::{IssuePage, ListIssueQuery};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn list_issues(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<BoardPath>,

2827 Query(q): Query<ListIssueQuery>,

2928) -> Result<AppResponseData<IssuePage>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let page = service

3230 .list_issues(uid, &path.space_name, path.board_id, q)

3331 .await?;

Modified lib/service/issues/src/handlers/issues/reopen_issue.rs +2 −4 View lib/service/issues/src/handlers/issues/reopen_issue.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::issues::{IssueDto, IssuePath};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn reopen_issue(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827) -> Result<AppResponseData<IssueDto>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/issues/update_issue.rs +2 −4 View lib/service/issues/src/handlers/issues/update_issue.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::issues::{IssueDto, IssuePath, UpdateIssueCmd};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn update_issue(

2625 State(service): State<IssueService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<IssuePath>,

2928 Json(cmd): Json<UpdateIssueCmd>,

3029) -> Result<AppResponseData<IssueDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let issue_id = service

3331 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3432 .await?;

Modified lib/service/issues/src/handlers/labels/bind_label.rs +2 −4 View lib/service/issues/src/handlers/labels/bind_label.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::labels::IssueLabelPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn bind_label(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssueLabelPath>,

2827) -> Result<AppResponseData<NoData>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/labels/create_label.rs +2 −4 View lib/service/issues/src/handlers/labels/create_label.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::labels::{CreateLabelCmd, LabelDto};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_label(

2827 State(service): State<IssueService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<BoardPath>,

3130 Json(cmd): Json<CreateLabelCmd>,

3231) -> Result<AppResponseData<LabelDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let dto = service

3533 .create_label(uid, &path.space_name, path.board_id, cmd)

3634 .await?;

Modified lib/service/issues/src/handlers/labels/delete_label.rs +2 −4 View lib/service/issues/src/handlers/labels/delete_label.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::labels::LabelPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_label(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<LabelPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .delete_label(uid, &path.space_name, path.board_id, path.label_id)

3129 .await?;

Modified lib/service/issues/src/handlers/labels/get_label.rs +2 −4 View lib/service/issues/src/handlers/labels/get_label.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::labels::{LabelDto, LabelPath};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn get_label(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<LabelPath>,

2726) -> Result<AppResponseData<LabelDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let dto = service

3028 .get_label(uid, &path.space_name, path.board_id, path.label_id)

3129 .await?;

Modified lib/service/issues/src/handlers/labels/list_labels.rs +2 −4 View lib/service/issues/src/handlers/labels/list_labels.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::labels::{LabelPage, ListLabelQuery};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn list_labels(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<BoardPath>,

2827 Query(q): Query<ListLabelQuery>,

2928) -> Result<AppResponseData<LabelPage>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let page = service

3230 .list_labels(uid, &path.space_name, path.board_id, q)

3331 .await?;

Modified lib/service/issues/src/handlers/labels/list_labels_for_issue.rs +2 −4 View lib/service/issues/src/handlers/labels/list_labels_for_issue.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issues::IssuePath;

77use crate::services::labels::LabelDto;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_labels_for_issue(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827) -> Result<AppResponseData<Vec<LabelDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/labels/unbind_label.rs +2 −4 View lib/service/issues/src/handlers/labels/unbind_label.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::labels::IssueLabelPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn unbind_label(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<IssueLabelPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/labels/update_label.rs +2 −4 View lib/service/issues/src/handlers/labels/update_label.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::labels::{LabelDto, LabelPath, UpdateLabelCmd};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn update_label(

2625 State(service): State<IssueService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<LabelPath>,

2928 Json(cmd): Json<UpdateLabelCmd>,

3029) -> Result<AppResponseData<LabelDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let dto = service

3331 .update_label(uid, &path.space_name, path.board_id, path.label_id, cmd)

3432 .await?;

Modified lib/service/issues/src/handlers/members/create_member.rs +2 −4 View lib/service/issues/src/handlers/members/create_member.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issues::IssuePath;

77use crate::services::members::{CreateIssueMemberCmd, IssueMemberDto};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_member(

2827 State(service): State<IssueService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<IssuePath>,

3130 Json(cmd): Json<CreateIssueMemberCmd>,

3231) -> Result<AppResponseData<IssueMemberDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let issue_id = service

3533 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3634 .await?;

Modified lib/service/issues/src/handlers/members/delete_member.rs +2 −4 View lib/service/issues/src/handlers/members/delete_member.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::members::IssueMemberPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_member(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<IssueMemberPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/members/list_members.rs +2 −4 View lib/service/issues/src/handlers/members/list_members.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issues::IssuePath;

77use crate::services::members::{IssueMemberPage, ListIssueMemberQuery};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn list_issue_members(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827 Query(q): Query<ListIssueMemberQuery>,

2928) -> Result<AppResponseData<IssueMemberPage>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let issue_id = service

3230 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3331 .await?;

Modified lib/service/issues/src/handlers/milestones/create_milestone.rs +2 −4 View lib/service/issues/src/handlers/milestones/create_milestone.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::milestones::{CreateMilestoneCmd, MilestoneDto};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_milestone(

2827 State(service): State<IssueService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<BoardPath>,

3130 Json(cmd): Json<CreateMilestoneCmd>,

3231) -> Result<AppResponseData<MilestoneDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let dto = service

3533 .create_milestone(uid, &path.space_name, path.board_id, cmd)

3634 .await?;

Modified lib/service/issues/src/handlers/milestones/delete_milestone.rs +2 −4 View lib/service/issues/src/handlers/milestones/delete_milestone.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::milestones::MilestonePath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_milestone(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<MilestonePath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .delete_milestone(uid, &path.space_name, path.board_id, path.milestone_id)

3129 .await?;

Modified lib/service/issues/src/handlers/milestones/get_milestone.rs +2 −4 View lib/service/issues/src/handlers/milestones/get_milestone.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::milestones::{MilestoneDto, MilestonePath};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn get_milestone(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<MilestonePath>,

2726) -> Result<AppResponseData<MilestoneDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let dto = service

3028 .get_milestone(uid, &path.space_name, path.board_id, path.milestone_id)

3129 .await?;

Modified lib/service/issues/src/handlers/milestones/list_milestones.rs +2 −4 View lib/service/issues/src/handlers/milestones/list_milestones.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::milestones::{ListMilestoneQuery, MilestonePage};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn list_milestones(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<BoardPath>,

2827 Query(q): Query<ListMilestoneQuery>,

2928) -> Result<AppResponseData<MilestonePage>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let page = service

3230 .list_milestones(uid, &path.space_name, path.board_id, q)

3331 .await?;

Modified lib/service/issues/src/handlers/milestones/update_milestone.rs +2 −4 View lib/service/issues/src/handlers/milestones/update_milestone.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::milestones::{MilestoneDto, MilestonePath, UpdateMilestoneCmd};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn update_milestone(

2625 State(service): State<IssueService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<MilestonePath>,

2928 Json(cmd): Json<UpdateMilestoneCmd>,

3029) -> Result<AppResponseData<MilestoneDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let dto = service

3331 .update_milestone(uid, &path.space_name, path.board_id, path.milestone_id, cmd)

3432 .await?;

Modified lib/service/issues/src/handlers/pins/create_pin.rs +2 −4 View lib/service/issues/src/handlers/pins/create_pin.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::pins::{CreatePinCmd, PinDto};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_pin(

2827 State(service): State<IssueService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<BoardPath>,

3130 Json(cmd): Json<CreatePinCmd>,

3231) -> Result<AppResponseData<PinDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let dto = service

3533 .create_pin(uid, &path.space_name, path.board_id, cmd)

3634 .await?;

Modified lib/service/issues/src/handlers/pins/delete_pin.rs +2 −4 View lib/service/issues/src/handlers/pins/delete_pin.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::pins::PinPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_pin(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<PinPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .delete_pin(uid, &path.space_name, path.board_id, path.pin_id)

3129 .await?;

Modified lib/service/issues/src/handlers/pins/list_pins.rs +2 −4 View lib/service/issues/src/handlers/pins/list_pins.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::boards::BoardPath;

77use crate::services::pins::PinDto;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_board_pins(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<BoardPath>,

2827) -> Result<AppResponseData<Vec<PinDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let pins = service

3129 .list_pins(uid, &path.space_name, path.board_id)

3230 .await?;

Modified lib/service/issues/src/handlers/pins/update_pin.rs +2 −4 View lib/service/issues/src/handlers/pins/update_pin.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::pins::{PinDto, PinPath, UpdatePinCmd};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn update_pin(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<PinPath>,

2827 Json(cmd): Json<UpdatePinCmd>,

2928) -> Result<AppResponseData<PinDto>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let dto = service

3230 .update_pin(uid, &path.space_name, path.board_id, path.pin_id, cmd)

3331 .await?;

Modified lib/service/issues/src/handlers/reactions/add_comment_reaction.rs +2 −4 View lib/service/issues/src/handlers/reactions/add_comment_reaction.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::reactions::{CommentReactionPath, CreateReactionCmd, ReactionDto};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 put,

@@ -25,11 +24,10 @@

2524)]

2625pub async fn add_comment_reaction(

2726 State(service): State<IssueService>,

28 session: Session,

27 AuthedUser(uid): AuthedUser,

2928 Path(path): Path<CommentReactionPath>,

3029 Json(cmd): Json<CreateReactionCmd>,

3130) -> Result<AppResponseData<ReactionDto>, ApiError> {

32 let uid = session::require_uid(&session)?;

3331 let issue_id = service

3432 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3533 .await?;

Modified lib/service/issues/src/handlers/reactions/add_reaction.rs +2 −4 View lib/service/issues/src/handlers/reactions/add_reaction.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issues::IssuePath;

77use crate::services::reactions::{CreateReactionCmd, ReactionDto};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 put,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn add_issue_reaction(

2827 State(service): State<IssueService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<IssuePath>,

3130 Json(cmd): Json<CreateReactionCmd>,

3231) -> Result<AppResponseData<ReactionDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let issue_id = service

3533 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3634 .await?;

Modified lib/service/issues/src/handlers/reactions/list_comment_reactions.rs +2 −4 View lib/service/issues/src/handlers/reactions/list_comment_reactions.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::reactions::{CommentReactionPath, ReactionAggDto};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn list_comment_reactions(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<CommentReactionPath>,

2726) -> Result<AppResponseData<Vec<ReactionAggDto>>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/reactions/list_reactions.rs +2 −4 View lib/service/issues/src/handlers/reactions/list_reactions.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issues::IssuePath;

77use crate::services::reactions::ReactionAggDto;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_issue_reactions(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827) -> Result<AppResponseData<Vec<ReactionAggDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/reactions/remove_comment_reaction.rs +2 −4 View lib/service/issues/src/handlers/reactions/remove_comment_reaction.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::reactions::{CommentReactionPath, EmojiQuery};

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,11 +21,10 @@

2221)]

2322pub async fn remove_comment_reaction(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<CommentReactionPath>,

2726 Query(q): Query<EmojiQuery>,

2827) -> Result<AppResponseData<NoData>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/reactions/remove_reaction.rs +2 −4 View lib/service/issues/src/handlers/reactions/remove_reaction.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issues::IssuePath;

77use crate::services::reactions::EmojiQuery;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 delete,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn remove_issue_reaction(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827 Query(q): Query<EmojiQuery>,

2928) -> Result<AppResponseData<NoData>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let issue_id = service

3230 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3331 .await?;

Modified lib/service/issues/src/handlers/repo_relations/create_repo_relation.rs +2 −4 View lib/service/issues/src/handlers/repo_relations/create_repo_relation.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issues::IssuePath;

77use crate::services::repo_relations::{CreateRepoRelCmd, RepoRelDto};

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_repo_relation(

2827 State(service): State<IssueService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<IssuePath>,

3130 Json(cmd): Json<CreateRepoRelCmd>,

3231) -> Result<AppResponseData<RepoRelDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let issue_id = service

3533 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3634 .await?;

Modified lib/service/issues/src/handlers/repo_relations/delete_repo_relation.rs +2 −4 View lib/service/issues/src/handlers/repo_relations/delete_repo_relation.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::repo_relations::RepoRelPath;

77use crate::services::service::IssueService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_repo_relation(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<RepoRelPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/repo_relations/list_repo_relations.rs +2 −4 View lib/service/issues/src/handlers/repo_relations/list_repo_relations.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::issues::IssuePath;

77use crate::services::repo_relations::RepoRelDto;

88use crate::services::service::IssueService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_repo_relations(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<IssuePath>,

2827) -> Result<AppResponseData<Vec<RepoRelDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/stopwatch/get_stopwatch.rs +2 −4 View lib/service/issues/src/handlers/stopwatch/get_stopwatch.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::service::IssueService;

77use crate::services::stopwatch::{StopwatchDto, StopwatchPath};

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn get_stopwatch(

2423 State(service): State<IssueService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<StopwatchPath>,

2726) -> Result<AppResponseData<StopwatchDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let issue_id = service

3028 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3129 .await?;

Modified lib/service/issues/src/handlers/stopwatch/start_stopwatch.rs +2 −4 View lib/service/issues/src/handlers/stopwatch/start_stopwatch.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::service::IssueService;

77use crate::services::stopwatch::{StopwatchDto, StopwatchPath};

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn start_stopwatch(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<StopwatchPath>,

2827) -> Result<AppResponseData<StopwatchDto>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/stopwatch/stop_stopwatch.rs +2 −4 View lib/service/issues/src/handlers/stopwatch/stop_stopwatch.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::service::IssueService;

77use crate::services::stopwatch::StopwatchPath;

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn stop_stopwatch(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<StopwatchPath>,

2827) -> Result<AppResponseData<NoData>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let issue_id = service

3129 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3230 .await?;

Modified lib/service/issues/src/handlers/tracked_time/create_tracked_time.rs +2 −4 View lib/service/issues/src/handlers/tracked_time/create_tracked_time.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::service::IssueService;

77use crate::services::tracked_time::{CreateTrackedTimeCmd, TrackedTimeDto, TrackedTimePath};

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn create_tracked_time(

2524 State(service): State<IssueService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<TrackedTimePath>,

2827 Json(cmd): Json<CreateTrackedTimeCmd>,

2928) -> Result<AppResponseData<TrackedTimeDto>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let issue_id = service

3230 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3331 .await?;

Modified lib/service/issues/src/handlers/tracked_time/delete_tracked_time.rs +2 −4 View lib/service/issues/src/handlers/tracked_time/delete_tracked_time.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::service::IssueService;

77use crate::services::tracked_time::TrackedTimeIdPath;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -21,10 +20,9 @@

2120)]

2221pub async fn delete_tracked_time(

2322 State(service): State<IssueService>,

24 session: Session,

23 AuthedUser(uid): AuthedUser,

2524 Path(path): Path<TrackedTimeIdPath>,

2625) -> Result<AppResponseData<NoData>, ApiError> {

27 let uid = session::require_uid(&session)?;

2826 let issue_id = service

2927 .resolve_issue_ref(uid, &path.space_name, path.board_id, &path.issue_id)

3028 .await?;

Modified lib/service/issues/src/share/mod.rs +0 −1 View lib/service/issues/src/share/mod.rs

@@ -1,3 +1,2 @@

11pub mod authz;

2pub mod guard;

32pub mod lookup;

Modified lib/service/issues/src/routes.rs +1 −2 View lib/service/issues/src/routes.rs

@@ -65,7 +65,7 @@

6565use crate::handlers::watches::upsert_watch::upsert_issue_watch;

6666use crate::services::service::IssueService;

6767

68pub fn router(_service: IssueService) -> Router<IssueService> {

68pub fn protected(_service: IssueService) -> Router<IssueService> {

6969 Router::new()

7070 .route(

7171 "/issues/attachments",

@@ -248,5 +248,4 @@

248248 "/issues/{space_name}/boards/{board_id}/issues/{issue_id}/repos/{rel_id}",

249249 delete(delete_repo_relation),

250250 )

251 .wrap(api::http::Guard::Session)

252251}

Modified lib/service/pulls/src/handlers/inbox.rs +3 −3 View lib/service/pulls/src/handlers/inbox.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::AppResponseData;

44

@@ -24,11 +24,11 @@

2424)]

2525pub async fn list_my_pulls(

2626 State(service): State<PullService>,

27 session: Session,

27 AuthedUser(uid): AuthedUser,

2828 Path(path): Path<InboxPath>,

2929 Query(query): Query<InboxQuery>,

3030) -> Result<AppResponseData<InboxPage>, ApiError> {

31 let caller = PullService::uid(&session).map_err(ApiError::from)?;

31 let caller = uid;

3232 let scope = match path.scope.as_str() {

3333 "created" => crate::services::inbox::InboxScope::Created,

3434 "review-requested" => crate::services::inbox::InboxScope::ReviewRequested,

Modified lib/service/pulls/src/services/service.rs +0 −5 View lib/service/pulls/src/services/service.rs

@@ -1,4 +1,3 @@

1use ::session::Session;

21use db::AppDatabase;

32use git::facade::GitService;

43use models::pull_request::pull_requests;

@@ -37,10 +36,6 @@

3736

3837 pub fn db_write(&self) -> &DatabaseConnection {

3938 self.database.write()

40 }

41

42 pub fn uid(session: &Session) -> Result<i64, PullError> {

43 session.uid().ok_or(PullError::Unauthorized)

4439 }

4540

4641 /// 开放 PR 数量回填 `repos.nums_pr`，状态变更后调用。

Modified lib/service/pulls/src/share/lookup.rs +25 −15 View lib/service/pulls/src/share/lookup.rs

@@ -1,4 +1,3 @@

1use ::session::Session;

21use git::facade as access;

32use git::facade::GitContext;

43use models::pull_request::pull_requests;

@@ -18,26 +17,25 @@

1817

1918pub async fn repo_read(

2019 svc: &PullService,

21 session: &Session,

20 viewer: Option<i64>,

2221 space_name: String,

2322 repo_name: String,

2423) -> Result<(GitContext, Option<i64>), PullError> {

2524 let ctx = svc.git.context(space_name, repo_name).await?;

2625 if ctx.model.is_private {

27 let uid = PullService::uid(session)?;

26 let uid = viewer.ok_or(PullError::Unauthorized)?;

2827 access::authorize_repo_access(&svc.git, uid, &ctx, false, false).await?;

2928 return Ok((ctx, Some(uid)));

3029 }

31 Ok((ctx, session.uid()))

30 Ok((ctx, viewer))

3231}

3332

3433pub async fn repo_write(

3534 svc: &PullService,

36 session: &Session,

35 uid: i64,

3736 space_name: String,

3837 repo_name: String,

3938) -> Result<(GitContext, i64), PullError> {

40 let uid = PullService::uid(session)?;

4139 let ctx = svc.git.context(space_name, repo_name).await?;

4240 access::authorize_repo_access(&svc.git, uid, &ctx, true, false).await?;

4341 Ok((ctx, uid))

@@ -79,20 +77,14 @@

7977 row.ok_or(PullError::NotFound)

8078}

8179

82pub async fn pull_handle(

80pub async fn pull_handle_read(

8381 svc: &PullService,

84 session: &Session,

82 viewer: Option<i64>,

8583 space_name: String,

8684 repo_name: String,

8785 pull_ref: String,

88 write: bool,

8986) -> Result<PullHandle, PullError> {

90 let (ctx, caller) = if write {

91 let (ctx, uid) = repo_write(svc, session, space_name, repo_name).await?;

92 (ctx, Some(uid))

93 } else {

94 repo_read(svc, session, space_name, repo_name).await?

95 };

87 let (ctx, caller) = repo_read(svc, viewer, space_name, repo_name).await?;

9688 let pull = find_pull(svc, ctx.model.id, &pull_ref).await?;

9789 let admin = match caller {

9890 Some(uid) => is_admin(svc, uid, &ctx).await,

@@ -105,3 +97,21 @@

10597 admin,

10698 })

10799}

100

101pub async fn pull_handle_write(

102 svc: &PullService,

103 uid: i64,

104 space_name: String,

105 repo_name: String,

106 pull_ref: String,

107) -> Result<PullHandle, PullError> {

108 let (ctx, uid) = repo_write(svc, uid, space_name, repo_name).await?;

109 let pull = find_pull(svc, ctx.model.id, &pull_ref).await?;

110 let admin = is_admin(svc, uid, &ctx).await;

111 Ok(PullHandle {

112 ctx,

113 pull,

114 caller: Some(uid),

115 admin,

116 })

117}

Modified lib/service/space/src/handlers/assign_group.rs +2 −4 View lib/service/space/src/handlers/assign_group.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dto::MemberPath;

77use crate::services::groups::AssignGroupCmd;

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn assign_group(

2827 State(service): State<SpaceService>,

29 session: Session,

28 AuthedUser(caller): AuthedUser,

3029 Path(path): Path<MemberPath>,

3130 Json(cmd): Json<AssignGroupCmd>,

3231) -> Result<AppResponseData<NoData>, ApiError> {

33 let caller = session::require_uid(&session)?;

3432 service

3533 .assign_group(caller, &path.space_name, path.user_id, cmd)

3634 .await?;

Modified lib/service/space/src/handlers/create_dir_node.rs +2 −4 View lib/service/space/src/handlers/create_dir_node.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dir::{CreateDirCmd, DirNodeDto};

77use crate::services::dto::SpacePath;

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_dir_node(

2827 State(service): State<SpaceService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<SpacePath>,

3130 Json(cmd): Json<CreateDirCmd>,

3231) -> Result<AppResponseData<DirNodeDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let node = service.create_dir_node(uid, &path.space_name, cmd).await?;

3533 Ok(AppResponseData::ok(node))

3634}

Modified lib/service/space/src/handlers/create_group.rs +2 −4 View lib/service/space/src/handlers/create_group.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dto::SpacePath;

77use crate::services::groups::{CreateGroupCmd, GroupDto};

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_group(

2827 State(service): State<SpaceService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<SpacePath>,

3130 Json(cmd): Json<CreateGroupCmd>,

3231) -> Result<AppResponseData<GroupDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let group = service.create_group(uid, &path.space_name, cmd).await?;

3533 Ok(AppResponseData::ok(group))

3634}

Modified lib/service/space/src/handlers/create_join_rule.rs +2 −4 View lib/service/space/src/handlers/create_join_rule.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dto::SpacePath;

77use crate::services::join_rules::{CreateJoinRuleCmd, JoinRuleDto};

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn create_join_rule(

2827 State(service): State<SpaceService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<SpacePath>,

3130 Json(cmd): Json<CreateJoinRuleCmd>,

3231) -> Result<AppResponseData<JoinRuleDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let dto = service.create_join_rule(uid, &path.space_name, cmd).await?;

3533 Ok(AppResponseData::ok(dto))

3634}

Modified lib/service/space/src/handlers/delete_group.rs +2 −4 View lib/service/space/src/handlers/delete_group.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::handlers::get_group::GroupPath;

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_group(

2423 State(service): State<SpaceService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<GroupPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .delete_group(uid, &path.space_name, path.group_id)

3129 .await?;

Modified lib/service/space/src/handlers/delete_join_rule.rs +2 −4 View lib/service/space/src/handlers/delete_join_rule.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::join_rules::JoinRulePath;

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_join_rule(

2423 State(service): State<SpaceService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<JoinRulePath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .delete_join_rule(uid, &path.space_name, path.rule_id)

3129 .await?;

Modified lib/service/space/src/handlers/delete_space_image.rs +2 −4 View lib/service/space/src/handlers/delete_space_image.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::images::SpaceImageKindPath;

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_space_image(

2423 State(service): State<SpaceService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<SpaceImageKindPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .images

3129 .delete_space_image(uid, &path.space_name, path.kind)

Modified lib/service/space/src/handlers/explore_spaces.rs +5 −10 View lib/service/space/src/handlers/explore_spaces.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::{AuthedUser, OptionalUser};

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -9,7 +9,6 @@

99 ListJoinRequestsQuery,

1010};

1111use crate::services::service::SpaceService;

12use ::session::share::session;

1312

1413#[utoipa::path(

1514 get,

@@ -24,10 +23,9 @@

2423)]

2524pub async fn explore_spaces(

2625 State(service): State<SpaceService>,

27 session: Session,

26 OptionalUser(viewer): OptionalUser,

2827 Query(query): Query<ExploreQuery>,

2928) -> Result<AppResponseData<ExploreSpacePage>, ApiError> {

30 let viewer = session.uid();

3129 let page = service.explore_spaces(viewer, query).await?;

3230 Ok(AppResponseData::ok(page))

3331}

@@ -47,11 +45,10 @@

4745)]

4846pub async fn list_join_requests(

4947 State(service): State<SpaceService>,

50 session: Session,

48 AuthedUser(uid): AuthedUser,

5149 Path(path): Path<SpacePath>,

5250 Query(query): Query<ListJoinRequestsQuery>,

5351) -> Result<AppResponseData<JoinRequestPage>, ApiError> {

54 let uid = session::require_uid(&session)?;

5552 let page = service

5653 .list_join_requests(uid, &path.space_name, query)

5754 .await?;

@@ -74,10 +71,9 @@

7471)]

7572pub async fn approve_join_request(

7673 State(service): State<SpaceService>,

77 session: Session,

74 AuthedUser(uid): AuthedUser,

7875 Path(path): Path<JoinRequestPath>,

7976) -> Result<AppResponseData<JoinRequestDto>, ApiError> {

80 let uid = session::require_uid(&session)?;

8177 let request = service

8278 .approve_join_request(uid, &path.space_name, path.request_id)

8379 .await?;

@@ -100,10 +96,9 @@

10096)]

10197pub async fn reject_join_request(

10298 State(service): State<SpaceService>,

103 session: Session,

99 AuthedUser(uid): AuthedUser,

104100 Path(path): Path<JoinRequestPath>,

105101) -> Result<AppResponseData<JoinRequestDto>, ApiError> {

106 let uid = session::require_uid(&session)?;

107102 let request = service

108103 .reject_join_request(uid, &path.space_name, path.request_id)

109104 .await?;

Modified lib/service/space/src/handlers/get_group.rs +2 −3 View lib/service/space/src/handlers/get_group.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44use serde::Deserialize;

@@ -29,10 +29,9 @@

2929)]

3030pub async fn get_group(

3131 State(service): State<SpaceService>,

32 session: Session,

32 OptionalUser(caller): OptionalUser,

3333 Path(path): Path<GroupPath>,

3434) -> Result<AppResponseData<GroupDto>, ApiError> {

35 let caller = session.uid();

3635 let group = service

3736 .get_group(caller, &path.space_name, path.group_id)

3837 .await?;

Modified lib/service/space/src/handlers/get_space_dir_tree.rs +2 −4 View lib/service/space/src/handlers/get_space_dir_tree.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44use serde::Deserialize;

@@ -7,7 +7,6 @@

77use crate::services::dir::DirNodeDto;

88use crate::services::dto::SpacePath;

99use crate::services::service::SpaceService;

10use ::session::share::session;

1110

1211#[derive(Debug, Clone, Deserialize, utoipa::IntoParams)]

1312pub struct DirTreeQuery {

@@ -29,11 +28,10 @@

2928)]

3029pub async fn get_space_dir_tree(

3130 State(service): State<SpaceService>,

32 session: Session,

31 AuthedUser(uid): AuthedUser,

3332 Path(path): Path<SpacePath>,

3433 Query(q): Query<DirTreeQuery>,

3534) -> Result<AppResponseData<Vec<DirNodeDto>>, ApiError> {

36 let uid = session::require_uid(&session)?;

3735 let tree = service

3836 .get_space_dir_tree(uid, &path.space_name, q.parent_id)

3937 .await?;

Modified lib/service/space/src/handlers/get_space_image.rs +2 −3 View lib/service/space/src/handlers/get_space_image.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -20,10 +20,9 @@

2020)]

2121pub async fn get_space_image(

2222 State(service): State<SpaceService>,

23 session: Session,

23 OptionalUser(caller): OptionalUser,

2424 Path(path): Path<SpaceImageKindPath>,

2525) -> Result<AppResponseData<Option<SpaceImageDto>>, ApiError> {

26 let caller = session.uid();

2726 let img = service

2827 .images

2928 .get_space_image(caller, &path.space_name, path.kind)

Modified lib/service/space/src/handlers/get_space_image_file.rs +3 −3 View lib/service/space/src/handlers/get_space_image_file.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use actix_web::http::header;

33use api::http::{Path, Query, Response, State};

44use imaging::layout::ImageVariant;

@@ -31,14 +31,14 @@

3131)]

3232pub async fn get_space_image_file(

3333 State(service): State<SpaceService>,

34 session: Session,

34 OptionalUser(viewer): OptionalUser,

3535 Path(path): Path<SpaceImageKindPath>,

3636 Query(query): Query<SpaceImageVariantQuery>,

3737) -> Result<Response, ApiError> {

3838 let url = service

3939 .images

4040 .space_image_file_url(

41 session.uid(),

41 viewer,

4242 &path.space_name,

4343 path.kind,

4444 query.variant.unwrap_or(ImageVariant::Preview),

Modified lib/service/space/src/handlers/join_group_self.rs +2 −4 View lib/service/space/src/handlers/join_group_self.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::handlers::get_group::GroupPath;

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn join_group_self(

2524 State(service): State<SpaceService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<GroupPath>,

2827) -> Result<AppResponseData<NoData>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 service

3129 .join_group_self(uid, &path.space_name, path.group_id)

3230 .await?;

Modified lib/service/space/src/handlers/join_requests.rs +3 −6 View lib/service/space/src/handlers/join_requests.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dto::SpacePath;

77use crate::services::join_requests::{CreateJoinRequestCmd, JoinRequestDto, JoinRequestPath};

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -27,11 +26,10 @@

2726)]

2827pub async fn create_join_request(

2928 State(service): State<SpaceService>,

30 session: Session,

29 AuthedUser(uid): AuthedUser,

3130 Path(path): Path<SpacePath>,

3231 Json(cmd): Json<CreateJoinRequestCmd>,

3332) -> Result<AppResponseData<JoinRequestDto>, ApiError> {

34 let uid = session::require_uid(&session)?;

3533 let request = service

3634 .create_join_request(uid, &path.space_name, cmd)

3735 .await?;

@@ -53,10 +51,9 @@

5351)]

5452pub async fn withdraw_join_request(

5553 State(service): State<SpaceService>,

56 session: Session,

54 AuthedUser(uid): AuthedUser,

5755 Path(path): Path<JoinRequestPath>,

5856) -> Result<AppResponseData<NoData>, ApiError> {

59 let uid = session::require_uid(&session)?;

6057 service

6158 .withdraw_join_request(uid, &path.space_name, path.request_id)

6259 .await?;

Modified lib/service/space/src/handlers/leave_group_self.rs +2 −4 View lib/service/space/src/handlers/leave_group_self.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::handlers::get_group::GroupPath;

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn leave_group_self(

2423 State(service): State<SpaceService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<GroupPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .leave_group_self(uid, &path.space_name, path.group_id)

3129 .await?;

Modified lib/service/space/src/handlers/list_dir_group_overwrites.rs +2 −4 View lib/service/space/src/handlers/list_dir_group_overwrites.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::dir::{DirPath, GroupOverwriteDto};

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn list_dir_group_overwrites(

2423 State(service): State<SpaceService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<DirPath>,

2726) -> Result<AppResponseData<Vec<GroupOverwriteDto>>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let list = service

3028 .list_dir_group_overwrites(uid, &path.space_name, path.dir_id)

3129 .await?;

Modified lib/service/space/src/handlers/list_dir_user_overwrites.rs +2 −4 View lib/service/space/src/handlers/list_dir_user_overwrites.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::dir::{DirPath, UserOverwriteDto};

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn list_dir_user_overwrites(

2423 State(service): State<SpaceService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<DirPath>,

2726) -> Result<AppResponseData<Vec<UserOverwriteDto>>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let list = service

3028 .list_dir_user_overwrites(uid, &path.space_name, path.dir_id)

3129 .await?;

Modified lib/service/space/src/handlers/list_groups.rs +2 −4 View lib/service/space/src/handlers/list_groups.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dto::{PageQuery, SpacePath};

77use crate::services::groups::GroupPage;

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,11 +22,10 @@

2322)]

2423pub async fn list_groups(

2524 State(service): State<SpaceService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<SpacePath>,

2827 Query(query): Query<PageQuery>,

2928) -> Result<AppResponseData<GroupPage>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let page = service.list_groups(uid, &path.space_name, query).await?;

3230 Ok(AppResponseData::ok(page))

3331}

Modified lib/service/space/src/handlers/list_join_rules.rs +2 −4 View lib/service/space/src/handlers/list_join_rules.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dto::SpacePath;

77use crate::services::join_rules::JoinRuleDto;

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_join_rules(

2524 State(service): State<SpaceService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Path(path): Path<SpacePath>,

2827) -> Result<AppResponseData<Vec<JoinRuleDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let rules = service.list_join_rules(uid, &path.space_name).await?;

3129 Ok(AppResponseData::ok(rules))

3230}

Modified lib/service/space/src/handlers/move_dir_node.rs +2 −4 View lib/service/space/src/handlers/move_dir_node.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::dir::{DirNodeDto, DirPath, MoveDirCmd};

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn move_dir_node(

2625 State(service): State<SpaceService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<DirPath>,

2928 Json(cmd): Json<MoveDirCmd>,

3029) -> Result<AppResponseData<DirNodeDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let node = service

3331 .move_dir_node(uid, &path.space_name, path.dir_id, cmd)

3432 .await?;

Modified lib/service/space/src/handlers/remove_dir_group_overwrite.rs +2 −4 View lib/service/space/src/handlers/remove_dir_group_overwrite.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::handlers::set_dir_group_overwrite::DirGroupPath;

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn remove_dir_group_overwrite(

2423 State(service): State<SpaceService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<DirGroupPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .remove_dir_group_overwrite(uid, &path.space_name, path.dir_id, path.group_id)

3129 .await?;

Modified lib/service/space/src/handlers/remove_dir_user_overwrite.rs +2 −4 View lib/service/space/src/handlers/remove_dir_user_overwrite.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::handlers::set_dir_user_overwrite::DirUserPath;

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn remove_dir_user_overwrite(

2423 State(service): State<SpaceService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(path): Path<DirUserPath>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service

3028 .remove_dir_user_overwrite(uid, &path.space_name, path.dir_id, path.user_id)

3129 .await?;

Modified lib/service/space/src/handlers/repair_dir_parents.rs +2 −4 View lib/service/space/src/handlers/repair_dir_parents.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::dir::RepairDirResp;

77use crate::services::dto::SpacePath;

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 post,

@@ -24,10 +23,9 @@

2423)]

2524pub async fn repair_dir_parents(

2625 State(service): State<SpaceService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<SpacePath>,

2928) -> Result<AppResponseData<RepairDirResp>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let resp = service.repair_dir_parents(uid, &path.space_name).await?;

3230 Ok(AppResponseData::ok(resp))

3331}

Modified lib/service/space/src/handlers/set_dir_group_overwrite.rs +2 −4 View lib/service/space/src/handlers/set_dir_group_overwrite.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44use serde::Deserialize;

@@ -8,7 +8,6 @@

88use crate::errors::ApiError;

99use crate::services::dir::{GroupOverwriteDto, SetOverwriteCmd};

1010use crate::services::service::SpaceService;

11use ::session::share::session;

1211

1312#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]

1413pub struct DirGroupPath {

@@ -34,11 +33,10 @@

3433)]

3534pub async fn set_dir_group_overwrite(

3635 State(service): State<SpaceService>,

37 session: Session,

36 AuthedUser(uid): AuthedUser,

3837 Path(path): Path<DirGroupPath>,

3938 Json(cmd): Json<SetOverwriteCmd>,

4039) -> Result<AppResponseData<GroupOverwriteDto>, ApiError> {

41 let uid = session::require_uid(&session)?;

4240 let dto = service

4341 .set_dir_group_overwrite(uid, &path.space_name, path.dir_id, path.group_id, cmd)

4442 .await?;

Modified lib/service/space/src/handlers/set_dir_user_overwrite.rs +2 −4 View lib/service/space/src/handlers/set_dir_user_overwrite.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44use serde::Deserialize;

@@ -8,7 +8,6 @@

88use crate::errors::ApiError;

99use crate::services::dir::{SetOverwriteCmd, UserOverwriteDto};

1010use crate::services::service::SpaceService;

11use ::session::share::session;

1211

1312#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]

1413pub struct DirUserPath {

@@ -34,11 +33,10 @@

3433)]

3534pub async fn set_dir_user_overwrite(

3635 State(service): State<SpaceService>,

37 session: Session,

36 AuthedUser(uid): AuthedUser,

3837 Path(path): Path<DirUserPath>,

3938 Json(cmd): Json<SetOverwriteCmd>,

4039) -> Result<AppResponseData<UserOverwriteDto>, ApiError> {

41 let uid = session::require_uid(&session)?;

4240 let dto = service

4341 .set_dir_user_overwrite(uid, &path.space_name, path.dir_id, path.user_id, cmd)

4442 .await?;

Modified lib/service/space/src/handlers/unassign_group.rs +2 −4 View lib/service/space/src/handlers/unassign_group.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44use serde::Deserialize;

@@ -7,7 +7,6 @@

77

88use crate::errors::ApiError;

99use crate::services::service::SpaceService;

10use ::session::share::session;

1110

1211#[derive(Debug, Clone, Deserialize, IntoParams, ToSchema)]

1312pub struct MemberGroupPath {

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

3130)]

3231pub async fn unassign_group(

3332 State(service): State<SpaceService>,

34 session: Session,

33 AuthedUser(caller): AuthedUser,

3534 Path(path): Path<MemberGroupPath>,

3635) -> Result<AppResponseData<NoData>, ApiError> {

37 let caller = session::require_uid(&session)?;

3836 service

3937 .unassign_group(caller, &path.space_name, path.user_id, path.group_id)

4038 .await?;

Modified lib/service/space/src/handlers/update_dir_node.rs +2 −4 View lib/service/space/src/handlers/update_dir_node.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::dir::{DirNodeDto, DirPath, UpdateDirCmd};

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn update_dir_node(

2625 State(service): State<SpaceService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(path): Path<DirPath>,

2928 Json(cmd): Json<UpdateDirCmd>,

3029) -> Result<AppResponseData<DirNodeDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let node = service

3331 .update_dir_node(uid, &path.space_name, path.dir_id, cmd)

3432 .await?;

Modified lib/service/space/src/handlers/update_group.rs +2 −4 View lib/service/space/src/handlers/update_group.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::handlers::get_group::GroupPath;

77use crate::services::groups::{GroupDto, UpdateGroupCmd};

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 patch,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn update_group(

2827 State(service): State<SpaceService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 Path(path): Path<GroupPath>,

3130 Json(cmd): Json<UpdateGroupCmd>,

3231) -> Result<AppResponseData<GroupDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let group = service

3533 .update_group(uid, &path.space_name, path.group_id, cmd)

3634 .await?;

Modified lib/service/space/src/handlers/update_join_rule.rs +2 −4 View lib/service/space/src/handlers/update_join_rule.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::join_rules::{JoinRuleDto, JoinRulePath, UpdateJoinRuleCmd};

77use crate::services::service::SpaceService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 patch,

@@ -25,11 +24,10 @@

2524)]

2625pub async fn update_join_rule(

2726 State(service): State<SpaceService>,

28 session: Session,

27 AuthedUser(uid): AuthedUser,

2928 Path(path): Path<JoinRulePath>,

3029 Json(cmd): Json<UpdateJoinRuleCmd>,

3130) -> Result<AppResponseData<JoinRuleDto>, ApiError> {

32 let uid = session::require_uid(&session)?;

3331 let dto = service

3432 .update_join_rule(uid, &path.space_name, path.rule_id, cmd)

3533 .await?;

Modified lib/service/space/src/handlers/upload_space_image.rs +2 −4 View lib/service/space/src/handlers/upload_space_image.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use actix_web::http::header::CONTENT_TYPE;

33use api::http::{Bytes, HeaderMap, Path, Query, State};

44use api::rest::{AppResponseData, NoData};

@@ -6,7 +6,6 @@

66use crate::errors::ApiError;

77use crate::services::images::{SpaceImageDto, SpaceImageKindPath, SpaceImageUploadQuery};

88use crate::services::service::SpaceService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 put,

@@ -29,13 +28,12 @@

2928)]

3029pub async fn upload_space_image(

3130 State(service): State<SpaceService>,

32 session: Session,

31 AuthedUser(uid): AuthedUser,

3332 Path(path): Path<SpaceImageKindPath>,

3433 Query(query): Query<SpaceImageUploadQuery>,

3534 headers: HeaderMap,

3635 body: Bytes,

3736) -> Result<AppResponseData<SpaceImageDto>, ApiError> {

38 let uid = session::require_uid(&session)?;

3937 let content_type = headers

4038 .get(CONTENT_TYPE)

4139 .and_then(|v| v.to_str().ok())

Modified lib/service/space/src/share/mod.rs +0 −1 View lib/service/space/src/share/mod.rs

@@ -1,6 +1,5 @@

11pub mod authz;

22pub mod crypto;

33pub mod dir_visibility;

4pub mod guard;

54pub mod lookup;

65pub mod validate;

Modified lib/service/space/src/routes.rs +6 −7 View lib/service/space/src/routes.rs

@@ -35,17 +35,19 @@

3535use crate::handlers::upload_space_image::upload_space_image;

3636use crate::services::service::SpaceService;

3737

38pub fn router(_service: SpaceService) -> Router<SpaceService> {

39 let public: Router<SpaceService> = Router::new()

38pub fn public(_service: SpaceService) -> Router<SpaceService> {

39 Router::<SpaceService>::new()

4040 .route("/spaces/explore", get(explore_spaces))

4141 .route("/spaces/{space_name}/groups/{group_id}", get(get_group))

4242 .route("/spaces/{space_name}/images/{kind}", get(get_space_image))

4343 .route(

4444 "/spaces/{space_name}/images/{kind}/file",

4545 get(get_space_image_file),

46 );

46 )

47}

4748

48 let protected = Router::<SpaceService>::new()

49pub fn protected(_service: SpaceService) -> Router<SpaceService> {

50 Router::<SpaceService>::new()

4951 .route(

5052 "/spaces/{space_name}/images/{kind}",

5153 put(upload_space_image)

@@ -231,7 +233,4 @@

231233 "/spaces/{space_name}/permissions/check",

232234 post(crate::handlers::space_admin::check_permission),

233235 )

234 .wrap(api::http::Guard::Session);

235

236 public.merge(protected)

237236}

Modified lib/service/user/src/handlers/create_meme.rs +2 −4 View lib/service/user/src/handlers/create_meme.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::profile::{MemeDto, UpsertMemeCmd};

77use crate::services::service::UserService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn create_meme(

2423 State(service): State<UserService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Json(cmd): Json<UpsertMemeCmd>,

2726) -> Result<AppResponseData<MemeDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let meme = service.create_meme(uid, cmd).await?;

3028 Ok(AppResponseData::ok(meme))

3129}

Modified lib/service/user/src/handlers/delete_avatar.rs +2 −4 View lib/service/user/src/handlers/delete_avatar.rs

@@ -1,10 +1,9 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::State;

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::service::UserService;

7use ::session::share::session;

87

98#[utoipa::path(

109 delete,

@@ -18,9 +17,8 @@

1817)]

1918pub async fn delete_avatar(

2019 State(service): State<UserService>,

21 session: Session,

20 AuthedUser(uid): AuthedUser,

2221) -> Result<AppResponseData<NoData>, ApiError> {

23 let uid = session::require_uid(&session)?;

2422 service.avatars.delete_avatar(uid).await?;

2523 Ok(AppResponseData::empty())

2624}

Modified lib/service/user/src/handlers/delete_meme.rs +2 −4 View lib/service/user/src/handlers/delete_meme.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44use uuid::Uuid;

55

66use crate::errors::ApiError;

77use crate::services::service::UserService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_meme(

2423 State(service): State<UserService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(meme_id): Path<Uuid>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service.delete_meme(uid, meme_id).await?;

3028 Ok(AppResponseData::empty())

3129}

Modified lib/service/user/src/handlers/delete_push_subscription.rs +2 −4 View lib/service/user/src/handlers/delete_push_subscription.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44use uuid::Uuid;

55

66use crate::errors::ApiError;

77use crate::services::service::UserService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn delete_push_subscription(

2423 State(service): State<UserService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(push_id): Path<Uuid>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service.delete_push_subscription(uid, push_id).await?;

3028 Ok(AppResponseData::empty())

3129}

Modified lib/service/user/src/handlers/get_avatar.rs +2 −4 View lib/service/user/src/handlers/get_avatar.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::State;

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::avatar::AvatarDto;

77use crate::services::service::UserService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -20,9 +19,8 @@

2019)]

2120pub async fn get_avatar(

2221 State(service): State<UserService>,

23 session: Session,

22 AuthedUser(uid): AuthedUser,

2423) -> Result<AppResponseData<Option<AvatarDto>>, ApiError> {

25 let uid = session::require_uid(&session)?;

2624 let avatar = service.avatars.current_avatar(uid).await?;

2725 Ok(AppResponseData::ok(avatar))

2826}

Modified lib/service/user/src/handlers/get_profile_detail.rs +2 −3 View lib/service/user/src/handlers/get_profile_detail.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::OptionalUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -21,10 +21,9 @@

2121)]

2222pub async fn get_profile_detail(

2323 State(service): State<UserService>,

24 session: Session,

24 OptionalUser(viewer): OptionalUser,

2525 Path(user_id): Path<i64>,

2626) -> Result<AppResponseData<ProfileDetailDto>, ApiError> {

27 let viewer = session.uid();

2827 let detail = service.profile_detail(viewer, user_id).await?;

2928 Ok(AppResponseData::ok(detail))

3029}

Modified lib/service/user/src/handlers/get_user_avatar.rs +2 −4 View lib/service/user/src/handlers/get_user_avatar.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use actix_web::http::header;

43use api::http::{Path, Query, Response, State};

54use imaging::layout::ImageVariant;

@@ -31,13 +30,12 @@

3130)]

3231pub async fn get_user_avatar(

3332 State(service): State<UserService>,

34 session: Session,

33 AuthedUser(_uid): AuthedUser,

3534 Path(user_id): Path<i64>,

3635 Query(query): Query<AvatarVariantQuery>,

3736) -> Result<Response, ApiError> {

3837 // A session is still required to reach the endpoint at all; what is

3938 // deliberately *not* checked is who the caller is relative to the target.

40 session::require_uid(&session).map_err(|_| ApiError::unauthorized())?;

4139 let url = service

4240 .avatars

4341 .avatar_redirect_url(user_id, query.variant.unwrap_or(ImageVariant::Preview))

Modified lib/service/user/src/handlers/list_memes.rs +2 −4 View lib/service/user/src/handlers/list_memes.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Query, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::profile::{ListLimitQuery, MemeDto};

77use crate::services::service::UserService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_memes(

2524 State(service): State<UserService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Query(query): Query<ListLimitQuery>,

2827) -> Result<AppResponseData<Vec<MemeDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let memes = service.list_memes(uid, query.limit).await?;

3129 Ok(AppResponseData::ok(memes))

3230}

Modified lib/service/user/src/handlers/list_push_subscriptions.rs +2 −4 View lib/service/user/src/handlers/list_push_subscriptions.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Query, State};

33use api::pagination::Page;

44use api::rest::{AppResponseData, NoData};

@@ -7,7 +7,6 @@

77use crate::services::push_subscriptions::PushSubscriptionDto;

88use crate::services::service::UserService;

99use crate::share::page::PageQuery;

10use ::session::share::session;

1110

1211#[utoipa::path(

1312 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_push_subscriptions(

2524 State(service): State<UserService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Query(query): Query<PageQuery>,

2827) -> Result<AppResponseData<Page<PushSubscriptionDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let list = service.list_push_subscriptions(uid, query).await?;

3129 Ok(AppResponseData::ok(list))

3230}

Modified lib/service/user/src/handlers/list_saved_messages.rs +2 −4 View lib/service/user/src/handlers/list_saved_messages.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Query, State};

33use api::pagination::Page;

44use api::rest::{AppResponseData, NoData};

@@ -7,7 +7,6 @@

77use crate::services::notifications::SavedMessageDto;

88use crate::services::service::UserService;

99use crate::share::page::PageQuery;

10use ::session::share::session;

1110

1211#[utoipa::path(

1312 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn list_saved_messages(

2524 State(service): State<UserService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Query(query): Query<PageQuery>,

2827) -> Result<AppResponseData<Page<SavedMessageDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let list = service.list_saved_messages(uid, query).await?;

3129 Ok(AppResponseData::ok(list))

3230}

Modified lib/service/user/src/handlers/my_reports.rs +2 −4 View lib/service/user/src/handlers/my_reports.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Query, State};

33use api::pagination::Page;

44use api::rest::{AppResponseData, NoData};

@@ -7,7 +7,6 @@

77use crate::services::notifications::UserReportDto;

88use crate::services::service::UserService;

99use crate::share::page::PageQuery;

10use ::session::share::session;

1110

1211#[utoipa::path(

1312 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn my_reports(

2524 State(service): State<UserService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Query(query): Query<PageQuery>,

2827) -> Result<AppResponseData<Page<UserReportDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let reports = service.my_reports(uid, query).await?;

3129 Ok(AppResponseData::ok(reports))

3230}

Modified lib/service/user/src/handlers/my_spaces.rs +2 −4 View lib/service/user/src/handlers/my_spaces.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Query, State};

33use api::pagination::Page;

44use api::rest::{AppResponseData, NoData};

@@ -7,7 +7,6 @@

77use crate::services::profile::MySpaceDto;

88use crate::services::service::UserService;

99use crate::share::page::PageQuery;

10use ::session::share::session;

1110

1211#[utoipa::path(

1312 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn my_spaces(

2524 State(service): State<UserService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Query(query): Query<PageQuery>,

2827) -> Result<AppResponseData<Page<MySpaceDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let spaces = service.my_spaces(uid, query).await?;

3129 Ok(AppResponseData::ok(spaces))

3230}

Modified lib/service/user/src/handlers/my_suspensions.rs +2 −4 View lib/service/user/src/handlers/my_suspensions.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Query, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::service::UserService;

77use crate::services::suspensions::{IncludeRevokedQuery, SuspensionDto};

8use ::session::share::session;

98

109#[utoipa::path(

1110 get,

@@ -23,10 +22,9 @@

2322)]

2423pub async fn my_suspensions(

2524 State(service): State<UserService>,

26 session: Session,

25 AuthedUser(uid): AuthedUser,

2726 Query(query): Query<IncludeRevokedQuery>,

2827) -> Result<AppResponseData<Vec<SuspensionDto>>, ApiError> {

29 let uid = session::require_uid(&session)?;

3028 let list = service.my_suspensions(uid, query).await?;

3129 Ok(AppResponseData::ok(list))

3230}

Modified lib/service/user/src/handlers/recent_mentions.rs +2 −4 View lib/service/user/src/handlers/recent_mentions.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Query, State};

33use api::rest::{AppResponseData, NoData};

44

@@ -6,7 +6,6 @@

66use crate::services::notifications::RecentMentionDto;

77use crate::services::profile::ListLimitQuery;

88use crate::services::service::UserService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 get,

@@ -24,10 +23,9 @@

2423)]

2524pub async fn recent_mentions(

2625 State(service): State<UserService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Query(query): Query<ListLimitQuery>,

2928) -> Result<AppResponseData<Vec<RecentMentionDto>>, ApiError> {

30 let uid = session::require_uid(&session)?;

3129 let mentions = service.recent_mentions(uid, query.limit).await?;

3230 Ok(AppResponseData::ok(mentions))

3331}

Modified lib/service/user/src/handlers/save_message.rs +2 −4 View lib/service/user/src/handlers/save_message.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::notifications::{SaveMessageCmd, SavedMessageDto};

77use crate::services::service::UserService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn save_message(

2423 State(service): State<UserService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Json(cmd): Json<SaveMessageCmd>,

2726) -> Result<AppResponseData<SavedMessageDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let saved = service.save_message(uid, cmd).await?;

3028 Ok(AppResponseData::ok(saved))

3129}

Modified lib/service/user/src/handlers/unsave_message.rs +2 −4 View lib/service/user/src/handlers/unsave_message.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Path, State};

33use api::rest::{AppResponseData, NoData};

44use uuid::Uuid;

55

66use crate::errors::ApiError;

77use crate::services::service::UserService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 delete,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn unsave_message(

2423 State(service): State<UserService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Path(message_id): Path<Uuid>,

2726) -> Result<AppResponseData<NoData>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 service.unsave_message(uid, message_id).await?;

3028 Ok(AppResponseData::empty())

3129}

Modified lib/service/user/src/handlers/update_meme.rs +2 −4 View lib/service/user/src/handlers/update_meme.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, Path, State};

33use api::rest::{AppResponseData, NoData};

44use uuid::Uuid;

@@ -6,7 +6,6 @@

66use crate::errors::ApiError;

77use crate::services::profile::{MemeDto, UpsertMemeCmd};

88use crate::services::service::UserService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 put,

@@ -24,11 +23,10 @@

2423)]

2524pub async fn update_meme(

2625 State(service): State<UserService>,

27 session: Session,

26 AuthedUser(uid): AuthedUser,

2827 Path(meme_id): Path<Uuid>,

2928 Json(cmd): Json<UpsertMemeCmd>,

3029) -> Result<AppResponseData<MemeDto>, ApiError> {

31 let uid = session::require_uid(&session)?;

3230 let meme = service.update_meme(uid, meme_id, cmd).await?;

3331 Ok(AppResponseData::ok(meme))

3432}

Modified lib/service/user/src/handlers/upload_avatar.rs +2 −4 View lib/service/user/src/handlers/upload_avatar.rs

@@ -1,4 +1,4 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use actix_web::http::header::CONTENT_TYPE;

33use api::http::{Bytes, HeaderMap, State};

44use api::rest::{AppResponseData, NoData};

@@ -6,7 +6,6 @@

66use crate::errors::ApiError;

77use crate::services::avatar::AvatarDto;

88use crate::services::service::UserService;

9use ::session::share::session;

109

1110#[utoipa::path(

1211 put,

@@ -26,11 +25,10 @@

2625)]

2726pub async fn upload_avatar(

2827 State(service): State<UserService>,

29 session: Session,

28 AuthedUser(uid): AuthedUser,

3029 headers: HeaderMap,

3130 body: Bytes,

3231) -> Result<AppResponseData<AvatarDto>, ApiError> {

33 let uid = session::require_uid(&session)?;

3432 let content_type = headers

3533 .get(CONTENT_TYPE)

3634 .and_then(|v| v.to_str().ok())

Modified lib/service/user/src/handlers/upsert_push_subscription.rs +2 −4 View lib/service/user/src/handlers/upsert_push_subscription.rs

@@ -1,11 +1,10 @@

1use ::session::Session;

1use ::session::AuthedUser;

22use api::http::{Json, State};

33use api::rest::{AppResponseData, NoData};

44

55use crate::errors::ApiError;

66use crate::services::push_subscriptions::{PushSubscriptionDto, UpsertPushCmd};

77use crate::services::service::UserService;

8use ::session::share::session;

98

109#[utoipa::path(

1110 post,

@@ -22,10 +21,9 @@

2221)]

2322pub async fn upsert_push_subscription(

2423 State(service): State<UserService>,

25 session: Session,

24 AuthedUser(uid): AuthedUser,

2625 Json(cmd): Json<UpsertPushCmd>,

2726) -> Result<AppResponseData<PushSubscriptionDto>, ApiError> {

28 let uid = session::require_uid(&session)?;

2927 let sub = service.upsert_push_subscription(uid, cmd).await?;

3028 Ok(AppResponseData::ok(sub))

3129}

Modified lib/service/user/src/share/mod.rs +0 −1 View lib/service/user/src/share/mod.rs

@@ -1,4 +1,3 @@

1pub mod guard;

21pub mod page;

32pub mod types;

43

Modified lib/service/user/src/routes.rs +6 −7 View lib/service/user/src/routes.rs

@@ -21,15 +21,17 @@

2121use crate::handlers::upsert_push_subscription::upsert_push_subscription;

2222use crate::services::service::UserService;

2323

24pub fn router(_service: UserService) -> Router<UserService> {

25 let public: Router<UserService> = Router::new()

24pub fn public(_service: UserService) -> Router<UserService> {

25 Router::<UserService>::new()

2626 .route("/users/{user_id}/profile-detail", get(get_profile_detail))

2727 .route(

2828 "/push/config",

2929 get(crate::handlers::push_config::push_config),

30 );

30 )

31}

3132

32 let protected = Router::<UserService>::new()

33pub fn protected(_service: UserService) -> Router<UserService> {

34 Router::<UserService>::new()

3335 .route(

3436 "/auth/ssh-keys",

3537 get(crate::handlers::ssh_key::ssh_key_list).post(crate::handlers::ssh_key::ssh_key_add),

@@ -69,7 +71,4 @@

6971 )

7072 .route("/me/messages/saved/{message_id}", delete(unsave_message))

7173 .route("/me/suspensions", get(my_suspensions))

72 .wrap(api::http::Guard::Session);

73

74 public.merge(protected)

7574}

Modified lib/service/webapi/src/domains/account_deletion.rs +2 −3 View lib/service/webapi/src/domains/account_deletion.rs

@@ -1,9 +1,9 @@

11use ::bootstrap::AppState;

2use api::http::{Guard, Router};

2use api::http::Router;

33

44use crate::bootstrap::Deps;

55

6pub fn router(deps: &Deps) -> Router<()> {

6pub fn protected(deps: &Deps) -> Router<()> {

77 Router::<AppState>::new()

88 .route(

99 "/me/deletion",

@@ -11,6 +11,5 @@

1111 .post(crate::account_deletion::request_account_deletion)

1212 .delete(crate::account_deletion::cancel_account_deletion),

1313 )

14 .wrap(Guard::Session)

1514 .with_state(deps.state.clone())

1615}

Modified lib/service/webapi/src/domains/auth.rs +6 −2 View lib/service/webapi/src/domains/auth.rs

@@ -2,8 +2,12 @@

22

33use crate::bootstrap::Deps;

44

5pub fn router(deps: &Deps) -> Router<()> {

6 auth::routes::router(deps.auth.clone()).with_state(deps.auth.clone())

5pub fn public(deps: &Deps) -> Router<()> {

6 auth::routes::public(deps.auth.clone()).with_state(deps.auth.clone())

7}

8

9pub fn protected(deps: &Deps) -> Router<()> {

10 auth::routes::protected(deps.auth.clone()).with_state(deps.auth.clone())

711}

812

913pub fn pages(deps: &Deps) -> Router<()> {

Modified lib/service/webapi/src/domains/chat.rs +6 −2 View lib/service/webapi/src/domains/chat.rs

@@ -2,8 +2,12 @@

22

33use crate::bootstrap::Deps;

44

5pub fn router(deps: &Deps) -> Router<()> {

6 chat::routes::router(deps.chat.clone()).with_state(deps.chat.clone())

5pub fn public(deps: &Deps) -> Router<()> {

6 chat::routes::public(deps.chat.clone()).with_state(deps.chat.clone())

7}

8

9pub fn protected(deps: &Deps) -> Router<()> {

10 chat::routes::protected(deps.chat.clone()).with_state(deps.chat.clone())

711}

812

913pub fn internal(deps: &Deps) -> Router<()> {

Modified lib/service/webapi/src/domains/issues.rs +2 −2 View lib/service/webapi/src/domains/issues.rs

@@ -2,6 +2,6 @@

22

33use crate::bootstrap::Deps;

44

5pub fn router(deps: &Deps) -> Router<()> {

6 issues::routes::router(deps.issues.clone()).with_state(deps.issues.clone())

5pub fn protected(deps: &Deps) -> Router<()> {

6 issues::routes::protected(deps.issues.clone()).with_state(deps.issues.clone())

77}

Modified lib/service/webapi/src/domains/space.rs +6 −2 View lib/service/webapi/src/domains/space.rs

@@ -2,6 +2,10 @@

22

33use crate::bootstrap::Deps;

44

5pub fn router(deps: &Deps) -> Router<()> {

6 space::routes::router(deps.space.clone()).with_state(deps.space.clone())

5pub fn public(deps: &Deps) -> Router<()> {

6 space::routes::public(deps.space.clone()).with_state(deps.space.clone())

7}

8

9pub fn protected(deps: &Deps) -> Router<()> {

10 space::routes::protected(deps.space.clone()).with_state(deps.space.clone())

711}

Modified lib/service/webapi/src/domains/user.rs +6 −2 View lib/service/webapi/src/domains/user.rs

@@ -2,6 +2,10 @@

22

33use crate::bootstrap::Deps;

44

5pub fn router(deps: &Deps) -> Router<()> {

6 user::routes::router(deps.user.clone()).with_state(deps.user.clone())

5pub fn public(deps: &Deps) -> Router<()> {

6 user::routes::public(deps.user.clone()).with_state(deps.user.clone())

7}

8

9pub fn protected(deps: &Deps) -> Router<()> {

10 user::routes::protected(deps.user.clone()).with_state(deps.user.clone())

711}

Modified lib/service/webapi/src/account_deletion.rs +4 −8 View lib/service/webapi/src/account_deletion.rs

@@ -1,5 +1,4 @@

1use ::session::Session;

2use ::session::share::session;

1use ::session::AuthedUser;

32use api::http::{Extension, State};

43use api::rest::{AppResponseData, NoData};

54use serde::Serialize;

@@ -40,9 +39,8 @@

4039)]

4140pub async fn account_deletion_status(

4241 State(state): State<AppState>,

43 session: Session,

42 AuthedUser(uid): AuthedUser,

4443) -> Result<AppResponseData<Option<AccountDeletionDto>>, ApiError> {

45 let uid = session::require_uid(&session)?;

4644 let status = deletion::account_deletion_status(&state, uid)

4745 .await

4846 .map_err(AuthBusinessError::from)?;

@@ -63,9 +61,8 @@

6361pub async fn request_account_deletion(

6462 State(state): State<AppState>,

6563 Extension(accounts): Extension<auth::Accounts>,

66 session: Session,

64 AuthedUser(uid): AuthedUser,

6765) -> Result<AppResponseData<AccountDeletionDto>, ApiError> {

68 let uid = session::require_uid(&session)?;

6966 let status = deletion::request_account_deletion(

7067 &state,

7168 &accounts,

@@ -91,9 +88,8 @@

9188pub async fn cancel_account_deletion(

9289 State(state): State<AppState>,

9390 Extension(accounts): Extension<auth::Accounts>,

94 session: Session,

91 AuthedUser(uid): AuthedUser,

9592) -> Result<AppResponseData<NoData>, ApiError> {

96 let uid = session::require_uid(&session)?;

9793 deletion::cancel_account_deletion(&state, &accounts, uid)

9894 .await

9995 .map_err(AuthBusinessError::from)?;

Modified lib/service/webapi/src/cleanup.rs +7 −13 View lib/service/webapi/src/cleanup.rs

@@ -8,8 +8,7 @@

88 */

99use std::collections::HashMap;

1010

11use ::session::Session;

12use ::session::share::session;

11use ::session::AuthedUser;

1312use api::http::routing::{delete, get, post};

1413use api::http::{Json, Path, Router, State};

1514use api::rest::{AppResponseData, NoData};

@@ -79,7 +78,7 @@

7978 pub archived: bool,

8079}

8180

82pub fn router(

81pub fn protected(

8382 database: std::sync::Arc<db::AppDatabase>,

8483 space: SpaceService,

8584 chat: chat::services::service::ChatService,

@@ -253,10 +252,9 @@

253252)]

254253pub async fn list_cleanup_objects(

255254 State(state): State<CleanupState>,

256 session: Session,

255 AuthedUser(uid): AuthedUser,

257256 Path(space_name): Path<String>,

258257) -> Result<AppResponseData<Vec<CleanupObjectDto>>, ApiError> {

259 let uid = session::require_uid(&session)?;

260258 let space = require_owner(&state, &space_name, uid).await?;

261259 let db = &state.database;

262260

@@ -433,11 +431,10 @@

433431)]

434432pub async fn set_cleanup_visibility(

435433 State(state): State<CleanupState>,

436 session: Session,

434 AuthedUser(uid): AuthedUser,

437435 Path((space_name, kind, object_id)): Path<(String, String, Uuid)>,

438436 Json(cmd): Json<SetCleanupVisibilityCmd>,

439437) -> Result<AppResponseData<NoData>, ApiError> {

440 let uid = session::require_uid(&session)?;

441438 let space = require_owner(&state, &space_name, uid).await?;

442439 let db = &state.database;

443440

@@ -515,11 +512,10 @@

515512)]

516513pub async fn set_cleanup_archive(

517514 State(state): State<CleanupState>,

518 session: Session,

515 AuthedUser(uid): AuthedUser,

519516 Path((space_name, kind, object_id)): Path<(String, String, Uuid)>,

520517 Json(cmd): Json<SetRepoArchivedCmd>,

521518) -> Result<AppResponseData<NoData>, ApiError> {

522 let uid = session::require_uid(&session)?;

523519 require_owner(&state, &space_name, uid).await?;

524520 if kind != "repo" {

525521 return Err(ApiError::bad_request("only repositories support archiving"));

@@ -552,10 +548,9 @@

552548)]

553549pub async fn delete_cleanup_object(

554550 State(state): State<CleanupState>,

555 session: Session,

551 AuthedUser(uid): AuthedUser,

556552 Path((space_name, kind, object_id)): Path<(String, String, Uuid)>,

557553) -> Result<AppResponseData<NoData>, ApiError> {

558 let uid = session::require_uid(&session)?;

559554 let space = require_owner(&state, &space_name, uid).await?;

560555 let db = &state.database;

561556

@@ -682,10 +677,9 @@

682677)]

683678pub async fn clear_cleanup_overwrites(

684679 State(state): State<CleanupState>,

685 session: Session,

680 AuthedUser(uid): AuthedUser,

686681 Path((space_name, kind, object_id)): Path<(String, String, Uuid)>,

687682) -> Result<AppResponseData<NoData>, ApiError> {

688 let uid = session::require_uid(&session)?;

689683 let space = require_owner(&state, &space_name, uid).await?;

690684 if !matches!(kind.as_str(), "dir" | "object" | "repo" | "board") {

691685 return Err(ApiError::bad_request(

Modified lib/service/webapi/src/lib.rs +26 −17 View lib/service/webapi/src/lib.rs

@@ -45,31 +45,40 @@

4545 .merge(domains::chat::internal(deps))

4646 .with_state(deps.internal_service_key.clone())

4747 .wrap(Guard::ServiceKey);

48 let public = Router::<()>::new()

49 .setup(move |scope| {

50 scope

51 .app_data(web::Data::new(accounts))

52 .app_data(web::Data::new(push_config))

53 })

54 .merge(domains::account_deletion::router(deps))

55 .merge(domains::auth::router(deps))

56 .merge(domains::chat::router(deps))

57 .merge(domains::issues::router(deps))

58 .merge(domains::space::router(deps))

59 .merge(domains::user::router(deps))

60 .merge(domains::git::router(deps))

61 .merge(domains::pulls::router(deps))

62 .merge(cleanup::router(

48 let protected = Router::<()>::new()

49 .merge(domains::account_deletion::protected(deps))

50 .merge(domains::auth::protected(deps))

51 .merge(domains::chat::protected(deps))

52 .merge(domains::issues::protected(deps))

53 .merge(domains::space::protected(deps))

54 .merge(domains::user::protected(deps))

55 .merge(cleanup::protected(

6356 state.database.clone(),

6457 deps.space.clone(),

6558 deps.chat.clone(),

6659 deps.issues.clone(),

6760 deps.git.clone(),

68 ));

61 ))

62 .wrap(Guard::Session);

63 let open = Router::<()>::new()

64 .merge(domains::auth::public(deps))

65 .merge(domains::chat::public(deps))

66 .merge(domains::space::public(deps))

67 .merge(domains::user::public(deps))

68 .merge(domains::git::router(deps))

69 .merge(domains::pulls::router(deps));

70 let api = Router::<()>::new()

71 .setup(move |scope| {

72 scope

73 .app_data(web::Data::new(accounts))

74 .app_data(web::Data::new(push_config))

75 })

76 .merge(open)

77 .merge(protected);

6978

7079 Router::<()>::new()

7180 .nest("/api/v1/internal", internal)

72 .nest("/api/v1", public)

81 .nest("/api/v1", api)

7382 .nest("/pages", domains::auth::pages(deps))

7483 .merge(::bootstrap::health::router(state.clone()))

7584 .into_scope(web::scope(""))