futucli/cmd/analysis/

price_reminder.rs

//! v1.4.110+ split (from cmd/analysis.rs): price_reminder domain.
//!
//! pub items: SetPriceReminderCommand,run_set_price_reminder,run_get_price_reminder,run_option_expiration_date.

use anyhow::{Result, anyhow, bail};
use futu_core::qot_price_reminder;
use prost::Message;
use serde::Serialize;
use tabled::Tabled;

use crate::common::{connect_gateway, parse_symbol};
use crate::output::OutputFormat;

pub struct SetPriceReminderCommand<'a> {
    pub gateway: &'a str,
    pub symbol: &'a str,
    pub op: i32,
    pub key: Option<i64>,
    pub reminder_type: Option<i32>,
    pub freq: Option<i32>,
    pub value: Option<f64>,
    pub note: Option<&'a str>,
    pub reminder_session_list: &'a [i32],
}

pub async fn run_set_price_reminder(input: SetPriceReminderCommand<'_>) -> Result<()> {
    let sec = parse_symbol(input.symbol)?;
    let (client, _rx) = connect_gateway(input.gateway, "futucli-set-price-reminder").await?;
    let req = futu_proto::qot_set_price_reminder::Request {
        c2s: futu_proto::qot_set_price_reminder::C2s {
            security: futu_proto::qot_common::Security {
                market: sec.market as i32,
                code: sec.code,
            },
            op: input.op,
            key: input.key,
            r#type: input.reminder_type,
            freq: input.freq,
            value: input.value,
            note: input.note.map(String::from),
            // v1.4.106 codex 1116 F4 [P2]: 透传 user 提供的 session list, daemon
            // 在 gateway 层统一处理美股默认 [Open, USPre, USAfter] / 非美股清空.
            reminder_session_list: input.reminder_session_list.to_vec(),
            header: None, // v1.4.110 codex Slice 1 schema 占位
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_SET_PRICE_REMINDER, body)
        .await?;
    let resp = futu_proto::qot_set_price_reminder::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "set_price_reminder ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let key_out = resp.s2c.map(|s| s.key);
    println!("✅ set_price_reminder ok: op={} key={key_out:?}", input.op);
    Ok(())
}

pub(super) fn parse_price_reminder_market(raw: &str) -> Result<i32> {
    if let Ok(value) = raw.parse::<i32>() {
        if qot_price_reminder::is_price_reminder_market(value) {
            return Ok(value);
        }
        bail!(
            "unknown price reminder market {value}: valid = {}",
            qot_price_reminder::PRICE_REMINDER_MARKET_VALID_VALUES
        );
    }

    qot_price_reminder::price_reminder_market_from_str_alias(raw).ok_or_else(|| {
        anyhow!(
            "unknown price reminder market {raw:?}: valid = {}",
            qot_price_reminder::PRICE_REMINDER_MARKET_VALID_VALUES
        )
    })
}

#[derive(Tabled)]
struct ReminderRow {
    #[tabled(rename = "Key")]
    key: i64,
    #[tabled(rename = "Type")]
    r#type: i32,
    #[tabled(rename = "Value")]
    value: String,
    #[tabled(rename = "Freq")]
    freq: i32,
    #[tabled(rename = "Enable")]
    enable: bool,
    #[tabled(rename = "Note")]
    note: String,
}

#[derive(Serialize)]
struct ReminderJson {
    symbol: String,
    name: Option<String>,
    key: i64,
    reminder_type: i32,
    value: f64,
    freq: i32,
    is_enable: bool,
    note: String,
}

pub async fn run_get_price_reminder(
    gateway: &str,
    symbol: Option<&str>,
    market: Option<&str>,
    format: OutputFormat,
) -> Result<()> {
    let (security, market_code) = match symbol {
        Some(s) => {
            let sec = parse_symbol(s)?;
            (
                Some(futu_proto::qot_common::Security {
                    market: sec.market as i32,
                    code: sec.code,
                }),
                None,
            )
        }
        None => (None, market.map(parse_price_reminder_market).transpose()?),
    };
    if security.is_none() && market_code.is_none() {
        bail!("need either --symbol or --market");
    }
    let (client, _rx) = connect_gateway(gateway, "futucli-price-reminder").await?;
    let req = futu_proto::qot_get_price_reminder::Request {
        c2s: futu_proto::qot_get_price_reminder::C2s {
            security,
            market: market_code,
            header: None,
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_GET_PRICE_REMINDER, body)
        .await?;
    let resp = futu_proto::qot_get_price_reminder::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "price_reminder ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let mut rows = Vec::new();
    let mut jsons = Vec::new();
    for pr in &s.price_reminder_list {
        let sym = format!("{}.{}", pr.security.market, pr.security.code);
        for r in &pr.item_list {
            rows.push(ReminderRow {
                key: r.key,
                r#type: r.r#type,
                value: format!("{:.3}", r.value),
                freq: r.freq,
                enable: r.is_enable,
                note: r.note.clone(),
            });
            jsons.push(ReminderJson {
                symbol: sym.clone(),
                name: pr.name.clone(),
                key: r.key,
                reminder_type: r.r#type,
                value: r.value,
                freq: r.freq,
                is_enable: r.is_enable,
                note: r.note.clone(),
            });
        }
    }
    format.print_rows(&rows, &jsons)?;
    Ok(())
}

#[derive(Tabled)]
struct OptionExpiryRow {
    #[tabled(rename = "Strike Time")]
    strike_time: String,
    #[tabled(rename = "Distance (days)")]
    distance: i32,
    #[tabled(rename = "Cycle")]
    cycle: String,
}

#[derive(Serialize)]
struct OptionExpiryJson {
    strike_time: Option<String>,
    distance_days: i32,
    cycle: Option<i32>,
}

pub async fn run_option_expiration_date(
    gateway: &str,
    owner: &str,
    index_type: Option<i32>,
    format: OutputFormat,
) -> Result<()> {
    let sec = parse_symbol(owner)?;
    let (client, _rx) = connect_gateway(gateway, "futucli-option-expiry").await?;
    let req = futu_proto::qot_get_option_expiration_date::Request {
        c2s: futu_proto::qot_get_option_expiration_date::C2s {
            owner: futu_proto::qot_common::Security {
                market: sec.market as i32,
                code: sec.code,
            },
            index_option_type: index_type,
            header: None, // v1.4.110 codex Slice 1 schema 占位
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_GET_OPTION_EXPIRATION_DATE, body)
        .await?;
    let resp = futu_proto::qot_get_option_expiration_date::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "option_expiration_date ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let mut rows = Vec::new();
    let mut jsons = Vec::new();
    for d in &s.date_list {
        rows.push(OptionExpiryRow {
            strike_time: d.strike_time.clone().unwrap_or_default(),
            distance: d.option_expiry_date_distance,
            cycle: d.cycle.map(|c| c.to_string()).unwrap_or_else(|| "-".into()),
        });
        jsons.push(OptionExpiryJson {
            strike_time: d.strike_time.clone(),
            distance_days: d.option_expiry_date_distance,
            cycle: d.cycle,
        });
    }
    format.print_rows(&rows, &jsons)?;
    Ok(())
}