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

using Hotline.Orders;
using Hotline.Share.Dtos;
using Hotline.Share.Dtos.Snapshot;
using Hotline.Share.Enums.Order;
using Hotline.Share.Enums.Snapshot;
using Hotline.Share.Tools;
using Hotline.Snapshot;
using Hotline.Snapshot.Interfaces;
using Mapster;
using SqlSugar;
using SqlSugar.Extensions;
using System.ComponentModel;
using XF.Domain.Authentications;
using XF.Domain.Dependency;
using XF.Domain.Exceptions;
using XF.Domain.Repository;
using XF.Utility.EnumExtensions;

namespace Hotline.Application.Snapshot;
public class RedPackApplication : IRedPackApplication, IScopeDependency
{
    private readonly IOrderSnapshotRepository _orderSnapshotRepository;
    private readonly IOrderRepository _orderRepository;
    private readonly ISnapshotSMSTemplateRepository _snapshotSMSTemplateRepository;
    private readonly IIndustryRepository _industryRepository;
    private readonly IRedPackAuditRepository _redPackAuditRepository;
    private readonly IRedPackRecordRepository _redPackRecordRepository;
    private readonly IRepository<OrderSpecial> _orderSpecialRepository;
    private readonly ISessionContext _sessionContext;
    private readonly IRedPackGuiderAuditRepository _redPackGuiderAuditRepository;
    private readonly IThirdAccountRepository _thirdAccountRepository;
    private readonly ISupplementRecordRepository _supplementRecordRepository;

    public RedPackApplication(IOrderSnapshotRepository orderSnapshotRepository, ISnapshotSMSTemplateRepository snapshotSMSTemplateRepository, IOrderRepository orderRepository, IIndustryRepository industryRepository, IRedPackAuditRepository redPackAuditRepository, IRedPackRecordRepository redPackRecordRepository, IRepository<OrderSpecial> orderSpecialRepository, ISessionContext sessionContext, IRedPackGuiderAuditRepository redPackGuiderAuditRepository, IThirdAccountRepository thirdAccountRepository, ISupplementRecordRepository supplementRecordRepository)
    {
        _orderSnapshotRepository = orderSnapshotRepository;
        _snapshotSMSTemplateRepository = snapshotSMSTemplateRepository;
        _orderRepository = orderRepository;
        _industryRepository = industryRepository;
        _redPackAuditRepository = redPackAuditRepository;
        _redPackRecordRepository = redPackRecordRepository;
        _orderSpecialRepository = orderSpecialRepository;
        _sessionContext = sessionContext;
        _redPackGuiderAuditRepository = redPackGuiderAuditRepository;
        _thirdAccountRepository = thirdAccountRepository;
        _supplementRecordRepository = supplementRecordRepository;
    }

    /// <summary>
    /// 审核红包发放
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    public async Task AuditRedPackAuditAsync(UpdateRedPackAuditInDto dto)
    {
        var redPackAudit = await _redPackAuditRepository.GetAsync(dto.RedPackAuditId) ?? throw UserFriendlyException.SameMessage("审核记录不存在");
        if (redPackAudit.Status != ERedPackAuditStatus.Pending) throw UserFriendlyException.SameMessage("已审核, 不可重复审核");
        redPackAudit.SMSTemplateId = dto.SMSTemplateId;
        redPackAudit.Status = dto.Status;
        redPackAudit.Remark = dto.Opinion;
        redPackAudit.IsSendSMS = dto.IsSendSms;
        var order = await _orderRepository.Queryable()
            .Where(m => m.Id == redPackAudit.OrderId)
            .Select(m => new { m.Id, m.No, m.FromName, m.FromPhone })
            .FirstAsync() ?? throw UserFriendlyException.SameMessage("工单不存在");
        if (dto.Status == ERedPackAuditStatus.Agree)
        {
            var third = await _thirdAccountRepository.GetByPhoneNumberAsync(order.FromPhone);
            var entity = new RedPackRecord
            {
                OrderId = redPackAudit.OrderId,
                RedPackAuditId = redPackAudit.Id,
                PeopleType = EReadPackUserType.Citizen,
                Name = order.FromName,
                PhoneNumber = order.FromPhone,
                WXOpenId = third?.OpenId,
                No = order.No,
                PickupStatus = ERedPackPickupStatus.Unreceived,
                DistributionState = EReadPackSendStatus.Unsend,
            };
            if (redPackAudit.ApprovedAmount.HasValue)
                entity.Amount = redPackAudit.ApprovedAmount.Value;
            await _redPackRecordRepository.AddAsync(entity);
        }
        await _redPackAuditRepository.UpdateAsync(redPackAudit);
    }

    /// <summary>
    /// 网格员审核红包发放
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    public async Task AuditRedPackGuiderAuditAsync(UpdateRedPackGuiderAuditInDto dto)
    {
        var redPackAudit = await _redPackGuiderAuditRepository.GetAsync(dto.RedPackAuditId) ?? throw UserFriendlyException.SameMessage("审核记录不存在");
        var orgName = _sessionContext.OrgName ?? string.Empty;
        RedPackRecord? entity = null;
        if (orgName.Contains("应急管理局"))
        {
            if (redPackAudit.LevelTwoStatus != ERedPackAuditStatus.Pending) throw UserFriendlyException.SameMessage("已审核, 不可重复审核");
            redPackAudit.LevelTwoStatus = dto.Status;

            if (dto.Status == ERedPackAuditStatus.Agree)
            {
                var order = await _orderRepository.Queryable()
                    .Where(m => m.Id == redPackAudit.OrderId)
                    .Select(m => new { m.Id, m.No, m.FromName, m.FromPhone })
                    .FirstAsync();
                entity = new RedPackRecord
                {
                    OrderId = redPackAudit.OrderId,
                    RedPackAuditId = redPackAudit.Id,
                    PeopleType = EReadPackUserType.Guider,
                    Name = order.FromName,
                    PhoneNumber = order.FromPhone,
                    No = order.No,
                    PickupStatus = ERedPackPickupStatus.Unreceived,
                    DistributionState = EReadPackSendStatus.Unsend,
                };
                if (redPackAudit.ApprovedAmount.HasValue)
                    entity.Amount = redPackAudit.ApprovedAmount.Value;
            }
        }
        else
        {
            if (redPackAudit.LevelOneStatus != ERedPackAuditStatus.Pending) throw UserFriendlyException.SameMessage("已审核, 不可重复审核");
            redPackAudit.LevelOneStatus = dto.Status;
        }
        redPackAudit.Remark = dto.Opinion;
        await _redPackGuiderAuditRepository.UpdateAsync(redPackAudit);
        if (entity != null)
            await _redPackRecordRepository.AddAsync(entity);
    }


    /// <summary>
    /// 获取网格员审核详情
    /// </summary>
    /// <param name="id">工单Id</param>
    /// <returns></returns>
    public async Task<SnapshotOrderAuditDetailOutDto> GetRedPackGuiderAuditDetailAsync(string id)
    {
        var order = await _orderRepository.GetAsync(id) ?? throw UserFriendlyException.SameMessage("工单不存在");
        var outDto = new SnapshotOrderAuditDetailOutDto { Order = order.Adapt<SnapshotOrderAuditOrderDetailOutDto>() };
        var industry = await _industryRepository.Queryable(includeDeleted: true)
            .LeftJoin<OrderSnapshot>((i, o) => i.Id == o.IndustryId)
            .Select((i, o) => new { i.Id, i.GuiderReadPackAmount })
            .FirstAsync();
        outDto.Amount = industry.GuiderReadPackAmount;
        outDto.RedPackTxt = $"{order.FromPhone}【】元; ";
        var dayStart = DateTime.Now.ToString("yyyy-MM-dd 00:00:00").ObjToDate();
        var dayEnd = DateTime.Now.ToString("yyyy-MM-dd 23:59:59").ObjToDate();
        var query = _redPackGuiderAuditRepository.Queryable()
            .Where(m => m.PhoneNumber == order.FromPhone && m.LevelTwoAuditTime >= dayStart && m.LevelTwoAuditTime <= dayEnd && m.LevelTwoStatus == ERedPackAuditStatus.Agree);

        var totalAmount = await query.SumAsync(m => m.ApprovedAmount);
        if (totalAmount != 0)
            outDto.RedPackTxt = $"{order.FromPhone}【{totalAmount}】元; ";
        var count = await query.CountAsync();
        if (count != 0)
            outDto.RedPackTxt += $"今天审批【{count}】个";

        outDto.AuditComBox = EnumExts.GetDescriptions<ERedPackAuditStatus>()
            .Where(m => m.Key.ToString() != "0").ToList(); ;
        return outDto;
    }


    /// <summary>
    /// 获取市民审核详情
    /// </summary>
    /// <param name="id">工单Id</param>
    /// <returns></returns>
    public async Task<SnapshotOrderAuditDetailOutDto> GetRedPackAuditDetailAsync(string id)
    {
        var order = await _orderRepository.GetAsync(id) ?? throw UserFriendlyException.SameMessage("工单不存在");
        var outDto = new SnapshotOrderAuditDetailOutDto { Order = order.Adapt<SnapshotOrderAuditOrderDetailOutDto>() };
        var industry = await _industryRepository.Queryable(includeDeleted: true)
            .LeftJoin<OrderSnapshot>((i, o) => i.Id == o.IndustryId)
            .Select((i, o) => new { i.Id, i.CitizenReadPackAmount })
            .FirstAsync();
        outDto.Amount = industry.CitizenReadPackAmount;
        outDto.RedPackTxt = $"{order.FromPhone}【】元; ";
        var dayStart = DateTime.Now.ToString("yyyy-MM-dd 00:00:00").ObjToDate();
        var dayEnd = DateTime.Now.ToString("yyyy-MM-dd 23:59:59").ObjToDate();
        var query = _redPackAuditRepository.Queryable()
            .Where(m => m.PhoneNumber == order.FromPhone && m.AuditTime >= dayStart && m.AuditTime <= dayEnd && m.Status == ERedPackAuditStatus.Agree);

        var totalAmount = await query.SumAsync(m => m.ApprovedAmount);
        if (totalAmount != 0)
            outDto.RedPackTxt = $"{order.FromPhone}【{totalAmount}】元; ";
        var count = await query.CountAsync();
        if (count != 0)
            outDto.RedPackTxt += $"今天审批【{count}】个";

        outDto.AuditComBox = EnumExts.GetDescriptions<ERedPackAuditStatus>()
            .Where(m => m.Key.ToString() != "0").ToList();
        return outDto;
    }

    /// <summary>
    /// 红包审核集合
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Description("市民红包审批")]
    public ISugarQueryable<SnapshotOrderAuditItemsOutDto> GetRedPackAuditItemsAsync(SnapshotOrderAuditItemsInDto dto)
    {
        ERedPackAuditStatus? status = null;
        if (dto.Status != -1 && Enum.TryParse<ERedPackAuditStatus>(dto.Status.ToString(), out var statusParse))
        {
            status = statusParse;
        }

        var query = _redPackAuditRepository.Queryable(includeDeleted: true)
            .LeftJoin<Order>((redPackAudit, order) => redPackAudit.OrderId == order.Id)
            .LeftJoin<OrderSnapshot>((redPackAudit, order, snapshot) => redPackAudit.OrderId == snapshot.Id)
            .LeftJoin<RedPackRecord>((redPackAudit, order, snapshot, record) => redPackAudit.Id == record.OrderId)
            .LeftJoin<Industry>((redPackAudit, order, snapshot, record, industry) => snapshot.IndustryId == industry.Id)
            .Where((redPackAudit, order, snapshot, record, industry) => order.Status >= EOrderStatus.Filed)
            .WhereIF(dto.No.NotNullOrEmpty(), (redPackAudit, order, snapshot, record, industry) => order.No.Contains(dto.No))
            .WhereIF(dto.Title.NotNullOrEmpty(), (redPackAudit, order, snapshot, record, industry) => order.Title.Contains(dto.Title))
            .WhereIF(dto.FromPhone.NotNullOrEmpty(), (redPackAudit, order, snapshot, record, industry) => order.FromPhone.Contains(dto.FromPhone))
            .WhereIF(dto.BeginCreationTime.HasValue && dto.EndCreationTime.HasValue, (redPackAudit, order, snapshot, record, industry) => order.CreationTime <= dto.EndCreationTime && order.CreationTime >= dto.BeginCreationTime)
            .WhereIF(dto.BeginFiledTime.HasValue && dto.EndFiledTime.HasValue, (redPackAudit, order, snapshot, record, industry) => order.FiledTime <= dto.EndFiledTime && order.FiledTime >= dto.BeginFiledTime)
            .WhereIF(dto.IsDeal.HasValue, (redPackAudit, order, snapshot, record, industry) => snapshot.IsDeal == dto.IsDeal)
            .WhereIF(dto.IsTruth.HasValue, (redPackAudit, order, snapshot, record, industry) => snapshot.IsTruth == dto.IsTruth)
            .WhereIF(dto.IsTruthDepartment.HasValue, (redPackAudit, order, snapshot, record, industry) => snapshot.IsTruthDepartment == dto.IsTruthDepartment)
            .WhereIF(dto.BeginAuditTime.HasValue && dto.EndAuditTime.HasValue, (redPackAudit, order, snapshot, record, industry) => redPackAudit.AuditTime <= dto.EndAuditTime && redPackAudit.AuditTime >= dto.BeginAuditTime)
            .WhereIF(dto.IsIssued.HasValue, (redPackAudit, order, snapshot, record, industry) => redPackAudit.IsIssued == dto.IsIssued)
            .WhereIF(dto.IndustryId.NotNullOrEmpty(), (redPackAudit, order, snapshot, record, industry) => snapshot.IndustryId == dto.IndustryId)
            .WhereIF(dto.ConfigAmount.HasValue, (redPackAudit, order, snapshot, record, industry) => industry.CitizenReadPackAmount == dto.ConfigAmount)
            .WhereIF(dto.AcutalAmount.HasValue, (redPackAudit, order, snapshot, record, industry) => redPackAudit.AcutalAmount == dto.AcutalAmount)
            .WhereIF(dto.ApprovedAmount.HasValue, (redPackAudit, order, snapshot, record, industry) => redPackAudit.ApprovedAmount == dto.ApprovedAmount)
            .WhereIF(dto.IsDanger.HasValue, (redPackAudit, order, snapshot, record, industry) => snapshot.IsDanger == dto.IsDanger)
            .WhereIF(status.HasValue, (redPackAudit, order, snapshot, record, industry) => redPackAudit.Status == status)
            .Select((redPackAudit, order, snapshot, record, industry) => new SnapshotOrderAuditItemsOutDto
            {
                Id = redPackAudit.Id,
                RedPackAuditId = redPackAudit.Id,
                OrderId = order.Id,
                No = order.No,
                Title = order.Title,
                IndustryName = industry.Name,
                IndustryId = industry.Id,
                SourceChannel = order.SourceChannel,
                SourceChannelCode = order.SourceChannelCode,
                Status = order.Status,
                IsDanger = snapshot.IsDanger,
                FromPhone = order.FromPhone,
                FromName = order.FromName,
                AuditTime = redPackAudit.AuditTime,
                ApprovedAmount = redPackAudit.ApprovedAmount,
                AcutalAmount = redPackAudit.AcutalAmount,
                IsIssued = redPackAudit.IsIssued,
                RecordRemark = record.Remark,
                County = order.County,
                // IsRectify = s.IsRepetition
                IsDeal = snapshot.IsDeal,
                NetworkENumber = snapshot.NetworkENumber,
                IsTruth = snapshot.IsTruth,
                IsTruthDepartment = snapshot.IsTruthDepartment,
                IsRepetition = snapshot.IsRepetition,
                CreationTime = order.CreationTime,
                OrgLevelOneCode = order.OrgLevelOneCode,
                OrgLevelOneName = order.OrgLevelOneName,
                AuditId = redPackAudit.AuditId,
                AuditName = redPackAudit.AuditName,
                AuditOrgId = redPackAudit.AuditOrgId,
                AuditOrgName = redPackAudit.AuditOrgName,
                AuditRemark = redPackAudit.AuditRemark,
                BankCardNo = record.BankCardNo,
                OpenBank = record.OpenBank,
                AuditStatus = redPackAudit.Status,
            });
        return query;
    }

    /// <summary>
    /// 网格员审核集合
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Description("网格员红包审批")]
    public ISugarQueryable<SnapshotOrderGuiderAuditItemsOutDto> GetRedPackGuiderAuditItemsAsync(SnapshotOrderGuiderAuditItemsInDto dto)
    {
        var areaCode = _sessionContext.OrgAreaCode;
        if (_sessionContext.OrgIsCenter)
        {
            areaCode = null;
        }
        ERedPackAuditStatus? status = null;
        if (dto.Status != -1 && Enum.TryParse<ERedPackAuditStatus>(dto.Status.ToString(), out var statusParse))
        {
            status = statusParse;
        }

        var query = _redPackGuiderAuditRepository.Queryable(includeDeleted: true)
            .LeftJoin<Order>((redPackAudit, order) => redPackAudit.OrderId == order.Id)
            .LeftJoin<OrderSnapshot>((redPackAudit, order, snapshot) => redPackAudit.OrderId == snapshot.Id)
            .LeftJoin<RedPackRecord>((redPackAudit, order, snapshot, record) => redPackAudit.Id == record.OrderId)
            .LeftJoin<Industry>((redPackAudit, order, snapshot, record, industry) => snapshot.IndustryId == industry.Id)
            .Where((redPackAudit, order, snapshot, record, industry) => order.Status == EOrderStatus.Filed)
            .WhereIF(dto.No.NotNullOrEmpty(), (redPackAudit, order, snapshot, record, industry) => order.No.Contains(dto.No))
            .WhereIF(dto.Title.NotNullOrEmpty(), (redPackAudit, order, snapshot, record, industry) => order.Title.Contains(dto.Title))
            .WhereIF(status.HasValue, (redPackAudit, order, snapshot, record, industry) => redPackAudit.LevelOneStatus == status)
            .WhereIF(areaCode.NotNullOrEmpty(), (redPackAudit, order, snapshot, record, industry) => order.AreaCode == areaCode);

        var orgName = _sessionContext.OrgName ?? string.Empty;
        if (orgName.Contains("应急管理局") && status != null)
            query.Where((redPackAudit, order, snapshot, record, industry) => redPackAudit.LevelTwoStatus == status);
        else if (status != null)
            query.Where((redPackAudit, order, snapshot, record, industry) => redPackAudit.LevelOneStatus == status);

        return query.Select((redPackAudit, order, snapshot, record, industry) => new SnapshotOrderGuiderAuditItemsOutDto
        {
            Id = redPackAudit.Id,
            RedPackAuditId = redPackAudit.Id,
            OrderId = order.Id,
            No = order.No,
            Title = order.Title,
            SourceChannel = order.SourceChannel,
            SourceChannelCode = order.SourceChannelCode,
            Status = order.Status,
            FromPhone = order.FromPhone,
            FromName = order.FromName,
            ApprovedAmount = redPackAudit.ApprovedAmount,
            IsIssued = redPackAudit.IsIssued,
            County = order.County,
            IsDeal = snapshot.IsDeal,
            NetworkENumber = snapshot.NetworkENumber,
            IsTruth = snapshot.IsTruth,
            IsTruthDepartment = snapshot.IsTruthDepartment,
            IsRepetition = snapshot.IsRepetition,
            IsRectify = snapshot.IsRectifyDepartment,
            CreationTime = order.CreationTime,
            LevelOneAuditName = redPackAudit.LevelOneAuditName,
            LevelOneAuditOrgName = redPackAudit.LevelOneAuditOrgName,
            LevelOneAuditRemark = redPackAudit.LevelOneAuditRemark,
            LevelOneAuditTime = redPackAudit.LevelOneAuditTime,
            NetworkRemark = snapshot.NetworkRemark,
            LevelOneStatus = redPackAudit.LevelOneStatus,
            LevelTwoStatus = redPackAudit.LevelTwoStatus,
            LevelTwoAuditTime = redPackAudit.LevelTwoAuditTime,
            LevelTwoAuditRemark = redPackAudit.LevelTwoAuditRemark,
        }, true);
    }

    /// <summary>
    /// 获取审核短信模板
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    public async Task<IList<GetRedPackAuditSMSTemplateOutDto>> GetRedPackAuditSMSTemplateAsync(GetRedPackAuditSMSTemplateInDto dto)
    {
        var industryId = await _orderSnapshotRepository.Queryable()
            .Where(m => m.Id == dto.OrderId)
            .Select(m => m.IndustryId).FirstAsync();
        var items = await _snapshotSMSTemplateRepository.Queryable(includeDeleted: true)
            .Where(sms => (sms.IsPublic == true || sms.IndustryId == industryId)
             && sms.Status == dto.Status && sms.IsEnable == true && sms.IsDeleted == false)
            .Select(sms => new GetRedPackAuditSMSTemplateOutDto
            {
                Id = sms.Id,
                Content = sms.Content
            })
            .GroupBy(sms => new { sms.Id, sms.Content })
            .ToListAsync();
        return items;
    }

    /// <summary>
    /// 审核添加备注
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    public async Task UpdateRedPackAuditRemarkAsync(UpdateRedPackAuditRemarkInDto dto)
    {
        var audit = await _redPackAuditRepository.GetAsync(dto.RedPackAuditId) ?? throw UserFriendlyException.SameMessage("审核记录不存在");
        audit.AcutalAmount = dto.AcutalAmount;
        if (dto.IsSend == false)
        {
            await _redPackRecordRepository.Queryable()
                .Where(m => m.RedPackAuditId == audit.Id)
                .FirstAsync()
                .Then(async (record) =>
                {
                    record.FailCase = dto.FailCase;
                    await _redPackRecordRepository.UpdateAsync(record);
                });
        }
        audit.SendRemarks = dto.SendRemarks;
        await _redPackAuditRepository.UpdateAsync(audit);
    }

    public async Task UpdateRedPackRecordAsync(UpdateRedPackRecordInDto dto)
    {
        var record = await _redPackRecordRepository.Queryable()
            .Where(m => m.RedPackAuditId == dto.RedPackAuditId)
            .FirstAsync() ?? throw UserFriendlyException.SameMessage("审核记录不存在");
        var audit = await _redPackAuditRepository.GetAsync(dto.RedPackAuditId) ?? throw UserFriendlyException.SameMessage("审核记录不存在");

        dto.Adapt(audit);
        await _redPackAuditRepository.UpdateAsync(audit);

        var entity = dto.Adapt<SupplementRecord>();
        var industryName = await _orderSnapshotRepository.Queryable()
            .Where(m => m.Id == record.OrderId)
            .Select(m => new { m.IndustryName, m.IndustryId })
            .FirstAsync();
        entity.OrderId = record.OrderId;
        entity.RedPackRecordId = record.Id;
        entity.RedPackAuditId = audit.Id;
        entity.No = record.No;
        entity.IndustryName = industryName.IndustryName;
        entity.IndustryId = industryName.IndustryId;
        await _supplementRecordRepository.AddAsync(entity);

        if (dto.IsSendSMS)
        {
            // TODO: 发送短信
        }
    }

    #region 红包发放记录

    /// <summary>
    /// 市民红包发放记录
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Description("市民红包发放记录")]
    public ISugarQueryable<SnapshotRedPackRecordItemsOutDto> GetRedPackRecordItemsAsync(SnapshotRedPackRecordItemsInDto dto)
    {
        var query = _redPackRecordRepository.Queryable()
            .Where(m => m.PeopleType == EReadPackUserType.Citizen)
            .WhereIF(dto.BeginCreationTime.HasValue && dto.EndCreationTime.HasValue, m => m.CreationTime >= dto.BeginCreationTime && m.CreationTime <= dto.EndCreationTime)
            .WhereIF(dto.No.NotNullOrEmpty(), m => m.No.Contains(dto.No))
            .WhereIF(dto.PhoneNumber.NotNullOrEmpty(), m => m.PhoneNumber.Contains(dto.PhoneNumber))
            .Select<SnapshotRedPackRecordItemsOutDto>();

        if (dto.Status == 3)
            query = query.Where(m => m.PickupStatus == ERedPackPickupStatus.Excuse);
        else
        {
            if (Enum.TryParse(dto.Status.ToString(), out EReadPackSendStatus status))
                query = query.Where(m => m.DistributionState == status);
        }
        return query;
    }

    /// <summary>
    /// 获取特提参数
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public async Task<GetAuditBackBaseDataOutDto> GetAuditBackBaseDataAsync(string id)
    {
        var order = await _orderRepository.Queryable()
            .Where(m => m.Id == id)
            .Select<GetAuditBackBaseDataOutDto>()
            .FirstAsync()
            ?? throw UserFriendlyException.SameMessage("工单不存在");

        order.SpecialNum = await _orderSpecialRepository.CountAsync(x => x.OrderId == id);
        return order;
    }

    [Description("网格员红包发放记录")]
    public ISugarQueryable<SnapshotRedPackRecordItemsGuiderOutDto> GetRedPackRecordGuiderItemsAsync(SnapshotRedPackRecordItemsGuiderInDto dto)
    {
        var query = _redPackRecordRepository.Queryable()
            .Where(m => m.PeopleType == EReadPackUserType.Guider)
            .WhereIF(dto.BeginCreationTime.HasValue && dto.EndCreationTime.HasValue, m => m.CreationTime >= dto.BeginCreationTime && m.CreationTime <= dto.EndCreationTime)
            .WhereIF(dto.No.NotNullOrEmpty(), m => m.No.Contains(dto.No))
            .WhereIF(dto.PhoneNumber.NotNullOrEmpty(), m => m.PhoneNumber.Contains(dto.PhoneNumber))
            .WhereIF(dto.Name.NotNullOrEmpty(), m => m.Name.Contains(dto.Name))
            .Select<SnapshotRedPackRecordItemsGuiderOutDto>();

        if (dto.Status == 3)
            query = query.Where(m => m.PickupStatus == ERedPackPickupStatus.Excuse);
        else
        {
            if (Enum.TryParse(dto.Status.ToString(), out EReadPackSendStatus status))
                query = query.Where(m => m.DistributionState == status);
        }
        return query;
    }

    [Description("红包发放明细")]
    public ISugarQueryable<SnapshotRedPackRecordSendOutDto> GetRedPackRecordDetailAsync(SnapshotRedPackRecordSendInDto dto)
    {
        var query = _redPackRecordRepository.Queryable()
            .LeftJoin<OrderSnapshot>((m , snapshot) => m.OrderId == snapshot.Id)
            .LeftJoin<Order>((m , snapshot, order) => m.OrderId == order.Id)
            .Where(m => m.DistributionState != EReadPackSendStatus.Unsend)
            .WhereIF(dto.Status == 1, m => m.PickupStatus == ERedPackPickupStatus.Received)
            .WhereIF(dto.Status == 2, m => m.PickupStatus == ERedPackPickupStatus.Back)
            .WhereIF(dto.Status == 3, m => m.DistributionState == EReadPackSendStatus.Fail)
            .WhereIF(dto.Status == 4, m => m.PickupStatus == ERedPackPickupStatus.Unreceived)
            .WhereIF(dto.IndustryId.NotNullOrEmpty(), (m, snapshot) => snapshot.IndustryId == dto.IndustryId)
            .WhereIF(dto.No.NotNullOrEmpty(), order => order.No.Contains(dto.No))
            .WhereIF(dto.UserType.HasValue, m => m.PeopleType == dto.UserType)
            .WhereIF(dto.OpenId.NotNullOrEmpty(), m => m.WXOpenId == dto.OpenId)
            .WhereIF(dto.SendStatus.HasValue, m => m.DistributionState == dto.SendStatus)
            .WhereIF(dto.IsReceive.HasValue && dto.IsReceive == true, m => m.PickupStatus == ERedPackPickupStatus.Received)
            .WhereIF(dto.IsReceive.HasValue && dto.IsReceive == false, m => m.PickupStatus == ERedPackPickupStatus.Unreceived)
            .WhereIF(dto.BeginCreationTime.HasValue && dto.EndCreationTime.HasValue, m => m.CreationTime >= dto.BeginCreationTime && m.CreationTime <= dto.EndCreationTime)
            .Select(m => new SnapshotRedPackRecordSendOutDto
            { 
                OrderId = m.OrderId,
                UserType = m.PeopleType
            }, true);
        return query;
    }

    /// <summary>
    /// 补充发放集合
    /// </summary>
    /// <param name="dto"></param>
    /// <returns></returns>
    [Description("补充发放")]
    public ISugarQueryable<SnapshotRedPackRecordSupplementItemsOutDto> GetRedPackRecordSupplementItemsAsync(SnapshotRedPackRecordSupplementItemsInDto dto)
    {
        var query = _supplementRecordRepository.Queryable()
            .LeftJoin<Order>((supp, order) => supp.OrderId == order.Id)
            .WhereIF(dto.No.NotNullOrEmpty(), (supp, order) => order.No.Contains(dto.No))
            .WhereIF(dto.FromPhone.NotNullOrEmpty(), (supp, order) => order.FromPhone.Contains(dto.FromPhone))
            .WhereIF(dto.Title.NotNullOrEmpty(), (supp, order) => order.Title.Contains(dto.Title))
            .WhereIF(dto.IndustryId.NotNullOrEmpty(), (supp, order) => supp.IndustryId == dto.IndustryId)
            .WhereIF(dto.BeginCreationTime.HasValue && dto.EndCreationTime.HasValue, (supp, order) => supp.CreationTime >= dto.BeginCreationTime && supp.CreationTime <= dto.EndCreationTime)
            .Select<SnapshotRedPackRecordSupplementItemsOutDto>();
        return query;
    }


    #endregion
}