QYZH.InteractiveMagazine/QYZH.InteractiveMagazine.Service/UserJournalService.cs

using Microsoft.Extensions.Logging;
using QYZH.InteractiveMagazine.IService;
using QYZH.InteractiveMagazine.Models.Common;
using QYZH.InteractiveMagazine.Models.Dto;
using QYZH.InteractiveMagazine.Models.Entity;
using QYZH.InteractiveMagazine.Repository;
using SqlSugar;

namespace QYZH.InteractiveMagazine.Service;

/// <summary>
/// 用户期刊关联服务实现
/// </summary>
public class UserJournalService(
    BaseRepository<UserJournal> userJournalRepository,
    BaseRepository<Users> usersRepository,
    BaseRepository<Journal> journalRepository,
    ILogger<UserJournalService> logger,
    IPetService petService)
    : BaseRepository<UserJournal>, IUserJournalService
{
    /// <summary>
    /// 用户绑定期刊（扫码绑定）
    /// </summary>
    public async Task<BindJournalOutput> BindJournalAsync(long userId, BindJournalInput input)
    {
        logger.LogInformation("用户绑定期刊，UserId: {UserId}, JournalId: {JournalId}, JournalInstanceId: {JournalInstanceId}, Type: {Type}",
            userId, input.JournalId, input.JournalInstanceId, input.Type);

        // 校验参数
        if (input.JournalId <= 0)
        {
            throw new BusinessException("期刊Id不能为空", 400);
        }

        // 校验用户是否存在
        var user = await usersRepository.GetByIdAsync(userId);
        if (user == null || user.IsDeleted)
        {
            logger.LogWarning("绑定期刊失败，用户不存在，UserId: {UserId}", userId);
            throw new BusinessException("用户不存在", 404);
        }

        // 校验期刊是否存在
        var journal = await journalRepository.GetByIdAsync(input.JournalId);
        if (journal == null || journal.IsDeleted)
        {
            logger.LogWarning("绑定期刊失败，期刊不存在，JournalId: {JournalId}", input.JournalId);
            throw new BusinessException("期刊不存在", 404);
        }

        // 校验期刊状态
        if (journal.Status != "Published")
        {
            logger.LogWarning("绑定期刊失败，期刊未发布，JournalId: {JournalId}, Status: {Status}", input.JournalId, journal.Status);
            throw new BusinessException("该期刊暂未发布，无法绑定", 400);
        }

        // 校验实例化期刊是否存在（如果传入了 JournalInstanceId）
        if (input.JournalInstanceId.HasValue && input.JournalInstanceId.Value > 0)
        {
            var instance = await journalRepository.GetByIdAsync(input.JournalInstanceId.Value);
            if (instance == null || instance.IsDeleted)
            {
                logger.LogWarning("绑定期刊失败，实例化期刊不存在，JournalInstanceId: {JournalInstanceId}", input.JournalInstanceId);
                throw new BusinessException("实例化期刊不存在", 404);
            }
        }

        // 防重复绑定：同一用户 + 期刊 + 实例 + 类型
        var isExist = userJournalRepository.Any(uj =>
            uj.UserId == userId &&
            uj.JournalId == input.JournalId &&
            uj.JournalInstanceId == input.JournalInstanceId &&
            uj.Type == input.Type &&
            !uj.IsDeleted);

        if (isExist)
        {
            logger.LogWarning("重复绑定期刊，UserId: {UserId}, JournalId: {JournalId}, Type: {Type}", userId, input.JournalId, input.Type);
            throw new BusinessException("您已绑定过该期刊，无需重复操作", 400);
        }

        // 检查是否为首次绑定期刊（用于激活宠物）
        var isFirstBind = !userJournalRepository.Context.Queryable<UserJournal>()
            .Any(uj => uj.UserId == userId);

        // 创建绑定记录
        var userJournal = new UserJournal
        {
            UserId = userId,
            JournalId = input.JournalId,
            JournalInstanceId = input.JournalInstanceId,
            Type = input.Type,
            Status = "Active",
            IsDeleted = false,
            CreatedBy = userId.ToString(),
            CreatedAt = DateTime.Now,
            UpdatedBy = userId.ToString(),
            UpdatedAt = DateTime.Now
        };

        var result = await userJournalRepository.InsertAsync(userJournal);
        if (!result)
        {
            logger.LogError("绑定期刊失败，写入数据库失败，UserId: {UserId}, JournalId: {JournalId}", userId, input.JournalId);
            throw new BusinessException("绑定期刊失败，请稍后重试", 500);
        }

        logger.LogInformation("用户绑定期刊成功，UserId: {UserId}, JournalId: {JournalId}, Id: {Id}", userId, input.JournalId, userJournal.Id);

        // 首次绑定期刊时激活宠物
        if (isFirstBind)
        {
            try
            {
                await petService.ActivatePetAsync(userId);
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "首次绑定期刊激活宠物失败，UserId: {UserId}", userId);
                // 宠物激活失败不阻断绑定流程
            }
        }

        return new BindJournalOutput
        {
            Id = userJournal.Id,
            UserId = userJournal.UserId,
            JournalId = userJournal.JournalId,
            JournalInstanceId = userJournal.JournalInstanceId,
            Type = userJournal.Type,
            Status = userJournal.Status,
            CreatedAt = userJournal.CreatedAt
        };
    }

    /// <summary>
    /// 获取用户的期刊绑定列表
    /// </summary>
    public async Task<PageListModel<BindJournalOutput>> GetUserJournalsAsync(long userId, UserJournalQueryInput input)
    {
        logger.LogInformation("查询用户期刊绑定列表，UserId: {UserId}, PageIndex: {PageIndex}, PageSize: {PageSize}",
            userId, input.PageIndex, input.PageSize);

        if (input.PageIndex <= 0)
        {
            throw new BusinessException("页码必须大于0", 400);
        }

        if (input.PageSize <= 0 || input.PageSize > 100)
        {
            throw new BusinessException("每页条数必须在1-100之间", 400);
        }

        RefAsync<int> totalNumber = 0;
        var pageResult = await userJournalRepository.Queryable()
            .Where(uj => uj.UserId == userId)
            .WhereIF(input.JournalId.HasValue, uj => uj.JournalId == input.JournalId.Value)
            .WhereIF(input.JournalInstanceId.HasValue, uj => uj.JournalInstanceId == input.JournalInstanceId.Value)
            .WhereIF(!string.IsNullOrWhiteSpace(input.Type), uj => uj.Type == input.Type)
            .OrderByDescending(uj => uj.CreatedAt)
            .Select(uj => new BindJournalOutput
            {
                Id = uj.Id,
                UserId = uj.UserId,
                JournalId = uj.JournalId,
                JournalInstanceId = uj.JournalInstanceId,
                Type = uj.Type,
                Status = uj.Status,
                CreatedAt = uj.CreatedAt
            }, true)
            .ToPageListAsync(input.PageIndex, input.PageSize, totalNumber);

        return new PageListModel<BindJournalOutput>(pageResult, input.PageIndex, input.PageSize, totalNumber);
    }

    /// <summary>
    /// 取消期刊绑定
    /// </summary>
    public async Task UnbindJournalAsync(long userId, long id)
    {
        logger.LogInformation("取消期刊绑定，UserId: {UserId}, Id: {Id}", userId, id);

        var userJournal = await userJournalRepository.GetByIdAsync(id);
        if (userJournal == null || userJournal.IsDeleted)
        {
            logger.LogWarning("取消绑定失败，记录不存在，Id: {Id}", id);
            throw new BusinessException("绑定记录不存在", 404);
        }

        // 校验归属权：只能取消自己的绑定
        if (userJournal.UserId != userId)
        {
            logger.LogWarning("取消绑定失败，无权操作，UserId: {UserId}, RecordUserId: {RecordUserId}", userId, userJournal.UserId);
            throw new BusinessException("无权取消该绑定", 403);
        }

        var result = await userJournalRepository.DeleteByIdAsync(id);
        if (!result)
        {
            logger.LogError("取消绑定失败，Id: {Id}", id);
            throw new BusinessException("取消绑定失败，请稍后重试", 500);
        }

        logger.LogInformation("取消期刊绑定成功，UserId: {UserId}, Id: {Id}", userId, id);
    }
}