shindo_coding_utils 0.4.9

use std::fmt;
use std::str::FromStr;

pub struct NatsPublishPayload<T: serde::Serialize> {
    pub stream: String,
    pub subject: String,
    pub data: T,
}

pub enum HandlerOutcome {
    Ack,
    AckAndPublish(NatsPublishPayload<serde_json::Value>),
    AckAndPublishFailed(NatsPublishPayload<serde_json::Value>),
    AckWithBusinessError(String), // Ticker code or relevant info
    Ignore,
    Error(String),
}

#[derive(Debug, Clone, PartialEq)]
pub enum SortOrder {
    Ascending,
    Descending,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AnalysisType {
    VolumeSpike,
    ForeignVolumeSpikeBuy,
    ForeignVolumeSpikeSell,
    SingleBuyOrderVolumeSpike,
    SingleSellOrderVolumeSpike,
}

impl FromStr for AnalysisType {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "volume_spike" => Ok(AnalysisType::VolumeSpike),
            "foreign_volume_spike_buy" => Ok(AnalysisType::ForeignVolumeSpikeBuy),
            "foreign_volume_spike_sell" => Ok(AnalysisType::ForeignVolumeSpikeSell),
            "single_buy_order_volume_spike" => Ok(AnalysisType::SingleBuyOrderVolumeSpike),
            "single_sell_order_volume_spike" => Ok(AnalysisType::SingleSellOrderVolumeSpike),
            _ => Err(()),
        }
    }
}

impl AnalysisType {
    pub fn as_str(&self) -> &'static str {
        match self {
            AnalysisType::VolumeSpike => "volume_spike",
            AnalysisType::ForeignVolumeSpikeBuy => "foreign_volume_spike_buy",
            AnalysisType::ForeignVolumeSpikeSell => "foreign_volume_spike_sell",
            AnalysisType::SingleBuyOrderVolumeSpike => "single_buy_order_volume_spike",
            AnalysisType::SingleSellOrderVolumeSpike => "single_sell_order_volume_spike",
        }
    }
}

impl fmt::Display for AnalysisType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}