Close DDD cleanup and tests-support closure

server-rs/crates/module-runtime-item/src/application.rs

@@ -1,3 +1,177 @@
-//! 运行时物品应用编排过渡落位。
+//! 运行时物品应用编排。
 //!
 //! 这里只返回奖励结果、记录快照和待写入背包事件。
+
+use crate::commands::TreasureResolveInput;
+use crate::domain::{
+    RuntimeItemEquipmentSlot, RuntimeItemRewardItemRarity, RuntimeItemRewardItemSnapshot,
+    TreasureRecordSnapshot,
+};
+use crate::errors::TreasureFieldError;
+use module_inventory::{
+    InventoryEquipmentSlot, InventoryItemRarity, InventoryItemSnapshot, InventoryItemSourceKind,
+};
+use serde::{Deserialize, Serialize};
+use shared_kernel::{
+    normalize_optional_string as normalize_shared_optional_string, normalize_required_string,
+    normalize_string_list as normalize_shared_string_list,
+};
+#[cfg(feature = "spacetime-types")]
+use spacetimedb::SpacetimeType;
+
+#[cfg_attr(feature = "spacetime-types", derive(SpacetimeType))]
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct TreasureRecordProcedureResult {
+    pub ok: bool,
+    pub record: Option<TreasureRecordSnapshot>,
+    pub error_message: Option<String>,
+}
+
+pub fn build_treasure_record_snapshot(
+    input: TreasureResolveInput,
+) -> Result<TreasureRecordSnapshot, TreasureFieldError> {
+    validate_treasure_input(&input)?;
+
+    Ok(TreasureRecordSnapshot {
+        treasure_record_id: input.treasure_record_id,
+        runtime_session_id: input.runtime_session_id,
+        story_session_id: input.story_session_id,
+        actor_user_id: input.actor_user_id,
+        encounter_id: input.encounter_id,
+        encounter_name: input.encounter_name,
+        scene_id: normalize_optional_value(input.scene_id),
+        scene_name: normalize_optional_value(input.scene_name),
+        action: input.action,
+        reward_items: input
+            .reward_items
+            .into_iter()
+            .map(normalize_reward_item)
+            .collect::<Result<Vec<_>, _>>()?,
+        reward_hp: input.reward_hp,
+        reward_mana: input.reward_mana,
+        reward_currency: input.reward_currency,
+        story_hint: normalize_optional_value(input.story_hint),
+        created_at_micros: input.created_at_micros,
+        updated_at_micros: input.updated_at_micros,
+    })
+}
+
+pub fn build_inventory_item_snapshot_from_reward_item(
+    treasure_record_id: &str,
+    reward_item: RuntimeItemRewardItemSnapshot,
+) -> Result<InventoryItemSnapshot, TreasureFieldError> {
+    let treasure_record_id = normalize_required_value(
+        treasure_record_id.to_string(),
+        TreasureFieldError::MissingTreasureRecordId,
+    )?;
+    let reward_item = normalize_reward_item(reward_item)?;
+
+    Ok(InventoryItemSnapshot {
+        item_id: reward_item.item_id,
+        category: reward_item.category,
+        name: reward_item.item_name,
+        description: reward_item.description,
+        quantity: reward_item.quantity,
+        rarity: map_reward_item_rarity(reward_item.rarity),
+        tags: reward_item.tags,
+        stackable: reward_item.stackable,
+        stack_key: reward_item.stack_key,
+        equipment_slot_id: reward_item
+            .equipment_slot_id
+            .map(map_reward_item_equipment_slot),
+        source_kind: InventoryItemSourceKind::TreasureReward,
+        source_reference_id: Some(treasure_record_id),
+    })
+}
+
+pub fn normalize_reward_item_snapshot(
+    reward_item: RuntimeItemRewardItemSnapshot,
+) -> Result<RuntimeItemRewardItemSnapshot, TreasureFieldError> {
+    normalize_reward_item(reward_item)
+}
+
+fn validate_treasure_input(input: &TreasureResolveInput) -> Result<(), TreasureFieldError> {
+    if input.treasure_record_id.trim().is_empty() {
+        return Err(TreasureFieldError::MissingTreasureRecordId);
+    }
+    if input.runtime_session_id.trim().is_empty() {
+        return Err(TreasureFieldError::MissingRuntimeSessionId);
+    }
+    if input.story_session_id.trim().is_empty() {
+        return Err(TreasureFieldError::MissingStorySessionId);
+    }
+    if input.actor_user_id.trim().is_empty() {
+        return Err(TreasureFieldError::MissingActorUserId);
+    }
+    if input.encounter_id.trim().is_empty() {
+        return Err(TreasureFieldError::MissingEncounterId);
+    }
+    if input.encounter_name.trim().is_empty() {
+        return Err(TreasureFieldError::MissingEncounterName);
+    }
+
+    Ok(())
+}
+
+fn normalize_optional_value(value: Option<String>) -> Option<String> {
+    normalize_shared_optional_string(value)
+}
+
+fn normalize_reward_item(
+    mut item: RuntimeItemRewardItemSnapshot,
+) -> Result<RuntimeItemRewardItemSnapshot, TreasureFieldError> {
+    item.item_id = normalize_required_value(item.item_id, TreasureFieldError::MissingRewardItemId)?;
+    item.category =
+        normalize_required_value(item.category, TreasureFieldError::MissingRewardItemCategory)?;
+    item.item_name =
+        normalize_required_value(item.item_name, TreasureFieldError::MissingRewardItemName)?;
+    item.description = normalize_optional_value(item.description);
+    if item.quantity == 0 {
+        return Err(TreasureFieldError::InvalidRewardItemQuantity);
+    }
+    if !item.stackable && item.quantity != 1 {
+        return Err(TreasureFieldError::RewardNonStackableItemMustStaySingleQuantity);
+    }
+    if item.equipment_slot_id.is_some() && item.stackable {
+        return Err(TreasureFieldError::RewardEquipmentItemCannotStack);
+    }
+    item.tags = normalize_string_list(item.tags);
+    item.stack_key = if item.stackable {
+        normalize_required_value(
+            item.stack_key,
+            TreasureFieldError::MissingRewardItemStackKey,
+        )?
+    } else {
+        normalize_optional_value(Some(item.stack_key)).unwrap_or_else(|| item.item_id.clone())
+    };
+    Ok(item)
+}
+
+fn normalize_required_value(
+    value: String,
+    error: TreasureFieldError,
+) -> Result<String, TreasureFieldError> {
+    normalize_required_string(value).ok_or(error)
+}
+
+fn normalize_string_list(values: Vec<String>) -> Vec<String> {
+    normalize_shared_string_list(values)
+}
+
+fn map_reward_item_rarity(rarity: RuntimeItemRewardItemRarity) -> InventoryItemRarity {
+    match rarity {
+        RuntimeItemRewardItemRarity::Common => InventoryItemRarity::Common,
+        RuntimeItemRewardItemRarity::Uncommon => InventoryItemRarity::Uncommon,
+        RuntimeItemRewardItemRarity::Rare => InventoryItemRarity::Rare,
+        RuntimeItemRewardItemRarity::Epic => InventoryItemRarity::Epic,
+        RuntimeItemRewardItemRarity::Legendary => InventoryItemRarity::Legendary,
+    }
+}
+
+fn map_reward_item_equipment_slot(slot: RuntimeItemEquipmentSlot) -> InventoryEquipmentSlot {
+    match slot {
+        RuntimeItemEquipmentSlot::Weapon => InventoryEquipmentSlot::Weapon,
+        RuntimeItemEquipmentSlot::Armor => InventoryEquipmentSlot::Armor,
+        RuntimeItemEquipmentSlot::Relic => InventoryEquipmentSlot::Relic,
+    }
+}