97 lines
2.6 KiB
Rust
97 lines
2.6 KiB
Rust
use crate::download::download_asset_version;
|
|
use crate::nats_types::UploadMapfixRequest;
|
|
|
|
#[allow(dead_code)]
|
|
#[derive(Debug)]
|
|
pub enum InnerError{
|
|
Download(crate::download::Error),
|
|
IO(std::io::Error),
|
|
Json(serde_json::Error),
|
|
Upload(rbx_asset::cookie::UploadError),
|
|
}
|
|
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 upload_inner(
|
|
upload_info:UploadMapfixRequest,
|
|
cloud_context:&rbx_asset::cloud::Context,
|
|
cookie_context:&rbx_asset::cookie::Context,
|
|
group_id:Option<u64>,
|
|
)->Result<(),InnerError>{
|
|
// download the map model
|
|
let maybe_gzip=download_asset_version(cloud_context,rbx_asset::cloud::GetAssetVersionRequest{
|
|
asset_id:upload_info.ModelID,
|
|
version:upload_info.ModelVersion,
|
|
}).await.map_err(InnerError::Download)?;
|
|
|
|
// transparently handle gzipped models
|
|
let model_data=maybe_gzip.to_vec().map_err(InnerError::IO)?;
|
|
|
|
// upload the map to the strafesnet group
|
|
let _upload_response=cookie_context.upload(rbx_asset::cookie::UploadRequest{
|
|
assetid:upload_info.TargetAssetID,
|
|
groupId:group_id,
|
|
name:None,
|
|
description:None,
|
|
ispublic:None,
|
|
allowComments:None,
|
|
},model_data).await.map_err(InnerError::Upload)?;
|
|
|
|
Ok(())
|
|
}
|
|
#[allow(dead_code)]
|
|
#[derive(Debug)]
|
|
pub enum Error{
|
|
ApiActionMapfixUploaded(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 upload_mapfix(&self,upload_info:UploadMapfixRequest)->Result<(),Error>{
|
|
let mapfix_id=upload_info.MapfixID;
|
|
let result=upload_inner(
|
|
upload_info,
|
|
&self.cloud_context,
|
|
&self.cookie_context,
|
|
self.group_id,
|
|
).await;
|
|
|
|
// update the mapfix depending on the result
|
|
match result{
|
|
Ok(())=>{
|
|
// mark mapfix as uploaded, TargetAssetID is unchanged
|
|
self.mapfixes.set_status_uploaded(rust_grpc::validator::MapfixId{
|
|
id:mapfix_id,
|
|
}).await.map_err(Error::ApiActionMapfixUploaded)?;
|
|
},
|
|
Err(e)=>{
|
|
// log error
|
|
println!("[upload_mapfix] Error: {e}");
|
|
|
|
self.mapfixes.create_audit_error(
|
|
rust_grpc::validator::AuditErrorRequest{
|
|
id:mapfix_id,
|
|
error_message:e.to_string(),
|
|
}
|
|
).await.map_err(Error::ApiActionMapfixUploaded)?;
|
|
|
|
// update the mapfix model status to accepted
|
|
self.mapfixes.set_status_not_uploaded(rust_grpc::validator::MapfixId{
|
|
id:mapfix_id,
|
|
}).await.map_err(Error::ApiActionMapfixUploaded)?;
|
|
},
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|