k88936
e472b8d22d
保留外部生成异步提交、幂等轮询与托管MCP能力 融合角色动作正式序列帧资源与素材持久化契约 保留内部处理元数据脱敏与图集批量持久化门禁 补齐画布资源权威恢复、测试与Skill文档
1126 lines
42 KiB
Rust
1126 lines
42 KiB
Rust
use super::*;
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct EditorSpritesheetSlicePersistItemRecordInput {
|
|
pub asset_object: module_assets::AssetObjectUpsertInput,
|
|
pub project_resource: Option<EditorProjectResourceCreateRecordInput>,
|
|
pub asset: Option<EditorAssetCreateRecordInput>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct EditorSpritesheetSliceBatchPersistRecordInput {
|
|
pub owner_user_id: String,
|
|
pub task_id: String,
|
|
pub group_task_id: Option<String>,
|
|
pub expected_asset_count: u32,
|
|
pub items: Vec<EditorSpritesheetSlicePersistItemRecordInput>,
|
|
pub completed_at_micros: i64,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct EditorSpritesheetSlicePersistedItemRecord {
|
|
pub asset_object: module_assets::AssetObjectUpsertSnapshot,
|
|
pub project_resource: Option<EditorProjectResourceRecord>,
|
|
pub asset: Option<EditorAssetRecord>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct EditorSpritesheetSliceBatchPersistRecord {
|
|
pub items: Vec<EditorSpritesheetSlicePersistedItemRecord>,
|
|
}
|
|
|
|
impl From<EditorSpritesheetSlicePersistItemRecordInput>
|
|
for crate::module_bindings::EditorSpritesheetSlicePersistItemInput
|
|
{
|
|
fn from(input: EditorSpritesheetSlicePersistItemRecordInput) -> Self {
|
|
Self {
|
|
asset_object: input.asset_object.into(),
|
|
project_resource: input.project_resource.map(Into::into),
|
|
asset: input.asset.map(Into::into),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<EditorSpritesheetSliceBatchPersistRecordInput>
|
|
for crate::module_bindings::EditorSpritesheetSliceBatchPersistInput
|
|
{
|
|
fn from(input: EditorSpritesheetSliceBatchPersistRecordInput) -> Self {
|
|
Self {
|
|
owner_user_id: input.owner_user_id,
|
|
task_id: input.task_id,
|
|
group_task_id: input.group_task_id,
|
|
expected_asset_count: input.expected_asset_count,
|
|
items: input.items.into_iter().map(Into::into).collect(),
|
|
completed_at_micros: input.completed_at_micros,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl SpacetimeClient {
|
|
pub async fn persist_editor_spritesheet_slice_batch(
|
|
&self,
|
|
input: EditorSpritesheetSliceBatchPersistRecordInput,
|
|
) -> Result<EditorSpritesheetSliceBatchPersistRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"persist_editor_spritesheet_slice_batch_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.persist_editor_spritesheet_slice_batch_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_spritesheet_slice_batch_persist_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn create_editor_project(
|
|
&self,
|
|
input: EditorProjectCreateRecordInput,
|
|
) -> Result<EditorProjectRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"create_editor_project_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.create_editor_project_and_return_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_required_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn get_recent_editor_project(
|
|
&self,
|
|
owner_user_id: String,
|
|
) -> Result<Option<EditorProjectRecord>, SpacetimeClientError> {
|
|
let procedure_input = EditorProjectGetRecentInput { owner_user_id };
|
|
|
|
self.call_after_connect(
|
|
"get_recent_editor_project_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.get_recent_editor_project_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_optional_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn get_editor_project(
|
|
&self,
|
|
input: EditorProjectGetRecordInput,
|
|
) -> Result<EditorProjectRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"get_editor_project_and_return",
|
|
move |connection, sender| {
|
|
connection.procedures().get_editor_project_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_required_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn list_editor_projects(
|
|
&self,
|
|
owner_user_id: String,
|
|
) -> Result<Vec<EditorProjectRecord>, SpacetimeClientError> {
|
|
let procedure_input = EditorProjectListInput { owner_user_id };
|
|
|
|
self.call_after_connect(
|
|
"list_editor_projects_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.list_editor_projects_and_return_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_list_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn rename_editor_project(
|
|
&self,
|
|
input: EditorProjectRenameRecordInput,
|
|
) -> Result<EditorProjectRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"rename_editor_project_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.rename_editor_project_and_return_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_required_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn delete_editor_project(
|
|
&self,
|
|
input: EditorProjectDeleteRecordInput,
|
|
) -> Result<String, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"delete_editor_project_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.delete_editor_project_and_return_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_delete_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn save_editor_project_layout(
|
|
&self,
|
|
input: EditorProjectLayoutSaveRecordInput,
|
|
) -> Result<EditorProjectRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"save_editor_project_layout_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.save_editor_project_layout_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_required_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn save_editor_project_layout_ack(
|
|
&self,
|
|
input: EditorProjectLayoutSaveRecordInput,
|
|
) -> Result<EditorProjectLayoutSaveAckRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"save_editor_project_layout_ack",
|
|
move |connection, sender| {
|
|
connection.procedures().save_editor_project_layout_ack_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_layout_save_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn save_editor_project_layout_v2_ack(
|
|
&self,
|
|
input: EditorProjectLayoutSaveV2RecordInput,
|
|
) -> Result<EditorProjectLayoutSaveV2AckRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"save_editor_project_layout_v_2_ack",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.save_editor_project_layout_v_2_ack_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_layout_save_v2_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn save_editor_project_layout_v2(
|
|
&self,
|
|
input: EditorProjectLayoutSaveV2RecordInput,
|
|
) -> Result<EditorProjectRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"save_editor_project_layout_v_2_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.save_editor_project_layout_v_2_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_required_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn create_editor_project_resource(
|
|
&self,
|
|
input: EditorProjectResourceCreateRecordInput,
|
|
) -> Result<EditorProjectResourceRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"create_editor_project_resource_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.create_editor_project_resource_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_resource_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn repair_editor_project_resource_media(
|
|
&self,
|
|
input: EditorProjectResourceMediaRepairRecordInput,
|
|
) -> Result<EditorProjectResourceRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"repair_editor_project_resource_media_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.repair_editor_project_resource_media_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_resource_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn update_editor_project_resource_showcase(
|
|
&self,
|
|
input: EditorProjectResourceShowcaseUpdateRecordInput,
|
|
) -> Result<EditorProjectResourceRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"update_editor_project_resource_showcase_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.update_editor_project_resource_showcase_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_resource_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn list_public_editor_project_resources(
|
|
&self,
|
|
input: EditorProjectResourcePublicShowcaseListRecordInput,
|
|
) -> Result<Vec<EditorProjectResourceRecord>, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"list_public_editor_project_resources_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.list_public_editor_project_resources_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_project_resource_list_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn get_editor_asset_library(
|
|
&self,
|
|
owner_user_id: String,
|
|
now_micros: i64,
|
|
) -> Result<EditorAssetLibraryRecord, SpacetimeClientError> {
|
|
let procedure_input = EditorAssetLibraryGetInput {
|
|
owner_user_id,
|
|
now_micros,
|
|
};
|
|
|
|
self.call_after_connect(
|
|
"get_editor_asset_library_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.get_editor_asset_library_and_return_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_library_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn admin_list_editor_assets(
|
|
&self,
|
|
input: AdminEditorAssetListRecordInput,
|
|
) -> Result<Vec<AdminEditorAssetRecord>, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"admin_list_editor_assets_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.admin_list_editor_assets_and_return_then(procedure_input, move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_admin_editor_asset_list_procedure_result);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn find_editor_asset_group_source(
|
|
&self,
|
|
input: EditorAssetGroupSourceLookupRecordInput,
|
|
) -> Result<Option<EditorAssetRecord>, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"find_editor_asset_group_source_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.find_editor_asset_group_source_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_optional_editor_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn create_editor_asset_folder(
|
|
&self,
|
|
input: EditorAssetFolderCreateRecordInput,
|
|
) -> Result<EditorAssetFolderRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"create_editor_asset_folder_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.create_editor_asset_folder_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_folder_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn update_editor_asset_folder(
|
|
&self,
|
|
input: EditorAssetFolderUpdateRecordInput,
|
|
) -> Result<EditorAssetFolderRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"update_editor_asset_folder_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.update_editor_asset_folder_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_folder_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn delete_editor_asset_folder(
|
|
&self,
|
|
input: EditorAssetFolderDeleteRecordInput,
|
|
) -> Result<EditorAssetLibraryRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"delete_editor_asset_folder_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.delete_editor_asset_folder_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_folder_library_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn create_editor_asset(
|
|
&self,
|
|
input: EditorAssetCreateRecordInput,
|
|
) -> Result<EditorAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"create_editor_asset_and_return",
|
|
move |connection, sender| {
|
|
connection.procedures().create_editor_asset_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn complete_editor_asset_group_cohort(
|
|
&self,
|
|
input: EditorAssetGroupCohortCompleteRecordInput,
|
|
) -> Result<EditorAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"complete_editor_asset_group_cohort_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.complete_editor_asset_group_cohort_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn update_editor_asset(
|
|
&self,
|
|
input: EditorAssetUpdateRecordInput,
|
|
) -> Result<EditorAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"update_editor_asset_and_return",
|
|
move |connection, sender| {
|
|
connection.procedures().update_editor_asset_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn repair_editor_asset_media(
|
|
&self,
|
|
input: EditorAssetMediaRepairRecordInput,
|
|
) -> Result<EditorAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"repair_editor_asset_media_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.repair_editor_asset_media_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn delete_editor_asset(
|
|
&self,
|
|
input: EditorAssetDeleteRecordInput,
|
|
) -> Result<EditorAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"delete_editor_asset_and_return",
|
|
move |connection, sender| {
|
|
connection.procedures().delete_editor_asset_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn submit_editor_showcase_asset(
|
|
&self,
|
|
input: EditorShowcaseAssetSubmitRecordInput,
|
|
) -> Result<EditorShowcaseAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"submit_editor_showcase_asset_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.submit_editor_showcase_asset_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn list_public_editor_showcase_assets(
|
|
&self,
|
|
input: EditorShowcaseAssetPublicListRecordInput,
|
|
) -> Result<Vec<EditorShowcaseAssetRecord>, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"list_public_editor_showcase_assets_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.list_public_editor_showcase_assets_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_asset_list_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn admin_list_editor_showcase_assets(
|
|
&self,
|
|
input: EditorShowcaseAssetAdminListRecordInput,
|
|
) -> Result<Vec<EditorShowcaseAssetRecord>, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"admin_list_editor_showcase_assets_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.admin_list_editor_showcase_assets_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_asset_list_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn admin_review_editor_showcase_asset(
|
|
&self,
|
|
input: EditorShowcaseAssetAdminReviewRecordInput,
|
|
) -> Result<EditorShowcaseAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"admin_review_editor_showcase_asset_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.admin_review_editor_showcase_asset_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn update_editor_showcase_asset_display(
|
|
&self,
|
|
input: EditorShowcaseAssetDisplayUpdateRecordInput,
|
|
) -> Result<EditorShowcaseAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"update_editor_showcase_asset_display_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.update_editor_showcase_asset_display_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn mark_editor_showcase_asset_refunded(
|
|
&self,
|
|
input: EditorShowcaseAssetRefundMarkRecordInput,
|
|
) -> Result<EditorShowcaseAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"mark_editor_showcase_asset_refunded_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.mark_editor_showcase_asset_refunded_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn toggle_editor_showcase_asset_like(
|
|
&self,
|
|
input: EditorShowcaseAssetLikeToggleRecordInput,
|
|
) -> Result<EditorShowcaseAssetRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"toggle_editor_showcase_asset_like_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.toggle_editor_showcase_asset_like_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_asset_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn get_editor_showcase_campaign_config(
|
|
&self,
|
|
input: EditorShowcaseCampaignConfigGetRecordInput,
|
|
) -> Result<Option<EditorShowcaseCampaignConfigRecord>, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"get_editor_showcase_campaign_config_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.get_editor_showcase_campaign_config_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_campaign_config_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn upsert_editor_showcase_campaign_config(
|
|
&self,
|
|
input: EditorShowcaseCampaignConfigUpsertRecordInput,
|
|
) -> Result<Option<EditorShowcaseCampaignConfigRecord>, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"upsert_editor_showcase_campaign_config_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.upsert_editor_showcase_campaign_config_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(map_editor_showcase_campaign_config_procedure_result);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn get_editor_generation_pricing_config(
|
|
&self,
|
|
) -> Result<Option<EditorGenerationPricingConfigRecord>, SpacetimeClientError> {
|
|
self.call_after_connect(
|
|
"get_editor_generation_pricing_config_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.get_editor_generation_pricing_config_and_return_then(move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(
|
|
map_editor_generation_pricing_config_optional_procedure_result,
|
|
);
|
|
send_once(&sender, mapped);
|
|
});
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn upsert_editor_generation_pricing_config(
|
|
&self,
|
|
input: EditorGenerationPricingConfigUpsertRecordInput,
|
|
) -> Result<EditorGenerationPricingConfigRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"upsert_editor_generation_pricing_config_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.upsert_editor_generation_pricing_config_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(
|
|
map_editor_generation_pricing_config_required_procedure_result,
|
|
);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
|
|
pub async fn initialize_editor_generation_pricing_config_if_missing(
|
|
&self,
|
|
input: EditorGenerationPricingConfigUpsertRecordInput,
|
|
) -> Result<EditorGenerationPricingConfigRecord, SpacetimeClientError> {
|
|
let procedure_input = input.into();
|
|
|
|
self.call_after_connect(
|
|
"initialize_editor_generation_pricing_config_if_missing_and_return",
|
|
move |connection, sender| {
|
|
connection
|
|
.procedures()
|
|
.initialize_editor_generation_pricing_config_if_missing_and_return_then(
|
|
procedure_input,
|
|
move |_, result| {
|
|
let mapped = result
|
|
.map_err(SpacetimeClientError::from_sdk_error)
|
|
.and_then(
|
|
map_editor_generation_pricing_config_required_procedure_result,
|
|
);
|
|
send_once(&sender, mapped);
|
|
},
|
|
);
|
|
},
|
|
)
|
|
.await
|
|
}
|
|
}
|
|
|
|
fn map_editor_spritesheet_slice_batch_persist_result(
|
|
result: crate::module_bindings::EditorSpritesheetSliceBatchPersistResult,
|
|
) -> Result<EditorSpritesheetSliceBatchPersistRecord, SpacetimeClientError> {
|
|
if !result.ok {
|
|
return Err(SpacetimeClientError::procedure_failed(result.error_message));
|
|
}
|
|
let items = result
|
|
.items
|
|
.into_iter()
|
|
.map(|item| {
|
|
Ok(EditorSpritesheetSlicePersistedItemRecord {
|
|
asset_object: map_editor_spritesheet_asset_object_snapshot(item.asset_object),
|
|
project_resource: item
|
|
.project_resource
|
|
.map(map_editor_spritesheet_project_resource_snapshot)
|
|
.transpose()?,
|
|
asset: item
|
|
.asset
|
|
.map(map_editor_spritesheet_asset_snapshot)
|
|
.transpose()?,
|
|
})
|
|
})
|
|
.collect::<Result<Vec<_>, SpacetimeClientError>>()?;
|
|
Ok(EditorSpritesheetSliceBatchPersistRecord { items })
|
|
}
|
|
|
|
fn map_editor_spritesheet_asset_object_snapshot(
|
|
snapshot: crate::module_bindings::AssetObjectUpsertSnapshot,
|
|
) -> module_assets::AssetObjectUpsertSnapshot {
|
|
module_assets::AssetObjectUpsertSnapshot {
|
|
asset_object_id: snapshot.asset_object_id,
|
|
bucket: snapshot.bucket,
|
|
object_key: snapshot.object_key,
|
|
access_policy: match snapshot.access_policy {
|
|
crate::module_bindings::AssetObjectAccessPolicy::Private => {
|
|
module_assets::AssetObjectAccessPolicy::Private
|
|
}
|
|
crate::module_bindings::AssetObjectAccessPolicy::PublicRead => {
|
|
module_assets::AssetObjectAccessPolicy::PublicRead
|
|
}
|
|
},
|
|
content_type: snapshot.content_type,
|
|
content_length: snapshot.content_length,
|
|
content_hash: snapshot.content_hash,
|
|
version: snapshot.version,
|
|
source_job_id: snapshot.source_job_id,
|
|
owner_user_id: snapshot.owner_user_id,
|
|
profile_id: snapshot.profile_id,
|
|
entity_id: snapshot.entity_id,
|
|
asset_kind: snapshot.asset_kind,
|
|
created_at_micros: snapshot.created_at_micros,
|
|
updated_at_micros: snapshot.updated_at_micros,
|
|
}
|
|
}
|
|
|
|
fn map_editor_spritesheet_project_resource_snapshot(
|
|
snapshot: crate::module_bindings::EditorProjectResourceSnapshot,
|
|
) -> Result<EditorProjectResourceRecord, SpacetimeClientError> {
|
|
Ok(EditorProjectResourceRecord {
|
|
resource_id: snapshot.resource_id,
|
|
project_id: snapshot.project_id,
|
|
owner_user_id: snapshot.owner_user_id,
|
|
asset_object_id: snapshot.asset_object_id,
|
|
image_src: snapshot.image_src,
|
|
object_key: snapshot.object_key,
|
|
width: snapshot.width,
|
|
height: snapshot.height,
|
|
source_type: snapshot.source_type,
|
|
prompt: snapshot.prompt,
|
|
actual_prompt: snapshot.actual_prompt,
|
|
model: snapshot.model,
|
|
provider: snapshot.provider,
|
|
task_id: snapshot.task_id,
|
|
source_resource_id: snapshot.source_resource_id,
|
|
asset_kind: snapshot.asset_kind,
|
|
generation_inputs: parse_editor_spritesheet_generation_inputs(
|
|
snapshot.generation_inputs_json,
|
|
"图片画布图集切片资源生成输入 JSON",
|
|
)?,
|
|
image_sequence_frames: parse_editor_spritesheet_generation_inputs(
|
|
snapshot.image_sequence_frames_json,
|
|
"图片画布图集切片资源序列帧 JSON",
|
|
)?,
|
|
image_sequence_duration_ms: snapshot.image_sequence_duration_ms,
|
|
public_showcase_enabled: snapshot.public_showcase_enabled,
|
|
created_at: format_timestamp_micros(snapshot.created_at_micros),
|
|
updated_at: format_timestamp_micros(snapshot.updated_at_micros),
|
|
})
|
|
}
|
|
|
|
fn map_editor_spritesheet_asset_snapshot(
|
|
snapshot: crate::module_bindings::EditorAssetSnapshot,
|
|
) -> Result<EditorAssetRecord, SpacetimeClientError> {
|
|
Ok(EditorAssetRecord {
|
|
asset_id: snapshot.asset_id,
|
|
folder_id: snapshot.folder_id,
|
|
label: snapshot.label,
|
|
asset_object_id: snapshot.asset_object_id,
|
|
image_src: snapshot.image_src,
|
|
object_key: snapshot.object_key,
|
|
width: snapshot.width,
|
|
height: snapshot.height,
|
|
source_type: snapshot.source_type,
|
|
prompt: snapshot.prompt,
|
|
actual_prompt: snapshot.actual_prompt,
|
|
model: snapshot.model,
|
|
provider: snapshot.provider,
|
|
task_id: snapshot.task_id,
|
|
asset_kind: snapshot.asset_kind,
|
|
generation_inputs: parse_editor_spritesheet_generation_inputs(
|
|
snapshot.generation_inputs_json,
|
|
"图片画布图集切片素材生成输入 JSON",
|
|
)?,
|
|
image_sequence_frames: parse_editor_spritesheet_generation_inputs(
|
|
snapshot.image_sequence_frames_json,
|
|
"图片画布图集切片素材序列帧 JSON",
|
|
)?,
|
|
image_sequence_duration_ms: snapshot.image_sequence_duration_ms,
|
|
source_resource_id: snapshot.source_resource_id,
|
|
public_showcase_enabled: snapshot.public_showcase_enabled,
|
|
thumbnail_src: snapshot.thumbnail_src,
|
|
generation_cost_mud_points: snapshot.generation_cost_mud_points,
|
|
showcase_id: snapshot.showcase_id,
|
|
showcase_review_status: snapshot.showcase_review_status,
|
|
showcase_display_enabled: snapshot.showcase_display_enabled,
|
|
showcase_like_count: snapshot.showcase_like_count,
|
|
created_at: format_timestamp_micros(snapshot.created_at_micros),
|
|
updated_at: format_timestamp_micros(snapshot.updated_at_micros),
|
|
})
|
|
}
|
|
|
|
fn parse_editor_spritesheet_generation_inputs(
|
|
raw: Option<String>,
|
|
label: &str,
|
|
) -> Result<Option<serde_json::Value>, SpacetimeClientError> {
|
|
raw.map(|value| {
|
|
serde_json::from_str(&value).map_err(|error| {
|
|
SpacetimeClientError::validation_failed(format!("{label} 无法解析：{error}"))
|
|
})
|
|
})
|
|
.transpose()
|
|
}
|