src/api/dialog_info.rs

use std::collections::HashMap;
use actix_web::{HttpResponse, post, web};
use serde::Deserialize;
use serde_json::Value;
use serde_json::json;
use crate::api::JsonResponse;
use crate::AppState;
use crate::entity::dialog_info;
use crate::errors::AppError;
use crate::service::dialog_info::Query;
use crate::service::dialog_info::Mutation;

#[derive(Debug, Deserialize)]
pub struct ListParams {
    pub uid: i64,
    pub dialog_id: Option<i64>
}
#[post("/v1.0/dialogs")]
async fn list(params: web::Json<ListParams>, data: web::Data<AppState>) -> Result<HttpResponse, AppError> {
    let mut result = HashMap::new();
    if let Some(dia_id) = params.dialog_id{
        let dia = Query::find_dialog_info_by_id(&data.conn, dia_id).await?.unwrap();
        let kb = crate::service::kb_info::Query::find_kb_info_by_id(&data.conn, dia.kb_id).await?.unwrap();
        print!("{:?}", dia.history);
        let hist:Value = serde_json::from_str(&dia.history)?;
        let detail = json!({
            "dialog_id": dia_id,
            "dialog_name": dia.dialog_name.to_owned(),
            "created_at": dia.created_at.to_string().to_owned(),
            "updated_at": dia.updated_at.to_string().to_owned(),
            "history": hist,
            "kb_info": kb
        });

        result.insert("dialogs", vec![detail]);
    }
    else{
        let mut dias = Vec::<Value>::new();
        for dia in Query::find_dialog_infos_by_uid(&data.conn, params.uid).await?{
            let kb = crate::service::kb_info::Query::find_kb_info_by_id(&data.conn, dia.kb_id).await?.unwrap();
            let hist:Value = serde_json::from_str(&dia.history)?;
            dias.push(json!({
                "dialog_id": dia.dialog_id,
                "dialog_name": dia.dialog_name.to_owned(),
                "created_at": dia.created_at.to_string().to_owned(),
                "updated_at": dia.updated_at.to_string().to_owned(),
                "history": hist,
                "kb_info": kb
            }));
        }
        result.insert("dialogs", dias);
    }
    let json_response = JsonResponse {
        code: 200,
        err: "".to_owned(),
        data: result,
    };

    Ok(HttpResponse::Ok()
        .content_type("application/json")
        .body(serde_json::to_string(&json_response)?))
}

#[derive(Debug, Deserialize)]
pub struct RmParams {
    pub uid: i64,
    pub dialog_id: i64
}
#[post("/v1.0/delete_dialog")]
async fn delete(params: web::Json<RmParams>, data: web::Data<AppState>) -> Result<HttpResponse, AppError> {
    let _ = Mutation::delete_dialog_info(&data.conn, params.dialog_id).await?;

    let json_response = JsonResponse {
        code: 200,
        err: "".to_owned(),
        data: (),
    };

    Ok(HttpResponse::Ok()
        .content_type("application/json")
        .body(serde_json::to_string(&json_response)?))
}

#[derive(Debug, Deserialize)]
pub struct CreateParams {
    pub uid: i64,
    pub dialog_id: Option<i64>,
    pub kb_id: i64,
    pub name: String
}
#[post("/v1.0/create_dialog")]
async fn create(param: web::Json<CreateParams>, data: web::Data<AppState>) -> Result<HttpResponse, AppError> {
    let mut result = HashMap::new();
    if let Some(dia_id) = param.dialog_id {
        result.insert("dialog_id", dia_id);
        let dia = Query::find_dialog_info_by_id(&data.conn, dia_id).await?;
        let _ = Mutation::update_dialog_info_by_id(&data.conn, dia_id, &param.name, &dia.unwrap().history).await?;
    }
    else{
        let dia = Mutation::create_dialog_info(&data.conn, param.uid, param.kb_id, &param.name).await?;
        result.insert("dialog_id", dia.dialog_id.unwrap());
    }

    let json_response = JsonResponse {
        code: 200,
        err: "".to_owned(),
        data: result,
    };

    Ok(HttpResponse::Ok()
        .content_type("application/json")
        .body(serde_json::to_string(&json_response)?))
}


#[derive(Debug, Deserialize)]
pub struct UpdateHistoryParams {
    pub uid: i64,
    pub dialog_id: i64,
    pub history: Value
}
#[post("/v1.0/update_history")]
async fn update_history(param: web::Json<UpdateHistoryParams>, data: web::Data<AppState>) -> Result<HttpResponse, AppError> {
    let mut json_response = JsonResponse {
        code: 200,
        err: "".to_owned(),
        data: (),
    };

    if let Some(dia) = Query::find_dialog_info_by_id(&data.conn, param.dialog_id).await?{
        let _ = Mutation::update_dialog_info_by_id(&data.conn, param.dialog_id, &dia.dialog_name, 
                    &param.history.to_string()).await?;
    }
    else{
        json_response.code = 500;
        json_response.err = "Can't find dialog data!".to_owned();
    }
    

    Ok(HttpResponse::Ok()
        .content_type("application/json")
        .body(serde_json::to_string(&json_response)?))
}