futucli/cmd/analysis/

screen.rs

//! Stock screener CLI adapter.

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

use crate::common::connect_gateway;
use crate::output::OutputFormat;

#[derive(Tabled)]
struct StockScreenRow {
    #[tabled(rename = "Stock ID")]
    stock_id: String,
    #[tabled(rename = "Results")]
    result_count: usize,
}

#[derive(Serialize)]
struct StockScreenJson {
    data_list: Vec<futu_proto::qot_stock_screen::StockScreenItem>,
    last_page: Option<i32>,
    all_count: Option<i32>,
}

#[derive(Tabled)]
struct OptionScreenRow {
    #[tabled(rename = "Security")]
    security: String,
    #[tabled(rename = "Name")]
    name: String,
    #[tabled(rename = "Price")]
    price: String,
}

#[derive(Serialize)]
struct OptionScreenJson {
    data_list: Vec<futu_proto::qot_option_screen::OptionScreenItem>,
    last_page: bool,
    all_count: i32,
}

#[derive(Tabled)]
struct WarrantScreenRow {
    #[tabled(rename = "Stock ID")]
    stock_id: String,
    #[tabled(rename = "Owner")]
    stock_owner: String,
    #[tabled(rename = "Price")]
    current_price: String,
}

#[derive(Serialize)]
struct WarrantScreenJson {
    warrants: Vec<futu_proto::qot_warrant_screen::WarrantItem>,
    last_page: Option<bool>,
    all_count: Option<i32>,
}

fn parse_stock_screen_c2s(json: &str) -> Result<futu_proto::qot_stock_screen::C2s> {
    let value: serde_json::Value =
        serde_json::from_str(json).map_err(|e| anyhow!("stock-screen c2s json: {e}"))?;
    serde_json::from_value(value).map_err(|e| anyhow!("stock-screen c2s json: {e}"))
}

fn parse_option_screen_c2s(json: &str) -> Result<futu_proto::qot_option_screen::C2s> {
    let value: serde_json::Value =
        serde_json::from_str(json).map_err(|e| anyhow!("option-screen c2s json: {e}"))?;
    serde_json::from_value(value).map_err(|e| anyhow!("option-screen c2s json: {e}"))
}

fn parse_warrant_screen_c2s(json: &str) -> Result<futu_proto::qot_warrant_screen::C2s> {
    let value: serde_json::Value =
        serde_json::from_str(json).map_err(|e| anyhow!("warrant-screen c2s json: {e}"))?;
    serde_json::from_value(value).map_err(|e| anyhow!("warrant-screen c2s json: {e}"))
}

pub async fn run_stock_screen(gateway: &str, c2s_json: &str, format: OutputFormat) -> Result<()> {
    let c2s = parse_stock_screen_c2s(c2s_json)?;
    let (client, _rx) = connect_gateway(gateway, "futucli-stock-screen").await?;
    let req = futu_proto::qot_stock_screen::Request { c2s };
    let frame = client
        .request(futu_core::proto_id::QOT_STOCK_SCREEN, req.encode_to_vec())
        .await?;
    let resp = futu_proto::qot_stock_screen::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode stock_screen: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "stock_screen ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s2c = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let rows: Vec<StockScreenRow> = s2c
        .data_list
        .iter()
        .map(|item| StockScreenRow {
            stock_id: item.stock_id.map(|id| id.to_string()).unwrap_or_default(),
            result_count: item.results.len(),
        })
        .collect();
    let json = StockScreenJson {
        data_list: s2c.data_list,
        last_page: s2c.last_page,
        all_count: s2c.all_count,
    };
    format.print_rows(&rows, &[json])?;
    Ok(())
}

pub async fn run_option_screen(gateway: &str, c2s_json: &str, format: OutputFormat) -> Result<()> {
    let c2s = parse_option_screen_c2s(c2s_json)?;
    let (client, _rx) = connect_gateway(gateway, "futucli-option-screen").await?;
    let req = futu_proto::qot_option_screen::Request { c2s };
    let frame = client
        .request(futu_core::proto_id::QOT_OPTION_SCREEN, req.encode_to_vec())
        .await?;
    let resp = futu_proto::qot_option_screen::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode option_screen: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "option_screen ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s2c = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let rows: Vec<OptionScreenRow> = s2c
        .data_list
        .iter()
        .map(|item| {
            let security = item
                .security
                .as_ref()
                .map(|sec| format!("{}.{}", sec.market, sec.code))
                .unwrap_or_default();
            OptionScreenRow {
                security,
                name: item.option_name.clone().unwrap_or_default(),
                price: item.price.map(|v| v.to_string()).unwrap_or_default(),
            }
        })
        .collect();
    let json = OptionScreenJson {
        data_list: s2c.data_list,
        last_page: s2c.last_page,
        all_count: s2c.all_count,
    };
    format.print_rows(&rows, &[json])?;
    Ok(())
}

pub async fn run_warrant_screen(gateway: &str, c2s_json: &str, format: OutputFormat) -> Result<()> {
    let c2s = parse_warrant_screen_c2s(c2s_json)?;
    let (client, _rx) = connect_gateway(gateway, "futucli-warrant-screen").await?;
    let req = futu_proto::qot_warrant_screen::Request { c2s };
    let frame = client
        .request(futu_core::proto_id::QOT_WARRANT_SCREEN, req.encode_to_vec())
        .await?;
    let resp = futu_proto::qot_warrant_screen::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode warrant_screen: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "warrant_screen ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s2c = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let rows: Vec<WarrantScreenRow> = s2c
        .warrants
        .iter()
        .map(|item| WarrantScreenRow {
            stock_id: item.stock_id.map(|id| id.to_string()).unwrap_or_default(),
            stock_owner: item
                .stock_owner
                .map(|id| id.to_string())
                .unwrap_or_default(),
            current_price: item
                .current_price
                .map(|price| price.to_string())
                .unwrap_or_default(),
        })
        .collect();
    let json = WarrantScreenJson {
        warrants: s2c.warrants,
        last_page: s2c.last_page,
        all_count: s2c.all_count,
    };
    format.print_rows(&rows, &[json])?;
    Ok(())
}