Add basic queue CRUD

2 files changed, 228 insertions, 1 deletions

diff --git a/src/routers/mod.rs b/src/routers/mod.rs
index 80f9e74..c73e1f8 100644
--- a/src/routers/mod.rs
+++ b/src/routers/mod.rs
@@ -1,4 +1,5 @@
 mod account;
+mod queue;
 
 use utoipa::OpenApi;
 use utoipa_axum::router::OpenApiRouter;
@@ -6,5 +7,7 @@ use utoipa_axum::router::OpenApiRouter;
 use crate::{AppOpenApi, AppState};
 
 pub fn router() -> OpenApiRouter<AppState> {
-    OpenApiRouter::with_openapi(AppOpenApi::openapi()).nest("/account", account::router())
+    OpenApiRouter::with_openapi(AppOpenApi::openapi())
+        .nest("/account", account::router())
+        .nest("/queue", queue::routes())
 }
diff --git a/src/routers/queue.rs b/src/routers/queue.rs
new file mode 100644
index 0000000..1e93b2a
--- /dev/null
+++ b/src/routers/queue.rs
@@ -0,0 +1,224 @@
+use axum::extract::State;
+use entity::{queues, users};
+use sea_orm::{
+    ActiveModelTrait, ActiveValue::Set, ColumnTrait, DatabaseConnection, EntityTrait,
+    IntoActiveModel, ModelTrait, QueryFilter,
+};
+use serde::Deserialize;
+use utoipa::ToSchema;
+use utoipa_axum::{router::OpenApiRouter, routes};
+
+use crate::{
+    ApiError, ApiResult, AppState, ClientError, GlobalResponses, SuccessResponse,
+    extract::{ApiJson, Auth},
+    models::Queue,
+    tags::QUEUE,
+};
+
+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> {
+    Ok(queues::Entity::find_by_id(id)
+        .filter(queues::Column::OwnerId.eq(owner_id))
+        .one(db)
+        .await?
+        .ok_or(ClientError::QueueNotFound { id })?)
+}
+
+#[derive(Deserialize, ToSchema)]
+struct CreateQueueRequest {
+    #[schema(examples("John's queue", "Очередь Ивана"))]
+    name: String,
+}
+
+#[derive(Deserialize, ToSchema)]
+struct ChangeQueueNameRequest {
+    #[schema(examples(1))]
+    id: i64,
+    #[schema(examples("John's queue", "Очередь Ивана"))]
+    new_name: String,
+}
+
+#[derive(Deserialize, ToSchema)]
+struct ChangeQueueOwnerRequest {
+    #[schema(examples(1))]
+    id: i64,
+    #[schema(examples(1))]
+    new_owner_id: i64,
+}
+
+#[derive(Deserialize, ToSchema)]
+struct DeleteQueueRequest {
+    #[schema(examples(1))]
+    id: i64,
+}
+
+#[utoipa::path(
+    get,
+    path = "/owned",
+    tag = QUEUE,
+    summary = "Get owned",
+    description = "Get your own queues",
+    responses(
+        (
+            status = 200, body = SuccessResponse<Vec<Queue>>,
+            description = "Success response with your queues"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn owned(State(state): State<AppState>, Auth(user): Auth) -> ApiResult<Vec<Queue>> {
+    return Ok(SuccessResponse::ok(
+        queues::Entity::find()
+            .filter(queues::Column::OwnerId.eq(user.id))
+            .all(&state.db)
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect(),
+    ));
+}
+
+#[utoipa::path(
+    post,
+    path = "/create",
+    tag = QUEUE,
+    summary = "Create",
+    description = "Create a new queue",
+    request_body = CreateQueueRequest,
+    responses(
+        (
+            status = 200, body = SuccessResponse<Queue>,
+            description = "Success response with created queue"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn create(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiJson(req): ApiJson<CreateQueueRequest>,
+) -> ApiResult<Queue> {
+    Ok(SuccessResponse::ok(
+        queues::ActiveModel {
+            owner_id: Set(user.id),
+            name: Set(req.name),
+            ..Default::default()
+        }
+        .insert(&state.db)
+        .await?
+        .into(),
+    ))
+}
+
+#[utoipa::path(
+    put,
+    path = "/change/name",
+    tag = QUEUE,
+    summary = "Change name",
+    description = "Change queue name",
+    request_body = ChangeQueueNameRequest,
+    responses(
+        (
+            status = 200, body = SuccessResponse<Queue>,
+            description = "Success response with changed queue data"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn change_name(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiJson(req): ApiJson<ChangeQueueNameRequest>,
+) -> ApiResult<Queue> {
+    let mut active_queue = get_owned_queue(req.id, user.id, &state.db)
+        .await?
+        .into_active_model();
+
+    active_queue.name = Set(req.new_name);
+
+    let queue = active_queue.update(&state.db).await?;
+    Ok(SuccessResponse::ok(queue.into()))
+}
+
+#[utoipa::path(
+    put,
+    path = "/change/owner",
+    tag = QUEUE,
+    summary = "Change owner",
+    description = "Transfer ownership of the queue",
+    request_body = ChangeQueueOwnerRequest,
+    responses(
+        (
+            status = 200, body = SuccessResponse<Queue>,
+            description = "Success response with changed queue data"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn change_owner(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiJson(req): ApiJson<ChangeQueueOwnerRequest>,
+) -> ApiResult<Queue> {
+    if !user_exists(req.new_owner_id, &state.db).await? {
+        return Err(ClientError::UserNotFound {
+            id: req.new_owner_id,
+        }
+        .into());
+    }
+
+    let mut active_queue = get_owned_queue(req.id, user.id, &state.db)
+        .await?
+        .into_active_model();
+
+    active_queue.owner_id = Set(req.new_owner_id);
+
+    let queue = active_queue.update(&state.db).await?;
+    Ok(SuccessResponse::ok(queue.into()))
+}
+
+#[utoipa::path(
+    delete,
+    path = "/delete",
+    tag = QUEUE,
+    summary = "Delete",
+    description = "Delete queue",
+    request_body = DeleteQueueRequest,
+    responses(
+        (
+            status = 200, body = SuccessResponse<Queue>,
+            description = "Success response with deleted queue data"
+        ),
+        GlobalResponses
+    ),
+    security(("auth" = [])),
+)]
+async fn delete(
+    State(state): State<AppState>,
+    Auth(user): Auth,
+    ApiJson(req): ApiJson<DeleteQueueRequest>,
+) -> ApiResult<Queue> {
+    let queue = get_owned_queue(req.id, user.id, &state.db).await?;
+    queue.clone().delete(&state.db).await?;
+    Ok(SuccessResponse::ok(queue.into()))
+}
+
+pub fn routes() -> OpenApiRouter<AppState> {
+    OpenApiRouter::new()
+        .routes(routes!(owned))
+        .routes(routes!(create))
+        .routes(routes!(change_name))
+        .routes(routes!(change_owner))
+        .routes(routes!(delete))
+}