aidan9382/asset-tool
1
Fork 0
forked from StrafesNET/asset-tool
Code Pull Requests Activity

builds

Browse Source
This commit is contained in:
Quaternions 2024-07-02 15:22:22 -07:00
parent cc7e445498
commit d53efd7441
4 changed files with 256 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

@ -1166,7 +1166,7 @@ dependencies = [
[[package]] [[package]]
name = "rbx_asset" name = "rbx_asset"
version = "0.1.0" version = "0.2.0"
dependencies = [ dependencies = [
"chrono", "chrono",
"flate2", "flate2",

2
rbx_asset/Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "rbx_asset" name = "rbx_asset"
version = "0.1.0" version = "0.2.0"
edition = "2021" edition = "2021"
publish = ["strafesnet"] publish = ["strafesnet"]

16
rbx_asset/src/context.rs
View File

@ -103,17 +103,17 @@ pub struct GetAssetRequest{
pub version:Option<u64>, pub version:Option<u64>,
} }
#[derive(Debug)] #[derive(Debug)]
pub enum DownloadError{ pub enum GetError{
ParseError(url::ParseError), ParseError(url::ParseError),
Reqwest(reqwest::Error), Reqwest(reqwest::Error),
IO(std::io::Error) IO(std::io::Error)
} }
impl std::fmt::Display for DownloadError{ impl std::fmt::Display for GetError{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f,"{self:?}") write!(f,"{self:?}")
} }
} }
impl std::error::Error for DownloadError{} impl std::error::Error for GetError{}
pub struct AssetVersionsRequest{ pub struct AssetVersionsRequest{
pub asset_id:u64, pub asset_id:u64,
@ -267,8 +267,8 @@ impl RobloxContext{
Ok(resp.json::<AssetResponse>().await.map_err(UpdateError::Reqwest)?) Ok(resp.json::<AssetResponse>().await.map_err(UpdateError::Reqwest)?)
} }
pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,DownloadError>{ pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(DownloadError::ParseError)?; let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(GetError::ParseError)?;
//url borrow scope //url borrow scope
{ {
let mut query=url.query_pairs_mut();//borrow here let mut query=url.query_pairs_mut();//borrow here
@ -277,15 +277,15 @@ impl RobloxContext{
query.append_pair("version",version.to_string().as_str()); query.append_pair("version",version.to_string().as_str());
} }
} }
let resp=self.get(url).await.map_err(DownloadError::Reqwest)?; let resp=self.get(url).await.map_err(GetError::Reqwest)?;
let body=resp.bytes().await.map_err(DownloadError::Reqwest)?; let body=resp.bytes().await.map_err(GetError::Reqwest)?;
match maybe_gzip_decode(&mut std::io::Cursor::new(body)){ match maybe_gzip_decode(&mut std::io::Cursor::new(body)){
Ok(ReaderType::GZip(readable))=>read_readable(readable), Ok(ReaderType::GZip(readable))=>read_readable(readable),
Ok(ReaderType::Raw(readable))=>read_readable(readable), Ok(ReaderType::Raw(readable))=>read_readable(readable),
Err(e)=>Err(e), Err(e)=>Err(e),
}.map_err(DownloadError::IO) }.map_err(GetError::IO)
} }
pub async fn get_asset_versions(&self,config:AssetVersionsRequest)->Result<AssetVersionsResponse,AssetVersionsError>{ pub async fn get_asset_versions(&self,config:AssetVersionsRequest)->Result<AssetVersionsResponse,AssetVersionsError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions",config.asset_id); let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions",config.asset_id);

358
src/main.rs
View File

@ -25,8 +25,10 @@ enum Commands{
DownloadGroupInventoryJson(DownloadGroupInventoryJsonSubcommand), DownloadGroupInventoryJson(DownloadGroupInventoryJsonSubcommand),
CreateAsset(CreateAssetSubcommand), CreateAsset(CreateAssetSubcommand),
UploadAsset(UpdateAssetSubcommand), UploadAsset(UpdateAssetSubcommand),
UploadPlace(UpdatePlaceSubcommand),
Compile(CompileSubcommand), Compile(CompileSubcommand),
CompileUpload(CompileUploadSubcommand), CompileUploadAsset(CompileUploadAssetSubcommand),
CompileUploadPlace(CompileUploadPlaceSubcommand),
Decompile(DecompileSubcommand), Decompile(DecompileSubcommand),
DecompileHistoryIntoGit(DecompileHistoryIntoGitSubcommand), DecompileHistoryIntoGit(DecompileHistoryIntoGitSubcommand),
DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand), DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand),
@ -36,10 +38,12 @@ enum Commands{
struct DownloadHistorySubcommand{ struct DownloadHistorySubcommand{
#[arg(long)] #[arg(long)]
asset_id:AssetID, asset_id:AssetID,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie_type:CookieType, api_key_literal:Option<String>,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie:String, api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
output_folder:Option<PathBuf>, output_folder:Option<PathBuf>,
#[arg(long)] #[arg(long)]
@ -51,10 +55,12 @@ struct DownloadHistorySubcommand{
} }
#[derive(Args)] #[derive(Args)]
struct DownloadSubcommand{ struct DownloadSubcommand{
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie_type:CookieType, api_key_literal:Option<String>,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie:String, api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
output_folder:Option<PathBuf>, output_folder:Option<PathBuf>,
#[arg(required=true)] #[arg(required=true)]
@ -62,10 +68,12 @@ struct DownloadSubcommand{
} }
#[derive(Args)] #[derive(Args)]
struct DownloadGroupInventoryJsonSubcommand{ struct DownloadGroupInventoryJsonSubcommand{
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie_type:CookieType, api_key_literal:Option<String>,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie:String, api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
output_folder:Option<PathBuf>, output_folder:Option<PathBuf>,
#[arg(long)] #[arg(long)]
@ -73,10 +81,12 @@ struct DownloadGroupInventoryJsonSubcommand{
} }
#[derive(Args)] #[derive(Args)]
struct CreateAssetSubcommand{ struct CreateAssetSubcommand{
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie_type:CookieType, api_key_literal:Option<String>,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie:String, api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
model_name:String, model_name:String,
#[arg(long)] #[arg(long)]
@ -85,19 +95,32 @@ struct CreateAssetSubcommand{
input_file:PathBuf, input_file:PathBuf,
#[arg(long)] #[arg(long)]
group:Option<u64>, group:Option<u64>,
#[arg(long)]
free_model:Option<bool>,
#[arg(long)]
allow_comments:Option<bool>,
} }
#[derive(Args)] #[derive(Args)]
struct UpdateAssetSubcommand{ struct UpdateAssetSubcommand{
#[arg(long)] #[arg(long)]
asset_id:AssetID, asset_id:AssetID,
#[arg(long,group="api_key",required=true)]
api_key_literal:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
cookie_type:CookieType, input_file:PathBuf,
}
#[derive(Args)]
struct UpdatePlaceSubcommand{
#[arg(long)] #[arg(long)]
cookie:String, place_id:u64,
#[arg(long)]
universe_id:u64,
#[arg(long,group="api_key",required=true)]
api_key_literal:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
input_file:PathBuf, input_file:PathBuf,
} }
@ -113,17 +136,38 @@ struct CompileSubcommand{
template:Option<PathBuf>, template:Option<PathBuf>,
} }
#[derive(Args)] #[derive(Args)]
struct CompileUploadSubcommand{ struct CompileUploadAssetSubcommand{
#[arg(long)] #[arg(long)]
asset_id:AssetID, asset_id:AssetID,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie_type:CookieType, api_key_literal:Option<String>,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie:String, api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
input_file:PathBuf, input_file:PathBuf,
#[arg(long)] #[arg(long)]
group:Option<u64>, input_folder:Option<PathBuf>,
#[arg(long)]
style:Option<Style>,
#[arg(long)]
template:Option<PathBuf>,
}
#[derive(Args)]
struct CompileUploadPlaceSubcommand{
#[arg(long)]
place_id:u64,
#[arg(long)]
universe_id:u64,
#[arg(long,group="api_key",required=true)]
api_key_literal:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)]
input_file:PathBuf,
#[arg(long)] #[arg(long)]
input_folder:Option<PathBuf>, input_folder:Option<PathBuf>,
#[arg(long)] #[arg(long)]
@ -148,10 +192,12 @@ struct DecompileSubcommand{
} }
#[derive(Args)] #[derive(Args)]
struct DownloadDecompileSubcommand{ struct DownloadDecompileSubcommand{
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie_type:CookieType, api_key_literal:Option<String>,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie:String, api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
output_folder:Option<PathBuf>, output_folder:Option<PathBuf>,
#[arg(long)] #[arg(long)]
@ -188,10 +234,12 @@ struct DecompileHistoryIntoGitSubcommand{
struct DownloadAndDecompileHistoryIntoGitSubcommand{ struct DownloadAndDecompileHistoryIntoGitSubcommand{
#[arg(long)] #[arg(long)]
asset_id:AssetID, asset_id:AssetID,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie_type:CookieType, api_key_literal:Option<String>,
#[arg(long)] #[arg(long,group="api_key",required=true)]
cookie:String, api_key_envvar:Option<String>,
#[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>,
//currently output folder must be the current folder due to git2 limitations //currently output folder must be the current folder due to git2 limitations
//output_folder:cli.output.unwrap(), //output_folder:cli.output.unwrap(),
#[arg(long)] #[arg(long)]
@ -208,16 +256,6 @@ struct DownloadAndDecompileHistoryIntoGitSubcommand{
write_scripts:Option<bool>, write_scripts:Option<bool>,
} }
#[derive(Clone,clap::ValueEnum)]
enum ApiKeyLocation{
///String literal
Literal,
///Read an environment variable
Environment,
///Read a file
File,
}
#[derive(Clone,Copy,Debug,clap::ValueEnum)] #[derive(Clone,Copy,Debug,clap::ValueEnum)]
enum Style{ enum Style{
Rox, Rox,
@ -243,13 +281,21 @@ async fn main()->AResult<()>{
end_version:subcommand.end_version, end_version:subcommand.end_version,
start_version:subcommand.start_version.unwrap_or(0), start_version:subcommand.start_version.unwrap_or(0),
output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()), output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
cookie:Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0, api_key:ApiKey::from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
asset_id:subcommand.asset_id, asset_id:subcommand.asset_id,
}).await, }).await,
Commands::Download(subcommand)=>{ Commands::Download(subcommand)=>{
let output_folder=subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()); let output_folder=subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap());
download_list( download_list(
Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0, ApiKey::from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
subcommand.asset_ids.into_iter().map(|asset_id|{ subcommand.asset_ids.into_iter().map(|asset_id|{
let mut path=output_folder.clone(); let mut path=output_folder.clone();
path.push(asset_id.to_string()); path.push(asset_id.to_string());
@ -259,7 +305,11 @@ async fn main()->AResult<()>{
}, },
Commands::DownloadDecompile(subcommand)=>{ Commands::DownloadDecompile(subcommand)=>{
download_decompile(DownloadDecompileConfig{ download_decompile(DownloadDecompileConfig{
cookie:Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0, api_key:ApiKey::from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
asset_id:subcommand.asset_id, asset_id:subcommand.asset_id,
output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()), output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
style:subcommand.style.rox(), style:subcommand.style.rox(),
@ -269,37 +319,73 @@ async fn main()->AResult<()>{
}).await }).await
}, },
Commands::DownloadGroupInventoryJson(subcommand)=>download_group_inventory_json( Commands::DownloadGroupInventoryJson(subcommand)=>download_group_inventory_json(
Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0, ApiKey::from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
subcommand.group, subcommand.group,
subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()), subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
).await, ).await,
Commands::CreateAsset(subcommand)=>create(CreateConfig{ Commands::CreateAsset(subcommand)=>create(CreateConfig{
cookie:Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0, api_key:ApiKey::from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
group:subcommand.group, group:subcommand.group,
input_file:subcommand.input_file, input_file:subcommand.input_file,
model_name:subcommand.model_name, model_name:subcommand.model_name,
description:subcommand.description.unwrap_or_else(||String::with_capacity(0)), description:subcommand.description.unwrap_or_else(||String::with_capacity(0)),
free_model:subcommand.free_model.unwrap_or(false),
allow_comments:subcommand.allow_comments.unwrap_or(false),
}).await, }).await,
Commands::UploadAsset(subcommand)=>upload_list( Commands::UploadAsset(subcommand)=>upload_asset(UploadAssetConfig{
Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0, api_key:ApiKey::from_args(
vec![(subcommand.asset_id,subcommand.input_file)] subcommand.api_key_literal,
).await, subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
asset_id:subcommand.asset_id,
input_file:subcommand.input_file,
}).await,
Commands::UploadPlace(subcommand)=>upload_place(UploadPlaceConfig{
api_key:ApiKey::from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
place_id:subcommand.place_id,
universe_id:subcommand.universe_id,
input_file:subcommand.input_file,
}).await,
Commands::Compile(subcommand)=>compile(CompileConfig{ Commands::Compile(subcommand)=>compile(CompileConfig{
input_folder:subcommand.input_folder.unwrap_or_else(||std::env::current_dir().unwrap()), input_folder:subcommand.input_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
output_file:subcommand.output_file, output_file:subcommand.output_file,
template:subcommand.template, template:subcommand.template,
style:subcommand.style.map(|s|s.rox()), style:subcommand.style.map(|s|s.rox()),
}).await, }).await,
Commands::CompileUpload(subcommand)=>compile_upload(CompileUploadConfig{ Commands::CompileUploadAsset(subcommand)=>compile_upload_asset(CompileUploadAssetConfig{
input_folder:subcommand.input_folder.unwrap_or_else(||std::env::current_dir().unwrap()), input_folder:subcommand.input_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
template:subcommand.template, template:subcommand.template,
style:subcommand.style.map(|s|s.rox()), style:subcommand.style.map(|s|s.rox()),
cookie:Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0, api_key:ApiKey::from_args(
group:subcommand.group, subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
asset_id:subcommand.asset_id, asset_id:subcommand.asset_id,
}).await, }).await,
Commands::CompileUploadPlace(subcommand)=>compile_upload_place(CompileUploadPlaceConfig{
input_folder:subcommand.input_folder.unwrap_or_else(||std::env::current_dir().unwrap()),
template:subcommand.template,
style:subcommand.style.map(|s|s.rox()),
api_key:ApiKey::from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
place_id:subcommand.place_id,
universe_id:subcommand.universe_id,
}).await,
Commands::Decompile(subcommand)=>decompile(DecompileConfig{ Commands::Decompile(subcommand)=>decompile(DecompileConfig{
style:subcommand.style.rox(), style:subcommand.style.rox(),
input_file:subcommand.input_file, input_file:subcommand.input_file,
@ -321,7 +407,11 @@ async fn main()->AResult<()>{
Commands::DownloadAndDecompileHistoryIntoGit(subcommand)=>download_and_decompile_history_into_git(DownloadAndDecompileHistoryConfig{ Commands::DownloadAndDecompileHistoryIntoGit(subcommand)=>download_and_decompile_history_into_git(DownloadAndDecompileHistoryConfig{
git_committer_name:subcommand.git_committer_name, git_committer_name:subcommand.git_committer_name,
git_committer_email:subcommand.git_committer_email, git_committer_email:subcommand.git_committer_email,
cookie:Cookie::from_type(subcommand.cookie_type,subcommand.cookie).await?.0, api_key:ApiKey::from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?.get(),
asset_id:subcommand.asset_id, asset_id:subcommand.asset_id,
output_folder:std::env::current_dir()?, output_folder:std::env::current_dir()?,
style:subcommand.style.rox(), style:subcommand.style.rox(),
@ -332,30 +422,33 @@ async fn main()->AResult<()>{
} }
} }
struct Cookie(String); struct ApiKey(String);
impl Cookie{ impl ApiKey{
async fn from_type(cookie_type:CookieType,cookie_string:String)->AResult<Self>{ fn get(self)->String{
Ok(Self(format!(".ROBLOSECURITY={}",match cookie_type{ self.0
CookieType::Literal=>cookie_string, }
CookieType::Environment=>std::env::var(cookie_string)?, async fn from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<Self>{
CookieType::File=>tokio::fs::read_to_string(cookie_string).await?, let api_key=match (literal,environment,file){
}))) (Some(api_key_literal),None,None)=>api_key_literal,
(None,Some(api_key_environment),None)=>std::env::var(api_key_environment)?,
(None,None,Some(api_key_file))=>tokio::fs::read_to_string(api_key_file).await?,
_=>Err(anyhow::Error::msg("Illegal api key argument triple"))?,
};
Ok(Self(api_key))
} }
} }
struct CreateConfig{ struct CreateConfig{
cookie:String, api_key:String,
model_name:String, model_name:String,
description:String, description:String,
input_file:PathBuf, input_file:PathBuf,
group:Option<u64>, group:Option<u64>,
free_model:bool,
allow_comments:bool,
} }
///This is hardcoded to create models atm ///This is hardcoded to create models atm
async fn create(config:CreateConfig)->AResult<()>{ async fn create(config:CreateConfig)->AResult<()>{
let resp=RobloxContext::new(config.cookie) let resp=RobloxContext::new(config.api_key)
.create_asset(rbx_asset::context::CreateAssetRequest{ .create_asset(rbx_asset::context::CreateAssetRequest{
assetType:rbx_asset::context::AssetType::Model, assetType:rbx_asset::context::AssetType::Model,
displayName:config.model_name, displayName:config.model_name,
@ -372,29 +465,33 @@ async fn create(config:CreateConfig)->AResult<()>{
Ok(()) Ok(())
} }
async fn upload_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult<()>{ struct UploadAssetConfig{
let context=RobloxContext::new(cookie); api_key:String,
//this is calling map on the vec because the closure produces an iterator of futures asset_id:u64,
futures::stream::iter(asset_id_file_map.into_iter() input_file:PathBuf,
.map(|(asset_id,file)|{ }
let context=&context; async fn upload_asset(config:UploadAssetConfig)->AResult<()>{
async move{ let context=RobloxContext::new(config.api_key);
Ok((asset_id,context.update_asset(rbx_asset::context::UpdateAssetRequest{ context.update_asset(rbx_asset::context::UpdateAssetRequest{
assetId:asset_id, assetId:config.asset_id,
displayName:None, displayName:None,
description:None, description:None,
},tokio::fs::read(file).await?).await?)) },tokio::fs::read(config.input_file).await?).await?;
Ok(())
} }
}))
.buffer_unordered(CONCURRENT_REQUESTS) struct UploadPlaceConfig{
.for_each(|b:AResult<_>|async{ api_key:String,
match b{ place_id:u64,
Ok((asset_id,body))=>{ universe_id:u64,
println!("asset_id={} UploadResponse={:?}",asset_id,body); input_file:PathBuf,
},
Err(e)=>eprintln!("ul error: {}",e),
} }
}).await; async fn upload_place(config:UploadPlaceConfig)->AResult<()>{
let context=RobloxContext::new(config.api_key);
context.update_place(rbx_asset::context::UpdatePlaceRequest{
placeId:config.place_id,
universeId:config.universe_id,
},tokio::fs::read(config.input_file).await?).await?;
Ok(()) Ok(())
} }
@ -404,7 +501,7 @@ async fn download_list(cookie:String,asset_id_file_map:AssetIDFileMap)->AResult<
.map(|(asset_id,file)|{ .map(|(asset_id,file)|{
let context=&context; let context=&context;
async move{ async move{
Ok((file,context.download(rbx_asset::context::GetAssetRequest{asset_id,version:None}).await?)) Ok((file,context.get_asset(rbx_asset::context::GetAssetRequest{asset_id,version:None}).await?))
} }
})) }))
.buffer_unordered(CONCURRENT_REQUESTS) .buffer_unordered(CONCURRENT_REQUESTS)
@ -451,7 +548,7 @@ async fn get_version_history(context:&RobloxContext,asset_id:AssetID)->AResult<V
let mut cursor:Option<String>=None; let mut cursor:Option<String>=None;
let mut asset_list=Vec::new(); let mut asset_list=Vec::new();
loop{ loop{
let mut page=context.history_page(rbx_asset::context::AssetVersionsRequest{asset_id,cursor}).await?; let mut page=context.get_asset_versions(rbx_asset::context::AssetVersionsRequest{asset_id,cursor}).await?;
asset_list.append(&mut page.data); asset_list.append(&mut page.data);
if page.nextPageCursor.is_none(){ if page.nextPageCursor.is_none(){
break; break;
@ -467,7 +564,7 @@ struct DownloadHistoryConfig{
end_version:Option<u64>, end_version:Option<u64>,
start_version:u64, start_version:u64,
output_folder:PathBuf, output_folder:PathBuf,
cookie:String, api_key:String,
asset_id:AssetID, asset_id:AssetID,
} }
@ -508,7 +605,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
None=>Err(anyhow::Error::msg("Cannot continue from versions.json - there are no previous versions"))?, None=>Err(anyhow::Error::msg("Cannot continue from versions.json - there are no previous versions"))?,
} }
} }
let context=RobloxContext::new(config.cookie); let context=RobloxContext::new(config.api_key);
//limit concurrent downloads //limit concurrent downloads
let mut join_set=tokio::task::JoinSet::new(); let mut join_set=tokio::task::JoinSet::new();
@ -516,7 +613,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
//poll paged list of all asset versions //poll paged list of all asset versions
let mut cursor:Option<String>=None; let mut cursor:Option<String>=None;
loop{ loop{
let mut page=context.history_page(rbx_asset::context::AssetVersionsRequest{asset_id:config.asset_id,cursor}).await?; let mut page=context.get_asset_versions(rbx_asset::context::AssetVersionsRequest{asset_id:config.asset_id,cursor}).await?;
let context=&context; let context=&context;
let output_folder=config.output_folder.clone(); let output_folder=config.output_folder.clone();
let data=&page.data; let data=&page.data;
@ -546,7 +643,7 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
let mut path=output_folder.clone(); let mut path=output_folder.clone();
path.push(format!("{}_v{}.rbxl",config.asset_id,version_number)); path.push(format!("{}_v{}.rbxl",config.asset_id,version_number));
join_set.spawn(async move{ join_set.spawn(async move{
let file=context.download(rbx_asset::context::GetAssetRequest{asset_id:config.asset_id,version:Some(version_number)}).await?; let file=context.get_asset(rbx_asset::context::GetAssetRequest{asset_id:config.asset_id,version:Some(version_number)}).await?;
tokio::fs::write(path,file).await?; tokio::fs::write(path,file).await?;
@ -641,7 +738,7 @@ async fn decompile(config:DecompileConfig)->AResult<()>{
} }
struct DownloadDecompileConfig{ struct DownloadDecompileConfig{
cookie:String, api_key:String,
asset_id:AssetID, asset_id:AssetID,
style:rox_compiler::Style, style:rox_compiler::Style,
output_folder:PathBuf, output_folder:PathBuf,
@ -651,8 +748,8 @@ struct DownloadDecompileConfig{
} }
async fn download_decompile(config:DownloadDecompileConfig)->AResult<()>{ async fn download_decompile(config:DownloadDecompileConfig)->AResult<()>{
let context=RobloxContext::new(config.cookie); let context=RobloxContext::new(config.api_key);
let file=context.download(rbx_asset::context::GetAssetRequest{asset_id:config.asset_id,version:None}).await?; let file=context.get_asset(rbx_asset::context::GetAssetRequest{asset_id:config.asset_id,version:None}).await?;
let dom=load_dom(std::io::Cursor::new(file))?; let dom=load_dom(std::io::Cursor::new(file))?;
let context=rox_compiler::DecompiledContext::from_dom(dom); let context=rox_compiler::DecompiledContext::from_dom(dom);
@ -809,7 +906,7 @@ async fn decompile_history_into_git(config:DecompileHistoryConfig)->AResult<()>{
} }
struct DownloadAndDecompileHistoryConfig{ struct DownloadAndDecompileHistoryConfig{
cookie:String, api_key:String,
asset_id:AssetID, asset_id:AssetID,
git_committer_name:String, git_committer_name:String,
git_committer_email:String, git_committer_email:String,
@ -821,7 +918,7 @@ struct DownloadAndDecompileHistoryConfig{
} }
async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHistoryConfig)->AResult<()>{ async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHistoryConfig)->AResult<()>{
let context=RobloxContext::new(config.cookie); let context=RobloxContext::new(config.api_key);
//poll paged list of all asset versions //poll paged list of all asset versions
let asset_list=get_version_history(&context,config.asset_id).await?; let asset_list=get_version_history(&context,config.asset_id).await?;
@ -834,7 +931,7 @@ async fn download_and_decompile_history_into_git(config:DownloadAndDecompileHist
.map(|asset_version|{ .map(|asset_version|{
let context=context.clone(); let context=context.clone();
tokio::task::spawn(async move{ tokio::task::spawn(async move{
let file=context.download(rbx_asset::context::GetAssetRequest{asset_id,version:Some(asset_version.assetVersionNumber)}).await?; let file=context.get_asset(rbx_asset::context::GetAssetRequest{asset_id,version:Some(asset_version.assetVersionNumber)}).await?;
let dom=load_dom(std::io::Cursor::new(file))?; let dom=load_dom(std::io::Cursor::new(file))?;
Ok::<_,anyhow::Error>((asset_version,rox_compiler::DecompiledContext::from_dom(dom))) Ok::<_,anyhow::Error>((asset_version,rox_compiler::DecompiledContext::from_dom(dom)))
}) })
@ -888,15 +985,14 @@ async fn compile(config:CompileConfig)->AResult<()>{
Ok(()) Ok(())
} }
struct CompileUploadConfig{ struct CompileUploadAssetConfig{
input_folder:PathBuf, input_folder:PathBuf,
template:Option<PathBuf>, template:Option<PathBuf>,
style:Option<rox_compiler::Style>, style:Option<rox_compiler::Style>,
cookie:String, api_key:String,
group:Option<u64>,
asset_id:AssetID, asset_id:AssetID,
} }
async fn compile_upload(config:CompileUploadConfig)->AResult<()>{ async fn compile_upload_asset(config:CompileUploadAssetConfig)->AResult<()>{
let mut dom=match config.template{ let mut dom=match config.template{
//mr dom doesn't like tokio files //mr dom doesn't like tokio files
Some(template_path)=>load_dom(std::io::BufReader::new(std::fs::File::open(template_path)?))?, Some(template_path)=>load_dom(std::io::BufReader::new(std::fs::File::open(template_path)?))?,
@ -913,14 +1009,44 @@ async fn compile_upload(config:CompileUploadConfig)->AResult<()>{
rbx_binary::to_writer(std::io::Cursor::new(&mut data),&dom,dom.root().children())?; rbx_binary::to_writer(std::io::Cursor::new(&mut data),&dom,dom.root().children())?;
//upload it //upload it
let context=RobloxContext::new(config.cookie); let context=RobloxContext::new(config.api_key);
context.upload(rbx_asset::context::UpdateAssetRequest{ context.update_asset(rbx_asset::context::UpdateAssetRequest{
assetid:config.asset_id, assetId:config.asset_id,
name:None, displayName:None,
description:None, description:None,
ispublic:None, },data).await?;
allowComments:None, Ok(())
groupId:config.group, }
struct CompileUploadPlaceConfig{
input_folder:PathBuf,
template:Option<PathBuf>,
style:Option<rox_compiler::Style>,
api_key:String,
place_id:u64,
universe_id:u64,
}
async fn compile_upload_place(config:CompileUploadPlaceConfig)->AResult<()>{
let mut dom=match config.template{
//mr dom doesn't like tokio files
Some(template_path)=>load_dom(std::io::BufReader::new(std::fs::File::open(template_path)?))?,
None=>rbx_dom_weak::WeakDom::new(rbx_dom_weak::InstanceBuilder::new("DataModel")),
};
rox_compiler::compile(rox_compiler::CompileConfig{
input_folder:config.input_folder,
style:config.style,
},&mut dom).await?;
//make a binary file in a buffer in memory
let mut data=Vec::new();
rbx_binary::to_writer(std::io::Cursor::new(&mut data),&dom,dom.root().children())?;
//upload it
let context=RobloxContext::new(config.api_key);
context.update_place(rbx_asset::context::UpdatePlaceRequest{
universeId:config.universe_id,
placeId:config.place_id,
},data).await?; },data).await?;
Ok(()) Ok(())
} }