Populate garage data from factory purchase better #6

rc_core/src/factory/adapter_enum.rs

@@ -6,7 +6,7 @@ pub enum Factory {
 
 #[async_trait::async_trait]
 impl rc_factory::VehicleFactoryAdapter for Factory {
-    async fn vehicle(&self, id: u32) -> Result<Option<rc_factory::VehicleInfo>, Box<dyn std::error::Error>> {
+    async fn vehicle(&self, id: u32) -> Result<Option<(rc_factory::VehicleInfo, rc_factory::VehicleQueryInfo)>, Box<dyn std::error::Error>> {
         match self {
             Self::Arc(x) => x.vehicle(id).await,
             Self::Custom(x) => x.vehicle(id).await,

rc_core/src/persist/user/account_json.rs

@@ -333,6 +333,8 @@ impl <C: Clone> super::User<C> for UserData {
             weapon_order: rc_database::sea_orm::ActiveValue::Set(rc_database::schema::dump_csv(&vehicle.weapon_order)),
             robot_data: rc_database::sea_orm::ActiveValue::Set(vehicle.robot_data),
             colour_data: rc_database::sea_orm::ActiveValue::Set(vehicle.colour_data),
+            crf_id: if let Some(crf_id) = vehicle.crf_id { rc_database::sea_orm::ActiveValue::Set(Some(crf_id as u32)) } else { Default::default() },
+            name: if let Some(new_name) = vehicle.name { rc_database::sea_orm::ActiveValue::Set(new_name) } else { Default::default() },
             ..Default::default()
         };
         self.save_garage_by_slot(entity, vehicle.slot as u32).await.map_err(|e| {

rc_core/src/persist/user/traits.rs

@@ -104,8 +104,10 @@ pub struct NewSlotData<C> {
 }
 
 pub struct VehicleData {
+    pub name: Option<String>,
     pub slot: i32,
     pub robot_data: Vec<u8>,
     pub colour_data: Vec<u8>,
     pub weapon_order: Vec<i32>,
+    pub crf_id: Option<i32>,
 }

rc_factory/src/arc/adapter.rs

@@ -23,16 +23,43 @@ impl ArcAdapter {
 
 #[async_trait::async_trait]
 impl crate::VehicleFactoryAdapter for ArcAdapter {
-    async fn vehicle(&self, id: u32) -> Result<Option<crate::VehicleInfo>, Box<dyn std::error::Error>> {
-        log::debug!("Get vehicle id {}", id);
-        let cubes = super::entities::robot_cubes::Entity::find_by_id(id).one(&self.orm).await?;
-        if let Some(cubes) = cubes {
+    async fn vehicle(&self, id: u32) -> Result<Option<(crate::VehicleInfo, crate::VehicleQueryInfo)>, Box<dyn std::error::Error>> {
+        log::debug!("Get vehicle by id {}", id);
+        let cubes = super::entities::robot_cubes::Entity::find_by_id(id).one(&self.orm);
+        let meta = super::entities::robot_metadata::Entity::find_by_id(id).one(&self.orm);
+        let cubes = cubes.await?;
+        let meta = meta.await?;
+        if let (Some(cubes), Some(meta)) = (cubes, meta) {
             use base64::Engine;
-            Ok(Some(crate::VehicleInfo {
-                id: id as _,
-                cube_data: base64::prelude::BASE64_STANDARD.decode(cubes.cube_data.as_bytes()).unwrap_or_default(),
-                colour_data: base64::prelude::BASE64_STANDARD.decode(cubes.colour_data.as_bytes()).unwrap_or_default(),
-            }))
+            Ok(Some((
+                crate::VehicleInfo {
+                    id: id as _,
+                    cube_data: base64::prelude::BASE64_STANDARD.decode(cubes.cube_data.as_bytes()).unwrap_or_default(),
+                    colour_data: base64::prelude::BASE64_STANDARD.decode(cubes.colour_data.as_bytes()).unwrap_or_default(),
+                },
+                crate::VehicleQueryInfo {
+                    id: meta.id as _,
+                    name: meta.name,
+                    description: meta.description,
+                    thumbnail: meta.thumbnail,
+                    added_by: meta.added_by,
+                    added_by_display_name: meta.added_by_display_name,
+                    added_date: crate::traits::parse_rc_date(&meta.added_date).unwrap_or_default(),
+                    expiry_date: if self.ignore_expiry { chrono::Utc::now() + chrono::Duration::weeks(2) } else {  crate::traits::parse_rc_date(&meta.expiry_date).unwrap_or_default() },
+                    cpu: meta.cpu as _,
+                    total_robot_ranking: meta.total_robot_ranking as _,
+                    rent_count: meta.rent_count as _,
+                    buy_count: meta.buy_count as _,
+                    buyable: meta.buyable != 0,
+                    removed_date: Default::default(),
+                    ban_date: Default::default(),
+                    featured: meta.featured != 0,
+                    banner_message: Default::default(),
+                    combat_rating: meta.combat_rating,
+                    cosmetic_rating: meta.cosmetic_rating,
+                    cube_amounts: Default::default(),
+                }
+            )))
         } else {
             Ok(None)
         }

rc_factory/src/traits.rs

@@ -1,6 +1,6 @@
 #[async_trait::async_trait]
 pub trait VehicleFactoryAdapter: Send + Sync + 'static {
-    async fn vehicle(&self, id: u32) -> Result<Option<VehicleInfo>, Box<dyn std::error::Error>>;
+    async fn vehicle(&self, id: u32) -> Result<Option<(VehicleInfo, VehicleQueryInfo)>, Box<dyn std::error::Error>>;
     async fn list(&self, query: libfj::robocraft::ListQuery) -> Result<Vec<VehicleQueryInfo>, Box<dyn std::error::Error>>;
 }
 

rc_services_room/src/operations/crf_purchase.rs

@@ -20,16 +20,18 @@ async fn do_handling(params: ParameterTable<()>, user: &crate::UserTy, factory:
     };
     if let Some(Typed::Int(factory_id)) = params.remove(&FACTORY_ID_PARAM_KEY) {
         // TODO charge for robot?
-        let vehicle_to_copy = factory.vehicle(factory_id as _).await.map_err(|e| {
+        let vehicle = factory.vehicle(factory_id as _).await.map_err(|e| {
             log::error!("Failed to retrieve vehicle {} (for copy-construct) from factory: {}", factory_id, e);
             rc_core::data::error_codes::WebServicesError::DatabaseError as i16
         })?;
-        if let Some(vehicle_to_copy) = vehicle_to_copy {
+        if let Some((vehicle_to_copy, vehicle_meta)) = vehicle {
             let to_save = rc_core::persist::user::VehicleData {
+                name: Some(vehicle_meta.name),
                 slot,
                 robot_data: vehicle_to_copy.cube_data,
                 colour_data: vehicle_to_copy.colour_data,
                 weapon_order: Vec::default(), // FIXME calculate this somehow? Or maybe get the factory adapter to calculate this
+                crf_id: Some(factory_id),
             };
             user_info.save_slot(to_save).await?;
         } else {

rc_services_room/src/operations/crf_vehicle_data.rs

@@ -15,7 +15,7 @@ async fn do_handling(params: ParameterTable<()>, _user: &crate::UserTy, factory:
             rc_core::data::error_codes::WebServicesError::DatabaseError as i16
         })?;
         if let Some(vehicle) = vehicle {
-            let vehicle_data = crate::data::crf::ItemData::from(vehicle);
+            let vehicle_data = crate::data::crf::ItemData::from(vehicle.0);
             params.insert(DATA_PARAM_KEY, vehicle_data.as_transmissible());
         } else {
             log::warn!("Failed to retrieve non-existent factory vehicle {}", id);

rc_services_room/src/operations/machine.rs

@@ -73,10 +73,12 @@ async fn do_save(params: ParameterTable<()>, user: &crate::UserTy) -> Result<Par
                     let weapon_order_filtered: Vec<_> = weapon_order.items.into_iter().filter_map(|ty| if let Typed::Int(i) = ty { Some(i) } else { None }).collect();
                     let user_info = user.user()?;
                     let vehicle_data = rc_core::persist::user::VehicleData {
+                        name: None,
                         slot: slot_index,
                         robot_data: robot_data.vec,
                         colour_data: colour_data.vec,
                         weapon_order: weapon_order_filtered,
+                        crf_id: None,
                     };
                     user_info.save_slot(vehicle_data).await?;
                     let mut params_out = std::collections::HashMap::with_capacity(1);