NGnius
/
libfj
mirror of https://github.com/NGnius/libfj
Watch 1
Star 0
Fork 0
Code Issues 0 Releases 1 Wiki Activity
An unofficial collection of APIs used in FreeJam games and mods
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
38 Commits
1 Branch
181KB
Tree: f024193b43
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f024193b43'
${ noResults }
libfj/src/robocraft2/factory_json.rs

307 lines
8.7KB
Raw Blame History 

  1. use serde::{Deserialize, Serialize};

  2. 

  3. pub mod order {

  4.     pub const ASCENDING: &str = "ascending";

  5.     pub const DESCENDING: &str = "descending";

  6.     pub(super) fn default() -> &'static str {

  7.         ASCENDING

  8.     }

  9. }

  10. 

  11. pub mod sort {

  12.     pub const CPU_POWER: &str = "cpuPower";

  13.     pub const FIRE_POWER: &str = "firePower";

  14.     pub const ENGINE_POWER: &str = "enginePower";

  15.     pub const PRICE: &str = "price";

  16.     pub const DATE: &str = "date";

  17.     pub const CLUSTER_COUNT: &str = "clusterCount";

  18.     pub const VIEWS: &str = "views";

  19.     pub const MOST_PURCHASED: &str = "mostPurchased";

  20.     pub const DEFAULT: &str = "default";

  21.     pub(super) fn default() -> &'static str {

  22.         DEFAULT

  23.     }

  24. }

  25. 

  26. pub mod moderation {

  27.     pub const NO_FILTER: &str = "none";

  28.     pub const NEEDS_MODERATION: &str = "needsModeration";

  29.     pub const MODERATED: &str = "moderatedOnly";

  30.     pub(super) fn default() -> &'static str {

  31.         NO_FILTER

  32.     }

  33. }

  34. 

  35. #[derive(Deserialize, Serialize, Debug, Clone)]

  36. pub struct ErrorPayload {

  37.     #[serde(rename = "error")]

  38.     pub error: isize,

  39.     #[serde(rename = "errorMessage")]

  40.     pub error_message: String,

  41. }

  42. 

  43. // search endpoint

  44. 

  45. #[derive(Deserialize, Serialize, Clone)]

  46. pub struct SearchPayload {

  47.     #[serde(rename = "text")]

  48.     pub text: Option<String>,

  49.     #[serde(rename = "baseCpuMinimum")]

  50.     pub base_minimum_cpu: Option<isize>,

  51.     #[serde(rename = "baseCpuMaximum")]

  52.     pub base_maximum_cpu: Option<isize>,

  53.     #[serde(rename = "weaponCpuMinimum")]

  54.     pub weapon_minimum_cpu: Option<isize>,

  55.     #[serde(rename = "weaponCpuMaximum")]

  56.     pub weapon_maximum_cpu: Option<isize>,

  57.     #[serde(rename = "cosmeticCpuMinimum")]

  58.     pub cosmetic_minimum_cpu: Option<isize>,

  59.     #[serde(rename = "cosmeticCpuMaximum")]

  60.     pub cosmetic_maximum_cpu: Option<isize>,

  61.     #[serde(rename = "clusterMinimum")]

  62.     pub cluster_minimum: Option<isize>,

  63.     #[serde(rename = "clusterMaximum")]

  64.     pub cluster_maximum: Option<isize>,

  65.     #[serde(rename = "dateMinimum")]

  66.     pub date_minimum: Option<String>,

  67.     #[serde(rename = "dateMaximum")]

  68.     pub date_maximum: Option<String>,

  69.     #[serde(rename = "purchasedOnly")]

  70.     pub purchased_only: Option<bool>,

  71.     #[serde(rename = "creatorId")]

  72.     pub creator_id: Option<String>, // GUID

  73.     #[serde(rename = "page")]

  74.     pub page: Option<isize>,

  75.     #[serde(rename = "count")]

  76.     pub count: Option<isize>,

  77.     #[serde(rename = "sortBy", default="sort::default")]

  78.     pub sort_by: &'static str,

  79.     #[serde(rename = "orderBy", default="order::default")]

  80.     pub order_by: &'static str,

  81.     #[serde(rename = "modFilter", default="moderation::default")]

  82.     pub moderation_filter: &'static str,

  83. }

  84. 

  85. impl Default for SearchPayload {

  86.     fn default() -> Self {

  87.         Self {

  88.             text: None,

  89.             base_minimum_cpu: None,

  90.             base_maximum_cpu: None,

  91.             weapon_minimum_cpu: None,

  92.             weapon_maximum_cpu: None,

  93.             cosmetic_minimum_cpu: None,

  94.             cosmetic_maximum_cpu: None,

  95.             cluster_minimum: None,

  96.             cluster_maximum: None,

  97.             date_minimum: None,

  98.             date_maximum: None,

  99.             purchased_only: None,

  100.             creator_id: None,

  101.             page: None,

  102.             count: None,

  103.             sort_by: sort::DEFAULT,

  104.             order_by: order::ASCENDING,

  105.             moderation_filter: moderation::NO_FILTER,

  106.         }

  107.     }

  108. }

  109. 

  110. #[derive(Deserialize, Serialize, Clone, Debug)]

  111. pub struct SearchResponse {

  112.     #[serde(rename = "results")]

  113.     pub results: Vec<SearchResponseItem>,

  114. }

  115. 

  116. #[derive(Deserialize, Serialize, Clone, Debug)]

  117. pub struct SearchResponseItem {

  118.     #[serde(rename = "robot")]

  119.     pub robot: RobotInfo,

  120.     #[serde(rename = "prices")]

  121.     pub prices: Vec<RobotPrice>,

  122.     #[serde(rename = "purchased")]

  123.     pub purchased: bool,

  124. }

  125. 

  126. #[derive(Deserialize, Serialize, Clone, Debug)]

  127. pub struct RobotInfo {

  128.     #[serde(rename = "id")]

  129.     pub id: String, // GUID

  130.     #[serde(rename = "name")]

  131.     pub name: String,

  132.     #[serde(rename = "creatorId")]

  133.     pub creator_id: String, // GUID

  134.     #[serde(rename = "creatorName")]

  135.     pub creator_name: String,

  136.     #[serde(rename = "created")]

  137.     pub created: String, // date

  138.     #[serde(rename = "image")]

  139.     pub image: Option<String>, // url

  140.     #[serde(rename = "baseCpu")]

  141.     pub base_cpu: isize,

  142.     #[serde(rename = "weaponCpu")]

  143.     pub weapon_cpu: isize,

  144.     #[serde(rename = "cosmeticCpu")]

  145.     pub cosmetic_cpu: isize,

  146.     #[serde(rename = "clusterCount")]

  147.     pub cluster_count: isize,

  148.     #[serde(rename = "blockCounts")]

  149.     pub block_counts: std::collections::HashMap<usize, usize>,

  150.     #[serde(rename = "materialsUsed")]

  151.     pub materials_used: std::collections::HashSet<isize>,

  152.     #[serde(rename = "minimumOffsetX")]

  153.     pub minimum_offset_x: f64,

  154.     #[serde(rename = "minimumOffsetY")]

  155.     pub minimum_offset_y: f64,

  156.     #[serde(rename = "minimumOffsetZ")]

  157.     pub minimum_offset_z: f64,

  158.     #[serde(rename = "maximumOffsetX")]

  159.     pub maximum_offset_x: f64,

  160.     #[serde(rename = "maximumOffsetY")]

  161.     pub maximum_offset_y: f64,

  162.     #[serde(rename = "maximumOffsetZ")]

  163.     pub maximum_offset_z: f64,

  164. }

  165. 

  166. impl std::string::ToString for RobotInfo {

  167.     fn to_string(&self) -> String {

  168.         format!("{} ({}) by {} ({})", &self.name, &self.id, &self.creator_name, &self.creator_id)

  169.     }

  170. }

  171. 

  172. #[derive(Deserialize, Serialize, Clone, Debug)]

  173. pub struct RobotPrice {

  174.     #[serde(rename = "currency")]

  175.     pub currency: isize,

  176.     #[serde(rename = "amount")]

  177.     pub amount: isize,

  178. }

  179. 

  180. // create robot endpoint

  181. 

  182. #[derive(Deserialize, Serialize, Clone, Debug)]

  183. pub struct CreateRobotPayload {

  184.     #[serde(rename = "name")]

  185.     pub name: String,

  186.     #[serde(rename = "data")]

  187.     pub data: String, // base64

  188.     #[serde(rename = "image")]

  189.     pub image: String, // base64??

  190.     #[serde(rename = "baseCpu")]

  191.     pub base_cpu: isize,

  192.     #[serde(rename = "weaponCpu")]

  193.     pub weapon_cpu: isize,

  194.     #[serde(rename = "cosmeticCpu")]

  195.     pub cosmetic_cpu: isize,

  196.     #[serde(rename = "clusterCount")]

  197.     pub cluster_count: isize,

  198.     #[serde(rename = "blockCounts")]

  199.     pub block_counts: std::collections::HashMap<usize, usize>,

  200.     #[serde(rename = "materialsUsed")]

  201.     pub materials_used: std::collections::HashSet<isize>,

  202.     #[serde(rename = "minimumOffsetX")]

  203.     pub minimum_offset_x: f64,

  204.     #[serde(rename = "minimumOffsetY")]

  205.     pub minimum_offset_y: f64,

  206.     #[serde(rename = "minimumOffsetZ")]

  207.     pub minimum_offset_z: f64,

  208.     #[serde(rename = "maximumOffsetX")]

  209.     pub maximum_offset_x: f64,

  210.     #[serde(rename = "maximumOffsetY")]

  211.     pub maximum_offset_y: f64,

  212.     #[serde(rename = "maximumOffsetZ")]

  213.     pub maximum_offset_z: f64,

  214. }

  215. 

  216. #[derive(Deserialize, Serialize, Clone, Debug)]

  217. pub struct CreateRobotResponse {

  218.     #[serde(rename = "header")]

  219.     pub header: RobotInfo,

  220. }

  221. 

  222. // factory info endpoint

  223. 

  224. // (no payload -- this is a GET request)

  225. 

  226. #[derive(Deserialize, Serialize, Clone, Debug)]

  227. pub struct FactoryInfoResponse {

  228.     #[serde(rename = "robotCount")]

  229.     pub robot_count: isize,

  230.     #[serde(rename = "robotLimit")]

  231.     pub robot_limit: isize,

  232.     #[serde(rename = "publishedRobotCount")]

  233.     pub published_robot_count: isize,

  234.     #[serde(rename = "publishedRobotLimit")]

  235.     pub published_robot_limit: isize,

  236. }

  237. 

  238. // publish robot endpoint

  239. 

  240. #[derive(Deserialize, Serialize, Clone, Debug)]

  241. pub struct PublishRobotPayload {

  242.     #[serde(rename = "name")]

  243.     pub name: String,

  244.     #[serde(rename = "description")]

  245.     pub description: String,

  246.     #[serde(rename = "techPoints")]

  247.     pub techpoints: isize,

  248.     #[serde(rename = "bloxCoin")]

  249.     pub bloxcoin: isize,

  250. }

  251. 

  252. #[derive(Deserialize, Serialize, Clone, Debug)]

  253. pub struct PublishRobotResponse {

  254.     #[serde(rename = "header")]

  255.     pub header: RobotInfo,

  256.     #[serde(rename = "data")]

  257.     pub data: String, // base64

  258. }

  259. 

  260. // get my robots endpoint

  261. 

  262. // (no payload -- this is a GET request)

  263. 

  264. #[derive(Deserialize, Serialize, Clone, Debug)]

  265. pub struct MyRobotsResponse {

  266.     #[serde(rename = "vehicles")]

  267.     pub vehicles: Vec<RobotInfo>,

  268. }

  269. 

  270. // get robot endpoint

  271. 

  272. // (no payload -- this is a GET request)

  273. 

  274. #[derive(Deserialize, Serialize, Clone, Debug)]

  275. pub struct GetRobotResponse {

  276.     #[serde(rename = "header")]

  277.     pub header: RobotInfo,

  278.     #[serde(rename = "data")]

  279.     pub data: String, // base64

  280.     #[serde(rename = "description")]

  281.     pub description: String,

  282.     #[serde(rename = "created")]

  283.     pub created: String, // date

  284. }

  285. 

  286. // moderate robot endpoint

  287. 

  288. #[derive(Deserialize, Serialize, Clone, Debug)]

  289. pub struct ModerateRobotPayload {

  290.     #[serde(rename = "approve")]

  291.     pub approve: bool,

  292.     #[serde(rename = "reason")]

  293.     pub reason: String,

  294. }

  295. 

  296. // (no response)

  297. 

  298. // report robot endpoint

  299. 

  300. #[derive(Deserialize, Serialize, Clone, Debug)]

  301. pub struct ReportRobotPayload {

  302.     #[serde(rename = "reason")]

  303.     pub reason: String,

  304. }

  305. 

  306. // (no response)