Compare commits

..

16 Commits

Author SHA1 Message Date
6365a5fad0 wip 2024-07-03 13:09:53 -07:00
b1b5602d66 c 2024-07-03 13:03:18 -07:00
5883a13b7d revive old api code 2024-07-03 12:37:21 -07:00
d4b5e27e73 rename context to cloud 2024-07-03 12:22:39 -07:00
08b0c311cb improve type safety for secrets 2024-07-03 12:20:11 -07:00
ee7f06a243 manually specify creator :/ 2024-07-03 11:03:58 -07:00
2ba98eb83d v0.4.0 new roblox api 2024-07-02 22:02:52 -07:00
19afc649aa refactor for new api 2024-07-02 22:02:52 -07:00
2b6ecc9027 move type conversion to argument stuff 2024-07-02 22:02:52 -07:00
d6f08354d8 v0.3.4 download-decompile 2024-07-02 22:02:52 -07:00
58ab2816e9 download-decompile 2024-07-02 22:02:52 -07:00
caf05f9555 v0.3.3 compile-upload 2024-07-02 22:02:52 -07:00
44ef08cc73 compile-upload 2024-07-02 22:02:52 -07:00
63d22846cd fix compiling with no template 2024-07-02 22:02:52 -07:00
0ea613715c v0.3.2 rox_compiler 2024-07-02 22:02:52 -07:00
0f797356fb refactor rox_compiler into module 2024-07-02 22:02:52 -07:00
12 changed files with 551 additions and 1122 deletions

View File

@ -1,24 +0,0 @@
---
kind: pipeline
type: docker
platform:
os: linux
arch: amd64
steps:
- name: image
image: plugins/docker
settings:
registry: git.itzana.me
repo: git.itzana.me/strafesnet/asset-tool
tags:
- latest
username:
from_secret: GIT_USER
password:
from_secret: GIT_PASS
dockerfile: Containerfile
when:
branch:
- master

596
Cargo.lock generated

File diff suppressed because it is too large Load Diff

View File

@ -1,7 +1,7 @@
workspace = { members = ["rbx_asset", "rox_compiler"] } workspace = { members = ["rbx_asset", "rox_compiler"] }
[package] [package]
name = "asset-tool" name = "asset-tool"
version = "0.4.6" version = "0.4.0"
edition = "2021" edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

View File

@ -1,6 +1,6 @@
# Using the `rust-musl-builder` as base image, instead of # Using the `rust-musl-builder` as base image, instead of
# the official Rust toolchain # the official Rust toolchain
FROM docker.io/clux/muslrust:stable AS chef FROM clux/muslrust:stable AS chef
USER root USER root
RUN cargo install cargo-chef RUN cargo install cargo-chef
WORKDIR /app WORKDIR /app
@ -16,8 +16,8 @@ RUN cargo chef cook --release --target x86_64-unknown-linux-musl --recipe-path r
COPY . . COPY . .
RUN cargo build --release --target x86_64-unknown-linux-musl --bin asset-tool RUN cargo build --release --target x86_64-unknown-linux-musl --bin asset-tool
FROM docker.io/alpine:latest AS runtime FROM alpine AS runtime
RUN addgroup -S myuser && adduser -S myuser -G myuser RUN addgroup -S myuser && adduser -S myuser -G myuser
COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/asset-tool /usr/local/bin/ COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/asset-tool /usr/local/bin/
USER myuser USER myuser
ENTRYPOINT ["/usr/local/bin/asset-tool"] CMD ["/usr/local/bin/asset-tool"]

View File

@ -1,21 +1,3 @@
# asset-tool # asset-tool
[![Build Status](https://ci.itzana.me/api/badges/StrafesNET/asset-tool/status.svg?ref=refs/heads/master)](https://ci.itzana.me/StrafesNET/asset-tool)
For uploading and downloading roblox assets. For uploading and downloading roblox assets.
See [releases](https://git.itzana.me/StrafesNET/asset-tool/releases) for downloads.
To get started, you will need an api key and/or cookie depending on which command you use. Api keys can be created from the open cloud section on the creator hub, cookies must be extracted from a browser session. Do not share your cookie file with anyone or use it with tools that you do not trust, as it gives unrestricted permissions to do any account actions on your behalf. The api keys are significantly more safe because you can choose exactly what permissions the given key has, and which ip addresses can use it.
The help text lists available commands:
`asset-tool --help`
For help with a specific command:
`asset-tool download --help`
Example incantation to download a list of models:
`asset-tool download --cookie-file Documents\mycookie.txt 255299419 1213190363`

View File

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

View File

@ -14,33 +14,9 @@ pub struct CreateAssetRequest{
pub displayName:String, pub displayName:String,
} }
#[derive(Debug)] #[derive(Debug)]
pub enum AssetOperationError{
Operation(OperationError),
Serialize(serde_json::Error),
}
impl std::fmt::Display for AssetOperationError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for AssetOperationError{}
#[derive(Debug)]
pub struct AssetOperation{
operation:RobloxOperation,
}
impl AssetOperation{
pub async fn try_get_asset(&self,context:&CloudContext)->Result<AssetResponse,AssetOperationError>{
serde_json::from_value(
self.operation
.try_get_reponse(context).await
.map_err(AssetOperationError::Operation)?
).map_err(AssetOperationError::Serialize)
}
}
#[derive(Debug)]
pub enum CreateError{ pub enum CreateError{
Parse(url::ParseError), ParseError(url::ParseError),
Serialize(serde_json::Error), SerializeError(serde_json::Error),
Reqwest(reqwest::Error), Reqwest(reqwest::Error),
} }
impl std::fmt::Display for CreateError{ impl std::fmt::Display for CreateError{
@ -59,29 +35,24 @@ pub struct UpdateAssetRequest{
} }
//woo nested roblox stuff //woo nested roblox stuff
#[derive(Clone,Debug,serde::Deserialize,serde::Serialize)] #[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub enum Creator{ pub struct Creator{
userId(String),//u64 string pub userId:u64,
groupId(String),//u64 string pub groupId:u64,
} }
#[derive(Debug,serde::Deserialize,serde::Serialize)] #[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct CreationContext{ pub struct CreationContext{
pub creator:Creator, pub creator:Creator,
pub expectedPrice:Option<u64>, pub expectedPrice:u64,
} }
#[derive(Debug,serde::Deserialize,serde::Serialize)] #[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub enum ModerationState{ pub enum ModerationResult{
Reviewing, MODERATION_STATE_REVIEWING,
Rejected, MODERATION_STATE_REJECTED,
Approved, MODERATION_STATE_APPROVED,
}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct ModerationResult{
pub moderationState:ModerationState,
} }
#[derive(Debug,serde::Deserialize,serde::Serialize)] #[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
@ -89,6 +60,20 @@ pub struct Preview{
pub asset:String, pub asset:String,
pub altText:String, pub altText:String,
} }
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct AssetResponse{
pub assetId:u64,
pub creationContext:CreationContext,
pub description:String,
pub displayName:String,
pub path:String,
pub revisionId:u64,
pub revisionCreateTime:chrono::DateTime<chrono::Utc>,
pub moderationResult:ModerationResult,
pub icon:String,
pub previews:Vec<Preview>,
}
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct UpdatePlaceRequest{ pub struct UpdatePlaceRequest{
pub universeId:u64, pub universeId:u64,
@ -106,59 +91,12 @@ pub enum UpdateError{
Reqwest(reqwest::Error), Reqwest(reqwest::Error),
} }
impl std::fmt::Display for UpdateError{ impl std::fmt::Display for UpdateError{
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 UpdateError{} impl std::error::Error for UpdateError{}
struct GetAssetOperationRequest{
operation_id:String,
}
pub struct GetAssetInfoRequest{
pub asset_id:u64,
}
/*
{
"assetId": "5692158972",
"assetType": "Model",
"creationContext":{
"creator":
{
"groupId": "6980477"
}
},
"description": "DisplayName: Ares\nCreator: titanicguy54",
"displayName": "bhop_ares.rbxmx",
"path": "assets/5692158972",
"revisionCreateTime": "2020-09-14T16:08:05.063Z",
"revisionId": "1",
"moderationResult":{
"moderationState": "Approved"
},
"state": "Active"
}
*/
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
pub struct AssetResponse{
pub assetId:String,//u64 wrapped in quotes wohoo!!
pub assetType:AssetType,
pub creationContext:CreationContext,
pub description:String,
pub displayName:String,
pub path:String,
pub revisionCreateTime:chrono::DateTime<chrono::Utc>,
pub revisionId:String,//u64
pub moderationResult:ModerationResult,
pub icon:Option<String>,
pub previews:Option<Vec<Preview>>,
}
#[allow(nonstandard_style,dead_code)]
pub struct GetAssetVersionRequest{
pub asset_id:u64,
pub version:u64,
}
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct GetAssetRequest{ pub struct GetAssetRequest{
pub asset_id:u64, pub asset_id:u64,
@ -171,7 +109,7 @@ pub enum GetError{
IO(std::io::Error) IO(std::io::Error)
} }
impl std::fmt::Display for GetError{ 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:?}")
} }
} }
@ -181,7 +119,7 @@ pub struct AssetVersionsRequest{
pub asset_id:u64, pub asset_id:u64,
pub cursor:Option<String>, pub cursor:Option<String>,
} }
#[derive(Debug,serde::Deserialize,serde::Serialize)] #[derive(serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct AssetVersion{ pub struct AssetVersion{
pub Id:u64, pub Id:u64,
@ -193,7 +131,7 @@ pub struct AssetVersion{
pub created:chrono::DateTime<chrono::Utc>, pub created:chrono::DateTime<chrono::Utc>,
pub isPublished:bool, pub isPublished:bool,
} }
#[derive(Debug,serde::Deserialize)] #[derive(serde::Deserialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct AssetVersionsResponse{ pub struct AssetVersionsResponse{
pub previousPageCursor:Option<String>, pub previousPageCursor:Option<String>,
@ -206,7 +144,7 @@ pub enum AssetVersionsError{
Reqwest(reqwest::Error), Reqwest(reqwest::Error),
} }
impl std::fmt::Display for AssetVersionsError{ impl std::fmt::Display for AssetVersionsError{
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:?}")
} }
} }
@ -216,13 +154,13 @@ pub struct InventoryPageRequest{
pub group:u64, pub group:u64,
pub cursor:Option<String>, pub cursor:Option<String>,
} }
#[derive(Debug,serde::Deserialize,serde::Serialize)] #[derive(serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct InventoryItem{ pub struct InventoryItem{
pub id:u64, pub id:u64,
pub name:String, pub name:String,
} }
#[derive(Debug,serde::Deserialize,serde::Serialize)] #[derive(serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct InventoryPageResponse{ pub struct InventoryPageResponse{
pub totalResults:u64,//up to 50 pub totalResults:u64,//up to 50
@ -241,53 +179,11 @@ pub enum InventoryPageError{
Reqwest(reqwest::Error), Reqwest(reqwest::Error),
} }
impl std::fmt::Display for InventoryPageError{ impl std::fmt::Display for InventoryPageError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for InventoryPageError{}
#[derive(Debug)]
pub enum OperationError{
Get(GetError),
NoOperationId,
NotDone,
}
impl std::fmt::Display for OperationError{
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 OperationError{} impl std::error::Error for InventoryPageError{}
#[derive(Debug,serde::Deserialize,serde::Serialize)]
#[allow(nonstandard_style,dead_code)]
struct RobloxOperation{
pub path:Option<String>,
pub metadata:Option<String>,
pub done:Option<bool>,
pub error:Option<String>,
pub response:Option<serde_json::Value>,
pub operationId:Option<String>,
}
impl RobloxOperation{
pub fn operation_id(&self)->Option<&str>{
match self.operationId.as_deref(){
//try getting it from undocumented operationId first
Some(operation_id)=>Some(operation_id),
//skip the first 11 characters
//operations/[uuid]
None=>self.path.as_deref()?.get(11..),
}
}
pub async fn try_get_reponse(&self,context:&CloudContext)->Result<serde_json::Value,OperationError>{
context.get_asset_operation(GetAssetOperationRequest{
operation_id:self.operation_id()
.ok_or(OperationError::NoOperationId)?
.to_owned(),
}).await.map_err(OperationError::Get)?
.response.ok_or(OperationError::NotDone)
}
}
//idk how to do this better //idk how to do this better
enum ReaderType<R:std::io::Read>{ enum ReaderType<R:std::io::Read>{
@ -355,29 +251,20 @@ impl CloudContext{
.multipart(form) .multipart(form)
.send().await .send().await
} }
pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetOperation,CreateError>{ pub async fn create_asset(&self,config:CreateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetResponse,CreateError>{
let url=reqwest::Url::parse("https://apis.roblox.com/assets/v1/assets").map_err(CreateError::Parse)?; let url=reqwest::Url::parse("https://apis.roblox.com/assets/v1/assets").map_err(CreateError::ParseError)?;
let request_config=serde_json::to_string(&config).map_err(CreateError::Serialize)?; let request_config=serde_json::to_string(&config).map_err(CreateError::SerializeError)?;
let part=reqwest::multipart::Part::bytes(body)
//you must have a file name or roblox will 400!!!!!!!!!
.file_name("image");
let form=reqwest::multipart::Form::new() let form=reqwest::multipart::Form::new()
.text("request",request_config) .text("request",request_config)
.part("fileContent",part); .part("fileContent",reqwest::multipart::Part::bytes(body));
let operation=self.post_form(url,form).await let resp=self.post_form(url,form).await.map_err(CreateError::Reqwest)?;
.map_err(CreateError::Reqwest)?
.error_for_status().map_err(CreateError::Reqwest)?
.json::<RobloxOperation>().await.map_err(CreateError::Reqwest)?;
Ok(AssetOperation{ Ok(resp.json::<AssetResponse>().await.map_err(CreateError::Reqwest)?)
operation,
})
} }
pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetOperation,UpdateError>{ pub async fn update_asset(&self,config:UpdateAssetRequest,body:impl Into<std::borrow::Cow<'static,[u8]>>)->Result<AssetResponse,UpdateError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.assetId); let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.assetId);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?; let url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?;
@ -387,39 +274,23 @@ impl CloudContext{
.text("request",request_config) .text("request",request_config)
.part("fileContent",reqwest::multipart::Part::bytes(body)); .part("fileContent",reqwest::multipart::Part::bytes(body));
let operation=self.patch_form(url,form).await let resp=self.patch_form(url,form).await.map_err(UpdateError::Reqwest)?;
.map_err(UpdateError::Reqwest)?
//roblox api documentation is very poor, just give the status code and drop the json
.error_for_status().map_err(UpdateError::Reqwest)?
.json::<RobloxOperation>().await.map_err(UpdateError::Reqwest)?;
Ok(AssetOperation{ Ok(resp.json::<AssetResponse>().await.map_err(UpdateError::Reqwest)?)
operation,
})
} }
async fn get_asset_operation(&self,config:GetAssetOperationRequest)->Result<RobloxOperation,GetError>{ pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/operations/{}",config.operation_id); let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(GetError::ParseError)?;
let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?; //url borrow scope
{
self.get(url).await.map_err(GetError::Reqwest)? let mut query=url.query_pairs_mut();//borrow here
.error_for_status().map_err(GetError::Reqwest)? query.append_pair("ID",config.asset_id.to_string().as_str());
.json::<RobloxOperation>().await.map_err(GetError::Reqwest) if let Some(version)=config.version{
query.append_pair("version",version.to_string().as_str());
} }
pub async fn get_asset_info(&self,config:GetAssetInfoRequest)->Result<AssetResponse,GetError>{
let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}",config.asset_id);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
self.get(url).await.map_err(GetError::Reqwest)?
.error_for_status().map_err(GetError::Reqwest)?
.json::<AssetResponse>().await.map_err(GetError::Reqwest)
} }
pub async fn get_asset_version(&self,config:GetAssetVersionRequest)->Result<Vec<u8>,GetError>{ let resp=self.get(url).await.map_err(GetError::Reqwest)?;
let raw_url=format!("https://apis.roblox.com/assets/v1/assets/{}/versions/{}",config.asset_id,config.version);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(GetError::ParseError)?;
let body=self.get(url).await.map_err(GetError::Reqwest)? let body=resp.bytes().await.map_err(GetError::Reqwest)?;
.error_for_status().map_err(GetError::Reqwest)?
.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),
@ -427,23 +298,12 @@ impl CloudContext{
Err(e)=>Err(e), Err(e)=>Err(e),
}.map_err(GetError::IO) }.map_err(GetError::IO)
} }
pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{
let version=match config.version{
Some(version)=>version,
None=>self.get_asset_info(GetAssetInfoRequest{asset_id:config.asset_id}).await?.revisionId.parse().unwrap(),
};
self.get_asset_version(GetAssetVersionRequest{
asset_id:config.asset_id,
version,
}).await
}
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);
let url=reqwest::Url::parse(raw_url.as_str()).map_err(AssetVersionsError::ParseError)?; let url=reqwest::Url::parse(raw_url.as_str()).map_err(AssetVersionsError::ParseError)?;
self.get(url).await.map_err(AssetVersionsError::Reqwest)? Ok(self.get(url).await.map_err(AssetVersionsError::Reqwest)?
.error_for_status().map_err(AssetVersionsError::Reqwest)? .json::<AssetVersionsResponse>().await.map_err(AssetVersionsError::Reqwest)?)
.json::<AssetVersionsResponse>().await.map_err(AssetVersionsError::Reqwest)
} }
pub async fn inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{ pub async fn inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{
let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/group/{}/10?limit=50",config.group).as_str()).map_err(InventoryPageError::ParseError)?; let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/group/{}/10?limit=50",config.group).as_str()).map_err(InventoryPageError::ParseError)?;
@ -455,21 +315,15 @@ impl CloudContext{
} }
} }
self.get(url).await.map_err(InventoryPageError::Reqwest)? Ok(self.get(url).await.map_err(InventoryPageError::Reqwest)?
.error_for_status().map_err(InventoryPageError::Reqwest)? .json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)?)
.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)
} }
pub async fn update_place(&self,config:UpdatePlaceRequest,body:impl Into<reqwest::Body>+Clone)->Result<UpdatePlaceResponse,UpdateError>{ pub async fn update_place(&self,config:UpdatePlaceRequest,body:impl Into<reqwest::Body>+Clone)->Result<UpdatePlaceResponse,UpdateError>{
let raw_url=format!("https://apis.roblox.com/universes/v1/{}/places/{}/versions",config.universeId,config.placeId); let raw_url=format!("https://apis.roblox.com/universes/v1/{}/places/{}/versions",config.universeId,config.placeId);
let mut url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?; let url=reqwest::Url::parse(raw_url.as_str()).map_err(UpdateError::ParseError)?;
//url borrow scope
{
let mut query=url.query_pairs_mut();//borrow here
query.append_pair("versionType","Published");
}
self.post(url,body).await.map_err(UpdateError::Reqwest)? let resp=self.post(url,body).await.map_err(UpdateError::Reqwest)?;
.error_for_status().map_err(UpdateError::Reqwest)?
.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest) Ok(resp.json::<UpdatePlaceResponse>().await.map_err(UpdateError::Reqwest)?)
} }
} }

View File

@ -62,22 +62,22 @@ pub struct UploadResponse{
} }
#[allow(nonstandard_style,dead_code)] #[allow(nonstandard_style,dead_code)]
pub struct GetAssetRequest{ pub struct DownloadRequest{
pub asset_id:u64, pub asset_id:u64,
pub version:Option<u64>, pub version:Option<u64>,
} }
#[derive(Debug)] #[derive(Debug)]
pub enum GetError{ pub enum DownloadError{
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 GetError{ impl std::fmt::Display for DownloadError{
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 GetError{} impl std::error::Error for DownloadError{}
pub struct AssetVersionsPageRequest{ pub struct AssetVersionsPageRequest{
pub asset_id:u64, pub asset_id:u64,
@ -228,14 +228,15 @@ impl CookieContext{
query.append_pair("description",config.description.as_str()); query.append_pair("description",config.description.as_str());
query.append_pair("ispublic",if config.ispublic{"True"}else{"False"}); query.append_pair("ispublic",if config.ispublic{"True"}else{"False"});
query.append_pair("allowComments",if config.allowComments{"True"}else{"False"}); query.append_pair("allowComments",if config.allowComments{"True"}else{"False"});
if let Some(group_id)=config.groupId{ match config.groupId{
query.append_pair("groupId",group_id.to_string().as_str()); Some(group_id)=>{query.append_pair("groupId",group_id.to_string().as_str());},
None=>(),
} }
} }
self.post(url,body).await.map_err(CreateError::PostError)? let resp=self.post(url,body).await.map_err(CreateError::PostError)?;
.error_for_status().map_err(CreateError::Reqwest)?
.json::<UploadResponse>().await.map_err(CreateError::Reqwest) Ok(resp.json::<UploadResponse>().await.map_err(CreateError::Reqwest)?)
} }
pub async fn upload(&self,config:UploadRequest,body:impl Into<reqwest::Body>+Clone)->Result<UploadResponse,UploadError>{ pub async fn upload(&self,config:UploadRequest,body:impl Into<reqwest::Body>+Clone)->Result<UploadResponse,UploadError>{
let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1").map_err(UploadError::ParseError)?; let mut url=reqwest::Url::parse("https://data.roblox.com/Data/Upload.ashx?json=1&type=Model&genreTypeId=1").map_err(UploadError::ParseError)?;
@ -264,12 +265,12 @@ impl CookieContext{
} }
} }
self.post(url,body).await.map_err(UploadError::PostError)? let resp=self.post(url,body).await.map_err(UploadError::PostError)?;
.error_for_status().map_err(UploadError::Reqwest)?
.json::<UploadResponse>().await.map_err(UploadError::Reqwest) Ok(resp.json::<UploadResponse>().await.map_err(UploadError::Reqwest)?)
} }
pub async fn get_asset(&self,config:GetAssetRequest)->Result<Vec<u8>,GetError>{ pub async fn download(&self,config:DownloadRequest)->Result<Vec<u8>,DownloadError>{
let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(GetError::ParseError)?; let mut url=reqwest::Url::parse("https://assetdelivery.roblox.com/v1/asset/").map_err(DownloadError::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
@ -278,15 +279,15 @@ impl CookieContext{
query.append_pair("version",version.to_string().as_str()); query.append_pair("version",version.to_string().as_str());
} }
} }
let body=self.get(url).await.map_err(GetError::Reqwest)? let resp=self.get(url).await.map_err(DownloadError::Reqwest)?;
.error_for_status().map_err(GetError::Reqwest)?
.bytes().await.map_err(GetError::Reqwest)?; let body=resp.bytes().await.map_err(DownloadError::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(GetError::IO) }.map_err(DownloadError::IO)
} }
pub async fn get_asset_versions_page(&self,config:AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,AssetVersionsPageError>{ pub async fn get_asset_versions_page(&self,config:AssetVersionsPageRequest)->Result<AssetVersionsPageResponse,AssetVersionsPageError>{
let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.asset_id).as_str()).map_err(AssetVersionsPageError::ParseError)?; let mut url=reqwest::Url::parse(format!("https://develop.roblox.com/v1/assets/{}/saved-versions",config.asset_id).as_str()).map_err(AssetVersionsPageError::ParseError)?;
@ -301,11 +302,10 @@ impl CookieContext{
} }
} }
self.get(url).await.map_err(AssetVersionsPageError::Reqwest)? Ok(self.get(url).await.map_err(AssetVersionsPageError::Reqwest)?
.error_for_status().map_err(AssetVersionsPageError::Reqwest)? .json::<AssetVersionsPageResponse>().await.map_err(AssetVersionsPageError::Reqwest)?)
.json::<AssetVersionsPageResponse>().await.map_err(AssetVersionsPageError::Reqwest)
} }
pub async fn get_inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{ pub async fn inventory_page(&self,config:InventoryPageRequest)->Result<InventoryPageResponse,InventoryPageError>{
let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/group/{}/10?limit=50",config.group).as_str()).map_err(InventoryPageError::ParseError)?; let mut url=reqwest::Url::parse(format!("https://apis.roblox.com/toolbox-service/v1/creations/group/{}/10?limit=50",config.group).as_str()).map_err(InventoryPageError::ParseError)?;
//url borrow scope //url borrow scope
{ {
@ -315,8 +315,7 @@ impl CookieContext{
} }
} }
self.get(url).await.map_err(InventoryPageError::Reqwest)? Ok(self.get(url).await.map_err(InventoryPageError::Reqwest)?
.error_for_status().map_err(InventoryPageError::Reqwest)? .json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)?)
.json::<InventoryPageResponse>().await.map_err(InventoryPageError::Reqwest)
} }
} }

View File

@ -19,15 +19,15 @@ impl PropertiesOverride{
impl std::fmt::Display for PropertiesOverride{ impl std::fmt::Display for PropertiesOverride{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{ fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
if let Some(name)=self.name.as_deref(){ if let Some(name)=self.name.as_deref(){
writeln!(f,"-- Properties.Name = \"{}\"",name)?; writeln!(f,"--!Properties.Name = \"{}\"",name)?;
} }
if let Some(class)=self.class.as_deref(){ if let Some(class)=self.class.as_deref(){
writeln!(f,"-- Properties.ClassName = \"{}\"",class)?; writeln!(f,"--!Properties.ClassName = \"{}\"",class)?;
} }
Ok(()) Ok(())
} }
} }
pub(crate) fn sanitize(s:&str)->std::borrow::Cow<'_,str>{ pub(crate) fn sanitize<'a>(s:&'a str)->std::borrow::Cow<'a,str>{
lazy_regex::regex!(r"[^A-Za-z0-9.-]").replace_all(s,"_") lazy_regex::regex!(r"[^A-z0-9.-]").replace_all(s,"_")
} }

View File

@ -1,4 +1,4 @@
use std::path::{Path,PathBuf}; use std::path::PathBuf;
use futures::{StreamExt, TryStreamExt}; use futures::{StreamExt, TryStreamExt};
use tokio::io::AsyncReadExt; use tokio::io::AsyncReadExt;
@ -55,9 +55,9 @@ struct QuerySingle{
script:QueryHandle, script:QueryHandle,
} }
impl QuerySingle{ impl QuerySingle{
fn rox(search_path:&Path,search_name:&str)->Self{ fn rox(search_path:&PathBuf,search_name:&str)->Self{
Self{ Self{
script:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.lua",search_name))) script:tokio::spawn(get_file_async(search_path.clone(),format!("{}.lua",search_name)))
} }
} }
} }
@ -76,7 +76,7 @@ struct QueryTriple{
client:QueryHandle, client:QueryHandle,
} }
impl QueryTriple{ impl QueryTriple{
fn rox_rojo(search_path:&Path,search_name:&str,search_module:bool)->Self{ fn rox_rojo(search_path:&PathBuf,search_name:&str,search_module:bool)->Self{
//this should be implemented as constructors of Triplet and Quadruplet to fully support Trey's suggestion //this should be implemented as constructors of Triplet and Quadruplet to fully support Trey's suggestion
let module_name=if search_module{ let module_name=if search_module{
format!("{}.module.lua",search_name) format!("{}.module.lua",search_name)
@ -84,12 +84,12 @@ impl QueryTriple{
format!("{}.lua",search_name) format!("{}.lua",search_name)
}; };
Self{ Self{
module:tokio::spawn(get_file_async(search_path.to_owned(),module_name)), module:tokio::spawn(get_file_async(search_path.clone(),module_name)),
server:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.server.lua",search_name))), server:tokio::spawn(get_file_async(search_path.clone(),format!("{}.server.lua",search_name))),
client:tokio::spawn(get_file_async(search_path.to_owned(),format!("{}.client.lua",search_name))), client:tokio::spawn(get_file_async(search_path.clone(),format!("{}.client.lua",search_name))),
} }
} }
fn rojo(search_path:&Path)->Self{ fn rojo(search_path:&PathBuf)->Self{
QueryTriple::rox_rojo(search_path,"init",false) QueryTriple::rox_rojo(search_path,"init",false)
} }
} }
@ -146,9 +146,9 @@ impl Query for QueryTriple{
async fn resolve(self)->QueryHintResult{ async fn resolve(self)->QueryHintResult{
let (module,server,client)=tokio::join!(self.module,self.server,self.client); let (module,server,client)=tokio::join!(self.module,self.server,self.client);
mega_triple_join(( mega_triple_join((
module.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}), module.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
server.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::Script}), server.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::Script}),
client.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}), client.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}),
)) ))
} }
} }
@ -159,7 +159,7 @@ struct QueryQuad{
client:QueryHandle, client:QueryHandle,
} }
impl QueryQuad{ impl QueryQuad{
fn rox_rojo(search_path:&Path,search_name:&str)->Self{ fn rox_rojo(search_path:&PathBuf,search_name:&str)->Self{
let fill=QueryTriple::rox_rojo(search_path,search_name,true); let fill=QueryTriple::rox_rojo(search_path,search_name,true);
Self{ Self{
module_implicit:QuerySingle::rox(search_path,search_name).script,//Script.lua module_implicit:QuerySingle::rox(search_path,search_name).script,//Script.lua
@ -173,10 +173,10 @@ impl Query for QueryQuad{
async fn resolve(self)->QueryHintResult{ async fn resolve(self)->QueryHintResult{
let (module_implicit,module_explicit,server,client)=tokio::join!(self.module_implicit,self.module_explicit,self.server,self.client); let (module_implicit,module_explicit,server,client)=tokio::join!(self.module_implicit,self.module_explicit,self.server,self.client);
mega_quadruple_join(( mega_quadruple_join((
module_implicit.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}), module_implicit.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
module_explicit.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}), module_explicit.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::ModuleScript}),
server.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::Script}), server.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::Script}),
client.map_err(QueryResolveError::JoinError)?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}), client.map_err(|e|QueryResolveError::JoinError(e))?.map(|file|FileHint{file,hint:ScriptHint::LocalScript}),
)) ))
} }
} }
@ -203,7 +203,7 @@ impl ScriptWithOverrides{
let mut count=0; let mut count=0;
for line in source.lines(){ for line in source.lines(){
//only string type properties are supported atm //only string type properties are supported atm
if let Some(captures)=lazy_regex::regex!(r#"^\-\-\s*Properties\.([A-Za-z]\w*)\s*\=\s*"(\w+)"$"#) if let Some(captures)=lazy_regex::regex!(r#"^\-\-\!\s*Properties\.([A-z]\w*)\s*\=\s*"(\w+)"$"#)
.captures(line){ .captures(line){
count+=line.len(); count+=line.len();
match &captures[1]{ match &captures[1]{
@ -248,7 +248,7 @@ pub enum CompileNodeError{
extension:String, extension:String,
style:Option<Style>, style:Option<Style>,
}, },
UnknownExtension, NoExtension,
} }
impl std::fmt::Display for CompileNodeError{ impl std::fmt::Display for CompileNodeError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{ fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
@ -338,9 +338,12 @@ impl CompileNode{
.into_string() .into_string()
.map_err(CompileNodeError::FileName)?; .map_err(CompileNodeError::FileName)?;
//reject goobers //reject goobers
let is_goober=matches!(style,Some(Style::Rojo)); let is_goober=match style{
Some(Style::Rojo)=>true,
_=>false,
};
let (ext_len,file_discernment)={ let (ext_len,file_discernment)={
if let Some(captures)=lazy_regex::regex!(r"^.*(\.module\.lua|\.client\.lua|\.server\.lua)$") if let Some(captures)=lazy_regex::regex!(r"^.*(.module.lua|.client.lua|.server.lua|.rbxmx|.lua)$")
.captures(file_name.as_str()){ .captures(file_name.as_str()){
let ext=&captures[1]; let ext=&captures[1];
(ext.len(),match ext{ (ext.len(),match ext{
@ -352,12 +355,6 @@ impl CompileNode{
}, },
".client.lua"=>FileDiscernment::Script(ScriptHint::LocalScript), ".client.lua"=>FileDiscernment::Script(ScriptHint::LocalScript),
".server.lua"=>FileDiscernment::Script(ScriptHint::Script), ".server.lua"=>FileDiscernment::Script(ScriptHint::Script),
_=>panic!("Regex failed"),
})
}else if let Some(captures)=lazy_regex::regex!(r"^.*(\.rbxmx|\.lua)$")
.captures(file_name.as_str()){
let ext=&captures[1];
(ext.len(),match ext{
".rbxmx"=>{ ".rbxmx"=>{
if is_goober{ if is_goober{
Err(CompileNodeError::ExtensionNotSupportedInStyle{extension:ext.to_owned(),style})?; Err(CompileNodeError::ExtensionNotSupportedInStyle{extension:ext.to_owned(),style})?;
@ -368,7 +365,7 @@ impl CompileNode{
_=>panic!("Regex failed"), _=>panic!("Regex failed"),
}) })
}else{ }else{
return Err(CompileNodeError::UnknownExtension); return Err(CompileNodeError::NoExtension);
} }
}; };
file_name.truncate(file_name.len()-ext_len); file_name.truncate(file_name.len()-ext_len);
@ -436,7 +433,7 @@ impl std::error::Error for CompileError{}
pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->Result<(),CompileError>{ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->Result<(),CompileError>{
//hack to traverse root folder as the root object //hack to traverse root folder as the root object
"src".clone_into(&mut dom.root_mut().name); dom.root_mut().name="src".to_owned();
//add in scripts and models //add in scripts and models
let mut folder=config.input_folder.clone(); let mut folder=config.input_folder.clone();
let mut stack:Vec<CompileStackInstruction>=vec![CompileStackInstruction::TraverseReferent(dom.root_ref(),None)]; let mut stack:Vec<CompileStackInstruction>=vec![CompileStackInstruction::TraverseReferent(dom.root_ref(),None)];
@ -456,9 +453,9 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
let mut exist_names:std::collections::HashSet<String>={ let mut exist_names:std::collections::HashSet<String>={
let item=dom.get_by_ref(item_ref).ok_or(CompileError::NullChildRef)?; let item=dom.get_by_ref(item_ref).ok_or(CompileError::NullChildRef)?;
//push existing dom children objects onto stack (unrelated to exist_names) //push existing dom children objects onto stack (unrelated to exist_names)
stack.extend(item.children().iter().map(|&referent|CompileStackInstruction::TraverseReferent(referent,None))); stack.extend(item.children().into_iter().map(|&referent|CompileStackInstruction::TraverseReferent(referent,None)));
//get names of existing objects //get names of existing objects
item.children().iter().map(|&child_ref|{ item.children().into_iter().map(|&child_ref|{
let child=dom.get_by_ref(child_ref).ok_or(CompileError::NullChildRef)?; let child=dom.get_by_ref(child_ref).ok_or(CompileError::NullChildRef)?;
Ok::<_,CompileError>(sanitize(child.name.as_str()).to_string()) Ok::<_,CompileError>(sanitize(child.name.as_str()).to_string())
}).collect::<Result<_,CompileError>>()? }).collect::<Result<_,CompileError>>()?
@ -475,7 +472,7 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
let ret1={ let ret1={
//capture a scoped mutable reference so we can forward dir to the next call even on an error //capture a scoped mutable reference so we can forward dir to the next call even on an error
let dir2=&mut dir1; let dir2=&mut dir1;
async move{//error catcher so I can use ? (||async move{//error catcher so I can use ?
let ret2=if let Some(entry)=dir2.next_entry().await?{ let ret2=if let Some(entry)=dir2.next_entry().await?{
//cull early even if supporting things with identical names is possible //cull early even if supporting things with identical names is possible
if exist_names.contains(entry.file_name().to_str().unwrap()){ if exist_names.contains(entry.file_name().to_str().unwrap()){
@ -487,7 +484,7 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
TooComplicated::Stop TooComplicated::Stop
}; };
Ok(ret2) Ok(ret2)
}.await })().await
}; };
match ret1{ match ret1{
Ok(TooComplicated::Stop)=>None, Ok(TooComplicated::Stop)=>None,
@ -503,19 +500,10 @@ pub async fn compile(config:CompileConfig,mut dom:&mut rbx_dom_weak::WeakDom)->R
Ok(Some(entry))=>tokio::spawn(async move{ Ok(Some(entry))=>tokio::spawn(async move{
let met=entry.metadata().await.map_err(CompileError::IO)?; let met=entry.metadata().await.map_err(CompileError::IO)?;
//discern that bad boy //discern that bad boy
let compile_class={ let compile_class=match met.is_dir(){
let result=match met.is_dir(){
true=>CompileNode::from_folder(&entry,style).await, true=>CompileNode::from_folder(&entry,style).await,
false=>CompileNode::from_file(&entry,style).await, false=>CompileNode::from_file(&entry,style).await,
}; }.map_err(CompileError::CompileNode)?;
match result{
Ok(compile_class)=>compile_class,
Err(e)=>{
println!("Ignoring file {entry:?} due to error {e}");
return Ok(None);
},
}
};
//prepare data structure //prepare data structure
Ok(Some((compile_class.blacklist,match compile_class.class{ Ok(Some((compile_class.blacklist,match compile_class.class{
CompileClass::Folder=>PreparedData::Builder(rbx_dom_weak::InstanceBuilder::new("Folder").with_name(compile_class.name.as_str())), CompileClass::Folder=>PreparedData::Builder(rbx_dom_weak::InstanceBuilder::new("Folder").with_name(compile_class.name.as_str())),

View File

@ -147,7 +147,10 @@ impl DecompiledContext{
"Model"=>Class::Model, "Model"=>Class::Model,
_=>Class::Folder, _=>Class::Folder,
}; };
let skip=class==Class::Model; let skip=match class{
Class::Model=>true,
_=>false,
};
if let Some(parent_node)=tree_refs.get_mut(&item.parent()){ if let Some(parent_node)=tree_refs.get_mut(&item.parent()){
let referent=item.referent(); let referent=item.referent();
let node=TreeNode::new(item.name.clone(),referent,parent_node.referent,class); let node=TreeNode::new(item.name.clone(),referent,parent_node.referent,class);
@ -179,14 +182,14 @@ impl DecompiledContext{
if node.class==Class::Folder&&script_count!=0{ if node.class==Class::Folder&&script_count!=0{
node.class=Class::Model node.class=Class::Model
} }
if node.class==Class::Folder&&node.children.is_empty(){ if node.class==Class::Folder&&node.children.len()==0{
delete=Some(node.parent); delete=Some(node.parent);
}else{ }else{
//how the hell do I do this better without recursion //how the hell do I do this better without recursion
let is_script=matches!( let is_script=match node.class{
node.class, Class::ModuleScript|Class::LocalScript|Class::Script=>true,
Class::ModuleScript|Class::LocalScript|Class::Script _=>false,
); };
//stack is popped from back //stack is popped from back
if is_script{ if is_script{
stack.push(TrimStackInstruction::DecrementScript); stack.push(TrimStackInstruction::DecrementScript);
@ -234,7 +237,7 @@ impl DecompiledContext{
WriteStackInstruction::Node(node,name_count)=>{ WriteStackInstruction::Node(node,name_count)=>{
//track properties that must be overriden to compile folder structure back into a place file //track properties that must be overriden to compile folder structure back into a place file
let mut properties=PropertiesOverride::default(); let mut properties=PropertiesOverride::default();
let has_children=!node.children.is_empty(); let has_children=node.children.len()!=0;
match node.class{ match node.class{
Class::Folder=>(), Class::Folder=>(),
Class::ModuleScript=>(),//.lua files are ModuleScript by default Class::ModuleScript=>(),//.lua files are ModuleScript by default
@ -294,7 +297,7 @@ impl DecompiledContext{
let write_models=config.write_models; let write_models=config.write_models;
let write_scripts=config.write_scripts; let write_scripts=config.write_scripts;
let results:Vec<Result<(),WriteError>>=rayon::iter::ParallelIterator::collect(rayon::iter::ParallelIterator::map(rayon::iter::IntoParallelIterator::into_par_iter(write_queue),|(write_path,node,node_name_override,properties,style)|{ let results:Vec<Result<(),WriteError>>=rayon::iter::ParallelIterator::collect(rayon::iter::ParallelIterator::map(rayon::iter::IntoParallelIterator::into_par_iter(write_queue),|(write_path,node,node_name_override,properties,style)|{
write_item(dom,write_path,node,node_name_override,properties,style,write_models,write_scripts) write_item(&dom,write_path,node,node_name_override,properties,style,write_models,write_scripts)
})); }));
for result in results{ for result in results{
result?; result?;

View File

@ -1,9 +1,9 @@
use std::{io::Read,path::PathBuf}; use std::{io::Read,path::PathBuf};
use clap::{Args,Parser,Subcommand}; use clap::{Args,Parser,Subcommand};
use anyhow::{anyhow,Result as AResult}; use anyhow::Result as AResult;
use futures::StreamExt; use futures::StreamExt;
use rbx_asset::cloud::{ApiKey,CloudContext}; use rbx_asset::cloud::{ApiKey,CloudContext,InventoryItem};
use rbx_asset::cookie::{Cookie,CookieContext,AssetVersion,InventoryItem}; use rbx_asset::cookie::{Cookie,CookieContext,AssetVersion};
type AssetID=u64; type AssetID=u64;
type AssetIDFileMap=Vec<(AssetID,PathBuf)>; type AssetIDFileMap=Vec<(AssetID,PathBuf)>;
@ -25,10 +25,7 @@ enum Commands{
DownloadDecompile(DownloadDecompileSubcommand), DownloadDecompile(DownloadDecompileSubcommand),
DownloadGroupInventoryJson(DownloadGroupInventoryJsonSubcommand), DownloadGroupInventoryJson(DownloadGroupInventoryJsonSubcommand),
CreateAsset(CreateAssetSubcommand), CreateAsset(CreateAssetSubcommand),
CreateAssetMedia(CreateAssetMediaSubcommand),
CreateAssetMedias(CreateAssetMediasSubcommand),
UploadAsset(UpdateAssetSubcommand), UploadAsset(UpdateAssetSubcommand),
UploadAssetMedia(UpdateAssetMediaSubcommand),
UploadPlace(UpdatePlaceSubcommand), UploadPlace(UpdatePlaceSubcommand),
Compile(CompileSubcommand), Compile(CompileSubcommand),
CompileUploadAsset(CompileUploadAssetSubcommand), CompileUploadAsset(CompileUploadAssetSubcommand),
@ -38,7 +35,6 @@ enum Commands{
DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand), DownloadAndDecompileHistoryIntoGit(DownloadAndDecompileHistoryIntoGitSubcommand),
} }
/// Download a range of assets from the asset version history. Download summary is saved to `output_folder/versions.json`, and can be optionally used to download only new versions the next time.
#[derive(Args)] #[derive(Args)]
struct DownloadHistorySubcommand{ struct DownloadHistorySubcommand{
#[arg(long)] #[arg(long)]
@ -58,21 +54,19 @@ struct DownloadHistorySubcommand{
#[arg(long)] #[arg(long)]
end_version:Option<u64>, end_version:Option<u64>,
} }
/// Download a single asset by id.
#[derive(Args)] #[derive(Args)]
struct DownloadSubcommand{ struct DownloadSubcommand{
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_literal:Option<String>, api_key_literal:Option<String>,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_envvar:Option<String>, api_key_envvar:Option<String>,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_file:Option<PathBuf>, api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
output_folder:Option<PathBuf>, output_folder:Option<PathBuf>,
#[arg(required=true)] #[arg(required=true)]
asset_ids:Vec<AssetID>, asset_ids:Vec<AssetID>,
} }
/// Download the list of asset ids (not the assets themselves) in a group inventory. The output is written to `output_folder/versions.json`
#[derive(Args)] #[derive(Args)]
struct DownloadGroupInventoryJsonSubcommand{ struct DownloadGroupInventoryJsonSubcommand{
#[arg(long,group="cookie",required=true)] #[arg(long,group="cookie",required=true)]
@ -86,31 +80,8 @@ struct DownloadGroupInventoryJsonSubcommand{
#[arg(long)] #[arg(long)]
group:u64, group:u64,
} }
/// Upload a (.rbxm, .rbxmx) model file, creating a new asset. Can be any type of model, including modulescripts.
#[derive(Args)] #[derive(Args)]
struct CreateAssetSubcommand{ struct CreateAssetSubcommand{
#[arg(long,group="cookie",required=true)]
cookie_literal:Option<String>,
#[arg(long,group="cookie",required=true)]
cookie_envvar:Option<String>,
#[arg(long,group="cookie",required=true)]
cookie_file:Option<PathBuf>,
#[arg(long)]
group_id:Option<u64>,
#[arg(long)]
input_file:PathBuf,
#[arg(long)]
model_name:String,
#[arg(long)]
description:Option<String>,
#[arg(long)]
free_model:Option<bool>,
#[arg(long)]
allow_comments:Option<bool>,
}
/// Upload a media file (.jpg, .png) to a new asset and print the asset id
#[derive(Args)]
struct CreateAssetMediaSubcommand{
#[arg(long,group="api_key",required=true)] #[arg(long,group="api_key",required=true)]
api_key_literal:Option<String>, api_key_literal:Option<String>,
#[arg(long,group="api_key",required=true)] #[arg(long,group="api_key",required=true)]
@ -124,68 +95,12 @@ struct CreateAssetMediaSubcommand{
#[arg(long)] #[arg(long)]
input_file:PathBuf, input_file:PathBuf,
#[arg(long)] #[arg(long)]
asset_type:AssetType, creator_user_id:u64,
#[arg(long,group="creator",required=true)] #[arg(long)]
creator_user_id:Option<u64>,
#[arg(long,group="creator",required=true)]
creator_group_id:Option<u64>, creator_group_id:Option<u64>,
/// Expected price limits how much robux can be spent to create the asset (defaults to 0)
#[arg(long)]
expected_price:Option<u64>,
} }
/// Upload multiple media files (.jpg, .png) Automatically detect the media type from file extension and generate asset name and description. If you want support for more file types (.fbx, .mp3, .ogg) it should be fairly straightforward, just ask.
#[derive(Args)]
struct CreateAssetMediasSubcommand{
#[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,group="cookie",required=true)]
cookie_literal:Option<String>,
#[arg(long,group="cookie",required=true)]
cookie_envvar:Option<String>,
#[arg(long,group="cookie",required=true)]
cookie_file:Option<PathBuf>,
#[arg(long)]
description:Option<String>,
#[arg(long,group="creator",required=true)]
creator_user_id:Option<u64>,
#[arg(long,group="creator",required=true)]
creator_group_id:Option<u64>,
/// Expected price limits how much robux can be spent to create the asset (defaults to 0)
#[arg(long)]
expected_price:Option<u64>,
input_files:Vec<PathBuf>,
}
/// Upload a (.rbxm, .rbxmx) model file to an existing asset. Can be any type of model, including modulescripts.
#[derive(Args)] #[derive(Args)]
struct UpdateAssetSubcommand{ struct UpdateAssetSubcommand{
#[arg(long)]
asset_id:AssetID,
#[arg(long,group="cookie",required=true)]
cookie_literal:Option<String>,
#[arg(long,group="cookie",required=true)]
cookie_envvar:Option<String>,
#[arg(long,group="cookie",required=true)]
cookie_file:Option<PathBuf>,
#[arg(long)]
group_id:Option<u64>,
#[arg(long)]
input_file:PathBuf,
#[arg(long)]
change_name:Option<String>,
#[arg(long)]
change_description:Option<String>,
#[arg(long)]
change_free_model:Option<bool>,
#[arg(long)]
change_allow_comments:Option<bool>,
}
/// Upload a media file (.jpg, .png) to an existing asset.
#[derive(Args)]
struct UpdateAssetMediaSubcommand{
#[arg(long)] #[arg(long)]
asset_id:AssetID, asset_id:AssetID,
#[arg(long,group="api_key",required=true)] #[arg(long,group="api_key",required=true)]
@ -197,7 +112,6 @@ struct UpdateAssetMediaSubcommand{
#[arg(long)] #[arg(long)]
input_file:PathBuf, input_file:PathBuf,
} }
/// Upload a place file (.rbxl, .rbxlx) to an existing place.
#[derive(Args)] #[derive(Args)]
struct UpdatePlaceSubcommand{ struct UpdatePlaceSubcommand{
#[arg(long)] #[arg(long)]
@ -213,7 +127,6 @@ struct UpdatePlaceSubcommand{
#[arg(long)] #[arg(long)]
input_file:PathBuf, input_file:PathBuf,
} }
/// Take an input folder containing scripts and models and turn it into a roblox file. The two types of files (.rbxl: place, .rbxm: model) are actually the same file format, only the contents differ.
#[derive(Args)] #[derive(Args)]
struct CompileSubcommand{ struct CompileSubcommand{
#[arg(long)] #[arg(long)]
@ -225,19 +138,18 @@ struct CompileSubcommand{
#[arg(long)] #[arg(long)]
template:Option<PathBuf>, template:Option<PathBuf>,
} }
/// Take an input folder containing scripts and models and turn it into a roblox file, then upload it to the specified asset id. Does not work for places.
#[derive(Args)] #[derive(Args)]
struct CompileUploadAssetSubcommand{ struct CompileUploadAssetSubcommand{
#[arg(long)] #[arg(long)]
asset_id:AssetID, asset_id:AssetID,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_literal:Option<String>, api_key_literal:Option<String>,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_envvar:Option<String>, api_key_envvar:Option<String>,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_file:Option<PathBuf>, api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
group_id:Option<u64>, input_file:PathBuf,
#[arg(long)] #[arg(long)]
input_folder:Option<PathBuf>, input_folder:Option<PathBuf>,
#[arg(long)] #[arg(long)]
@ -245,7 +157,6 @@ struct CompileUploadAssetSubcommand{
#[arg(long)] #[arg(long)]
template:Option<PathBuf>, template:Option<PathBuf>,
} }
/// Take an input folder containing scripts and models and turn it into a roblox file, then upload it to the specified place id. Does not work for model asset ids.
#[derive(Args)] #[derive(Args)]
struct CompileUploadPlaceSubcommand{ struct CompileUploadPlaceSubcommand{
#[arg(long)] #[arg(long)]
@ -259,13 +170,14 @@ struct CompileUploadPlaceSubcommand{
#[arg(long,group="api_key",required=true)] #[arg(long,group="api_key",required=true)]
api_key_file:Option<PathBuf>, api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
input_file:PathBuf,
#[arg(long)]
input_folder:Option<PathBuf>, input_folder:Option<PathBuf>,
#[arg(long)] #[arg(long)]
style:Option<Style>, style:Option<Style>,
#[arg(long)] #[arg(long)]
template:Option<PathBuf>, template:Option<PathBuf>,
} }
/// Take a roblox file (.rbxm, .rbxl) and turn it into a folder containing scripts and models. Rox style means property overrides are written to the top of scripts, Rojo style means property overrides are written to the script file extension (Script.server.lua).
#[derive(Args)] #[derive(Args)]
struct DecompileSubcommand{ struct DecompileSubcommand{
#[arg(long)] #[arg(long)]
@ -281,15 +193,14 @@ struct DecompileSubcommand{
#[arg(long)] #[arg(long)]
write_scripts:Option<bool>, write_scripts:Option<bool>,
} }
/// Download a model from the specified asset id, and decompile it into a folder in one swift motion. The model file is not saved to disk. This also works for places.
#[derive(Args)] #[derive(Args)]
struct DownloadDecompileSubcommand{ struct DownloadDecompileSubcommand{
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_literal:Option<String>, api_key_literal:Option<String>,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_envvar:Option<String>, api_key_envvar:Option<String>,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_file:Option<PathBuf>, api_key_file:Option<PathBuf>,
#[arg(long)] #[arg(long)]
output_folder:Option<PathBuf>, output_folder:Option<PathBuf>,
#[arg(long)] #[arg(long)]
@ -303,13 +214,12 @@ struct DownloadDecompileSubcommand{
#[arg(long)] #[arg(long)]
write_scripts:Option<bool>, write_scripts:Option<bool>,
} }
/// Take a folder of asset history (containing `versions.json`) and decompile each version into its own git commit. This must be run with the desired output folder as the current directory due to git2 limitations.
#[derive(Args)] #[derive(Args)]
struct DecompileHistoryIntoGitSubcommand{ struct DecompileHistoryIntoGitSubcommand{
#[arg(long)] #[arg(long)]
input_folder:PathBuf, input_folder:PathBuf,
#[arg(long)] //currently output folder must be the current folder due to git2 limitations
output_folder:Option<PathBuf>, //output_folder:cli.output.unwrap(),
#[arg(long)] #[arg(long)]
style:Style, style:Style,
#[arg(long)] #[arg(long)]
@ -323,19 +233,18 @@ struct DecompileHistoryIntoGitSubcommand{
#[arg(long)] #[arg(long)]
write_scripts:Option<bool>, write_scripts:Option<bool>,
} }
/// Download asset history, download asset versions, decompile into folder, create a git commit for each version. This is a combination of two commands (download-history, decompile-history-into-git) except without intermediate files.
#[derive(Args)] #[derive(Args)]
struct DownloadAndDecompileHistoryIntoGitSubcommand{ struct DownloadAndDecompileHistoryIntoGitSubcommand{
#[arg(long)] #[arg(long)]
asset_id:AssetID, asset_id:AssetID,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_literal:Option<String>, api_key_literal:Option<String>,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_envvar:Option<String>, api_key_envvar:Option<String>,
#[arg(long,group="cookie",required=true)] #[arg(long,group="api_key",required=true)]
cookie_file:Option<PathBuf>, api_key_file:Option<PathBuf>,
#[arg(long)] //currently output folder must be the current folder due to git2 limitations
output_folder:Option<PathBuf>, //output_folder:cli.output.unwrap(),
#[arg(long)] #[arg(long)]
style:Style, style:Style,
#[arg(long)] #[arg(long)]
@ -365,21 +274,6 @@ impl Style{
} }
} }
} }
#[derive(Clone,Copy,Debug,clap::ValueEnum)]
enum AssetType{
Audio,
Decal,
Model,
}
impl AssetType{
fn cloud(&self)->rbx_asset::cloud::AssetType{
match self{
AssetType::Audio=>rbx_asset::cloud::AssetType::Audio,
AssetType::Decal=>rbx_asset::cloud::AssetType::Decal,
AssetType::Model=>rbx_asset::cloud::AssetType::Model,
}
}
}
#[tokio::main] #[tokio::main]
async fn main()->AResult<()>{ async fn main()->AResult<()>{
@ -400,10 +294,10 @@ async fn main()->AResult<()>{
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_args( api_key_from_args(
subcommand.cookie_literal, subcommand.api_key_literal,
subcommand.cookie_envvar, subcommand.api_key_envvar,
subcommand.cookie_file, subcommand.api_key_file,
).await?, ).await?,
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();
@ -414,10 +308,10 @@ async fn main()->AResult<()>{
}, },
Commands::DownloadDecompile(subcommand)=>{ Commands::DownloadDecompile(subcommand)=>{
download_decompile(DownloadDecompileConfig{ download_decompile(DownloadDecompileConfig{
cookie:cookie_from_args( api_key:api_key_from_args(
subcommand.cookie_literal, subcommand.api_key_literal,
subcommand.cookie_envvar, subcommand.api_key_envvar,
subcommand.cookie_file, subcommand.api_key_file,
).await?, ).await?,
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()),
@ -436,71 +330,19 @@ async fn main()->AResult<()>{
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_asset(CreateAssetConfig{ Commands::CreateAsset(subcommand)=>create(CreateConfig{
cookie:cookie_from_args(
subcommand.cookie_literal,
subcommand.cookie_envvar,
subcommand.cookie_file,
).await?,
group:subcommand.group_id,
input_file:subcommand.input_file,
model_name:subcommand.model_name,
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,
Commands::CreateAssetMedia(subcommand)=>create_asset_media(CreateAssetMediaConfig{
api_key:api_key_from_args( api_key:api_key_from_args(
subcommand.api_key_literal, subcommand.api_key_literal,
subcommand.api_key_envvar, subcommand.api_key_envvar,
subcommand.api_key_file, subcommand.api_key_file,
).await?, ).await?,
creator:match (subcommand.creator_user_id,subcommand.creator_group_id){ creator_user_id:subcommand.creator_user_id,
(Some(user_id),None)=>rbx_asset::cloud::Creator::userId(user_id.to_string()), creator_group_id:subcommand.creator_group_id,
(None,Some(group_id))=>rbx_asset::cloud::Creator::groupId(group_id.to_string()),
other=>Err(anyhow!("Invalid creator {other:?}"))?,
},
input_file:subcommand.input_file, input_file:subcommand.input_file,
asset_type:subcommand.asset_type.cloud(),
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)),
expected_price:subcommand.expected_price,
}).await,
Commands::CreateAssetMedias(subcommand)=>create_asset_medias(CreateAssetMediasConfig{
api_key:api_key_from_args(
subcommand.api_key_literal,
subcommand.api_key_envvar,
subcommand.api_key_file,
).await?,
cookie:cookie_from_args(
subcommand.cookie_literal,
subcommand.cookie_envvar,
subcommand.cookie_file,
).await?,
creator:match (subcommand.creator_user_id,subcommand.creator_group_id){
(Some(user_id),None)=>rbx_asset::cloud::Creator::userId(user_id.to_string()),
(None,Some(group_id))=>rbx_asset::cloud::Creator::groupId(group_id.to_string()),
other=>Err(anyhow!("Invalid creator {other:?}"))?,
},
description:subcommand.description.unwrap_or_else(||String::with_capacity(0)),
input_files:subcommand.input_files,
expected_price:subcommand.expected_price,
}).await, }).await,
Commands::UploadAsset(subcommand)=>upload_asset(UploadAssetConfig{ Commands::UploadAsset(subcommand)=>upload_asset(UploadAssetConfig{
cookie:cookie_from_args(
subcommand.cookie_literal,
subcommand.cookie_envvar,
subcommand.cookie_file,
).await?,
asset_id:subcommand.asset_id,
group_id:subcommand.group_id,
input_file:subcommand.input_file,
change_name:subcommand.change_name,
change_description:subcommand.change_description,
change_free_model:subcommand.change_free_model,
change_allow_comments:subcommand.change_allow_comments,
}).await,
Commands::UploadAssetMedia(subcommand)=>upload_asset_media(UploadAssetMediaConfig{
api_key:api_key_from_args( api_key:api_key_from_args(
subcommand.api_key_literal, subcommand.api_key_literal,
subcommand.api_key_envvar, subcommand.api_key_envvar,
@ -529,13 +371,12 @@ async fn main()->AResult<()>{
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_args( api_key:api_key_from_args(
subcommand.cookie_literal, subcommand.api_key_literal,
subcommand.cookie_envvar, subcommand.api_key_envvar,
subcommand.cookie_file, subcommand.api_key_file,
).await?, ).await?,
asset_id:subcommand.asset_id, asset_id:subcommand.asset_id,
group_id:subcommand.group_id,
}).await, }).await,
Commands::CompileUploadPlace(subcommand)=>compile_upload_place(CompileUploadPlaceConfig{ Commands::CompileUploadPlace(subcommand)=>compile_upload_place(CompileUploadPlaceConfig{
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()),
@ -561,7 +402,7 @@ async fn main()->AResult<()>{
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,
input_folder:subcommand.input_folder, input_folder:subcommand.input_folder,
output_folder:subcommand.output_folder.unwrap_or_else(||std::env::current_dir().unwrap()), output_folder:std::env::current_dir()?,
style:subcommand.style.rox(), style:subcommand.style.rox(),
write_template:subcommand.write_template.unwrap_or(false), write_template:subcommand.write_template.unwrap_or(false),
write_models:subcommand.write_models.unwrap_or(false), write_models:subcommand.write_models.unwrap_or(false),
@ -570,13 +411,13 @@ 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_args( api_key:api_key_from_args(
subcommand.cookie_literal, subcommand.api_key_literal,
subcommand.cookie_envvar, subcommand.api_key_envvar,
subcommand.cookie_file, subcommand.api_key_file,
).await?, ).await?,
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:std::env::current_dir()?,
style:subcommand.style.rox(), style:subcommand.style.rox(),
write_template:subcommand.write_template.unwrap_or(false), write_template:subcommand.write_template.unwrap_or(false),
write_models:subcommand.write_models.unwrap_or(false), write_models:subcommand.write_models.unwrap_or(false),
@ -590,9 +431,9 @@ async fn cookie_from_args(literal:Option<String>,environment:Option<String>,file
(Some(cookie_literal),None,None)=>cookie_literal, (Some(cookie_literal),None,None)=>cookie_literal,
(None,Some(cookie_environment),None)=>std::env::var(cookie_environment)?, (None,Some(cookie_environment),None)=>std::env::var(cookie_environment)?,
(None,None,Some(cookie_file))=>tokio::fs::read_to_string(cookie_file).await?, (None,None,Some(cookie_file))=>tokio::fs::read_to_string(cookie_file).await?,
_=>Err(anyhow::Error::msg("Illegal cookie argument triple"))?, _=>Err(anyhow::Error::msg("Illegal api key argument triple"))?,
}; };
Ok(Cookie::new(format!(".ROBLOSECURITY={cookie}"))) Ok(Cookie::new(cookie))
} }
async fn api_key_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<ApiKey>{ async fn api_key_from_args(literal:Option<String>,environment:Option<String>,file:Option<PathBuf>)->AResult<ApiKey>{
let api_key=match (literal,environment,file){ let api_key=match (literal,environment,file){
@ -604,253 +445,46 @@ async fn api_key_from_args(literal:Option<String>,environment:Option<String>,fil
Ok(ApiKey::new(api_key)) Ok(ApiKey::new(api_key))
} }
struct CreateAssetConfig{ struct CreateConfig{
cookie:Cookie,
model_name:String,
description:String,
input_file:PathBuf,
group:Option<u64>,
free_model:bool,
allow_comments:bool,
}
async fn create_asset(config:CreateAssetConfig)->AResult<()>{
let resp=CookieContext::new(config.cookie)
.create(rbx_asset::cookie::CreateRequest{
name:config.model_name,
description:config.description,
ispublic:config.free_model,
allowComments:config.allow_comments,
groupId:config.group,
},tokio::fs::read(config.input_file).await?).await?;
println!("UploadResponse={:?}",resp);
Ok(())
}
struct CreateAssetMediaConfig{
api_key:ApiKey, api_key:ApiKey,
asset_type:rbx_asset::cloud::AssetType,
model_name:String, model_name:String,
description:String, description:String,
input_file:PathBuf, input_file:PathBuf,
creator:rbx_asset::cloud::Creator, creator_user_id:u64,
expected_price:Option<u64>, creator_group_id:Option<u64>,
} }
async fn get_asset_exp_backoff( ///This is hardcoded to create models atm
context:&CloudContext, async fn create(config:CreateConfig)->AResult<()>{
asset_operation:&rbx_asset::cloud::AssetOperation let resp=CloudContext::new(config.api_key)
)->Result<rbx_asset::cloud::AssetResponse,rbx_asset::cloud::AssetOperationError>{
const BACKOFF_MUL:f32=1.3956124250860895286;//exp(1/3)
let mut backoff=1000f32;
loop{
match asset_operation.try_get_asset(&context).await{
//try again when the operation is not done
Err(rbx_asset::cloud::AssetOperationError::Operation(rbx_asset::cloud::OperationError::NotDone))=>(),
//return all other results
other_result=>return other_result,
}
println!("Operation not complete; waiting {:.0}ms...",backoff);
tokio::time::sleep(std::time::Duration::from_millis(backoff as u64)).await;
backoff*=BACKOFF_MUL;
}
}
async fn create_asset_media(config:CreateAssetMediaConfig)->AResult<()>{
let context=CloudContext::new(config.api_key);
let asset_response=context
.create_asset(rbx_asset::cloud::CreateAssetRequest{ .create_asset(rbx_asset::cloud::CreateAssetRequest{
assetType:config.asset_type, assetType:rbx_asset::cloud::AssetType::Model,
displayName:config.model_name, displayName:config.model_name,
description:config.description, description:config.description,
creationContext:rbx_asset::cloud::CreationContext{ creationContext:rbx_asset::cloud::CreationContext{
creator:config.creator, creator:rbx_asset::cloud::Creator{
expectedPrice:Some(config.expected_price.unwrap_or(0)), userId:config.creator_user_id,
groupId:config.creator_group_id.unwrap_or(0),
},
expectedPrice:0,
} }
},tokio::fs::read(config.input_file).await?).await?; },tokio::fs::read(config.input_file).await?).await?;
//hardcode a 2 second sleep because roblox be slow println!("UploadResponse={:?}",resp);
println!("Asset submitted, waiting 2s...");
tokio::time::sleep(std::time::Duration::from_secs(2)).await;
let asset=get_asset_exp_backoff(&context,&asset_response).await?;
println!("CreateResponse={:?}",asset);
Ok(())
}
// complex operation requires both api key and cookie! how horrible! roblox please fix!
struct CreateAssetMediasConfig{
api_key:ApiKey,
cookie:Cookie,
description:String,
input_files:Vec<PathBuf>,
creator:rbx_asset::cloud::Creator,
expected_price:Option<u64>,
}
#[derive(Debug)]
#[allow(dead_code)]
enum CreateAssetMediasError{
NoFileStem(PathBuf),
IO(std::io::Error),
UnknownFourCC(Option<[u8;4]>),
Create(rbx_asset::cloud::CreateError),
}
impl std::fmt::Display for CreateAssetMediasError{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for CreateAssetMediasError{}
#[derive(Debug)]
#[allow(dead_code)]
enum PollOperationError{
CreateAssetMedias(CreateAssetMediasError),
AssetOperation(rbx_asset::cloud::AssetOperationError),
}
impl std::fmt::Display for PollOperationError{
fn fmt(&self, f: &mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for PollOperationError{}
#[derive(Debug)]
#[allow(dead_code)]
enum DownloadDecalError{
PollOperation(PollOperationError),
ParseInt(std::num::ParseIntError),
Get(rbx_asset::cookie::GetError),
LoadDom(LoadDomError),
NoFirstInstance,
NoTextureProperty,
TexturePropertyInvalid,
}
impl std::fmt::Display for DownloadDecalError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for DownloadDecalError{}
async fn create_asset_medias(config:CreateAssetMediasConfig)->AResult<()>{
let context=CloudContext::new(config.api_key);
let cookie_context=CookieContext::new(config.cookie);
let expected_price=Some(config.expected_price.unwrap_or(0));
futures::stream::iter(config.input_files.into_iter()
//step 1: read file, make create request
.map(|path|{
let description=&config.description;
let creator=&config.creator;
let context=&context;
async move{(path.clone(),
async move{
let model_name=path.file_stem()
.and_then(std::ffi::OsStr::to_str)
.ok_or_else(||CreateAssetMediasError::NoFileStem(path.clone()))?
.to_owned();
let file=tokio::fs::read(path).await.map_err(CreateAssetMediasError::IO)?;
let asset_type=match file.get(0..4){
//png
Some(b"\x89PNG")=>rbx_asset::cloud::AssetType::Decal,
//jpeg
Some(b"\xFF\xD8\xFF\xE0")=>rbx_asset::cloud::AssetType::Decal,
//Some("fbx")=>rbx_asset::cloud::AssetType::Model,
//Some("ogg")=>rbx_asset::cloud::AssetType::Audio,
fourcc=>Err(CreateAssetMediasError::UnknownFourCC(fourcc.map(|s|s.try_into().unwrap())))?,
};
context.create_asset(rbx_asset::cloud::CreateAssetRequest{
assetType:asset_type,
displayName:model_name,
description:description.clone(),
creationContext:rbx_asset::cloud::CreationContext{
creator:creator.clone(),
expectedPrice:expected_price,
}
},file).await.map_err(CreateAssetMediasError::Create)
}
.await)}
}))
//parallel requests
.buffer_unordered(CONCURRENT_REQUESTS)
//step 2: poll operation until it completes
.then(|(path,create_result)|{
let context=&context;
async{(path,
async{
let asset_operation=create_result.map_err(PollOperationError::CreateAssetMedias)?;
get_asset_exp_backoff(context,&asset_operation).await.map_err(PollOperationError::AssetOperation)
}
.await)}
})
//step 3: read decal id from operation and download it, decode it as a roblox file and extract the texture content url
.then(|(path,asset_response_result)|{
let cookie_context=&cookie_context;
async move{(path,
async move{
let asset_response=asset_response_result.map_err(DownloadDecalError::PollOperation)?;
let file=cookie_context.get_asset(rbx_asset::cookie::GetAssetRequest{
asset_id:asset_response.assetId.parse().map_err(DownloadDecalError::ParseInt)?,
version:None,
}).await.map_err(DownloadDecalError::Get)?;
let dom=load_dom(std::io::Cursor::new(file)).map_err(DownloadDecalError::LoadDom)?;
let instance=dom.get_by_ref(
*dom.root().children().first().ok_or(DownloadDecalError::NoFirstInstance)?
).ok_or(DownloadDecalError::NoFirstInstance)?;
let texture=instance.properties.get("Texture").ok_or(DownloadDecalError::NoTextureProperty)?;
let asset_url=match texture{
rbx_dom_weak::types::Variant::Content(url)=>url.clone().into_string(),
_=>Err(DownloadDecalError::TexturePropertyInvalid)?,
};
Ok::<_,DownloadDecalError>((asset_response.displayName,asset_url))
}
.await)}
})
.for_each(|(path,download_decal_result)|async move{
match download_decal_result{
Ok((file_name,asset_url))=>println!("{}={}",file_name,asset_url),
Err(e)=>eprintln!("ERROR file={:?} error={e}",path),
}
}).await;
Ok(()) Ok(())
} }
struct UploadAssetConfig{ struct UploadAssetConfig{
cookie:Cookie,
asset_id:AssetID,
change_name:Option<String>,
change_description:Option<String>,
change_free_model:Option<bool>,
change_allow_comments:Option<bool>,
group_id:Option<u64>,
input_file:PathBuf,
}
async fn upload_asset(config:UploadAssetConfig)->AResult<()>{
let context=CookieContext::new(config.cookie);
let resp=context.upload(rbx_asset::cookie::UploadRequest{
assetid:config.asset_id,
name:config.change_name,
description:config.change_description,
ispublic:config.change_free_model,
allowComments:config.change_allow_comments,
groupId:config.group_id,
},tokio::fs::read(config.input_file).await?).await?;
println!("UploadResponse={:?}",resp);
Ok(())
}
struct UploadAssetMediaConfig{
api_key:ApiKey, api_key:ApiKey,
asset_id:u64, asset_id:u64,
input_file:PathBuf, input_file:PathBuf,
} }
async fn upload_asset_media(config:UploadAssetMediaConfig)->AResult<()>{ async fn upload_asset(config:UploadAssetConfig)->AResult<()>{
let context=CloudContext::new(config.api_key); let context=CloudContext::new(config.api_key);
let resp=context.update_asset(rbx_asset::cloud::UpdateAssetRequest{ context.update_asset(rbx_asset::cloud::UpdateAssetRequest{
assetId:config.asset_id, assetId:config.asset_id,
displayName:None, displayName:None,
description:None, description:None,
},tokio::fs::read(config.input_file).await?).await?; },tokio::fs::read(config.input_file).await?).await?;
println!("UploadResponse={:?}",resp);
Ok(()) Ok(())
} }
@ -869,20 +503,23 @@ async fn upload_place(config:UploadPlaceConfig)->AResult<()>{
Ok(()) Ok(())
} }
async fn download_list(cookie:Cookie,asset_id_file_map:AssetIDFileMap)->AResult<()>{ async fn download_list(api_key:ApiKey,asset_id_file_map:AssetIDFileMap)->AResult<()>{
let context=CookieContext::new(cookie); let context=CloudContext::new(api_key);
futures::stream::iter(asset_id_file_map.into_iter() futures::stream::iter(asset_id_file_map.into_iter()
.map(|(asset_id,file)|{ .map(|(asset_id,file)|{
let context=&context; let context=&context;
async move{ async move{
Ok((file,context.get_asset(rbx_asset::cookie::GetAssetRequest{asset_id,version:None}).await?)) Ok((file,context.get_asset(rbx_asset::cloud::GetAssetRequest{asset_id,version:None}).await?))
} }
})) }))
.buffer_unordered(CONCURRENT_REQUESTS) .buffer_unordered(CONCURRENT_REQUESTS)
.for_each(|b:AResult<_>|async{ .for_each(|b:AResult<_>|async{
match b{ match b{
Ok((dest,data))=>if let Err(e)=tokio::fs::write(dest,data).await{ Ok((dest,data))=>{
eprintln!("fs error: {}",e); match tokio::fs::write(dest,data).await{
Err(e)=>eprintln!("fs error: {}",e),
_=>(),
}
}, },
Err(e)=>eprintln!("dl error: {}",e), Err(e)=>eprintln!("dl error: {}",e),
} }
@ -894,7 +531,7 @@ async fn get_inventory_pages(context:&CookieContext,group:u64)->AResult<Vec<Inve
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.get_inventory_page(rbx_asset::cookie::InventoryPageRequest{group,cursor}).await?; let mut page=context.inventory_page(rbx_asset::cookie::InventoryPageRequest{group,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;
@ -915,11 +552,11 @@ async fn download_group_inventory_json(cookie:Cookie,group:u64,output_folder:Pat
Ok(()) Ok(())
} }
async fn get_version_history(context:&CookieContext,asset_id:AssetID)->AResult<Vec<AssetVersion>>{ async fn get_version_history(context:&CloudContext,asset_id:AssetID)->AResult<Vec<AssetVersion>>{
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.get_asset_versions_page(rbx_asset::cookie::AssetVersionsPageRequest{asset_id,cursor}).await?; let mut page=context.get_asset_versions(rbx_asset::cloud::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;
@ -1014,7 +651,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.get_asset(rbx_asset::cookie::GetAssetRequest{asset_id:config.asset_id,version:Some(version_number)}).await?; let file=context.get_asset(rbx_asset::cloud::GetAssetRequest{asset_id:config.asset_id,version:Some(version_number)}).await?;
tokio::fs::write(path,file).await?; tokio::fs::write(path,file).await?;
@ -1059,34 +696,18 @@ async fn download_history(mut config:DownloadHistoryConfig)->AResult<()>{
Ok(()) Ok(())
} }
#[derive(Debug)] fn load_dom<R:Read>(input:R)->AResult<rbx_dom_weak::WeakDom>{
#[allow(dead_code)]
enum LoadDomError{
IO(std::io::Error),
RbxBinary(rbx_binary::DecodeError),
RbxXml(rbx_xml::DecodeError),
UnknownRobloxFile([u8;4]),
UnsupportedFile,
}
impl std::fmt::Display for LoadDomError{
fn fmt(&self,f:&mut std::fmt::Formatter<'_>)->std::fmt::Result{
write!(f,"{self:?}")
}
}
impl std::error::Error for LoadDomError{}
fn load_dom<R:Read>(input:R)->Result<rbx_dom_weak::WeakDom,LoadDomError>{
let mut buf=std::io::BufReader::new(input); let mut buf=std::io::BufReader::new(input);
let peek=std::io::BufRead::fill_buf(&mut buf).map_err(LoadDomError::IO)?; let peek=std::io::BufRead::fill_buf(&mut buf)?;
match &peek[0..4]{ match &peek[0..4]{
b"<rob"=>{ b"<rob"=>{
match &peek[4..8]{ match &peek[4..8]{
b"lox!"=>rbx_binary::from_reader(buf).map_err(LoadDomError::RbxBinary), b"lox!"=>rbx_binary::from_reader(buf).map_err(anyhow::Error::msg),
b"lox "=>rbx_xml::from_reader_default(buf).map_err(LoadDomError::RbxXml), b"lox "=>rbx_xml::from_reader_default(buf).map_err(anyhow::Error::msg),
other=>Err(LoadDomError::UnknownRobloxFile(other.try_into().unwrap())), other=>Err(anyhow::Error::msg(format!("Unknown Roblox file type {:?}",other))),
} }
}, },
_=>Err(LoadDomError::UnsupportedFile), _=>Err(anyhow::Error::msg("unsupported file type")),
} }
} }
@ -1125,7 +746,7 @@ async fn decompile(config:DecompileConfig)->AResult<()>{
} }
struct DownloadDecompileConfig{ struct DownloadDecompileConfig{
cookie:Cookie, api_key:ApiKey,
asset_id:AssetID, asset_id:AssetID,
style:rox_compiler::Style, style:rox_compiler::Style,
output_folder:PathBuf, output_folder:PathBuf,
@ -1135,8 +756,8 @@ struct DownloadDecompileConfig{
} }
async fn download_decompile(config:DownloadDecompileConfig)->AResult<()>{ async fn download_decompile(config:DownloadDecompileConfig)->AResult<()>{
let context=CookieContext::new(config.cookie); let context=CloudContext::new(config.api_key);
let file=context.get_asset(rbx_asset::cookie::GetAssetRequest{asset_id:config.asset_id,version:None}).await?; let file=context.get_asset(rbx_asset::cloud::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);
@ -1198,11 +819,11 @@ async fn write_commit(config:WriteCommitConfig,b:Result<AResult<(AssetVersion,ro
let sig=git2::Signature::new(config.git_committer_name.as_str(),config.git_committer_email.as_str(),&git2::Time::new(date.timestamp(),0)).unwrap(); let sig=git2::Signature::new(config.git_committer_name.as_str(),config.git_committer_email.as_str(),&git2::Time::new(date.timestamp(),0)).unwrap();
let tree_id={ let tree_id={
let mut tree_index = repo.index()?; let mut tree_index = repo.index()?;
match tree_index.add_all(std::iter::once("*"),git2::IndexAddOption::DEFAULT,None){ match tree_index.add_all(std::iter::once(config.output_folder.as_path()),git2::IndexAddOption::DEFAULT,None){
Ok(_)=>(), Ok(_)=>(),
Err(e)=>println!("tree_index.add_all error: {}",e), Err(e)=>println!("tree_index.add_all error: {}",e),
} }
match tree_index.update_all(std::iter::once("*"),None){ match tree_index.update_all(std::iter::once(config.output_folder.as_path()),None){
Ok(_)=>(), Ok(_)=>(),
Err(e)=>println!("tree_index.update_all error: {}",e), Err(e)=>println!("tree_index.update_all error: {}",e),
} }
@ -1293,7 +914,7 @@ async fn decompile_history_into_git(config:DecompileHistoryConfig)->AResult<()>{
} }
struct DownloadAndDecompileHistoryConfig{ struct DownloadAndDecompileHistoryConfig{
cookie:Cookie, api_key:ApiKey,
asset_id:AssetID, asset_id:AssetID,
git_committer_name:String, git_committer_name:String,
git_committer_email:String, git_committer_email:String,
@ -1305,7 +926,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=CookieContext::new(config.cookie); let context=CloudContext::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?;
@ -1318,7 +939,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.get_asset(rbx_asset::cookie::GetAssetRequest{asset_id,version:Some(asset_version.assetVersionNumber)}).await?; let file=context.get_asset(rbx_asset::cloud::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)))
}) })
@ -1376,8 +997,7 @@ 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:Cookie, api_key:ApiKey,
group_id:Option<u64>,
asset_id:AssetID, asset_id:AssetID,
} }
async fn compile_upload_asset(config:CompileUploadAssetConfig)->AResult<()>{ async fn compile_upload_asset(config:CompileUploadAssetConfig)->AResult<()>{
@ -1397,16 +1017,12 @@ async fn compile_upload_asset(config:CompileUploadAssetConfig)->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=CookieContext::new(config.cookie); let context=CloudContext::new(config.api_key);
let resp=context.upload(rbx_asset::cookie::UploadRequest{ context.update_asset(rbx_asset::cloud::UpdateAssetRequest{
groupId:config.group_id, assetId:config.asset_id,
assetid:config.asset_id, displayName:None,
name:None,
description:None, description:None,
ispublic:None,
allowComments:None,
},data).await?; },data).await?;
println!("UploadResponse={:?}",resp);
Ok(()) Ok(())
} }
@ -1436,10 +1052,9 @@ async fn compile_upload_place(config:CompileUploadPlaceConfig)->AResult<()>{
//upload it //upload it
let context=CloudContext::new(config.api_key); let context=CloudContext::new(config.api_key);
let resp=context.update_place(rbx_asset::cloud::UpdatePlaceRequest{ context.update_place(rbx_asset::cloud::UpdatePlaceRequest{
universeId:config.universe_id, universeId:config.universe_id,
placeId:config.place_id, placeId:config.place_id,
},data).await?; },data).await?;
println!("UploadResponse={:?}",resp);
Ok(()) Ok(())
} }