1use super::errors::*;
2use super::types::*;
3
4use serde::{Deserialize, Serialize};
5
6#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
8#[serde(untagged)]
9pub enum ApiResponse<T> {
10 Success(T),
11 Error {
12 #[serde(deserialize_with = "empty_object_as_vec")]
13 errors: Vec<String>,
14 },
15}
16
17pub trait IntoResponseResult {
18 type Err: From<ApiResponseError> + std::error::Error + std::fmt::Debug;
19}
20
21impl<T: IntoResponseResult> ApiResponse<T> {
22 pub fn into_result(self) -> Result<T, <T as IntoResponseResult>::Err> {
23 match self {
24 Self::Success(v) => Ok(v),
25 Self::Error { errors } => Err(ApiResponseError::from(errors).into()),
26 }
27 }
28}
29
30#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum LoginResponse {
34 Success(LoginSuccess),
35 CaptchaError(LoginCaptchaError),
36 TOTPError(LoginTOTPError),
37}
38
39impl IntoResponseResult for LoginResponse {
40 type Err = LoginResponseError;
41}
42
43#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
45pub struct TOTPResponse {
46 #[serde(flatten)]
47 pub success: LoginSuccess,
48}
49
50impl IntoResponseResult for TOTPResponse {
51 type Err = TOTPResponseError;
52}
53
54#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
56pub struct UserInfoResponse {
57 pub user: User,
58}
59
60impl IntoResponseResult for UserInfoResponse {
61 type Err = UserResponseError;
62}
63
64#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
66pub struct ProfileInfoResponse {
67 pub user: Profile,
68}
69
70impl IntoResponseResult for ProfileInfoResponse {
71 type Err = ApiResponseCommonErrors;
72}
73
74#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
76pub struct CreatedGamesResponse {
77 #[serde(deserialize_with = "empty_object_as_vec")]
78 pub games: Vec<CreatedGame>,
79}
80
81impl IntoResponseResult for CreatedGamesResponse {
82 type Err = ApiResponseCommonErrors;
83}
84
85#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
87pub struct OwnedKeysResponse {
88 pub page: u64,
89 pub per_page: u64,
90 #[serde(deserialize_with = "empty_object_as_vec")]
91 pub owned_keys: Vec<OwnedKey>,
92}
93
94impl IntoResponseResult for OwnedKeysResponse {
95 type Err = ApiResponseCommonErrors;
96}
97
98#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
100pub struct ProfileCollectionsResponse {
101 #[serde(deserialize_with = "empty_object_as_vec")]
102 pub collections: Vec<Collection>,
103}
104
105impl IntoResponseResult for ProfileCollectionsResponse {
106 type Err = ApiResponseCommonErrors;
107}
108
109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
111pub struct CollectionInfoResponse {
112 pub collection: Collection,
113}
114
115impl IntoResponseResult for CollectionInfoResponse {
116 type Err = CollectionResponseError;
117}
118
119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
121pub struct CollectionGamesResponse {
122 pub page: u64,
123 pub per_page: u64,
124 #[serde(deserialize_with = "empty_object_as_vec")]
125 pub collection_games: Vec<CollectionGameItem>,
126}
127
128impl IntoResponseResult for CollectionGamesResponse {
129 type Err = CollectionResponseError;
130}
131
132#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
134pub struct GameInfoResponse {
135 pub game: Game,
136}
137
138impl IntoResponseResult for GameInfoResponse {
139 type Err = GameResponseError;
140}
141
142#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
144pub struct GameUploadsResponse {
145 #[serde(deserialize_with = "empty_object_as_vec")]
146 pub uploads: Vec<Upload>,
147}
148
149impl IntoResponseResult for GameUploadsResponse {
150 type Err = GameResponseError;
151}
152
153#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
155pub struct UploadInfoResponse {
156 pub upload: Upload,
157}
158
159impl IntoResponseResult for UploadInfoResponse {
160 type Err = UploadResponseError;
161}
162
163#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
165pub struct UploadBuildsResponse {
166 #[serde(deserialize_with = "empty_object_as_vec")]
167 pub builds: Vec<UploadBuild>,
168}
169
170impl IntoResponseResult for UploadBuildsResponse {
171 type Err = UploadResponseError;
172}
173
174#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
176pub struct BuildInfoResponse {
177 pub build: Build,
178}
179
180impl IntoResponseResult for BuildInfoResponse {
181 type Err = BuildResponseError;
182}
183
184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
185pub struct BuildUpgradePathResponseBuilds {
186 #[serde(deserialize_with = "empty_object_as_vec")]
187 pub builds: Vec<UpgradePathBuild>,
188}
189
190#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
192pub struct BuildUpgradePathResponse {
193 pub upgrade_path: BuildUpgradePathResponseBuilds,
194}
195
196impl IntoResponseResult for BuildUpgradePathResponse {
197 type Err = UpgradePathResponseError;
198}
199
200#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
202pub struct UploadScannedArchiveResponse {
203 pub scanned_archive: ScannedArchive,
204}
205
206impl IntoResponseResult for UploadScannedArchiveResponse {
207 type Err = UploadResponseError;
208}
209
210#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
212pub struct BuildScannedArchiveResponse {
213 pub scanned_archive: ScannedArchive,
214}
215
216impl IntoResponseResult for BuildScannedArchiveResponse {
217 type Err = BuildResponseError;
218}