iot-platform-rust-lite/src/api/user.rs

use crate::{AppState, api::{JsonBack, DataBack, Page}, datasource::{Datasource,SqliteParams}};
use crate::api::{check_login,token,md5,token_fail};
use serde::{Deserialize,Serialize};
use axum::{Json, extract::State};

#[derive(Deserialize)]
pub struct Uloggin{
    uname: String,
    passwd: String,
}

#[derive(serde::Serialize)]
pub struct UTokenBack{
    pub errcode: i16,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub errmsg: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub token: Option<String>
}

pub async fn u_loggin(
    State(state): State<AppState>,
    Json(u): axum::extract::Json<Uloggin>
) -> Json<UTokenBack> {

    let uid = match state.db_lite.query(
        "select id from user where uname=? and passwd=? and isdelete=0", 
        [u.uname,md5(u.passwd)],
        |r| {r.get::<usize,i64>(0)}).await{
            Ok(ans) => ans,
            Err(e) => {
                if e != ""{
                    println!("error when loggin {e}");
                }
                return Json(UTokenBack{
                    errcode: 2000,
                    errmsg: Some(format!("登录失败")),
                    token: None,
                })
            }
        };
    let token = token();
    if let Err(e) = state.db_lite.execute("update user set lastlogin=current_timestamp,token=? where id=?", (token.clone(), uid)).await{
        println!("error when loggin {e}")
    }
    Json(UTokenBack{
        errcode: 0,
        errmsg: None,
        token: Some(token),
    })
}

#[derive(Deserialize, Serialize)]
pub struct Uedit{
    token: Option<String>,  // 为空时判断uname-passwd创建账户
    id: Option<u64>,  // 不为空时为编辑该用户的uname-passwd，若uname-passwd为空则删除用户
    // 以下为可编辑项
    uname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    passwd: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    group: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    nickname: Option<String>,
    lastlogin: Option<u64>,
    createtime: Option<u64>
}

pub async fn u_edit(
    State(state): State<AppState>,
    Json(u): axum::extract::Json<Uedit>
) -> Json<JsonBack> {
    if u.token.is_none() {
        // 新建用户
        return axum::Json(JsonBack{
        errcode: 3000,
        errmsg: Some(format!("不允许创建用户"))
    });
    }
    let uid = match check_login(&state, u.token.unwrap()).await{
        Ok(uid)=> uid,
        Err(()) => return token_fail()
    };
    if let Some(_) = u.id {
        // 删除对应uid的用户
        return Json(JsonBack{
            errcode: 0,
            errmsg: Some(format!("无效的操作"))
        })
    }
        
    let mut param:SqliteParams = vec![];
    
    if let Err(e) = state.db_lite.execute(format!("update user set isdelete=0{}{}{}{} where id=?",
        if let Some(filter)=u.uname {param.push(Box::new (filter.clone()));",uname=?"} else {""},
        if let Some(filter)=u.passwd {param.push(Box::new (filter.clone()));",passwd=?"} else {""},
        if let Some(filter)=u.group {param.push(Box::new (filter.clone()));",group=?"} else {""},
        if let Some(filter)=u.nickname {param.push(Box::new (filter.clone()));",group=?"} else {""},
    ).as_str(), rusqlite::params_from_iter({param.push(Box::new(uid));param})).await{
        return  Json(JsonBack{
            errcode: 0,
            errmsg: Some(format!("数据库操作失败: {e}"))
        });
    }

    Json(JsonBack{
        errcode: 0,
        errmsg: None
    })
}


#[derive(Deserialize)]
pub struct Ulist{
    token: String,
    #[serde(flatten)]
    page: Option<Page>,
    #[serde(skip_serializing_if = "Option::is_none")]
    nickname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    group: Option<String>
}


pub async fn u_list(
    State(state): State<AppState>,
    Json(u): axum::extract::Json<Ulist>
) -> Json<DataBack<Vec<Uedit>>> {
    // 在这里实现用户列表查询逻辑
    // 可以使用 u.page.page, u.page.size, u.nickname, u.group
    let _ = match check_login(&state, u.token).await{
        Ok(uid) => uid,
        Err(_) => return Json(DataBack { errcode: 2000, errmsg: Some("鉴权失败: token失效".to_string()), data: None })
    };
    
    let (page,size) = if let Some(p)=u.page {(p.page,p.size)} else {(1,20)};
    let mut params: SqliteParams = vec![];
    
    match state.db_lite.query_rows(
        format!("select u.id, u.uname, u.nickname, strftime('%s',  u.lastlogin)*1000, strftime('%s', u.createtime)*1000 from user u where isdelete=0{}{} limit ? offset ?",
        if let Some(ref filter) = u.nickname {params.push(Box::new(filter.clone())); " and u.nickname like ?"} else {""},
        if let Some(ref filter) = u.group {params.push(Box::new(filter.clone())); " and u.group like ?"} else {""}
    ).as_str(),
     rusqlite::params_from_iter({params.push(Box::new(size));params.push(Box::new(size*(page-1)));params}) , |r| {
            Ok(Uedit{
                token: None,
                id: r.get(0)?,
                uname: r.get(1)?,
                passwd: None,
                group: None,
                nickname: r.get(2)?,
                lastlogin: r.get(3)?,
                createtime: r.get(4)?
            })
        }).await{
            Ok(ans) => Json(DataBack{
                errcode: 0,
                errmsg:None,
                data: Some(ans)
            }),
            Err(e) => {
                Json(DataBack { 
                    errcode: 0,
                    errmsg: Some(format!("查询失败: {e}")),
                    data: None
                })
            }
        }
}