hotline/src/Hotline.Application/Snapshot/SnapshotApplication.cs

using Hotline.Orders;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.Article;
using Hotline.Share.Dtos.Snapshot;
using Hotline.Share.Tools;
using Hotline.Snapshot;
using Hotline.Users;
using SqlSugar;
using XF.Domain.Authentications;
using XF.Domain.Dependency;
using XF.Domain.Repository;
using Hotline.Repository.SqlSugar.Extensions;
using Hotline.Share.Enums;
using Hotline.Share.Enums.Order;
using Hotline.Share.Requests;
using Hotline.Share.Enums.Snapshot;

namespace Hotline.Application.Snapshot;

/// <summary>
/// 随手拍应用层
/// </summary>
public class SnapshotApplication : ISnapshotApplication, IScopeDependency
{
    private readonly IThirdAccountRepository _thirdAccountRepository;
    private readonly IRepository<Order> _orderRepository;
    private readonly IRepository<Article.Bulletin> _bulletinRepository;
    private readonly IRepository<Industry> _industryRepository;
    private readonly IThirdIdentiyService _thirdLoginService;
    private readonly ISessionContext _sessionContext;
    private readonly IRepository<RedPackRecord> _redPackRecordRepository;
    private readonly IRepository<OrderSnapshot> _orderSnapshotRepository;

    public SnapshotApplication(IThirdIdentiyService thirdLoginService, IRepository<Industry> industryRepository, IRepository<Article.Bulletin> bulletinRepository, ISessionContext sessionContext, IRepository<RedPackRecord> redPackRecordRepository, IRepository<Order> orderRepository, IThirdAccountRepository thirdAccountRepository, IRepository<OrderSnapshot> orderSnapshotRepository)
    {
        _thirdLoginService = thirdLoginService;
        _industryRepository = industryRepository;
        _bulletinRepository = bulletinRepository;
        _sessionContext = sessionContext;
        _redPackRecordRepository = redPackRecordRepository;
        _orderRepository = orderRepository;
        _thirdAccountRepository = thirdAccountRepository;
        _orderSnapshotRepository = orderSnapshotRepository;
    }

    /// <summary>
    /// 获取随手拍小程序首页数据
    /// </summary>
    /// <returns></returns>
    public async Task<IReadOnlyList<HomePageOutDto>> GetHomePageAsync()
    {
        return await _industryRepository.Queryable()
            .Where(m => m.IsEnable)
            .OrderBy(m => m.DisplayOrder)
            .ToListAsync(m => new HomePageOutDto());
    }

    /// <summary>
    /// 获取随手拍小程序公告
    /// </summary>
    /// <returns></returns>
    public async Task<IReadOnlyList<BulletinOutDto>> GetBulletinsAsync(BulletinInDto dto)
    {
        var items = await _bulletinRepository.Queryable()
            .Where(m => m.BulletinState == Share.Enums.Article.EBulletinState.ReviewPass)
            .LeftJoin<Industry>((bulletin, industry) => bulletin.BulletinTypeId == industry.BulletinTypePublicityId)
            .Where((bulletin, industry) => industry.Id == dto.IndustryId)
            .ToPageListAsync(dto.PageIndex, dto.PageSize);

        return items.MapTo<IReadOnlyList<BulletinOutDto>>();
    }

    /// <summary>
    /// 获取个人中心数据
    /// </summary>
    /// <returns></returns>
    public async Task<SnapshotUserInfoOutDto> GetSnapshotUserInfoAsync()
    {
        var openId = _sessionContext.OpenId;
        var thirdAccount = await _thirdAccountRepository.QueryByOpenIdAsync(openId);
        var dayTime = DateTime.Now;
        var readPack = await _redPackRecordRepository.Queryable()
            .Where(m => m.WXOpenId == openId && m.PickupStatus == Share.Enums.Snapshot.ERedPackPickupStatus.Received)
            .Where(m => m.CreationTime.Date == dayTime.Date)
            .Select(m => SqlFunc.AggregateSum(m.Amount))
            .FirstAsync();

        var outDto = await _orderRepository.Queryable()
            .Where(m => m.Contact == thirdAccount.PhoneNumber)
            .Select(m => new SnapshotUserInfoOutDto
            {
                NoReplyCount = SqlFunc.AggregateSum(SqlFunc.IIF(m.Status < Share.Enums.Order.EOrderStatus.Filed, 1, 0)),
                ReplyCount = SqlFunc.AggregateSum(SqlFunc.IIF(m.Status >= Share.Enums.Order.EOrderStatus.Filed, 1, 0)),
                AppraiseCount = SqlFunc.AggregateSum(SqlFunc.IIF(m.Status == Share.Enums.Order.EOrderStatus.Visited, 1, 0)),
            }).FirstAsync();
            
        outDto.DayAmount = readPack;
        outDto.TotalAmount = thirdAccount.TotalAmount;
        outDto.PhoneNumber = thirdAccount.PhoneNumber;
        return outDto;
    }

    public async Task<PagedDto<OrderOutDto>> GetSnapshotOrdersAsync(OrderInDto dto)
    {
        var member = await _thirdAccountRepository.QueryByOpenIdAsync(_sessionContext.OpenId);
        var (total, items) = await _orderSnapshotRepository.Queryable()
            .LeftJoin<Order>((snapshot, order) => snapshot.OrderId == order.Id)
            .Where((snapshot, order) => order.Contact == member.PhoneNumber)
            .WhereIF(dto.Status == EOrderQueryStatus.Appraise, (snapshot, order) => order.Status == EOrderStatus.Visited)
            .WhereIF(dto.Status == EOrderQueryStatus.NoReply, (snapshot, order) => order.Status < EOrderStatus.Filed)
            .WhereIF(dto.Status == EOrderQueryStatus.Reply, (snapshot, order) => order.Status >= EOrderStatus.Filed)
            .WhereIF(dto.KeyWords.NotNullOrEmpty(), (snapshot, order) => order.Title.Contains(dto.KeyWords))
            .Select((snapshot, order) => new OrderOutDto 
            {
                Id = snapshot.Id,
                OrderNo = order.No,
                Title = order.Title,
                Status = order.Status,
                IndustryName = snapshot.IndustryName,
                CreationTime = order.CreationTime,
                Area = order.City
            })
            .ToPagedListAsync(dto.PageIndex, dto.PageSize);

        return new PagedDto<OrderOutDto>(total, items);
    }

    public async Task<OrderDetailOutDto> GetSnapshotOrderDetailAsync(string id)
    {
        var detail = await _orderSnapshotRepository.Queryable()
            .Where(m => m.Id == id)
            .LeftJoin<Order>((snapshot, order) => snapshot.OrderId == order.Id)
            .Select((snapshot, order) => new OrderDetailOutDto
            {
                Id = snapshot.Id,
                OrderNo = order.No,
                Title = order.Title,
                Status = order.Status,
                IndustryName = snapshot.IndustryName,
                CreationTime = order.CreationTime,
                Area = order.City
            })
            .FirstAsync();

        return detail;
    }

    /// <summary>
    /// 获取当月详细红包列表
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    public async Task<PagedDto<RedPackOutDto>> GetRedPacksAsync(RedPacksInDto dto)
    {
        var openId = _sessionContext.OpenId;
        var (total, items) = await _redPackRecordRepository.Queryable()
            .Where(m => m.WXOpenId == openId)
            .Where(m => m.PickupStatus == dto.Status)
            .Where(m => m.CreationTime.ToString("yyyy-MM") == dto.Time)
            .LeftJoin<Order>((red, order) => red.OrderId == order.Id)
            .Select((red, order) => new RedPackOutDto 
            {
                Amount = red.Amount,
                Title = order.Title,
                CreationTime = red.CreationTime
            })
            .ToPagedListAsync(dto.PageIndex, dto.PageSize);

        return new PagedDto<RedPackOutDto>(total, items);
    }

    /// <summary>
    /// 按月统计红包金额
    /// </summary>
    /// <param name="count"></param>
    /// <returns></returns>
    public async Task<IReadOnlyList<RedPackDateOutDto>> GetRedPackDateAsync(RedPackDateInDto dto)
    { 
        var openId = _sessionContext.OpenId;
        var item = await _redPackRecordRepository.Queryable()
            .Where(m => m.WXOpenId == openId)
            .Where(m => m.PickupStatus == dto.Status)
            .GroupBy(m => m.CreationTime.ToString("yyyy-MM"))
            .OrderByDescending(m => m.CreationTime)
            .Select(m => new RedPackDateOutDto
            {
                CreationTime = SqlFunc.AggregateMax(m.CreationTime.Date),
                Amount = SqlFunc.AggregateSum(m.Amount)
            })
            .Take(dto.Count)
            .ToListAsync();

        return item;
    }

    public async Task<BulletinOutDto> GetBulletinsDetailAsync(string id)
    {
        var detail = await _bulletinRepository.Queryable()
            .Where(m => m.Id == id)
            .Where(m => m.BulletinState == Share.Enums.Article.EBulletinState.ReviewPass)
            .Select(m => new BulletinOutDto
            { 
                Id = m.Id,
                Title = m.Title,
                Content = m.Content
            })
            .FirstAsync();
        return detail;
    }
}