use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum Direction {
Call,
Put,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OptionType {
Binary,
Digital,
Blitz,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BuyBinaryRequest {
pub symbol: String,
pub amount: f64,
pub direction: Direction,
pub expiration_minutes: u64,
pub option_type: OptionType,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BuyDigitalRequest {
pub symbol: String,
pub amount: f64,
pub direction: Direction,
pub duration_minutes: u64,
pub strike: f64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BuyBlitzRequest {
pub symbol: String,
pub amount: f64,
pub direction: Direction,
pub expiration_size_secs: u64,
pub profit_percent: f64,
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct RolloverParams {
pub deadtime: u32,
pub limit: u32,
pub offset: u32,
pub offset_from_expiration: u32,
pub expiration_size: u32,
}
pub type OrderId = String;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OperationStatus {
Open,
Closed,
Cancelled,
Rejected,
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum OperationResult {
Win(f64),
Loss(f64),
Equal(f64),
Pending,
}
impl OperationResult {
pub fn net(&self) -> Option<f64> {
match self {
OperationResult::Win(n) => Some(*n),
OperationResult::Loss(amount) => Some(-*amount),
OperationResult::Equal(_) => Some(0.0),
OperationResult::Pending => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Operation {
pub id: OrderId,
pub symbol: String,
pub amount: f64,
pub direction: Direction,
pub option_type: OptionType,
pub status: OperationStatus,
pub result: Option<OperationResult>,
pub payout_percent: Option<f64>,
pub opened_at: i64,
pub closed_at: Option<i64>,
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn net_de_resultados() {
assert_eq!(OperationResult::Win(8.2).net(), Some(8.2));
assert_eq!(OperationResult::Loss(10.0).net(), Some(-10.0));
assert_eq!(OperationResult::Equal(10.0).net(), Some(0.0));
assert_eq!(OperationResult::Pending.net(), None);
}
#[test]
fn request_binaria_serializa() {
let r = BuyBinaryRequest {
symbol: "EURUSD".into(),
amount: 10.0,
direction: Direction::Call,
expiration_minutes: 1,
option_type: OptionType::Binary,
};
let json = serde_json::to_string(&r).unwrap();
assert!(json.contains("\"direction\":\"Call\""));
assert!(json.contains("\"expiration_minutes\":1"));
}
}