nomy-data-models 0.35.6

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
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#![allow(clippy::too_many_arguments, unused_imports, non_camel_case_types)]
//! Position 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;
use crate::enums::PositionDirection;
use crate::enums::PositionStatus;

/// Model for tracking trading positions.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Position {
    pub position_id: Uuid,
    pub chain_id: i32,
    pub exchange: String,
    pub market_type: String,
    pub position_direction: String,
    pub wallet_address: String,
    pub token_symbol_pair: String,
    pub token_address_pair: Option<String>,
    pub base_token_symbol: String,
    pub base_token_address: Option<String>,
    pub quote_token_symbol: String,
    pub quote_token_address: Option<String>,
    pub status: String,
    pub current_base_amount: Decimal,
    pub original_base_amount: Decimal,
    pub current_avg_entry_price: Decimal,
    pub avg_entry_price: Decimal,
    pub avg_exit_price: Decimal,
    pub cost_basis: Decimal,
    pub realized_pnl: Decimal,
    pub realized_pnl_usd: Decimal,
    pub realized_roi: Option<Decimal>,
    pub leverage: Option<Decimal>,
    pub opened_at: DateTime<Utc>,
    pub closed_at: Option<DateTime<Utc>>,
    pub fee_json: Option<JsonValue>,
    pub id: Uuid,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub created_by: Option<String>,
    pub updated_by: Option<String>,
}

impl Position {
    /// Create a new Position.
    pub fn new(
        position_id: Uuid,
        chain_id: i32,
        exchange: String,
        market_type: String,
        position_direction: String,
        wallet_address: String,
        token_symbol_pair: String,
        token_address_pair: String,
        base_token_symbol: String,
        base_token_address: String,
        quote_token_symbol: String,
        quote_token_address: String,
        status: String,
        current_base_amount: Decimal,
        original_base_amount: Decimal,
        current_avg_entry_price: Decimal,
        avg_entry_price: Decimal,
        avg_exit_price: Decimal,
        cost_basis: Decimal,
        realized_pnl: Decimal,
        realized_pnl_usd: Decimal,
        realized_roi: Decimal,
        leverage: Decimal,
        opened_at: DateTime<Utc>,
        closed_at: DateTime<Utc>,
        fee_json: JsonValue,
        id: Uuid,
        created_at: DateTime<Utc>,
        updated_at: DateTime<Utc>,
        created_by: String,
        updated_by: String,
    ) -> Self {
        Self {
            position_id,
            chain_id,
            exchange,
            market_type,
            position_direction,
            wallet_address,
            token_symbol_pair,
            token_address_pair: Some(token_address_pair),
            base_token_symbol,
            base_token_address: Some(base_token_address),
            quote_token_symbol,
            quote_token_address: Some(quote_token_address),
            status,
            current_base_amount,
            original_base_amount,
            current_avg_entry_price,
            avg_entry_price,
            avg_exit_price,
            cost_basis,
            realized_pnl,
            realized_pnl_usd,
            realized_roi: Some(realized_roi),
            leverage: Some(leverage),
            opened_at,
            closed_at: Some(closed_at),
            fee_json: Some(fee_json),
            id,
            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()
        }
    }
}