dealve-api 1.0.2

IsThereAnyDeal API client for Dealve
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
146
147
148
149
150
151
152

use serde::Deserialize;

#[derive(Debug, Deserialize)]
pub struct DealsResponse {
    pub list: Vec<DealItem>,
}

#[derive(Debug, Deserialize)]
pub struct GameSearchItem {
    pub id: String,
    pub title: String,
}

#[derive(Debug, Deserialize)]
pub struct DealItem {
    pub id: String,
    pub title: String,
    pub deal: DealInfo,
}

#[derive(Debug, Deserialize)]
pub struct DealInfo {
    pub shop: ShopInfo,
    pub price: PriceInfo,
    pub regular: PriceInfo,
    pub cut: u8,
    pub url: String,
    #[serde(rename = "historyLow")]
    pub history_low: Option<HistoryPrice>,
}

#[derive(Debug, Deserialize)]
pub struct ShopInfo {
    pub id: u32,
    pub name: String,
}

#[derive(Debug, Deserialize)]
pub struct PriceInfo {
    pub amount: f64,
    pub currency: String,
}

#[derive(Debug, Deserialize)]
pub struct HistoryPrice {
    pub amount: f64,
}

#[derive(Debug, Deserialize)]
pub struct GamePriceHistory {
    pub all: Option<PriceInfo>,
}

#[derive(Debug, Deserialize)]
pub struct GamePriceItem {
    pub id: String,
    #[serde(rename = "historyLow")]
    pub history_low: Option<GamePriceHistory>,
    pub deals: Vec<DealInfo>,
}

impl From<DealItem> for dealve_core::models::Deal {
    fn from(item: DealItem) -> Self {
        Self {
            id: item.id,
            title: item.title,
            shop: dealve_core::models::Shop {
                id: item.deal.shop.id.to_string(),
                name: item.deal.shop.name,
            },
            price: dealve_core::models::Price {
                amount: item.deal.price.amount,
                currency: item.deal.price.currency,
                discount: item.deal.cut,
            },
            regular_price: item.deal.regular.amount,
            url: item.deal.url,
            history_low: item.deal.history_low.map(|h| h.amount),
        }
    }
}

// Game Info API response types
#[derive(Debug, Deserialize)]
pub struct GameInfoResponse {
    pub id: String,
    pub title: String,
    #[serde(rename = "releaseDate")]
    pub release_date: Option<String>,
    pub developers: Option<Vec<CompanyInfo>>,
    pub publishers: Option<Vec<CompanyInfo>>,
    pub tags: Option<Vec<String>>,
}

#[derive(Debug, Deserialize)]
pub struct CompanyInfo {
    pub name: String,
}

impl From<GameInfoResponse> for dealve_core::models::GameInfo {
    fn from(resp: GameInfoResponse) -> Self {
        Self {
            id: resp.id,
            title: resp.title,
            release_date: resp.release_date,
            developers: resp
                .developers
                .map(|d| d.into_iter().map(|c| c.name).collect())
                .unwrap_or_default(),
            publishers: resp
                .publishers
                .map(|p| p.into_iter().map(|c| c.name).collect())
                .unwrap_or_default(),
            tags: resp.tags.unwrap_or_default(),
        }
    }
}

// Price History API response types
#[derive(Debug, Deserialize)]
pub struct PriceHistoryResponse(pub Vec<PriceHistoryItem>);

#[derive(Debug, Deserialize)]
pub struct PriceHistoryItem {
    pub timestamp: String,
    pub shop: ShopInfo,
    pub deal: Option<HistoryDeal>,
}

#[derive(Debug, Deserialize)]
pub struct HistoryDeal {
    pub price: PriceInfo,
}

impl PriceHistoryItem {
    /// Convert to core model, parsing the ISO timestamp to unix timestamp
    pub fn to_price_history_point(&self) -> Option<dealve_core::models::PriceHistoryPoint> {
        let deal = self.deal.as_ref()?;

        // Parse ISO 8601 timestamp to unix timestamp
        // Format: "2021-12-17T00:20:46+01:00"
        let timestamp = chrono::DateTime::parse_from_rfc3339(&self.timestamp)
            .map(|dt| dt.timestamp())
            .unwrap_or(0);

        Some(dealve_core::models::PriceHistoryPoint {
            timestamp,
            price: deal.price.amount,
            shop_name: self.shop.name.clone(),
        })
    }
}