ek_ui/

appconfig.rs

//! 无界面一次性写档共用面(0.9.0;BD-APP-2/4):`ekapp add-account` CLI 与
//! **等效判据**(tests/ui_app_contract.rs)共用同一构造函数 —— 判据钉的
//! 就是「CLI 写出的段,喂给**真受理方法** `apply_config` 必被全采纳」。
//!
//! 段形对齐真实受理面(`ek-cta::dump_config`):明文键 + `secret://` 引用行,
//! 密码**值**先进密库(Windows 凭据管理器)再出引用;值永不落文件。
//! 形态常量(`gw_td_password`/`gw_md_password`)与 ek-cta 单源同拼写 —— 改名
//! 必须双动(判据钉 willcatch 漂移)。

use ek_core::{Field, SectionMap};

/// CLI 一次提交的账户档要素(密码不入结构面:与本进程 stdin 通道分开)。
#[derive(Debug, Clone)]
pub struct AcctSpec {
    pub broker_id: String,
    pub user: String,
    pub td_addr: String,
    pub md_addr: String,
    pub app_id: String,
    pub auth_code: String,
    /// 收录产品类(单字符 CTP 码逗号分隔;空 = 不写档,交给缺省)。
    pub classes: String,
    pub md_user: String,
    /// 行情侧独立密码(缺省 = None → 段里不出 md_password,行情会话回落 td 凭据)。
    pub md_password: Option<String>,
}

/// 派生注册名(ek-cta 单源;形 `ctp_<broker>_<账号>`)。
pub fn derived_name(spec: &AcctSpec) -> Result<String, String> {
    ek_ctp::derived_gateway_name(&spec.broker_id, &spec.user).ok_or_else(|| {
        format!(
            "派生注册名失败(broker={:?} 账号={:?}):字符不合名纪律",
            spec.broker_id, spec.user
        )
    })
}

/// 0.9.10 用户裁定「同一账户可多套前置(不同 IP/端口),别名备注切换」:
/// 唯一键 = **(broker, 账号, td 前置整串)**;`td 前置整串` = host:port 全串,
/// 天然区分「同 IP 不同端口」「同端口不同 IP」。
///
/// 命名规则(用户拍板 = 后缀式,老档零迁移):
/// - 基名 `ctp_<broker>_<账号>` 空 → 直用;
/// - 基名被占且来者 td 前置**与占者不同** → `ctp_…_2`、`_3`… 递增找空位(总长≤32);
/// - (broker,账号,td 前置)三处全同 → `Err`(重复登记,列表不重复)。
///
/// `taken`: 在场档案清单 `(gw, broker, user, td_addr)`;UI 面板与 CLI 共用本函数
/// (算法单源,两路永不长出两种后缀)。
///
/// # Errors
/// 三全同重复;后缀位耗尽(>32 字符上限)。
pub fn unique_gw_name(
    taken: &[(String, String, String, String)],
    broker: &str,
    user: &str,
    td_addr: &str,
) -> Result<String, String> {
    let broker = broker.trim();
    let user = user.trim();
    let td = td_addr.trim();
    let base = ek_ctp::derived_gateway_name(broker, user)
        .ok_or_else(|| format!("派生注册名失败(broker={broker:?} 账号={user:?}):字符不合名纪律"))?;
    for (gw, b, u, t) in taken {
        if b.trim() == broker && u.trim() == user && t.trim() == td {
            return Err(format!(
                "该 broker+账号+td 前置已在册(行 {gw},前置 {td});同前置不重复登记"
            ));
        }
    }
    if !taken.iter().any(|(gw, _, _, _)| gw == &base) {
        return Ok(base);
    }
    for n in 2..=99u32 {
        let cand = format!("{base}_{n}");
        if cand.len() > 32 {
            return Err(format!(
                "同 broker+账号 的第 {n} 套前置超派生名 32 字符上限({cand})"
            ));
        }
        if !taken.iter().any(|(gw, _, _, _)| gw == &cand) {
            return Ok(cand);
        }
    }
    Err("同 broker+账号 的前置套数已超 98 条(找不着后缀空位)".to_string())
}

/// 档案侧在场清单(扫 ctp.* 段 → (gw, broker, user, td_addr)),UI 与 CLI 共用。
///
/// # Errors
/// 目录列举失败(配置根不可用)。
pub fn taken_accounts(
    store: &ek_cfg::Store,
) -> Result<Vec<(String, String, String, String)>, String> {
    let mut out = Vec::new();
    for ns in store
        .list_namespaces()
        .map_err(|e| format!("档案目录列举失败: {e:?}"))?
    {
        let Some(gw) = ns.strip_prefix("ctp.") else {
            continue;
        };
        if let Ok(ek_cfg::LoadOutcome::Loaded { map, .. }) = store.load(&ns) {
            out.push((
                gw.to_string(),
                map.get_plain("broker_id").unwrap_or("").to_string(),
                map.get_plain("td_user").unwrap_or("").to_string(),
                map.get_plain("td_addr").unwrap_or("").to_string(),
            ));
        }
    }
    Ok(out)
}

/// 组段(校验 + 秘面登记 + 段构造;**store 由调用方给**,判据用临时根,
/// CLI 用生态缺省根 —— 同一函数,一字不差)。
///
/// 返回:网关派生名;调用方即将其拼 `ns = "ctp.<gw>"` 存档。
///
/// # Errors
/// 派生名/必填项/product_classes 形制不合;密库登记失败(缺后端面)。
pub fn write_account(
    store: &ek_cfg::Store,
    spec: &AcctSpec,
    password: &str,
) -> Result<String, String> {
    if spec.broker_id.is_empty()
        || spec.user.is_empty()
        || spec.td_addr.is_empty()
        || spec.app_id.is_empty()
        || spec.auth_code.is_empty()
    {
        return Err("缺必填要素(broker/user/td 前置/app_id/auth_code)".to_string());
    }
    if password.trim().is_empty() {
        return Err("密码为空:档案不接受无密码账户(受理校验同款)".to_string());
    }
    let gw = unique_gw_name(
        &taken_accounts(store)?,
        &spec.broker_id,
        &spec.user,
        &spec.td_addr,
    )?;
    let ns = format!("ctp.{gw}");
    ek_cfg::secret::register(
        &ns,
        "gw_td_password",
        ek_cfg::SecretValue::from_bytes(password.trim().to_owned()),
    )
    .map_err(|e| format!("密码登记密库失败: {e:?}"))?;
    let mut map = SectionMap::new(1)
        .set("broker_id", Field::plain(spec.broker_id.trim()))
        .set("td_addr", Field::plain(spec.td_addr.trim()))
        .set("td_user", Field::plain(spec.user.trim()))
        .set("td_app_id", Field::plain(spec.app_id.trim()))
        .set("td_auth_code", Field::plain(spec.auth_code.trim()))
        .set("td_password", Field::secret("gw_td_password"));
    if !spec.md_addr.trim().is_empty() {
        map = map.set("md_addr", Field::plain(spec.md_addr.trim()));
        if !spec.md_user.trim().is_empty() {
            map = map.set("md_user", Field::plain(spec.md_user.trim()));
        }
        if let Some(mp) = spec.md_password.as_deref() {
            let mp = mp.trim();
            if !mp.is_empty() {
                ek_cfg::secret::register(
                    &ns,
                    "gw_md_password",
                    ek_cfg::SecretValue::from_bytes(mp),
                )
                .map_err(|e| format!("行情密码登记密库失败: {e:?}"))?;
                map = map.set("md_password", Field::secret("gw_md_password"));
            }
        }
    }
    let classes = spec.classes.trim();
    if !classes.is_empty() {
        for c in classes.split(',').map(str::trim) {
            if c.chars().count() != 1 {
                return Err(format!(
                    "product_classes 项 {c:?} 非单字符 CTP 码(D-PC-FILTER)"
                ));
            }
        }
        map = map.set("product_classes", Field::plain(classes));
    }
    store
        .save(&ns, &map)
        .map_err(|e| format!("档案落盘失败: {e:?}"))?;
    Ok(gw)
}

/// 抹一个网关的档案段(**与 `write_account` 对称**,0.9.10 用户实锤定罪):
/// 界面删账户若只摘内存清册,**档案段 `ctp.{gw}` 还在** —— 启动清点
/// (`restore_saved_accounts_from` 扫 `ctp.*` 段)会把删掉的账户原样复活
/// (用户报「删了不存在的第三个账户,下次启动又显示」= 这条鬼户口)。
/// 所以摘行必须连档案一起抹:段文件(current/.bak/.new 三态)+ 该 ns 的
/// 秘库条(`secret::delete_ns` 整 ns 清,引用串指向的值不留孤儿)。
/// 在 plugin worker 落盘拍执行(渲染线程零文件 IO 纪律,与别名/自动连接同规)。
///
/// # Errors
/// 档案段存在但读不动(存储根故障)。**文件本就不存在 = 成功**(幂等:
/// 重复摘、摘从未存过档的行都无所失)。
pub fn purge_account_archive(store: &ek_cfg::Store, gw: &str) -> Result<(), String> {
    purge_ns_direct(store, &format!("ctp.{gw}"))
}

/// 直清负形(步骤 3 铲插件自写后的**软集中托底**:cfg.delete 总线缺席时才走;
/// 语义 = `cfg.delete` 清段同形 —— 段文件三态 + 秘库整 ns 清,幂等)。
pub fn purge_ns_direct(store: &ek_cfg::Store, ns: &str) -> Result<(), String> {
    match store.load(ns) {
        Ok(ek_cfg::LoadOutcome::Loaded { .. }) => {}
        Ok(ek_cfg::LoadOutcome::Fresh) => return Ok(()),
        Err(e) => return Err(format!("档案 {ns} 读不动: {e}")),
    }
    // 步骤 4 门面:清段走 `clear_ns` 单口(文件形 = 三件尽删;库形 = 行尽删,
    // 禁删库文件)。秘面整 ns 清照旧配对(后端层,与 cfg.delete 同序)。
    store
        .purge(ns)
        .map_err(|e| format!("档案 {ns} 清段失败: {e}"))?;
    ek_cfg::secret::forget_ns(ns).map_err(|e| format!("秘库 {ns} 清理失败: {e}"))?;
    Ok(())
}