nomy-data-models 0.2.4

Data model definitions for Nomy wallet analysis data processing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

#![allow(clippy::too_many_arguments, unused_imports, non_camel_case_types)]
//! EnrichedTrade model definition.
//!
//! This file is generated automatically from the Python SQLAlchemy model.
//! Do not edit this file manually.

use serde::{Deserialize, Serialize};

// Standard imports that may be needed
use chrono::{DateTime, Utc};
use rust_decimal::Decimal;
use serde_json::Value as JsonValue;
use uuid::Uuid;

// Additional imports specific to this model
use crate::enums::MarketType;

/// Model for storing enriched trade data with PnL calculations.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EnrichedTrade {
    pub pnl_usd: Option<Decimal>,
    pub pnl: Option<Decimal>,
    pub roi: Option<Decimal>,
    pub holding_duration: Option<chrono::Duration>,
    pub fee_json: Option<JsonValue>,
    pub id: Uuid,
    pub event_at: DateTime<Utc>,
    pub txn_id: String,
    pub wallet_address: String,
    pub chain_id: i32,
    pub exchange: String,
    pub is_buy: bool,
    pub token_price: Decimal,
    pub token_symbol_pair: String,
    pub token_address_pair: Option<String>,
    pub base_token_symbol: String,
    pub quote_token_symbol: String,
    pub base_token_address: Option<String>,
    pub quote_token_address: Option<String>,
    pub base_amount: Decimal,
    pub quote_amount: Decimal,
    pub usd_amount: Option<Decimal>,
    pub market_type: String,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub created_by: Option<String>,
    pub updated_by: Option<String>,
}

impl EnrichedTrade {
    /// Create a new EnrichedTrade.
    pub fn new(
        pnl_usd: Decimal,
        pnl: Decimal,
        roi: Decimal,
        holding_duration: chrono::Duration,
        fee_json: JsonValue,
        id: Uuid,
        event_at: DateTime<Utc>,
        txn_id: String,
        wallet_address: String,
        chain_id: i32,
        exchange: String,
        is_buy: bool,
        token_price: Decimal,
        token_symbol_pair: String,
        token_address_pair: String,
        base_token_symbol: String,
        quote_token_symbol: String,
        base_token_address: String,
        quote_token_address: String,
        base_amount: Decimal,
        quote_amount: Decimal,
        usd_amount: Decimal,
        market_type: String,
        created_at: DateTime<Utc>,
        updated_at: DateTime<Utc>,
        created_by: String,
        updated_by: String,
    ) -> Self {
        Self {
            pnl_usd: Some(pnl_usd),
            pnl: Some(pnl),
            roi: Some(roi),
            holding_duration: Some(holding_duration),
            fee_json: Some(fee_json),
            id,
            event_at,
            txn_id,
            wallet_address,
            chain_id,
            exchange,
            is_buy,
            token_price,
            token_symbol_pair,
            token_address_pair: Some(token_address_pair),
            base_token_symbol,
            quote_token_symbol,
            base_token_address: Some(base_token_address),
            quote_token_address: Some(quote_token_address),
            base_amount,
            quote_amount,
            usd_amount: Some(usd_amount),
            market_type,
            created_at,
            updated_at,
            created_by: Some(created_by),
            updated_by: Some(updated_by),
        }
    }

    /// Convert to a JSON string.
    pub fn to_json(&self) -> Result<String, serde_json::Error> {
        serde_json::to_string(self)
    }

    /// Convert from a JSON string.
    pub fn from_json(json: &str) -> Result<Self, serde_json::Error> {
        serde_json::from_str(json)
    }

    /// Convert to a dictionary-like structure.
    pub fn to_dict(&self) -> serde_json::Map<String, serde_json::Value> {
        let json = serde_json::to_value(self).unwrap_or(serde_json::Value::Null);
        if let serde_json::Value::Object(map) = json {
            map
        } else {
            serde_json::Map::new()
        }
    }
}