romm-api 1.0.0

HTTP client and domain logic for the RomM API
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

//! Save sync session endpoints (`/api/sync/*`).

use serde::{Deserialize, Serialize};
use serde_json::Value;

use super::Endpoint;

/// One operation returned by `POST /api/sync/negotiate`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SyncOperation {
    pub action: String,
    pub rom_id: u64,
    pub save_id: Option<u64>,
    pub file_name: String,
    pub slot: Option<String>,
    pub emulator: Option<String>,
    pub reason: String,
    pub server_updated_at: Option<String>,
    pub server_content_hash: Option<String>,
}

/// `POST /api/sync/negotiate` response.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SyncNegotiateResponse {
    pub session_id: u64,
    pub operations: Vec<SyncOperation>,
    pub total_upload: u64,
    pub total_download: u64,
    pub total_conflict: u64,
    pub total_no_op: u64,
}

/// `GET /api/sync/sessions*` response row.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SyncSessionSchema {
    pub id: u64,
    pub device_id: String,
    pub user_id: u64,
    pub status: String,
    pub initiated_at: String,
    pub completed_at: Option<String>,
    pub operations_planned: u64,
    pub operations_completed: u64,
    pub operations_failed: u64,
    pub error_message: Option<String>,
    pub created_at: String,
    pub updated_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SyncCompleteResponse {
    pub session: SyncSessionSchema,
    pub play_session_ingest: Option<Value>,
}

/// `POST /api/sync/negotiate`.
#[derive(Debug, Clone)]
pub struct NegotiateSync {
    pub body: Value,
}

impl Endpoint for NegotiateSync {
    type Output = SyncNegotiateResponse;

    fn method(&self) -> &'static str {
        "POST"
    }

    fn path(&self) -> String {
        "/api/sync/negotiate".into()
    }

    fn body(&self) -> Option<Value> {
        Some(self.body.clone())
    }
}

/// `POST /api/sync/sessions/{session_id}/complete`.
#[derive(Debug, Clone)]
pub struct CompleteSyncSession {
    pub session_id: u64,
    pub body: Value,
}

impl Endpoint for CompleteSyncSession {
    type Output = SyncCompleteResponse;

    fn method(&self) -> &'static str {
        "POST"
    }

    fn path(&self) -> String {
        format!("/api/sync/sessions/{}/complete", self.session_id)
    }

    fn body(&self) -> Option<Value> {
        Some(self.body.clone())
    }
}

/// `GET /api/sync/sessions`.
#[derive(Debug, Clone, Default)]
pub struct ListSyncSessions {
    pub device_id: Option<String>,
    pub limit: Option<u32>,
}

impl Endpoint for ListSyncSessions {
    type Output = Vec<SyncSessionSchema>;

    fn method(&self) -> &'static str {
        "GET"
    }

    fn path(&self) -> String {
        "/api/sync/sessions".into()
    }

    fn query(&self) -> Vec<(String, String)> {
        let mut out = Vec::new();
        if let Some(ref device_id) = self.device_id {
            if !device_id.is_empty() {
                out.push(("device_id".into(), device_id.clone()));
            }
        }
        if let Some(limit) = self.limit {
            out.push(("limit".into(), limit.to_string()));
        }
        out
    }
}

/// `GET /api/sync/sessions/{session_id}`.
#[derive(Debug, Clone)]
pub struct GetSyncSession {
    pub session_id: u64,
}

impl Endpoint for GetSyncSession {
    type Output = SyncSessionSchema;

    fn method(&self) -> &'static str {
        "GET"
    }

    fn path(&self) -> String {
        format!("/api/sync/sessions/{}", self.session_id)
    }
}

/// `POST /api/sync/devices/{device_id}/push-pull`.
#[derive(Debug, Clone)]
pub struct TriggerPushPull {
    pub device_id: String,
}

impl Endpoint for TriggerPushPull {
    type Output = SyncSessionSchema;

    fn method(&self) -> &'static str {
        "POST"
    }

    fn path(&self) -> String {
        format!("/api/sync/devices/{}/push-pull", self.device_id)
    }
}