zero4rs 2.0.0

pub mod enums;
pub mod models;

use crate::commons::compute_password_hash;
use crate::services::user_account_service::models::FetchLists;
use crate::services::user_account_service::models::UserRecord;
use crate::services::user_account_service::models::UserRecordVo;
use sqlx::{FromRow, MySql, Pool, QueryBuilder};

use crate::services::user_account_service::models::UserAccountInfo;
use crate::services::user_account_service::models::UserIdentifierInfo;
use crate::services::user_account_service::models::UserProfileInfo;

use crate::core::error2::Error;
use crate::core::error2::Result;
use crate::map;

// 用户列表
pub async fn user_lists(pool: &Pool<MySql>, input: FetchLists) -> Result<Vec<UserRecordVo>> {
    let mut query_builder: QueryBuilder<MySql> = QueryBuilder::new(
        "SELECT
            nick_name,
            user_bio,
            user_maxim,
            gender,
            resource_id
        from t_users order by created_at desc",
    );

    query_builder.push(" LIMIT");

    if let Some(limit) = input.limit {
        query_builder.push_bind(limit);
    } else {
        query_builder.push_bind(30);
    }

    query_builder.push(" OFFSET");

    if let Some(skip) = input.skip {
        query_builder.push_bind(skip);
    } else {
        query_builder.push_bind(0);
    }

    query_builder
        .build()
        .fetch_all(pool)
        .await
        .map_err(|e| {
            log::error!("error={:?}", e);
            anyhow::anyhow!(e)
        })?
        .into_iter()
        .map(|r| UserRecordVo::from_row(&r).map_err(Error::run_time))
        .collect()
}

pub async fn query_user_record(pool: &Pool<MySql>, user_id: &str) -> Result<Option<UserRecord>> {
    let mut query_builder = UserRecord::select_by_pk(user_id);

    let data = UserRecord::from_row(query_builder.build().fetch_one(pool).await.map_err(|e| {
        log::error!("error={:?}", e);
        anyhow::anyhow!(e)
    })?);

    match data {
        Ok(data) => Ok(data),
        Err(err) => {
            log::error!("error={:?}", err);
            Err(Error::UnexpectedError(err))
        }
    }
}

pub async fn update_user_profile(
    pool: &Pool<MySql>,
    user_id: &str,
    data: &UserProfileInfo,
) -> Result<bool> {
    let mut query_builder: QueryBuilder<MySql> = QueryBuilder::new(r#"update t_users"#);

    query_builder.push(" set nick_name = ");

    if data.nick_name.trim() != "" {
        query_builder.push_bind(data.nick_name.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", user_bio = ");

    if data.user_bio.trim() != "" {
        query_builder.push_bind(data.user_bio.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", user_maxim = ");

    if data.user_maxim.trim() != "" {
        query_builder.push_bind(data.user_maxim.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", last_updated_at = ");
    query_builder.push_bind(crate::commons::timestamp_millis());

    query_builder.push(" where user_id = ");
    query_builder.push_bind(user_id);

    let update_result_int = query_builder
        .build()
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!(e))?
        .rows_affected();

    Ok(update_result_int > 0)
}

pub async fn update_passwd(
    client: &crate::core::mysql::MysqlClient,
    user_id: &str,
    new_password: &str,
) -> Result<bool> {
    let hash = compute_password_hash(new_password)?;
    let now = crate::commons::timestamp_millis();

    let affect_row_count = client
        .execute(
            "user_mapper_update_passwd",
            Some(&map!("user_id", user_id, "new_password", hash, "now", now)),
        )
        .await?;

    Ok(affect_row_count > 0)
}

pub async fn update_user_identifier(
    pool: &Pool<MySql>,
    user_id: &str,
    data: &UserIdentifierInfo,
) -> Result<bool> {
    let mut query_builder: QueryBuilder<MySql> = QueryBuilder::new(r#"update t_users"#);

    query_builder.push(" set real_name = ");

    if data.real_name.trim() != "" {
        query_builder.push_bind(data.real_name.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", user_phone = ");

    if data.user_phone.trim() != "" {
        query_builder.push_bind(data.user_phone.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", gender = ");

    if data.gender.trim() != "" {
        query_builder.push_bind(data.gender.trim().to_uppercase());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", idno = ");

    if data.idno.trim() != "" {
        query_builder.push_bind(data.idno.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", last_updated_at = ");
    query_builder.push_bind(crate::commons::timestamp_millis());

    query_builder.push(" where user_id = ");
    query_builder.push_bind(user_id);

    let update_result_int = query_builder
        .build()
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!(e))?
        .rows_affected();

    Ok(update_result_int > 0)
}

pub async fn update_user_account_settings(
    pool: &Pool<MySql>,
    user_id: &str,
    data: &UserAccountInfo,
) -> Result<bool> {
    let mut query_builder: QueryBuilder<MySql> = QueryBuilder::new(r#"update t_users"#);

    query_builder.push(" set user_phone_secondary = ");

    if data.user_phone_secondary.trim() != "" {
        query_builder.push_bind(data.user_phone_secondary.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", user_email = ");

    if data.user_email.trim() != "" {
        query_builder.push_bind(data.user_email.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", user_address = ");

    if data.user_address.trim() != "" {
        query_builder.push_bind(data.user_address.trim().to_uppercase());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", user_linkman = ");

    if data.user_linkman.trim() != "" {
        query_builder.push_bind(data.user_linkman.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", user_linkphone = ");

    if data.user_linkphone.trim() != "" {
        query_builder.push_bind(data.user_linkphone.trim());
    } else {
        query_builder.push_bind(None::<String>);
    }

    query_builder.push(", last_updated_at = ");
    query_builder.push_bind(crate::commons::timestamp_millis());

    query_builder.push(" where user_id = ");
    query_builder.push_bind(user_id);

    let update_result_int = query_builder
        .build()
        .execute(pool)
        .await
        .map_err(|e| anyhow::anyhow!(e))?
        .rows_affected();

    Ok(update_result_int > 0)
}