Skip to main content

nil_client/client/cheat/
infrastructure.rs

1// Copyright (C) Call of Nil contributors
2// SPDX-License-Identifier: AGPL-3.0-only
3
4use crate::client::Client;
5use crate::error::Result;
6use crate::http;
7use nil_core::continent::Coord;
8use nil_core::infrastructure::Infrastructure;
9use nil_core::infrastructure::building::academy::recruit_queue::AcademyRecruitQueue;
10use nil_core::infrastructure::building::prefecture::build_queue::PrefectureBuildQueue;
11use nil_core::infrastructure::building::stable::recruit_queue::StableRecruitQueue;
12use nil_core::infrastructure::storage::OverallStorageCapacity;
13use nil_payload::cheat::infrastructure::*;
14
15impl Client {
16  pub async fn cheat_get_academy_recruit_queue(
17    &self,
18    req: CheatGetAcademyRecruitQueueRequest,
19  ) -> Result<AcademyRecruitQueue> {
20    http::json_put("cheat-get-academy-recruit-queue")
21      .body(req)
22      .server(self.server)
23      .maybe_authorization(self.authorization.as_ref())
24      .circuit_breaker(self.circuit_breaker())
25      .retry(&self.retry)
26      .user_agent(&self.user_agent)
27      .send()
28      .await
29  }
30
31  pub async fn cheat_get_academy_recruit_queues(
32    &self,
33    req: CheatGetAcademyRecruitQueuesRequest,
34  ) -> Result<Vec<(Coord, AcademyRecruitQueue)>> {
35    http::json_put("cheat-get-academy-recruit-queues")
36      .body(req)
37      .server(self.server)
38      .maybe_authorization(self.authorization.as_ref())
39      .circuit_breaker(self.circuit_breaker())
40      .retry(&self.retry)
41      .user_agent(&self.user_agent)
42      .send()
43      .await
44  }
45
46  pub async fn cheat_get_all_academy_recruit_queues(
47    &self,
48    req: CheatGetAllAcademyRecruitQueuesRequest,
49  ) -> Result<Vec<(Coord, AcademyRecruitQueue)>> {
50    http::json_put("cheat-get-all-academy-recruit-queues")
51      .body(req)
52      .server(self.server)
53      .maybe_authorization(self.authorization.as_ref())
54      .circuit_breaker(self.circuit_breaker())
55      .retry(&self.retry)
56      .user_agent(&self.user_agent)
57      .send()
58      .await
59  }
60
61  pub async fn cheat_get_all_prefecture_build_queues(
62    &self,
63    req: CheatGetAllPrefectureBuildQueuesRequest,
64  ) -> Result<Vec<(Coord, PrefectureBuildQueue)>> {
65    http::json_put("cheat-get-all-prefecture-build-queues")
66      .body(req)
67      .server(self.server)
68      .maybe_authorization(self.authorization.as_ref())
69      .circuit_breaker(self.circuit_breaker())
70      .retry(&self.retry)
71      .user_agent(&self.user_agent)
72      .send()
73      .await
74  }
75
76  pub async fn cheat_get_all_stable_recruit_queues(
77    &self,
78    req: CheatGetAllStableRecruitQueuesRequest,
79  ) -> Result<Vec<(Coord, StableRecruitQueue)>> {
80    http::json_put("cheat-get-all-stable-recruit-queues")
81      .body(req)
82      .server(self.server)
83      .maybe_authorization(self.authorization.as_ref())
84      .circuit_breaker(self.circuit_breaker())
85      .retry(&self.retry)
86      .user_agent(&self.user_agent)
87      .send()
88      .await
89  }
90
91  pub async fn cheat_get_infrastructure(
92    &self,
93    req: CheatGetInfrastructureRequest,
94  ) -> Result<Infrastructure> {
95    http::json_put("cheat-get-infrastructure")
96      .body(req)
97      .server(self.server)
98      .maybe_authorization(self.authorization.as_ref())
99      .circuit_breaker(self.circuit_breaker())
100      .retry(&self.retry)
101      .user_agent(&self.user_agent)
102      .send()
103      .await
104  }
105
106  pub async fn cheat_get_prefecture_build_queue(
107    &self,
108    req: CheatGetPrefectureBuildQueueRequest,
109  ) -> Result<PrefectureBuildQueue> {
110    http::json_put("cheat-get-prefecture-build-queue")
111      .body(req)
112      .server(self.server)
113      .maybe_authorization(self.authorization.as_ref())
114      .circuit_breaker(self.circuit_breaker())
115      .retry(&self.retry)
116      .user_agent(&self.user_agent)
117      .send()
118      .await
119  }
120
121  pub async fn cheat_get_prefecture_build_queues(
122    &self,
123    req: CheatGetPrefectureBuildQueuesRequest,
124  ) -> Result<Vec<(Coord, PrefectureBuildQueue)>> {
125    http::json_put("cheat-get-prefecture-build-queues")
126      .body(req)
127      .server(self.server)
128      .maybe_authorization(self.authorization.as_ref())
129      .circuit_breaker(self.circuit_breaker())
130      .retry(&self.retry)
131      .user_agent(&self.user_agent)
132      .send()
133      .await
134  }
135
136  pub async fn cheat_get_stable_recruit_queue(
137    &self,
138    req: CheatGetStableRecruitQueueRequest,
139  ) -> Result<StableRecruitQueue> {
140    http::json_put("cheat-get-stable-recruit-queue")
141      .body(req)
142      .server(self.server)
143      .maybe_authorization(self.authorization.as_ref())
144      .circuit_breaker(self.circuit_breaker())
145      .retry(&self.retry)
146      .user_agent(&self.user_agent)
147      .send()
148      .await
149  }
150
151  pub async fn cheat_get_stable_recruit_queues(
152    &self,
153    req: CheatGetStableRecruitQueuesRequest,
154  ) -> Result<Vec<(Coord, StableRecruitQueue)>> {
155    http::json_put("cheat-get-stable-recruit-queues")
156      .body(req)
157      .server(self.server)
158      .maybe_authorization(self.authorization.as_ref())
159      .circuit_breaker(self.circuit_breaker())
160      .retry(&self.retry)
161      .user_agent(&self.user_agent)
162      .send()
163      .await
164  }
165
166  pub async fn cheat_get_storage_capacity(
167    &self,
168    req: CheatGetStorageCapacityRequest,
169  ) -> Result<OverallStorageCapacity> {
170    http::json_put("cheat-get-storage-capacity")
171      .body(req)
172      .server(self.server)
173      .maybe_authorization(self.authorization.as_ref())
174      .circuit_breaker(self.circuit_breaker())
175      .retry(&self.retry)
176      .user_agent(&self.user_agent)
177      .send()
178      .await
179  }
180
181  pub async fn cheat_set_building_level(&self, req: CheatSetBuildingLevelRequest) -> Result<()> {
182    http::post("cheat-set-building-level")
183      .body(req)
184      .server(self.server)
185      .maybe_authorization(self.authorization.as_ref())
186      .circuit_breaker(self.circuit_breaker())
187      .user_agent(&self.user_agent)
188      .send()
189      .await
190  }
191
192  pub async fn cheat_set_max_infrastructure(
193    &self,
194    req: CheatSetMaxInfrastructureRequest,
195  ) -> Result<()> {
196    http::post("cheat-set-max-infrastructure")
197      .body(req)
198      .server(self.server)
199      .maybe_authorization(self.authorization.as_ref())
200      .circuit_breaker(self.circuit_breaker())
201      .user_agent(&self.user_agent)
202      .send()
203      .await
204  }
205}