4 files changed, 310 insertions, 57 deletions

diff --git a/src/routers/account.rs b/src/routers/account.rs
index 51ce911..e39327a 100644
--- a/src/routers/account.rs
+++ b/src/routers/account.rs
@@ -2,30 +2,23 @@ use axum::extract::State;
 use chrono::{DateTime, Duration, Utc};
 use entity::users::{self};
 use sea_orm::{
-    ActiveModelTrait, ActiveValue::Set, ColumnTrait, DatabaseConnection, EntityTrait,
-    IntoActiveModel, ModelTrait, QueryFilter,
+    ActiveModelTrait, ActiveValue::Set, ColumnTrait, EntityTrait, IntoActiveModel, ModelTrait,
+    QueryFilter,
 };
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 use utoipa_axum::{router::OpenApiRouter, routes};
 
 use crate::{
-    ApiError, ApiResult, AppState, ClientError, GlobalResponses, JwtClaims, ServerError,
-    SuccessResponse, create_jwt, create_password,
+    ApiResult, AppState, ClientError, GlobalResponses, JwtClaims, ServerError, SuccessResponse,
+    create_jwt, create_password,
     extract::{ApiJson, Auth},
     models::Account,
     tags::ACCOUNT,
+    util::username_exists,
     validate_password,
 };
 
-async fn username_exists(username: &str, db: &DatabaseConnection) -> Result<bool, ApiError> {
-    Ok(users::Entity::find()
-        .filter(users::Column::Username.eq(username))
-        .one(db)
-        .await?
-        .is_some())
-}
-
 #[derive(Serialize, ToSchema)]
 #[schema(description = "Authorization token information")]
 struct Token {
@@ -205,7 +198,7 @@ async fn login(
 }
 
 #[utoipa::path(
-    put,
+    patch,
     path = "/update/password",
     tag = ACCOUNT,
     summary = "Change password",
@@ -214,7 +207,7 @@ async fn login(
     responses(
         (
             status = 200, body = SuccessResponse<Account>,
-            description = "Success response with the updated account data"
+            description = "Success response with the changed account data"
         ),
         GlobalResponses
     ),
@@ -238,7 +231,7 @@ async fn update_password(
 }
 
 #[utoipa::path(
-    put,
+    patch,
     path = "/update/username",
     tag = ACCOUNT,
     summary = "Change username",
@@ -247,7 +240,7 @@ async fn update_password(
     responses(
         (
             status = 200, body = SuccessResponse<Account>,
-            description = "Success response with the updated account data"
+            description = "Success response with the changed account data"
         ),
         GlobalResponses
     ),
@@ -273,7 +266,7 @@ async fn update_username(
 }
 
 #[utoipa::path(
-    put,
+    patch,
     path = "/update/name",
     tag = ACCOUNT,
     summary = "Change name",
@@ -282,7 +275,7 @@ async fn update_username(
     responses(
         (
             status = 200, body = SuccessResponse<Account>,
-            description = "Success response with the updated account data"
+            description = "Success response with the changed account data"
         ),
         GlobalResponses
     ),
@@ -332,7 +325,6 @@ async fn delete(
     }
 
     user.clone().delete(&state.db).await?;
-
     Ok(SuccessResponse::ok(user.into()))
 }
 
diff --git a/src/routers/queue/access.rs b/src/routers/queue/access.rs
index 1cba0b1..1aee8da 100644
--- a/src/routers/queue/access.rs
+++ b/src/routers/queue/access.rs
@@ -1,7 +1,260 @@
-use utoipa_axum::router::OpenApiRouter;
+use axum::extract::State;
+use chrono::{DateTime, Utc};
+use entity::invite_tokens;
+use sea_orm::{ActiveModelTrait, ActiveValue::Set, IntoActiveModel, ModelTrait};
+use serde::Deserialize;
+use utoipa::{IntoParams, ToSchema};
+use utoipa_axum::{router::OpenApiRouter, routes};
 
-use crate::AppState;
+use crate::{
+    ApiResult, AppState, GlobalResponses, SuccessResponse,
+    extract::{ApiJson, ApiQuery, Auth},
+    models::InviteToken,
+    tags::INVITE_TOKEN,
+    util::{get_owned_invite_token, get_owned_queue},
+};
+
+#[derive(Deserialize, IntoParams)]
+#[into_params(parameter_in = Query)]
+struct GetInviteTokenByIdQuery {
+    #[param(example = 1)]
+    id: i64,
+}
+
+#[derive(Deserialize, IntoParams)]
+#[into_params(parameter_in = Query)]
+struct GetInviteTokenByQueueIdQuery {
+    #[param(example = 1)]
+    queue_id: i64,
+}
+
+#[derive(Deserialize, ToSchema)]
+#[schema(description = "Body of the create invite token request")]
+struct CreateInviteTokenRequest {
+    #[schema(examples(1))]
+    queue_id: i64,
+    #[schema(examples("For classmates", "Для однокурсников"))]
+    name: String,
+    expiration_date: Option<DateTime<Utc>>,
+}
+
+#[derive(Deserialize, ToSchema)]
+#[schema(description = "Body of the expire invite token request")]
+struct ExpireInviteTokenRequest {
+    #[schema(examples(1))]
+    id: i64,
+}
+
+#[derive(Deserialize, ToSchema)]
+#[schema(description = "Body of the change invite token expiration date request")]
+struct ChangeInviteTokenExpirationDateRequest {
+    #[schema(examples(1))]
+    id: i64,
+    #[schema(examples("2000-01-01 00:00:00Z", "2000-01-01 03:00:00+03:00", json!(null)))]
+    expiration_date: Option<DateTime<Utc>>,
+}
+
+#[derive(Deserialize, ToSchema)]
+#[schema(description = "Body of the delete invite token request")]
+struct DeleteInviteTokenRequest {
+    #[schema(examples(1))]
+    id: i64,
+}
+
+#[utoipa::path(
+    get,
+    path = "/get/by_id",
+    tag = INVITE_TOKEN,
+    summary = "Get by id",
+    description = "Get the invite token by id",
+    params(GetInviteTokenByIdQuery),
+    responses(
+        (
+            status = 200, body = SuccessResponse<InviteToken>,
+            description = "Success response with the requested invite token"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn get_by_id(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiQuery(req): ApiQuery<GetInviteTokenByIdQuery>,
+) -> ApiResult<InviteToken> {
+    Ok(SuccessResponse::ok(
+        get_owned_invite_token(req.id, user.id, &state.db)
+            .await?
+            .into(),
+    ))
+}
+
+#[utoipa::path(
+    get,
+    path = "/get/by_queue_id",
+    tag = INVITE_TOKEN,
+    summary = "Get by queue id",
+    description = "Get the invite token by the queue id",
+    params(GetInviteTokenByQueueIdQuery),
+    responses(
+        (
+            status = 200, body = SuccessResponse<Vec<InviteToken>>,
+            description = "Success response with the requested invite tokens"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn get_by_queue_id(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiQuery(req): ApiQuery<GetInviteTokenByQueueIdQuery>,
+) -> ApiResult<Vec<InviteToken>> {
+    let queue = get_owned_queue(req.queue_id, user.id, &state.db).await?;
+
+    Ok(SuccessResponse::ok(
+        queue
+            .find_related(invite_tokens::Entity)
+            .all(&state.db)
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect(),
+    ))
+}
+
+#[utoipa::path(
+    post,
+    path = "/create",
+    tag = INVITE_TOKEN,
+    summary = "Create",
+    description = "Create a new invite token",
+    request_body = CreateInviteTokenRequest,
+    responses(
+        (
+            status = 200, body = SuccessResponse<InviteToken>,
+            description = "Success response with the created invite token"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn create(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiJson(req): ApiJson<CreateInviteTokenRequest>,
+) -> ApiResult<InviteToken> {
+    let queue = get_owned_queue(req.queue_id, user.id, &state.db).await?;
+
+    Ok(SuccessResponse::ok(
+        invite_tokens::ActiveModel {
+            token: Set(uuid::Uuid::new_v4()),
+            queue_id: Set(queue.id),
+            name: Set(req.name),
+            expiration_date: Set(req.expiration_date.as_ref().map(DateTime::naive_utc)),
+            ..Default::default()
+        }
+        .insert(&state.db)
+        .await?
+        .into(),
+    ))
+}
+
+#[utoipa::path(
+    patch,
+    path = "/expire",
+    tag = INVITE_TOKEN,
+    summary = "Expire",
+    description = "Expire the invite token",
+    request_body = ExpireInviteTokenRequest,
+    responses(
+        (
+            status = 200, body = SuccessResponse<InviteToken>,
+            description = "Success response with the changed invite token data"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn expire(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiJson(req): ApiJson<ExpireInviteTokenRequest>,
+) -> ApiResult<InviteToken> {
+    let mut active_invite_token = get_owned_invite_token(req.id, user.id, &state.db)
+        .await?
+        .into_active_model();
+
+    active_invite_token.expiration_date = Set(Some(Utc::now().naive_utc()));
+
+    let invite_token = active_invite_token.update(&state.db).await?;
+    Ok(SuccessResponse::ok(invite_token.into()))
+}
+
+#[utoipa::path(
+    patch,
+    path = "/update/expiration_date",
+    tag = INVITE_TOKEN,
+    summary = "Change expiration date",
+    description = "Change invite token expiration date",
+    request_body = ChangeInviteTokenExpirationDateRequest,
+    responses(
+        (
+            status = 200, body = SuccessResponse<InviteToken>,
+            description = "Success response with the changed invite token data"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn update_expiration_date(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiJson(req): ApiJson<ChangeInviteTokenExpirationDateRequest>,
+) -> ApiResult<InviteToken> {
+    let mut active_invite_token = get_owned_invite_token(req.id, user.id, &state.db)
+        .await?
+        .into_active_model();
+
+    active_invite_token.expiration_date =
+        Set(req.expiration_date.as_ref().map(DateTime::naive_utc));
+
+    let invite_token = active_invite_token.update(&state.db).await?;
+    Ok(SuccessResponse::ok(invite_token.into()))
+}
+
+#[utoipa::path(
+    delete,
+    path = "/delete",
+    tag = INVITE_TOKEN,
+    summary = "Delete",
+    description = "Delete the invite token",
+    request_body = DeleteInviteTokenRequest,
+    responses(
+        (
+            status = 200, body = SuccessResponse<InviteToken>,
+            description = "Success response with the deleted invite token data"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn delete(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiJson(req): ApiJson<DeleteInviteTokenRequest>,
+) -> ApiResult<InviteToken> {
+    let invite_token = get_owned_invite_token(req.id, user.id, &state.db).await?;
+    invite_token.clone().delete(&state.db).await?;
+    Ok(SuccessResponse::ok(invite_token.into()))
+}
 
 pub fn router() -> OpenApiRouter<AppState> {
     OpenApiRouter::new()
+        .routes(routes!(get_by_id))
+        .routes(routes!(get_by_queue_id))
+        .routes(routes!(create))
+        .routes(routes!(expire))
+        .routes(routes!(update_expiration_date))
+        .routes(routes!(delete))
 }
diff --git a/src/routers/queue/manage.rs b/src/routers/queue/manage.rs
index 8f42e07..b799458 100644
--- a/src/routers/queue/manage.rs
+++ b/src/routers/queue/manage.rs
@@ -1,50 +1,32 @@
 use axum::extract::State;
-use entity::{queues, users};
+use entity::queues;
 use sea_orm::{
-    ActiveModelTrait, ActiveValue::Set, ColumnTrait, DatabaseConnection, EntityTrait,
-    IntoActiveModel, ModelTrait, QueryFilter,
+    ActiveModelTrait, ActiveValue::Set, ColumnTrait, EntityTrait, IntoActiveModel, ModelTrait,
+    QueryFilter,
 };
 use serde::Deserialize;
 use utoipa::{IntoParams, ToSchema};
 use utoipa_axum::{router::OpenApiRouter, routes};
 
 use crate::{
-    ApiError, ApiResult, AppState, ClientError, GlobalResponses, SuccessResponse,
+    ApiResult, AppState, ClientError, GlobalResponses, SuccessResponse,
     extract::{ApiJson, ApiQuery, Auth},
     models::Queue,
     tags::QUEUE,
+    util::{get_owned_queue, user_exists},
 };
 
-async fn user_exists(id: i64, db: &DatabaseConnection) -> Result<bool, ApiError> {
-    Ok(users::Entity::find_by_id(id).one(db).await?.is_some())
-}
-
-async fn get_owned_queue(
-    id: i64,
-    owner_id: i64,
-    db: &DatabaseConnection,
-) -> Result<queues::Model, ApiError> {
-    let queue = queues::Entity::find_by_id(id)
-        .one(db)
-        .await?
-        .ok_or(ClientError::QueueNotFound { id })?;
-
-    if queue.owner_id != owner_id {
-        return Err(ClientError::NotQueueOwner { id: queue.id }.into());
-    }
-
-    Ok(queue)
-}
-
 #[derive(Deserialize, IntoParams)]
 #[into_params(parameter_in = Query)]
-struct GetByIdQueueQuery {
+struct GetQueueByIdQuery {
+    #[param(example = 1)]
     id: i64,
 }
 
 #[derive(Deserialize, IntoParams)]
 #[into_params(parameter_in = Query)]
 struct GetByOwnerIdQuery {
+    #[param(example = 1)]
     owner_id: i64,
 }
 
@@ -82,11 +64,11 @@ struct DeleteQueueRequest {
 
 #[utoipa::path(
     get,
-    path = "/get/id",
+    path = "/get/by_id",
     tag = QUEUE,
     summary = "Get by id",
     description = "Get the queue by id",
-    params(GetByIdQueueQuery),
+    params(GetQueueByIdQuery),
     responses(
         (
             status = 200, body = SuccessResponse<Option<Queue>>,
@@ -97,7 +79,7 @@ struct DeleteQueueRequest {
 )]
 async fn get_by_id(
     State(state): State<AppState>,
-    ApiQuery(req): ApiQuery<GetByIdQueueQuery>,
+    ApiQuery(req): ApiQuery<GetQueueByIdQuery>,
 ) -> ApiResult<Option<Queue>> {
     Ok(SuccessResponse::ok(
         queues::Entity::find_by_id(req.id)
@@ -109,10 +91,10 @@ async fn get_by_id(
 
 #[utoipa::path(
     get,
-    path = "/get/owner",
+    path = "/get/by_owner",
     tag = QUEUE,
     summary = "Get by owner",
-    description = "Get queues for a given owner",
+    description = "Get queues by the owner id",
     params(GetByOwnerIdQuery),
     responses(
         (
@@ -126,7 +108,7 @@ async fn get_by_owner(
     State(state): State<AppState>,
     ApiQuery(req): ApiQuery<GetByOwnerIdQuery>,
 ) -> ApiResult<Vec<Queue>> {
-    return Ok(SuccessResponse::ok(
+    Ok(SuccessResponse::ok(
         queues::Entity::find()
             .filter(queues::Column::OwnerId.eq(req.owner_id))
             .all(&state.db)
@@ -134,7 +116,32 @@ async fn get_by_owner(
             .into_iter()
             .map(Into::into)
             .collect(),
-    ));
+    ))
+}
+
+#[utoipa::path(
+    get,
+    path = "/get/owned",
+    tag = QUEUE,
+    summary = "Get owned",
+    description = "Get your queues",
+    responses(
+        (
+            status = 200, body = SuccessResponse<Vec<Queue>>,
+            description = "Success response with queues owned by you"
+        ),
+        GlobalResponses
+    ),
+)]
+async fn get_owned(State(state): State<AppState>, Auth(user): Auth) -> ApiResult<Vec<Queue>> {
+    Ok(SuccessResponse::ok(
+        user.find_related(queues::Entity)
+            .all(&state.db)
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect(),
+    ))
 }
 
 #[utoipa::path(
@@ -171,7 +178,7 @@ async fn create(
 }
 
 #[utoipa::path(
-    put,
+    patch,
     path = "/update/name",
     tag = QUEUE,
     summary = "Change name",
@@ -202,7 +209,7 @@ async fn update_name(
 }
 
 #[utoipa::path(
-    put,
+    patch,
     path = "/update/owner",
     tag = QUEUE,
     summary = "Change owner",
@@ -269,6 +276,7 @@ pub fn router() -> OpenApiRouter<AppState> {
     OpenApiRouter::new()
         .routes(routes!(get_by_id))
         .routes(routes!(get_by_owner))
+        .routes(routes!(get_owned))
         .routes(routes!(create))
         .routes(routes!(update_name))
         .routes(routes!(update_owner))
diff --git a/src/routers/queue/mod.rs b/src/routers/queue/mod.rs
index dd03956..9af1f01 100644
--- a/src/routers/queue/mod.rs
+++ b/src/routers/queue/mod.rs
@@ -8,5 +8,5 @@ use crate::AppState;
 pub fn router() -> OpenApiRouter<AppState> {
     OpenApiRouter::new()
         .merge(manage::router())
-        .merge(access::router())
+        .nest("/access", access::router())
 }