helios-server-rs/src/category/handler.rs

// use std::sync::Arc;
use axum::{http::StatusCode, extract::{State,Path}, Json, Router};
use axum::routing::{get, post};
use diesel::prelude::*;
// use diesel::update;
use serde::{Deserialize, Serialize};
// use serde_json::to_string;
use crate::util;
use crate::model::schema;
use crate::model::db_model;
// use crate::model::schema::categories::dsl::categories;
use crate::util::req::CommonResp;
use chrono::prelude::*;

#[derive(Serialize)]
pub struct CreateCategoryResponse {
    id: i64,
    name: String,
}

pub fn get_nest_handlers() -> Router<crate::AppState> {
    Router::new()
        .route("/", post(create_category).get(get_all_categories))
        .route("/:id", post(update_category).get(get_category))
}

#[derive(Deserialize)]
pub struct CreateCategoryRequest {
    name: String,
}

pub async fn create_category(
    State(app_state): State<crate::AppState>,
    Json(Payload): Json<CreateCategoryRequest>,
) -> Result<Json<db_model::Category>, (StatusCode, String)> {
    let uid: i64 = 123214124; // TODO replace with actual user id.
    // let ret = CreateCategoryResponse{id: 134132413541, name: "24532452".to_string()};
    let conn = app_state.db.get().await.map_err(util::req::internal_error)?;
    let new_category = db_model::CategoryForm{
        name: Payload.name,
        uid: uid,
    };
    let res = conn
        .interact(move |conn| {
            diesel::insert_into(schema::categories::table)
                .values(&new_category)
                .returning(db_model::Category::as_returning())
                .get_result(conn)
        })
        .await
        .map_err(util::req::internal_error)?
        .map_err(util::req::internal_error)?;
    // let ret = CreateCategoryResponse{id: res.id, name: res.name};
    Ok(Json(res))
}

pub async fn update_category(
    Path(id): Path<i64>,
    State(app_state): State<crate::AppState>,
    Json(Payload): Json<CreateCategoryRequest>,
) -> Result<Json<CommonResp>, (StatusCode, String)> {
    let uid: i64 = 123214124; // TODO replace with actual user id.
    // let ret = CreateCategoryResponse{id: 134132413541, name: "24532452".to_string()};
    let conn = app_state.db.get().await.map_err(util::req::internal_error)?;
    let now = Utc::now().naive_utc();
    let res = conn
        .interact(move |conn| {
            diesel::update(schema::categories::table)
                .filter(schema::categories::id.eq(id))
                .filter(schema::categories::uid.eq(uid))
                .set((
                         schema::categories::name.eq(Payload.name),
                        schema::categories::update_at.eq(now),
                ))
                .execute(conn)
        })
        .await
        .map_err(util::req::internal_error)?
        .map_err(util::req::internal_error)?;
    // let ret = CreateCategoryResponse{id: res.id, name: res.name};
    let resp = util::req::CommonResp{
        code: 0,
    };
    Ok(Json(resp))
}

pub async fn get_category(
    Path(id): Path<i64>,
    State(app_state): State<crate::AppState>,
) -> Result<Json<db_model::Category>, (StatusCode, String)>{
    let uid: i64 = 123214124; // TODO replace with actual user id.
    let conn = app_state.db.get().await.map_err(util::req::internal_error)?;
    let res = conn
        .interact(move |conn| {
            schema::categories::table
                .filter(schema::categories::id.eq(id))
                .filter(schema::categories::uid.eq(uid))
                .select(db_model::Category::as_select())
                .limit(1)
                .get_result(conn)
        })
        .await
        .map_err(util::req::internal_error)?
        .map_err(util::req::internal_error)?;
    Ok(Json(res))
}

pub async fn get_all_categories(
    State(app_state): State<crate::AppState>,
) -> Result<Json<Vec<db_model::Category>>, (StatusCode, String)>{
    let uid: i64 = 123214124; // TODO replace with actual user id.
    let conn = app_state.db.get().await.map_err(util::req::internal_error)?;
    let res = conn
        .interact(move |conn| {
            schema::categories::table
                .filter(schema::categories::uid.eq(uid))
                .select(db_model::Category::as_select())
                .load(conn)
        })
        .await
        .map_err(util::req::internal_error)?
        .map_err(util::req::internal_error)?;
    Ok(Json(res))
}