tdm_server_rust/service/

reward_service.rs

//! 奖励业务服务 (Reward Service)
//!
//! 悬赏/奖励/抽奖系统的业务逻辑：
//! - 活动余额查询
//! - 奖品兑换与库存扣减
//! - 奖券抽选（随机中奖者）
//! - 券转账与日志

use crate::{
    app::AppState,
    entity::reward::{
        EventBalanceDto, RewardRecordResultDto, RewardTicketResultDto, RewardTicketTransferLog,
        RewardTicketTransferRequest, RewardTicketsDetailDto, RewardWinnerDto, Rewardtb,
    },
    error::{ApiResult, AppError},
    repository::reward_repo::RewardRepository,
};
use chrono::NaiveDateTime;
use dashmap::{mapref::entry::Entry, DashMap};
use sqlx::Row;
use std::sync::OnceLock;

/// 兑换类奖品
const REWARD_CATEGORY_EXCHANGE: i16 = 2;
/// 抽奖类奖品
const REWARD_CATEGORY_LUCKY: i16 = 3;
/// 有效且待开奖
const TICKET_STATUS_AVAILABLE: i16 = 1;
/// 有效但未中奖
const TICKET_STATUS_NON_WIN: i16 = 2;
/// 因中同类奖作废
const TICKET_STATUS_SAME_TYPE_UNAVAILABLE: i16 = 3;
/// 已中奖
const TICKET_STATUS_WIN: i16 = 4;
/// 抽奖主持人组员 ID
const REWARD_HOST_MEMBER_ID: i32 = 154;

/// 正在处理中的转账请求
static TRANSFER_REQUESTS: OnceLock<DashMap<String, ()>> = OnceLock::new();

/// 奖励服务
pub struct RewardService;

impl RewardService {
    /// 查询活动余额
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_reward_balance(
        state: &AppState,
        member_id: i32,
        event_id: i32,
    ) -> ApiResult<EventBalanceDto> {
        let repo = RewardRepository::new(state.db.clone());
        if !repo.check_account_exists(member_id).await? {
            repo.create_balance_account(member_id, event_id).await?;
        }
        repo.get_reward_balance(member_id, event_id).await
    }

    /// 奖品列表（默认活动 1）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_rewards_list(state: &AppState) -> ApiResult<Vec<Rewardtb>> {
        RewardRepository::new(state.db.clone())
            .list_rewards(1)
            .await
    }

    /// 兑换奖品：兑换类写获奖记录，抽奖类写入奖池。
    ///
    /// # Errors
    ///
    /// - `AppError::business("奖品不存在喵")` — reward_id 无效
    /// - `AppError::business("余额不足喵")` — 兑换余额不足
    /// - `AppError::Database` — 数据库操作失败
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn exchange(
        state: &AppState,
        member_id: i32,
        reward_id: i32,
        exchange_number: i32,
        event_id: i32,
    ) -> ApiResult<()> {
        let repo = RewardRepository::new(state.db.clone());
        let reward = repo
            .get_reward_by_id(reward_id)
            .await?
            .ok_or_else(|| AppError::business("奖品不存在喵"))?;
        if is_deadline_expired(reward.dead_line) {
            return Err(AppError::business("已经超过兑换时间了哦~"));
        }

        let price = reward.price.unwrap_or(0) * exchange_number;
        match reward.reward_category.unwrap_or_default() {
            REWARD_CATEGORY_EXCHANGE => {
                if repo.deduct_exchange_balance(member_id, price).await? == 0 {
                    return Err(AppError::business("余额不足喵，下次再加油吧~"));
                }
                repo.insert_reward_record(member_id, reward_id, exchange_number)
                    .await?;
            }
            REWARD_CATEGORY_LUCKY => {
                let ticket_number = repo
                    .get_ticket_number(member_id)
                    .await?
                    .ok_or_else(|| AppError::business("这位猫娘没有奖券呢，下次一起参加活动吧~"))?;
                if ticket_number.total < 12 {
                    return Err(AppError::business("奖券没有达到参与标准哦，下次加油吧~"));
                }
                if ticket_number.lucky_balance < price {
                    return Err(AppError::business("抽奖券不够啦，请耐心等待结果哟亲亲~"));
                }
                if repo.deduct_lucky_balance(member_id, price).await? == 0 {
                    return Err(AppError::business("剩余抽奖券不足了哦~"));
                }
                repo.insert_lucky_tickets(
                    member_id,
                    reward_id,
                    event_id,
                    reward.physical_category,
                    exchange_number,
                )
                .await?;
            }
            _ => {
                return Err(AppError::business(
                    "奖品类型有误哦，请确认后再兑换或联系幻廊",
                ));
            }
        }
        Ok(())
    }

    /// 兑换记录
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_reward_record(
        state: &AppState,
        member_id: i32,
    ) -> ApiResult<Vec<RewardRecordResultDto>> {
        RewardRepository::new(state.db.clone())
            .select_reward_list(member_id)
            .await
    }

    /// 奖券列表
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_reward_tickets(
        state: &AppState,
        member_id: i32,
    ) -> ApiResult<Vec<RewardTicketResultDto>> {
        RewardRepository::new(state.db.clone())
            .get_reward_tickets(member_id)
            .await
    }

    /// 奖券详情
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_tickets_details(
        state: &AppState,
        member_id: i32,
    ) -> ApiResult<Vec<RewardTicketsDetailDto>> {
        RewardRepository::new(state.db.clone())
            .get_ticket_details(member_id)
            .await
    }

    /// 抽取中奖者
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn select_winner(
        state: &AppState,
        member_id: i32,
        reward_id: i32,
        event_id: i32,
        winner_number: i32,
    ) -> ApiResult<Vec<RewardWinnerDto>> {
        if member_id != REWARD_HOST_MEMBER_ID {
            return Err(AppError::business("请不要冒充主持人哦~"));
        }
        let mut tx = state.db.begin().await?;
        let reward_row = sqlx::query(
            "SELECT rewardId, physicalCategory, stock FROM rewardtb WHERE rewardId = ?",
        )
        .bind(reward_id)
        .fetch_optional(&mut *tx)
        .await?
        .ok_or_else(|| AppError::business("奖品不存在，请确认选项或联系管理员"))?;
        let physical_category: Option<i16> = reward_row.try_get("physicalCategory").ok();
        let mut stock: i32 = reward_row.try_get("stock").unwrap_or(0);
        let mut winners = Vec::new();

        for _ in 0..winner_number.max(0) {
            let winner_row = sqlx::query(
                "SELECT rt.memberId, m.username AS memberName, rt.rewardTicketId AS ticketId \
                 FROM rewardtickettb rt LEFT JOIN membertb m ON rt.memberId = m.Id \
                 WHERE rt.rewardId = ? AND rt.fromEventId = ? AND rt.status = ? \
                 ORDER BY RAND() LIMIT 1",
            )
            .bind(reward_id)
            .bind(event_id)
            .bind(TICKET_STATUS_AVAILABLE)
            .fetch_optional(&mut *tx)
            .await?;

            let Some(winner_row) = winner_row else {
                break;
            };
            let winner = RewardWinnerDto {
                member_id: winner_row.get("memberId"),
                member_name: winner_row.try_get("memberName").ok(),
                ticket_id: winner_row.try_get("ticketId").ok(),
            };
            sqlx::query(
                "UPDATE rewardtickettb SET status = ? \
                 WHERE memberId = ? AND fromEventId = ? AND physicalCategory = ?",
            )
            .bind(TICKET_STATUS_SAME_TYPE_UNAVAILABLE)
            .bind(winner.member_id)
            .bind(event_id)
            .bind(physical_category)
            .execute(&mut *tx)
            .await?;

            let record = sqlx::query(
                "INSERT INTO rewardrecordtb(memberId, rewardId, exchangeNumber, trackingNumber, exchangeTime) \
                 VALUES (?, ?, 1, '想起来了的话会填的喵~', NOW())",
            )
            .bind(winner.member_id)
            .bind(reward_id)
            .execute(&mut *tx)
            .await?;

            if let Some(ticket_id) = winner.ticket_id.as_deref() {
                sqlx::query(
                    "UPDATE rewardtickettb SET status = ?, rewardRecordID = ? WHERE rewardTicketId = ?",
                )
                .bind(TICKET_STATUS_WIN)
                .bind(record.last_insert_id() as i64)
                .bind(ticket_id)
                .execute(&mut *tx)
                .await?;
            }
            winners.push(winner);
        }

        let winner_count = winners.len() as i32;
        let stock_update = sqlx::query(
            "UPDATE rewardtb SET stock = stock - ? WHERE rewardId = ? AND fromEventId = ? AND stock >= ?",
        )
        .bind(winner_count)
        .bind(reward_id)
        .bind(event_id)
        .bind(winner_count)
        .execute(&mut *tx)
        .await?;
        if stock_update.rows_affected() != 1 {
            return Err(AppError::business("奖品信息不正确或者名额不足啦"));
        }
        stock -= winner_count;
        if stock == 0 {
            sqlx::query("UPDATE rewardtickettb SET status = ? WHERE rewardId = ? AND status = ?")
                .bind(TICKET_STATUS_NON_WIN)
                .bind(reward_id)
                .bind(TICKET_STATUS_AVAILABLE)
                .execute(&mut *tx)
                .await?;
        }

        tx.commit().await?;
        Ok(winners)
    }

    /// 修改活动结束时间（对齐 Java：更新 rewardtb.deadLine）
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn change_end_time(
        state: &AppState,
        member_id: i32,
        event_id: &str,
        end_time: &str,
    ) -> ApiResult<()> {
        if member_id != REWARD_HOST_MEMBER_ID {
            return Err(AppError::business("请不要冒充主持人哦~"));
        }
        let event_id: i32 = event_id
            .parse()
            .map_err(|_| AppError::business("活动ID无效喵"))?;
        let repo = RewardRepository::new(state.db.clone());
        if repo.has_opened_rewards(event_id).await? {
            return Err(AppError::business(
                "已经开过奖了，再修改时间会导致违反抽奖规则的情况出现，商量一下具体怎么处理吧喵~",
            ));
        }
        let new_end_time = NaiveDateTime::parse_from_str(end_time, "%Y-%m-%d %H:%M:%S")
            .map_err(|_| AppError::business("时间格式不正确设置不正确，转换失败，请联系幻廊"))?;
        repo.update_event_deadline(event_id, new_end_time).await?;
        Ok(())
    }

    /// 转账
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn transfer(
        state: &AppState,
        from_id: i32,
        body: RewardTicketTransferRequest,
    ) -> ApiResult<()> {
        let repo = RewardRepository::new(state.db.clone());
        if body.target_member_id == 0 {
            return Err(AppError::business("怎么没有设置目标组员呀"));
        }
        if body.amount == 0 {
            return Err(AppError::business("别转账0张券为难程序员呀"));
        }
        let request_key = format!(
            "{}_{}_{}_{}_{}",
            body.event_id, from_id, body.target_member_id, body.ticket_type, body.amount
        );
        let _guard = TransferRequestGuard::try_acquire(request_key)?;
        if !repo.check_account_exists(body.target_member_id).await? {
            return Err(AppError::business("转账目标的组员不存在，请确认后再执行"));
        }
        if !repo
            .check_balance_account_exists(body.target_member_id, body.event_id)
            .await?
        {
            repo.create_balance_account(body.target_member_id, body.event_id)
                .await?;
        }
        if repo
            .transfer_decr(from_id, body.event_id, body.ticket_type, body.amount)
            .await?
            == 0
        {
            return Err(AppError::business("余额不足喵"));
        }
        repo.transfer_incr(
            body.target_member_id,
            body.event_id,
            body.ticket_type,
            body.amount,
        )
        .await?;
        repo.insert_transfer_log(
            from_id,
            body.target_member_id,
            body.event_id,
            body.ticket_type,
            body.amount,
        )
        .await
    }

    /// 转账日志
    #[tracing::instrument(skip_all, level = "debug")]
    pub async fn get_transfer_log(
        state: &AppState,
        member_id: i32,
    ) -> ApiResult<Vec<RewardTicketTransferLog>> {
        RewardRepository::new(state.db.clone())
            .get_transfer_logs(member_id)
            .await
    }
}

/// 判断奖品是否超过兑换截止时间
fn is_deadline_expired(dead_line: Option<NaiveDateTime>) -> bool {
    dead_line.is_some_and(|deadline| {
        let now = chrono::Utc::now()
            .with_timezone(&crate::utils::shanghai_time::shanghai_offset())
            .naive_local();
        now > deadline
    })
}

/// 获取全局转账请求表
fn transfer_request_map() -> &'static DashMap<String, ()> {
    TRANSFER_REQUESTS.get_or_init(DashMap::new)
}

/// 转账防重复请求守卫
struct TransferRequestGuard {
    /// 防重复请求键
    key: String,
}

impl TransferRequestGuard {
    /// 尝试占用转账请求键
    fn try_acquire(key: String) -> ApiResult<Self> {
        match transfer_request_map().entry(key.clone()) {
            Entry::Vacant(entry) => {
                entry.insert(());
                Ok(Self { key })
            }
            Entry::Occupied(_) => Err(AppError::business("正在转账中，请稍后")),
        }
    }
}

impl Drop for TransferRequestGuard {
    /// 释放转账请求键
    fn drop(&mut self) {
        if let Some(map) = TRANSFER_REQUESTS.get() {
            map.remove(&self.key);
        }
    }
}