ds8-solution-pro/ds-wms-service/DS.WMS.Core/Fee/Method/FeeAuditService.cs

using DS.Module.Core;
using DS.Module.Core.Extensions;
using DS.Module.SqlSugar;
using DS.Module.UserModule;
using DS.WMS.Core.Fee.Dtos;
using DS.WMS.Core.Fee.Entity;
using DS.WMS.Core.Fee.Interface;
using DS.WMS.Core.Flow.Dtos;
using DS.WMS.Core.Flow.Entity;
using DS.WMS.Core.Flow.Interface;
using DS.WMS.Core.Op.Entity;
using DS.WMS.Core.Sys.Entity;
using Mapster;
using Microsoft.Extensions.DependencyInjection;
using SqlSugar;

namespace DS.WMS.Core.Fee.Method
{
    /// <summary>
    /// 费用审核
    /// </summary>
    public class FeeAuditService : IFeeAuditService
    {
        /// <summary>
        /// 待审核的状态值
        /// </summary>
        public static readonly FeeStatus[] AuditStatusArray = [FeeStatus.AuditSubmitted, FeeStatus.ApplyDeletion, FeeStatus.ApplyModification];

        /// <summary>
        /// 工作流运行状态值
        /// </summary>
        public static readonly int RunningStatus = (int)FlowStatusEnum.Running;

        readonly IServiceProvider _serviceProvider;
        readonly ISqlSugarClient db;
        readonly IUser user;
        readonly ISaasDbService saasService;
        readonly IClientFlowInstanceService flowService;

        public FeeAuditService(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
            db = _serviceProvider.GetRequiredService<ISqlSugarClient>();
            user = _serviceProvider.GetRequiredService<IUser>();
            saasService = _serviceProvider.GetRequiredService<ISaasDbService>();
            flowService = _serviceProvider.GetRequiredService<IClientFlowInstanceService>();
        }

        /// <summary>
        /// 获取费用审核列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public DataResult<List<FeeAuditBusiness>> GetListByPage(PageRequest request)
        {
            var flowList = db.Queryable<FlowInstance>().Where(x => x.FlowStatus == RunningStatus && x.MakerList.Contains(user.UserId))
                .Select(x => new { x.BusinessId, x.BusinessType }).ToList();
            //没有待审批的列表直接返回不再执行后续查询
            if (flowList.Count == 0)
                DataResult<List<FeeAuditBusiness>>.PageList(0, null, MultiLanguageConst.DataQuerySuccess);

            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
            var queryList = GetDataQuery(tenantDb);
            var bidList = flowList.Select(x => x.BusinessId);
            queryList = queryList.Where(x => bidList.Contains(x.Id));

            List<IConditionalModel> whereList = null;
            if (!request.QueryCondition.IsNullOrEmpty())
                whereList = db.ConfigQuery.Context.Utilities.JsonToConditionalModels(request.QueryCondition);

            if (whereList != null)
                queryList = queryList.Where(whereList);

            var result = queryList.ToQueryPage(request.PageCondition);

            if (result.Data.Count > 0)
            {
                //关联用户名称
                var userIds = result.Data.Where(x => x.OperatorId.HasValue).Select(x => x.OperatorId.Value)
                    .Union(result.Data.Select(x => x.CreateBy))
                    .Distinct();
                var users = db.Queryable<SysUser>().Where(x => userIds.Contains(x.Id)).Select(x => new { x.Id, x.UserName }).ToList();
                foreach (var item in result.Data)
                {
                    item.CreateByName = users.Find(x => x.Id == item.CreateBy)?.UserName;

                    if (item.OperatorId.HasValue)
                    {
                        item.Operator = users.Find(x => x.Id == item.OperatorId.Value)?.UserName;
                    }
                }
            }

            return result;
        }

        //获取各项业务数据的查询并集
        internal static ISugarQueryable<FeeAuditBusiness> GetDataQuery(SqlSugarScopeProvider tenantDb)
        {
            //海运出口
            var query1 = tenantDb.Queryable<SeaExport, BusinessFeeStatus, FeeRecord>((s, b, f) => new JoinQueryInfos(
                JoinType.Left, s.Id == b.BusinessId && b.BusinessType == BusinessType.OceanShippingExport,
                JoinType.Inner, s.Id == f.BusinessId && f.BusinessType == BusinessType.OceanShippingExport && AuditStatusArray.Contains(f.FeeStatus)
                ))
                .GroupBy(s => s.Id)
                .Select((s, b, f) => new FeeAuditBusiness
                {
                    Id = s.Id,
                    AccountDate = SqlFunc.ToDate(s.AccountDate),
                    APFeeStatus = b.APFeeStatus,
                    ARFeeStatus = b.ARFeeStatus,
                    BusinessType = BusinessType.OceanShippingExport,
                    BusinessStatus = s.BusinessStatusName,
                    BusinessDate = s.BusinessDate,//业务日期
                    BLType = s.BLType,
                    //BookingCompany = //订舱公司
                    //BusinessUnit = //经营单位
                    CargoId = s.CargoId,
                    Carrier = s.Carrier,
                    AgencyId = s.AgentId,
                    CBM = s.CBM,
                    CntrTotal = s.CntrTotal,
                    ContractNo = s.ContractNo,
                    CreateBy = s.CreateBy,
                    CustomerId = s.CustomerId,
                    CustomerName = s.CustomerName,//委托单位
                    CustomerNo = s.CustomerNo,
                    CustomerService = s.CustomerService,
                    CustomNo = s.CustomNo,
                    CustomsNum = s.CustomsNum,
                    DangerClass = s.DangerClass,
                    Destination = s.Destination,
                    DischargePort = s.DischargePort,
                    Doc = s.Doc,
                    ETD = s.ETD,
                    GoodsName = s.GoodsName,
                    HBLNO = s.HBLNO,
                    InvoiceNo = s.InvoiceNo,
                    IsBusinessLocking = b.IsBusinessLocking,
                    IsFeeLocking = b.IsFeeLocking,
                    IssueType = s.IssueType,
                    KGS = s.KGS,
                    LoadPort = s.LoadPort,
                    MBLFrt = s.MBLFrt,
                    MBLNO = s.MBLNO,
                    Note = s.Note,
                    OperatorId = s.OperatorId,
                    OrderNo = s.OrderNo,
                    PKGS = s.PKGS,
                    ReceiptPlace = s.ReceiptPlace,
                    Remark = s.Remark,
                    SaleDeptId = s.SaleDeptId,
                    SaleId = s.SaleId,//揽货人
                    SaleName = s.Sale,
                    SourceId = s.SourceId,
                    SourceDetailId = s.SourceDetailId,
                    TradeTerm = s.TradeTerm,
                    Vessel = s.Vessel,//船名
                    Voyage = s.Voyno,//航次
                    Yard = s.Yard
                });

            //海运进口

            return tenantDb.UnionAll(new List<ISugarQueryable<FeeAuditBusiness>> { query1 });
        }

        /// <summary>
        /// 批量费用审批
        /// </summary>
        /// <param name="yesOrNo">审批结果：1=通过，2=驳回</param>
        /// <param name="remark">备注</param>
        /// <param name="idArray">待审批的费用ID</param>
        /// <returns></returns>
        public DataResult Audit(int yesOrNo, string remark, params long[] idArray)
        {
            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
            var fees = tenantDb.Queryable<FeeRecord>().Where(x => idArray.Contains(x.Id)).Select(x => new
            {
                x.Id,
                x.FeeName,
                x.FeeStatus,
                x.FlowId
            }).ToList();

            if (fees.Count == 0)
                return DataResult.Failed("未能获取费用信息");

            if (fees.Exists(x => !x.FlowId.HasValue))
                return DataResult.Failed("提交数据中包含不在审批流程中的费用");

            if (fees.Exists(x => !AuditStatusArray.Contains(x.FeeStatus)))
                return DataResult.Failed("提交数据中包含不在待审批状态的费用");

            var flowIds = fees.Select(x => x.FlowId.GetValueOrDefault());
            var flows = db.Queryable<FlowInstance>().Where(x => flowIds.Contains(x.Id)).ToList();
            if (flows.Count == 0)
                return DataResult.Failed("未能获取审批工作流");

            if (flows.Exists(x => !x.MakerList.Contains(user.UserId)))
                return DataResult.Failed("所选费用包含不属于当前用户权限范围内的审批，禁止提交");

            List<string> list = new List<string>();
            foreach (var fee in fees)
            {
                var flow = flows.Find(x => x.Id == fee.FlowId.Value);
                if (flow == null)
                {
                    continue;
                }

                var result = flowService.AuditFlowInstance(new FlowAuditInfo
                {
                    Instance = flow,
                    Status = yesOrNo,
                    AuditNote = remark
                });

                if (!result.Succeeded)
                {
                    list.Add(fee.FeeName);
                }
            }

            if (list.Count > 0)
                return DataResult.Failed($"部分费用审批失败：{string.Join("、", list)}");

            return DataResult.Success;
        }

        /// <summary>
        /// 本票审核（一键审核当前登录用户的所有待审核项）
        /// </summary>
        /// <param name="yesOrNo">审批结果：1=通过，2=驳回</param>
        /// <param name="remark">备注</param>
        /// <returns></returns>
        public DataResult AuditBusiness(int yesOrNo, string remark)
        {
            var flowList = db.Queryable<FlowInstance>().Where(x => x.FlowStatus == RunningStatus && x.MakerList.Contains(user.UserId))
                .Select(x => new { x.BusinessId, x.BusinessType }).ToList();
            //没有待审批的列表直接返回不再执行后续查询
            if (flowList.Count == 0)
                return DataResult.Failed("当前暂无待审批的费用");

            var request = new FeeBizAuditRequest
            {
                Items = flowList.Select(x => new BizAudit { Id = x.BusinessId, BusinessType = x.BusinessType }).ToList(),
                Remark = remark,
                Result = yesOrNo
            };

            return AuditBusiness(request);
        }

        /// <summary>
        /// 整单审批
        /// </summary>
        /// <param name="request">审批请求</param>
        /// <returns></returns>
        public DataResult AuditBusiness(FeeBizAuditRequest request)
        {
            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
            var gpList = request.Items.GroupBy(x => x.BusinessType).ToList();
            foreach (var gp in gpList)
            {
                var bIdArr = gp.Select(x => x.Id).ToArray();
                var bizList = tenantDb.Queryable<BusinessFeeStatus>().Where(x => bIdArr.Contains(x.BusinessId) && x.BusinessType == gp.Key)
                .Select(x => new
                {
                    x.Id,
                    x.BillAuditStatus,
                    x.FlowId
                }).ToList();

                if (bizList.Count == 0)
                    return DataResult.Failed("未能获取业务信息");

                if (!bizList.Any(x => x.FlowId.HasValue))
                    return DataResult.Failed("业务未处于审批流程中");

                if (bizList.Any(x => x.BillAuditStatus != BillAuditStatus.AuditSubmitted))
                    return DataResult.Failed("业务的审批状态不正确");

                var fIdArr = bizList.Select(x => x.FlowId).ToArray();
                var flows = db.Queryable<FlowInstance>().Where(x => fIdArr.Contains(x.Id)).ToList();

                if (flows.Count == 0)
                    return DataResult.Failed("未能获取审批工作流");

                if (flows.Any(x => !x.MakerList.Contains(user.UserId)))
                    return DataResult.Failed("所选项包含不属于当前用户权限范围内的审批，禁止提交");

                foreach (var flow in flows)
                {
                    var result = flowService.AuditFlowInstance(new FlowAuditInfo
                    {
                        Instance = flow,
                        Status = request.Result,
                        AuditNote = request.Remark
                    });

                    if (!result.Succeeded)
                    {
                        //todo:记录未能成功审核的数据
                    }
                }

            }

            return DataResult.Success;
        }

        /// <summary>
        /// 设置业务费用锁定状态
        /// </summary>
        /// <param name="items">业务信息</param>
        /// <returns></returns>
        public DataResult SetFeeLocking(IEnumerable<BusinessFeeStatus> items)
        {
            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
            int rows = tenantDb.Updateable<BusinessFeeStatus>(items)
                .WhereColumns(x => new { x.BusinessId, x.BusinessType })
                .UpdateColumns(x => new { x.IsFeeLocking })
                .ExecuteCommand();

            return rows > 0 ? DataResult.Success : DataResult.Failed("更新失败");
        }

        /// <summary>
        /// 根据审批结果更新审批状态
        /// </summary>
        /// <param name="callback">回调信息</param>
        /// <returns></returns>
        public DataResult UpdateAuditStatus(FlowCallback callback)
        {
            var auditType = callback.AuditType.ToEnum<FeeAuditType>();
            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
            FeeRecord fee = null;
            BusinessFeeStatus biz = null;
            if (auditType == FeeAuditType.Business)
            {
                biz = tenantDb.Queryable<BusinessFeeStatus>().Where(x => x.Id == callback.BusinessId && x.BusinessType == callback.BusinessType)
                    .Select(x => new BusinessFeeStatus
                    {
                        Id = x.Id,
                        BusinessId = x.BusinessId,
                        BillAuditStatus = x.BillAuditStatus
                    }).First();
                if (biz == null)
                    return DataResult.Failed("未能找到业务信息，更新状态失败", MultiLanguageConst.Operation_Failed);
            }
            else
            {
                fee = tenantDb.Queryable<FeeRecord>().Where(x => x.Id == callback.BusinessId && x.BusinessType == callback.BusinessType).Select(
                x => new FeeRecord { Id = x.Id, FeeStatus = x.FeeStatus }).First();
                if (fee == null)
                    return DataResult.Failed("未能找到费用记录，更新状态失败", MultiLanguageConst.Operation_Failed);

                fee.Reason = callback.RejectReason;
            }

            long userId = long.Parse(user.UserId);
            DateTime dtNow = DateTime.Now;
            tenantDb.Ado.BeginTran();
            try
            {
                switch (auditType)
                {
                    case FeeAuditType.ApplyAudit:
                        fee.AuditBy = userId;
                        fee.AuditOperator = user.UserName;
                        fee.AuditDate = dtNow;

                        if (callback.FlowStatus == FlowStatusEnum.Approve)
                        {
                            fee.FeeStatus = FeeStatus.AuditPassed;
                            fee.Reason = string.Empty;
                        }
                        else if (callback.FlowStatus == FlowStatusEnum.Reject)
                            fee.FeeStatus = FeeStatus.RejectSubmission;

                        tenantDb.Updateable(fee).UpdateColumns(x => new
                        {
                            x.FeeStatus,
                            x.AuditBy,
                            x.AuditOperator,
                            x.AuditDate,
                            x.Reason,
                            x.FlowId
                        }).ExecuteCommand();
                        break;

                    case FeeAuditType.ApplyModification:
                        //申请修改审核成功需要回填费用信息
                        if (callback.FlowStatus == FlowStatusEnum.Approve)
                        {
                            var fm = tenantDb.Queryable<FeeModification>().Where(x => x.FeeRecordId == fee.Id).OrderByDescending(x => x.CreateTime).First();
                            if (fm == null)
                                return DataResult.Failed("未找到费用修改信息，更新失败", MultiLanguageConst.Operation_Failed);

                            var entity = fm.Adapt<FeeRecord>();
                            entity.Id = fm.FeeRecordId;
                            entity.FeeStatus = FeeStatus.AuditPassed;
                            entity.Reason = callback.RejectReason;
                            entity.UpdateBy = userId;
                            entity.UpdateTime = dtNow;
                            //全表更新
                            tenantDb.Updateable(entity).IgnoreColumns(
                                x => new { x.AuditBy, x.AuditDate, x.AuditOperator, x.SubmitBy, x.SubmitDate }).ExecuteCommand();

                            //逻辑删除暂存数据
                            fm.Deleted = true;
                            fm.DeleteTime = dtNow;
                            fm.DeleteBy = userId;
                            tenantDb.Updateable(fm).UpdateColumns(x => new
                            {
                                x.DeleteBy,
                                x.Deleted,
                                x.DeleteTime
                            }).ExecuteCommand();
                        }
                        else if (callback.FlowStatus == FlowStatusEnum.Reject)
                        {
                            fee.FeeStatus = FeeStatus.RejectApplication;
                            tenantDb.Updateable(fee).UpdateColumns(x => new
                            {
                                x.FeeStatus,
                                x.Reason,
                                x.FlowId
                            }).ExecuteCommand();
                        }

                        break;

                    case FeeAuditType.ApplyDeletion:
                        if (callback.FlowStatus == FlowStatusEnum.Approve)
                        {
                            fee.Deleted = true;
                            fee.DeleteBy = userId;
                            fee.DeleteTime = dtNow;

                            tenantDb.Updateable(fee).UpdateColumns(x => new
                            {
                                x.DeleteBy,
                                x.Deleted,
                                x.DeleteTime,
                                x.Reason,
                                x.FlowId
                            }).ExecuteCommand();

                            //tenantDb.Deleteable(fee).ExecuteCommand();
                        }
                        else
                        {
                            fee.FeeStatus = FeeStatus.RejectApplication;

                            tenantDb.Updateable(fee).UpdateColumns(x => new
                            {
                                x.FeeStatus,
                                x.Reason,
                                x.FlowId
                            }).ExecuteCommand();
                        }
                        break;

                    case FeeAuditType.Business:
                        FeeStatus status = FeeStatus.RejectSubmission;
                        if (callback.FlowStatus == FlowStatusEnum.Approve)
                        {
                            biz.BillAuditStatus = BillAuditStatus.AuditPassed;
                            status = FeeStatus.AuditPassed;
                        }
                        else if (callback.FlowStatus == FlowStatusEnum.Reject)
                        {
                            biz.BillAuditStatus = BillAuditStatus.Rejected;
                        }

                        tenantDb.Updateable(biz).UpdateColumns(x => new
                        {
                            x.BillAuditStatus,
                            x.FlowId
                        }).ExecuteCommand();


                        tenantDb.Updateable<FeeRecord>()
                            .SetColumns(x => x.FeeStatus == status)
                            .SetColumns(x => x.FlowId == null)
                            .SetColumns(x => x.AuditBy == userId)
                            .SetColumns(x => x.AuditOperator == user.UserName)
                            .SetColumns(x => x.AuditDate == dtNow)
                            .Where(x => x.BusinessId == biz.BusinessId && x.BusinessType == callback.BusinessType &&
                            (x.FeeStatus == FeeStatus.Entering || x.FeeStatus == FeeStatus.RejectSubmission)).ExecuteCommand();

                        break;
                    default:
                        return DataResult.Failed("费用未处于审批状态，更新失败", MultiLanguageConst.Operation_Failed);
                }

                //驳回申请则逻辑删除关联工作流
                if (callback.FlowStatus == FlowStatusEnum.Reject)
                {
                    db.Updateable(new FlowInstance
                    {
                        Id = callback.InstanceId,
                        Deleted = true,
                        DeleteBy = 0,
                        DeleteTime = DateTime.Now
                    }).UpdateColumns(x => new { x.Deleted, x.DeleteBy, x.DeleteTime }).ExecuteCommand();
                }

                tenantDb.Ado.CommitTran();
                return DataResult.Successed("提交成功!", MultiLanguageConst.DataUpdateSuccess);
            }
            catch (Exception ex)
            {
                tenantDb.Ado.RollbackTran();
                ex.Log(db);
                return DataResult.Failed("提交失败!", MultiLanguageConst.Operation_Failed);
            }
            finally
            {
                FeeRecordService.WriteBackStatus(tenantDb, callback.BusinessId, callback.BusinessType);
            }
        }


        //public DataResult<List<FeeAudit>> GetListByPage(PageRequest request)
        //{
        //    var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
        //    var whereList = db.ConfigQuery.Context.Utilities.JsonToConditionalModels(request.QueryCondition);

        //    var query1 = tenantDb.Queryable<FeeRecord>()
        //        .InnerJoin<SeaExport>((x, y) => x.BusinessId == y.Id)
        //        .LeftJoin<InfoClient>((x, y, z) => x.CustomerId == z.Id)
        //        .Select((x, y, z) => new FeeAudit
        //        {
        //            Id = x.Id,
        //            BusinessId = x.BusinessId,
        //            BusinessType = x.BusinessType,
        //            FeeStatus = x.FeeStatus,
        //            FeeType = x.FeeType,
        //            FeeName = x.FeeName,
        //            FeeEnName = x.FeeEnName,
        //            CustomerName = x.CustomerName,
        //            CustomerFullName = z.Description, //结算对象全称
        //            CustomerType = x.CustomerType,
        //            CustomerTypeText = x.CustomerTypeText,
        //            Unit = x.Unit,
        //            UnitText = x.UnitText,
        //            UnitPrice = x.UnitPrice,
        //            TaxUnitPrice = x.TaxUnitPrice,
        //            Quantity = x.Quantity,
        //            TaxRate = x.TaxRate,
        //            NoTaxAmount = x.NoTaxAmount,
        //            Amount = x.Amount,
        //            Currency = x.Currency,
        //            CurrencyText = x.CurrencyText,
        //            ExchangeRate = x.ExchangeRate,
        //            AccTaxRate = x.AccTaxRate,//销项汇率
        //            Remark = x.Remark,
        //            IsAdvancedPay = x.IsAdvancedPay,//是否垫付
        //            IsInvoice = x.IsInvoice, //是否开发票
        //            //FRT
        //            CommissionRate = x.CommissionRate, //佣金比率
        //            CreateBy = x.CreateBy,
        //            CreateTime = x.CreateTime,
        //            AuditOperator = x.AuditOperator,
        //            AuditDate = x.AuditDate,
        //            SettlementAmount = x.SettlementAmount,//结算金额
        //            InvoiceAmount = x.InvoiceAmount,//开票金额
        //            OrderAmount = x.OrderAmount,//申请金额
        //            InvoiceNum = x.InvoiceNum,//发票号
        //            Tax = x.Tax,//税额
        //            DebitNo = x.DebitNo,//对账编号
        //            SubmitBy = x.SubmitBy,
        //            SubmitDate = x.SubmitDate,
        //            SaleOrg = x.SaleOrg,
        //            Reason = x.Reason,
        //            IsOpen = x.IsOpen,//是否机密

        //        });

        //    var queryList = tenantDb.UnionAll(new List<ISugarQueryable<FeeAudit>> { query1 });
        //    var result = queryList.Where(whereList).ToQueryPage(request.PageCondition);

        //    if (result.Data.Count > 0)
        //    {
        //        //关联用户名称
        //        var userIds = result.Data.Where(x => x.SubmitBy.HasValue).Select(x => x.SubmitBy.Value)
        //            .Union(result.Data.Select(x => x.CreateBy))
        //            .Distinct();
        //        var users = db.Queryable<SysUser>().Where(x => userIds.Contains(x.Id)).Select(x => new { x.Id, x.UserName }).ToList();
        //        foreach (var item in result.Data)
        //        {
        //            item.CreateByName = users.Find(x => x.Id == item.CreateBy)?.UserName;

        //            if (item.SubmitBy.HasValue)
        //            {
        //                item.SubmitByName = users.Find(x => x.Id == item.SubmitBy.Value)?.UserName;
        //            }
        //        }
        //    }

        //    return result;
        //}
    }
}