102 lines
2.9 KiB
Rust
102 lines
2.9 KiB
Rust
use crate::download::download_asset_version;
|
|
use crate::nats_types::ReleaseMapfixRequest;
|
|
use crate::release::{count_modes,load_asset_versions};
|
|
|
|
#[expect(unused)]
|
|
#[derive(Debug)]
|
|
pub enum InnerError{
|
|
Download(crate::download::Error),
|
|
Modes(crate::release::ModesError),
|
|
LoadAssetVersions(crate::release::LoadAssetVersionsError),
|
|
LoadAssetVersionsListLength,
|
|
}
|
|
impl std::fmt::Display for InnerError{
|
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
|
write!(f,"{self:?}")
|
|
}
|
|
}
|
|
impl std::error::Error for InnerError{}
|
|
|
|
async fn release_inner(
|
|
cloud_context:&rbx_asset::cloud::Context,
|
|
cloud_context_luau_execution:&rbx_asset::cloud::Context,
|
|
load_asset_version_runtime:&rbx_asset::cloud::LuauSessionLatestRequest,
|
|
release_info:ReleaseMapfixRequest,
|
|
)->Result<rust_grpc::validator::MapfixReleaseRequest,InnerError>{
|
|
// download the map model
|
|
let maybe_gzip=download_asset_version(cloud_context,rbx_asset::cloud::GetAssetVersionRequest{
|
|
asset_id:release_info.ModelID,
|
|
version:release_info.ModelVersion,
|
|
}).await.map_err(InnerError::Download)?;
|
|
|
|
// count modes
|
|
let modes=count_modes(maybe_gzip).map_err(InnerError::Modes)?;
|
|
|
|
// fetch load asset version
|
|
let load_asset_versions=load_asset_versions(
|
|
cloud_context_luau_execution,
|
|
load_asset_version_runtime,
|
|
[release_info.TargetAssetID],
|
|
).await.map_err(InnerError::LoadAssetVersions)?;
|
|
|
|
// exactly one value in the results
|
|
let &[load_asset_version]=load_asset_versions.as_slice()else{
|
|
return Err(InnerError::LoadAssetVersionsListLength);
|
|
};
|
|
|
|
Ok(rust_grpc::validator::MapfixReleaseRequest{
|
|
mapfix_id:release_info.MapfixID,
|
|
target_asset_id:release_info.TargetAssetID,
|
|
asset_version:load_asset_version,
|
|
modes:modes,
|
|
})
|
|
}
|
|
|
|
#[expect(unused)]
|
|
#[derive(Debug)]
|
|
pub enum Error{
|
|
ApiActionMapfixRelease(tonic::Status),
|
|
}
|
|
impl std::fmt::Display for Error{
|
|
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
|
|
write!(f,"{self:?}")
|
|
}
|
|
}
|
|
impl std::error::Error for Error{}
|
|
|
|
impl crate::message_handler::MessageHandler{
|
|
pub async fn release_mapfix(&self,release_info:ReleaseMapfixRequest)->Result<(),Error>{
|
|
let mapfix_id=release_info.MapfixID;
|
|
let result=release_inner(
|
|
&self.cloud_context,
|
|
&self.cloud_context_luau_execution,
|
|
&self.load_asset_version_runtime,
|
|
release_info,
|
|
).await;
|
|
|
|
match result{
|
|
Ok(request)=>{
|
|
// update map metadata
|
|
self.mapfixes.set_status_released(request).await.map_err(Error::ApiActionMapfixRelease)?;
|
|
},
|
|
Err(e)=>{
|
|
// log error
|
|
println!("[release_mapfix] Error: {e}");
|
|
|
|
// post an error message to the audit log
|
|
self.mapfixes.create_audit_error(rust_grpc::validator::AuditErrorRequest{
|
|
id:mapfix_id,
|
|
error_message:e.to_string(),
|
|
}).await.map_err(Error::ApiActionMapfixRelease)?;
|
|
|
|
// update the mapfix model status to uploaded
|
|
self.mapfixes.set_status_not_released(rust_grpc::validator::MapfixId{
|
|
id:mapfix_id,
|
|
}).await.map_err(Error::ApiActionMapfixRelease)?;
|
|
},
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|