add public work share links

server-rs/crates/api-server/src/custom_world_ai.rs

@@ -42,6 +42,8 @@ use crate::{
     state::AppState,
 };
 
+const ASSET_GENERATION_POINTS_COST: u64 = 1;
+
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct CustomWorldEntityRequest {
@@ -440,108 +442,121 @@ pub async fn generate_custom_world_scene_image(
     let owner_user_id = authenticated.claims().user_id().to_string();
     let normalized = normalize_scene_image_request(payload)
         .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
-    let settings = require_dashscope_settings(&state)
-        .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
-    let http_client = build_dashscope_http_client(&settings)
-        .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
-    let reference_image =
-        if let Some(reference_image_src) = normalized.reference_image_src.as_deref() {
-            Some(
-                resolve_reference_image_as_data_url(
-                    &state,
-                    &http_client,
-                    reference_image_src,
-                    "referenceImageSrc",
+    let asset_id = format!("custom-scene-{}", current_utc_millis());
+    consume_asset_generation_points(
+        &state,
+        &owner_user_id,
+        "scene_image",
+        asset_id.as_str(),
+        &request_context,
+    )
+    .await?;
+    let asset_result = async {
+        let settings = require_dashscope_settings(&state)?;
+        let http_client = build_dashscope_http_client(&settings)?;
+        let reference_image =
+            if let Some(reference_image_src) = normalized.reference_image_src.as_deref() {
+                Some(
+                    resolve_reference_image_as_data_url(
+                        &state,
+                        &http_client,
+                        reference_image_src,
+                        "referenceImageSrc",
+                    )
+                    .await?,
                 )
-                .await
-                .map_err(|error| custom_world_ai_error_response(&request_context, error))?,
+            } else {
+                None
+            };
+        let generated = if let Some(reference_image) = reference_image.as_deref() {
+            create_reference_image_generation(
+                &http_client,
+                &settings,
+                state.config.dashscope_reference_image_model.as_str(),
+                normalized.prompt.as_str(),
+                normalized.size.as_str(),
+                &[reference_image.to_string()],
+                Some(normalized.negative_prompt.as_str()),
+                "创建参考图场景编辑任务失败",
+                "参考图场景编辑未返回图片地址",
+                "scene-edit",
             )
+            .await
         } else {
-            None
+            create_text_to_image_generation(
+                &http_client,
+                &settings,
+                state.config.dashscope_scene_image_model.as_str(),
+                normalized.prompt.as_str(),
+                Some(normalized.negative_prompt.as_str()),
+                normalized.size.as_str(),
+                "创建场景图片生成任务失败",
+                "查询场景图片任务失败",
+                "场景图片生成任务失败",
+                "场景图片生成超时或未返回图片地址",
+            )
+            .await
+        }?;
+        let scene_model = if reference_image.is_some() {
+            state.config.dashscope_reference_image_model.clone()
+        } else {
+            state.config.dashscope_scene_image_model.clone()
         };
-    let generated = if let Some(reference_image) = reference_image.as_deref() {
-        create_reference_image_generation(
+        let downloaded = download_remote_image(
             &http_client,
-            &settings,
-            state.config.dashscope_reference_image_model.as_str(),
-            normalized.prompt.as_str(),
-            normalized.size.as_str(),
-            &[reference_image.to_string()],
-            Some(normalized.negative_prompt.as_str()),
-            "创建参考图场景编辑任务失败",
-            "参考图场景编辑未返回图片地址",
-            "scene-edit",
+            generated.image_url.as_str(),
+            "下载生成图片失败",
         )
-        .await
-    } else {
-        create_text_to_image_generation(
-            &http_client,
-            &settings,
-            state.config.dashscope_scene_image_model.as_str(),
-            normalized.prompt.as_str(),
-            Some(normalized.negative_prompt.as_str()),
-            normalized.size.as_str(),
-            "创建场景图片生成任务失败",
-            "查询场景图片任务失败",
-            "场景图片生成任务失败",
-            "场景图片生成超时或未返回图片地址",
+        .await?;
+        let upload = PreparedAssetUpload {
+            prefix: LegacyAssetPrefix::CustomWorldScenes,
+            path_segments: vec![
+                sanitize_storage_segment(
+                    normalized
+                        .profile_id
+                        .as_deref()
+                        .unwrap_or(normalized.world_name.as_str()),
+                    "world",
+                ),
+                sanitize_storage_segment(normalized.entity_id.as_str(), "scene"),
+                asset_id.clone(),
+            ],
+            file_name: format!("scene.{}", downloaded.extension),
+            content_type: downloaded.mime_type,
+            body: downloaded.bytes,
+            asset_kind: "scene_image",
+            entity_kind: "custom_world_landmark",
+            entity_id: normalized.entity_id.clone(),
+            profile_id: normalized.profile_id.clone(),
+            slot: "scene_image",
+            source_job_id: Some(generated.task_id.clone()),
+        };
+        persist_custom_world_asset(
+            &state,
+            &owner_user_id,
+            upload,
+            GeneratedAssetResponse {
+                image_src: String::new(),
+                asset_id: asset_id.clone(),
+                source_type: "generated".to_string(),
+                model: Some(scene_model),
+                size: Some(normalized.size),
+                task_id: Some(generated.task_id),
+                prompt: Some(normalized.prompt),
+                actual_prompt: generated.actual_prompt,
+            },
         )
         .await
     }
-    .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
-    let scene_model = if reference_image.is_some() {
-        state.config.dashscope_reference_image_model.clone()
-    } else {
-        state.config.dashscope_scene_image_model.clone()
+    .await;
+
+    let asset = match asset_result {
+        Ok(asset) => asset,
+        Err(error) => {
+            refund_asset_generation_points(&state, &owner_user_id, "scene_image", &asset_id).await;
+            return Err(custom_world_ai_error_response(&request_context, error));
+        }
     };
-    let downloaded = download_remote_image(
-        &http_client,
-        generated.image_url.as_str(),
-        "下载生成图片失败",
-    )
-    .await
-    .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
-    let asset_id = format!("custom-scene-{}", current_utc_millis());
-    let upload = PreparedAssetUpload {
-        prefix: LegacyAssetPrefix::CustomWorldScenes,
-        path_segments: vec![
-            sanitize_storage_segment(
-                normalized
-                    .profile_id
-                    .as_deref()
-                    .unwrap_or(normalized.world_name.as_str()),
-                "world",
-            ),
-            sanitize_storage_segment(normalized.entity_id.as_str(), "scene"),
-            asset_id.clone(),
-        ],
-        file_name: format!("scene.{}", downloaded.extension),
-        content_type: downloaded.mime_type,
-        body: downloaded.bytes,
-        asset_kind: "scene_image",
-        entity_kind: "custom_world_landmark",
-        entity_id: normalized.entity_id.clone(),
-        profile_id: normalized.profile_id.clone(),
-        slot: "scene_image",
-        source_job_id: Some(generated.task_id.clone()),
-    };
-    let asset = persist_custom_world_asset(
-        &state,
-        &owner_user_id,
-        upload,
-        GeneratedAssetResponse {
-            image_src: String::new(),
-            asset_id: asset_id.clone(),
-            source_type: "generated".to_string(),
-            model: Some(scene_model),
-            size: Some(normalized.size),
-            task_id: Some(generated.task_id),
-            prompt: Some(normalized.prompt),
-            actual_prompt: generated.actual_prompt,
-        },
-    )
-    .await
-    .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
 
     Ok(json_success_body(Some(&request_context), asset))
 }
@@ -697,109 +712,123 @@ pub async fn generate_custom_world_cover_image(
         trim_to_option(payload.profile.name.as_deref()).unwrap_or_else(|| "world".to_string());
     let entity_id = profile_id.clone().unwrap_or_else(|| world_name.clone());
     let size = trim_to_option(payload.size.as_deref()).unwrap_or_else(|| "1600*900".to_string());
-    let settings = require_dashscope_settings(&state)
-        .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
-    let http_client = build_dashscope_http_client(&settings)
-        .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
-    let reference_sources = collect_cover_reference_image_sources(
-        &payload.profile,
-        &payload.character_role_ids,
-        payload.reference_image_src.as_deref().unwrap_or_default(),
-    );
-    let prompt = build_custom_world_cover_image_prompt(
-        &payload.profile,
-        &payload.character_role_ids,
-        payload.user_prompt.as_deref().unwrap_or_default(),
-        !reference_sources.is_empty(),
-    );
-    let mut reference_images = Vec::with_capacity(reference_sources.len());
-    for source in &reference_sources {
-        reference_images.push(
-            resolve_reference_image_as_data_url(
-                &state,
-                &http_client,
-                source.as_str(),
-                "referenceImageSrc",
-            )
-            .await
-            .map_err(|error| custom_world_ai_error_response(&request_context, error))?,
-        );
-    }
-    let generated = if reference_images.is_empty() {
-        create_text_to_image_generation(
-            &http_client,
-            &settings,
-            state.config.dashscope_cover_image_model.as_str(),
-            prompt.as_str(),
-            None,
-            size.as_str(),
-            "创建作品封面生成任务失败",
-            "查询作品封面任务失败",
-            "作品封面生成任务失败",
-            "作品封面生成超时或未返回图片地址",
-        )
-        .await
-    } else {
-        create_reference_image_generation(
-            &http_client,
-            &settings,
-            state.config.dashscope_reference_image_model.as_str(),
-            prompt.as_str(),
-            size.as_str(),
-            &reference_images,
-            None,
-            "创建参考图封面任务失败",
-            "封面生成未返回图片地址",
-            "cover-edit",
-        )
-        .await
-    }
-    .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
-    let downloaded = download_remote_image(
-        &http_client,
-        generated.image_url.as_str(),
-        "下载作品封面失败",
-    )
-    .await
-    .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
     let asset_id = format!("custom-cover-{}", current_utc_millis());
-    let upload = PreparedAssetUpload {
-        prefix: LegacyAssetPrefix::CustomWorldCovers,
-        path_segments: vec![
-            sanitize_storage_segment(entity_id.as_str(), "world"),
-            asset_id.clone(),
-        ],
-        file_name: format!("cover.{}", downloaded.extension),
-        content_type: downloaded.mime_type,
-        body: downloaded.bytes,
-        asset_kind: "custom_world_cover",
-        entity_kind: "custom_world_profile",
-        entity_id,
-        profile_id,
-        slot: "cover",
-        source_job_id: Some(generated.task_id.clone()),
-    };
-    let asset = persist_custom_world_asset(
+    consume_asset_generation_points(
         &state,
         &owner_user_id,
-        upload,
-        GeneratedAssetResponse {
-            image_src: String::new(),
-            asset_id: asset_id.clone(),
-            source_type: "generated".to_string(),
-            model: Some(if reference_images.is_empty() {
-                state.config.dashscope_cover_image_model.clone()
-            } else {
-                state.config.dashscope_reference_image_model.clone()
-            }),
-            size: Some(size),
-            task_id: Some(generated.task_id),
-            prompt: Some(prompt),
-            actual_prompt: generated.actual_prompt,
-        },
+        "custom_world_cover",
+        asset_id.as_str(),
+        &request_context,
     )
-    .await
-    .map_err(|error| custom_world_ai_error_response(&request_context, error))?;
+    .await?;
+    let asset_result = async {
+        let settings = require_dashscope_settings(&state)?;
+        let http_client = build_dashscope_http_client(&settings)?;
+        let reference_sources = collect_cover_reference_image_sources(
+            &payload.profile,
+            &payload.character_role_ids,
+            payload.reference_image_src.as_deref().unwrap_or_default(),
+        );
+        let prompt = build_custom_world_cover_image_prompt(
+            &payload.profile,
+            &payload.character_role_ids,
+            payload.user_prompt.as_deref().unwrap_or_default(),
+            !reference_sources.is_empty(),
+        );
+        let mut reference_images = Vec::with_capacity(reference_sources.len());
+        for source in &reference_sources {
+            reference_images.push(
+                resolve_reference_image_as_data_url(
+                    &state,
+                    &http_client,
+                    source.as_str(),
+                    "referenceImageSrc",
+                )
+                .await?,
+            );
+        }
+        let generated = if reference_images.is_empty() {
+            create_text_to_image_generation(
+                &http_client,
+                &settings,
+                state.config.dashscope_cover_image_model.clone().as_str(),
+                prompt.as_str(),
+                None,
+                size.as_str(),
+                "创建作品封面生成任务失败",
+                "查询作品封面任务失败",
+                "作品封面生成任务失败",
+                "作品封面生成超时或未返回图片地址",
+            )
+            .await
+        } else {
+            create_reference_image_generation(
+                &http_client,
+                &settings,
+                state.config.dashscope_reference_image_model.as_str(),
+                prompt.as_str(),
+                size.as_str(),
+                &reference_images,
+                None,
+                "创建参考图封面任务失败",
+                "封面生成未返回图片地址",
+                "cover-edit",
+            )
+            .await
+        }?;
+        let downloaded = download_remote_image(
+            &http_client,
+            generated.image_url.as_str(),
+            "下载作品封面失败",
+        )
+        .await?;
+        let upload = PreparedAssetUpload {
+            prefix: LegacyAssetPrefix::CustomWorldCovers,
+            path_segments: vec![
+                sanitize_storage_segment(entity_id.as_str(), "world"),
+                asset_id.clone(),
+            ],
+            file_name: format!("cover.{}", downloaded.extension),
+            content_type: downloaded.mime_type,
+            body: downloaded.bytes,
+            asset_kind: "custom_world_cover",
+            entity_kind: "custom_world_profile",
+            entity_id,
+            profile_id,
+            slot: "cover",
+            source_job_id: Some(generated.task_id.clone()),
+        };
+        persist_custom_world_asset(
+            &state,
+            &owner_user_id,
+            upload,
+            GeneratedAssetResponse {
+                image_src: String::new(),
+                asset_id: asset_id.clone(),
+                source_type: "generated".to_string(),
+                model: Some(if reference_images.is_empty() {
+                    state.config.dashscope_cover_image_model.clone()
+                } else {
+                    state.config.dashscope_reference_image_model.clone()
+                }),
+                size: Some(size),
+                task_id: Some(generated.task_id),
+                prompt: Some(prompt),
+                actual_prompt: generated.actual_prompt,
+            },
+        )
+        .await
+    }
+    .await;
+
+    let asset = match asset_result {
+        Ok(asset) => asset,
+        Err(error) => {
+            refund_asset_generation_points(&state, &owner_user_id, "custom_world_cover", &asset_id)
+                .await;
+            return Err(custom_world_ai_error_response(&request_context, error));
+        }
+    };
 
     Ok(json_success_body(Some(&request_context), asset))
 }
@@ -874,6 +903,81 @@ pub async fn upload_custom_world_cover_image(
     Ok(json_success_body(Some(&request_context), asset))
 }
 
+async fn consume_asset_generation_points(
+    state: &AppState,
+    owner_user_id: &str,
+    asset_kind: &str,
+    asset_id: &str,
+    request_context: &RequestContext,
+) -> Result<(), Response> {
+    let ledger_id = format!(
+        "asset_generation_consume:{}:{}:{}",
+        owner_user_id, asset_kind, asset_id
+    );
+    let created_at_micros = current_utc_micros();
+    state
+        .spacetime_client()
+        .consume_profile_wallet_points(
+            owner_user_id.to_string(),
+            ASSET_GENERATION_POINTS_COST,
+            ledger_id,
+            created_at_micros,
+        )
+        .await
+        .map(|_| ())
+        .map_err(|error| {
+            custom_world_ai_error_response(
+                request_context,
+                map_asset_generation_wallet_error(error),
+            )
+        })
+}
+
+async fn refund_asset_generation_points(
+    state: &AppState,
+    owner_user_id: &str,
+    asset_kind: &str,
+    asset_id: &str,
+) {
+    let ledger_id = format!(
+        "asset_generation_refund:{}:{}:{}",
+        owner_user_id, asset_kind, asset_id
+    );
+    if let Err(error) = state
+        .spacetime_client()
+        .refund_profile_wallet_points(
+            owner_user_id.to_string(),
+            ASSET_GENERATION_POINTS_COST,
+            ledger_id,
+            current_utc_micros(),
+        )
+        .await
+    {
+        tracing::error!(
+            owner_user_id,
+            asset_kind,
+            asset_id,
+            error = %error,
+            "资产生成失败后的叙世币退款失败"
+        );
+    }
+}
+
+fn map_asset_generation_wallet_error(error: SpacetimeClientError) -> AppError {
+    let status = match &error {
+        SpacetimeClientError::Runtime(_) => StatusCode::BAD_REQUEST,
+        SpacetimeClientError::Procedure(message) if message.contains("叙世币余额不足") => {
+            StatusCode::CONFLICT
+        }
+        _ => StatusCode::BAD_GATEWAY,
+    };
+
+    AppError::from_status(status).with_details(json!({
+        "provider": "profile-wallet",
+        "message": error.to_string(),
+    }))
+}
+
 async fn persist_custom_world_asset(
     state: &AppState,
     owner_user_id: &str,