using AutoMapper;
using Microsoft.EntityFrameworkCore.Storage;
using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WMS.Web.Core;
using WMS.Web.Core.Dto;
using WMS.Web.Core.Dto.Erp;
using WMS.Web.Core.Dto.InStockTask;
using WMS.Web.Core.Dto.Login;
using WMS.Web.Core.Internal.Results;
using WMS.Web.Domain.Entitys;
using WMS.Web.Domain.Infrastructure;
using WMS.Web.Domain.IService;
using WMS.Web.Domain.IService.Public;
using WMS.Web.Domain.Values;

namespace WMS.Web.Domain.Services
{
    /// <summary>
    /// 入库任务单-服务
    /// </summary>
    public class InStockTaskService : IInStockTaskService
    {
        private readonly IMapper _mapper;
        private ILogger<InStockTaskService> _logger;
        private readonly IErpService _erpService;
        private readonly ILoginService _loginService;
        private readonly IBasicsRepositories _basicsRepositories;
        private readonly IInStockRepositories _inStockRepositories;
        private readonly IInStockTaskRepositories _inStockTaskRepositories;
        public InStockTaskService(IMapper mapper, IErpService erpService, ILoginService loginService,
             IBasicsRepositories basicsRepositories, ILogger<InStockTaskService> logger,
            IInStockRepositories inStockRepositories, IInStockTaskRepositories inStockTaskRepositories)
        {
            this._logger = logger;
            _mapper = mapper;
            _erpService = erpService;
            _loginService = loginService;
            _basicsRepositories = basicsRepositories;
            _inStockRepositories = inStockRepositories;
            _inStockTaskRepositories = inStockTaskRepositories;
        }

        /// <summary>
        /// 来源单-金蝶校准-实时
        /// </summary>
        /// <param name="sourceBillNo"></param>
        /// <returns></returns>
        public async Task<Result> Adjust(string sourceBillNo)
        {
            //1.事务
            IDbContextTransaction _transaction = _basicsRepositories.GetTransaction();
            bool isRollback = false;
            bool isTransaction = false;

            //2.查看是否有入库任务单
            var task = await _inStockTaskRepositories.GetBySource(sourceBillNo);
            if (task == null)
                return Result.ReFailure(ResultCodes.OrderNoData);

            //3.有的话就同步一下金蝶的数据
            var billNos = new List<string>();
            billNos.Add(sourceBillNo);
            //3.1订单类型-进去金蝶交互更新
            if (task.Type == InstockType.Purchase)
            {
                var result = await this.SsynPurchaseInStock(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if (task.Type == InstockType.Miscellaneous)
            {
                var result = await this.SysnMiscellaneous(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if (task.Type == InstockType.Assembled)
            {
                var result = await this.SysnAssembledApp(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if (task.Type == InstockType.Stkdirecttransfers)
            {
                var result = await this.SysnTransferDirect(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }
            else if (task.Type == InstockType.StktransferInst)
            {
                var result = await this.SysnTransferin(billNos, isTransaction);
                if (!result.IsSuccess) isRollback = true;
            }

            //4.提交事务
            var isSuccess = _basicsRepositories.CommitTransaction(isRollback, _transaction);
            if (!isSuccess)
                return Result.ReFailure(ResultCodes.AdjustError);

            return Result.ReSuccess();
        }

        /// <summary>
        /// 同步：采购入库类型单据
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SsynPurchaseInStock(List<string> billNos = null, bool isTransaction = true)
        {
            //1.获取金蝶数据：采购订单数据
            var erp_result = await _erpService.BillQueryForPurchaseInStock(billNos);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;

            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }

        /// <summary>
        /// 同步：其他入库单
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnMiscellaneous(List<string> billNos = null, bool isTransaction = true)
        {
            //1.获取金蝶数据：其他入库订单数据
            var erp_result = await _erpService.BillQueryForMiscellaneous(billNos);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;

            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }

        /// <summary>
        /// 同步：直接调拨入库单
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnTransferDirect(List<string> billNos = null, bool isTransaction = true)
        {
            //1.获取金蝶数据：直接调拨入库订单数据
            var erp_result = await _erpService.BillQueryForTransferDirect(billNos);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;

            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }

        /// <summary>
        /// 同步：分步式调入单
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnTransferin(List<string> billNos = null, bool isTransaction = true)
        {
            //1.获取金蝶数据：分步式入库订单数据
            var erp_result = await _erpService.BillQueryForTransferin(billNos);
            if (!erp_result.IsSuccess)
                return Result.ReFailure(erp_result.Message, erp_result.Status);
            var erp_list = erp_result.Data;
            return await this.SysnDataNew(erp_list.ToList(), isTransaction);
        }

        /// <summary>
        /// 同步：组装拆卸单
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnAssembledApp(List<string> billNos = null, bool isTransaction = true)
        {
            var erp_list = new List<ErpInStockResultDto>();

            //1.获取金蝶数据：组装成品入库订单数据
            var erp_result_ass = await _erpService.BillQueryForAssembledApp_Assembly(billNos);
            if (!erp_result_ass.IsSuccess)
                return Result.ReFailure(erp_result_ass.Message, erp_result_ass.Status);
            var erp_list_ass = erp_result_ass.Data;
            erp_list.AddRange(erp_list_ass);
            //1.1.获取金蝶数据：拆卸子件入库订单数据
            var erp_result_disass = await _erpService.BillQueryForAssembledApp_Disassembly(billNos);
            if (!erp_result_disass.IsSuccess)
                return Result.ReFailure(erp_result_disass.Message, erp_result_disass.Status);
            var erp_list_disass = erp_result_disass.Data;
            erp_list.AddRange(erp_list_disass);

            return await this.SysnDataNew(erp_list, isTransaction);
        }

        /// <summary>
        /// 同步
        /// </summary>
        /// <param name="billNos"></param>
        /// <returns></returns>
        public async Task<Result> Sysn(List<string> billNos = null)
        {
            //1.事务
            IDbContextTransaction _transaction = _basicsRepositories.GetTransaction();
            bool isRollback = false;
            bool isTransaction = false;

            //3.同步数据
            var result = await this.InStock(billNos, isTransaction);
            if (!result.IsSuccess) isRollback = true;

            //3.提交事务
            var isSuccess = _basicsRepositories.CommitTransaction(isRollback, _transaction);
            if (!isSuccess)
                return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }

        /// <summary>
        /// 同步：入库单类型的数据
        /// </summary>
        /// <param name="billNos"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> InStock(List<string> billNos, bool isTransaction)
        {
            if (billNos == null || billNos.Count == 0)
            {
                //1.同步数据:采购订单
                var purchase_result = await this.SsynPurchaseInStock(null, isTransaction);
                if (!purchase_result.IsSuccess)
                    return Result.ReFailure(purchase_result.Message, purchase_result.Status);

                //2.同步数据：其他入库单
                var miscellaneou_result = await this.SysnMiscellaneous(null, isTransaction);
                if (!miscellaneou_result.IsSuccess)
                    return Result.ReFailure(miscellaneou_result.Message, miscellaneou_result.Status);

                //3.同步数据：直接调拨入库单
                var TransferDirect_result = await this.SysnTransferDirect(null, isTransaction);
                if (!TransferDirect_result.IsSuccess)
                    return Result.ReFailure(TransferDirect_result.Message, TransferDirect_result.Status);

                //4.同步数据：分步式入库单
                var Transferin_result = await this.SysnTransferin(null, isTransaction);
                if (!Transferin_result.IsSuccess)
                    return Result.ReFailure(Transferin_result.Message, Transferin_result.Status);

                //5.同步数据：组装拆卸单
                var AssembledApp_result = await this.SysnAssembledApp(null, isTransaction);
                if (!AssembledApp_result.IsSuccess)
                    return Result.ReFailure(AssembledApp_result.Message, AssembledApp_result.Status);
            }
            else 
            {
                List<string> Instock_sourceBillNos = new List<string>();
                List<string> Miscellaneous_sourceBillNos = new List<string>();
                List<string> TransferDirect_sourceBillNos = new List<string>();
                List<string> Transferin_sourceBillNos = new List<string>();
                List<string> AssembledApp_sourceBillNos = new List<string>();

                var taskList = await _inStockTaskRepositories.GetListBy(billNos);
                foreach (var entity in taskList)
                {
                    if (entity.Type == InstockType.Purchase)
                        Instock_sourceBillNos.Add(entity.SourceBillNo);
                    else if (entity.Type == InstockType.Stkdirecttransfers)
                        TransferDirect_sourceBillNos.Add(entity.SourceBillNo);
                    else if (entity.Type == InstockType.StktransferInst)
                        Transferin_sourceBillNos.Add(entity.SourceBillNo);
                    else if (entity.Type == InstockType.Assembled)
                        AssembledApp_sourceBillNos.Add(entity.SourceBillNo);
                    else if (entity.Type == InstockType.Miscellaneous)
                        Miscellaneous_sourceBillNos.Add(entity.SourceBillNo);
                }

                if (Instock_sourceBillNos.Count() > 0)
                {
                    //1.同步数据:采购订单
                    var purchase_result = await this.SsynPurchaseInStock(Instock_sourceBillNos, isTransaction);
                    if (!purchase_result.IsSuccess)
                        return Result.ReFailure(purchase_result.Message, purchase_result.Status);
                }
                if (Miscellaneous_sourceBillNos.Count() > 0)
                {
                    //2.同步数据：其他入库单
                    var miscellaneou_result = await this.SysnMiscellaneous(Miscellaneous_sourceBillNos, isTransaction);
                    if (!miscellaneou_result.IsSuccess)
                        return Result.ReFailure(miscellaneou_result.Message, miscellaneou_result.Status);
                }
                if (TransferDirect_sourceBillNos.Count() > 0)
                {
                    //3.同步数据：直接调拨入库单
                    var TransferDirect_result = await this.SysnTransferDirect(TransferDirect_sourceBillNos, isTransaction);
                    if (!TransferDirect_result.IsSuccess)
                        return Result.ReFailure(TransferDirect_result.Message, TransferDirect_result.Status);
                }
                if (Transferin_sourceBillNos.Count() > 0)
                {
                    //4.同步数据：分步式入库单
                    var Transferin_result = await this.SysnTransferin(Transferin_sourceBillNos, isTransaction);
                    if (!Transferin_result.IsSuccess)
                        return Result.ReFailure(Transferin_result.Message, Transferin_result.Status);
                }
                if (AssembledApp_sourceBillNos.Count() > 0)
                {
                    //5.同步数据：组装拆卸单
                    var AssembledApp_result = await this.SysnAssembledApp(AssembledApp_sourceBillNos, isTransaction);
                    if (!AssembledApp_result.IsSuccess)
                        return Result.ReFailure(AssembledApp_result.Message, AssembledApp_result.Status);
                }
            }
            return Result.ReSuccess();
        }

        /// <summary>
        /// ERP数据同步到WMS数据库-旧代码
        /// </summary>
        /// <param name="erp_list"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnData(List<ErpInStockResultDto> erp_list, bool isTransaction)
        {
            var type = (InstockType)erp_list.GroupBy(x => x.Type).Select(x => x.Key).FirstOrDefault();
            var totalCount = erp_list.Count;
            var totalUpdateCount = 0;
            var totalAddCount = 0;
            //1.通过单据编号找到wms系统现有的任务单；并修改
            var erp_remove_billNo = new List<string>();
            var SourceBillNo_list = erp_list.GroupBy(x => x.BillNo).Select(x => x.Key).ToList();
            var data_list = await _inStockTaskRepositories.GetListBy(SourceBillNo_list);
            if (data_list.Count != 0)
            {
                data_list.ForEach(x =>
                {
                    var erp_list_dets = erp_list.Where(t => t.BillNo == x.SourceBillNo).ToList();
                    if (erp_list_dets != null && erp_list_dets.Count != 0 && erp_list_dets.Count > x.Details.Count)
                    {
                        var xd_detids = x.Details.Select(xd => xd.ErpDetailId).ToList();
                        var task_no_materials = erp_list_dets.Where(ed => !xd_detids.Contains(ed.ErpDetailId)).ToList();
                        var Add_task_no_materials = _mapper.Map<List<InStockTaskDetails>>(task_no_materials);
                        x.Details.AddRange(Add_task_no_materials);
                    }
                });

                //2.1提取出wms任务单明细信息
                var data_list_details = data_list.SelectMany(x => x.Details).ToList();
                foreach (var item in data_list_details)
                {
                    var data = data_list.Where(x => x.Id == item.Fid).FirstOrDefault();
                    if (data == null)
                        continue;

                    //2.1.1对比erp的物料信息
                    var erp_data = erp_list.Where(x => x.ErpDetailId == item.ErpDetailId).FirstOrDefault();
                    if (erp_data != null)
                    {
                        //2.1.2修改数量
                        if (erp_data.Qty > item.AccruedQty && (erp_data.Qty > item.RealityQty && item.RealityQty != 0))
                            data.Status = InstockStatus.Part;
                        else if (erp_data.Qty <= item.AccruedQty && erp_data.Qty <= item.RealityQty)
                            data.Status = InstockStatus.Already;
                        item.Remark = erp_data.Remark;
                        item.AccruedQty = erp_data.Qty;
                        item.FactoryPrice = erp_data.FactoryPrice;
                        item.DeliveredQty = erp_data.DeliveredQty;
                        //打印日志：需要的修改条数
                        totalUpdateCount++;
                        erp_remove_billNo.Add(data.SourceBillNo);
                    }
                }

                //金蝶修改了物料：老物料，应收数量修改为0,
                var data_list_details_new = data_list.SelectMany(x => x.Details).ToList();
                data_list_details_new.ForEach(x =>
                {
                    //2.1.1对比erp的物料信息
                    var erp_data = erp_list.Where(t => t.ErpDetailId == x.ErpDetailId).FirstOrDefault();
                    if (erp_data != null)
                    {
                        if (erp_data.MaterialId != x.MaterialId)
                        {
                            //给老的物料应收数量改为0
                            x.AccruedQty = 0;
                        }
                    }
                    else if (erp_data == null)
                    {
                        x.AccruedQty = 0;
                    }
                });
                //新物料新增一条
                foreach (var item in erp_list)
                {
                    var local_data_order = data_list.Where(t => t.SourceBillNo == item.BillNo).FirstOrDefault();
                    if (local_data_order != null)
                    {
                        var local_data = data_list_details_new.Where(t => t.ErpDetailId == item.ErpDetailId).ToList();
                        if (local_data != null && local_data.Count != 0)
                        {
                            var isHaveMater_detail = local_data.Where(t => t.MaterialId == item.MaterialId).Any();
                            if (!isHaveMater_detail)
                            {
                                //明细的物料改变了：新的物料重新添加一条明细
                                var Add_task_no_materials = _mapper.Map<InStockTaskDetails>(item);
                                data_list.Where(x => x.SourceBillNo == item.BillNo).FirstOrDefault().Status = InstockStatus.Part;
                                data_list.Where(x => x.SourceBillNo == item.BillNo).FirstOrDefault()?.Details.Add(Add_task_no_materials);
                            }
                        }
                        else
                        {
                            //新增明细
                            var Add_task_det = _mapper.Map<InStockTaskDetails>(item);
                            data_list.Where(x => x.SourceBillNo == item.BillNo).FirstOrDefault().Status = InstockStatus.Part;
                            data_list.Where(x => x.SourceBillNo == item.BillNo).FirstOrDefault()?.Details.Add(Add_task_det);
                        }
                    }
                }

                //2.2.提交修改
                var isSuccess = await _inStockTaskRepositories.UpdateRange(data_list, isTransaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);


                //要剔除的来源单据编号：去重
                erp_remove_billNo = erp_remove_billNo.GroupBy(x => x).Select(x => x.Key).ToList();
                //2.3剔除:已修改的单据
                foreach (var item in erp_remove_billNo)
                {
                    erp_list.RemoveAll(x => x.BillNo == item);
                }

            }

            //打印日志
            //打印日志：需要的添加条数
            //totalAddCount = erp_list.Count;
            //this.LogInfomation( type,totalCount, totalUpdateCount, totalAddCount);

            //3.wms任务单的来源单据编号不存在于erp中，那么就新增
            if (erp_list.Count != 0)
            {
                var add_entitys = new List<InStockTask>();
                var current_billNos = erp_list.GroupBy(x => x.BillNo).Select(x => x.Key).ToList();

                foreach (var item in current_billNos)
                {
                    var current_order = erp_list.Where(x => x.BillNo == item).FirstOrDefault();
                    var dto = new InStockTask();
                    dto.Create((InstockType)current_order.Type, current_order.BillNo, current_order.CreateTime);

                    //找到当前对应来源单据编号的集合数据
                    var current_erp_details = erp_list.Where(x => x.BillNo == item).ToList();
                    //给到dto的实体明细中
                    dto.Details = _mapper.Map<List<InStockTaskDetails>>(current_erp_details);
                    add_entitys.Add(dto);
                }
                //3.1提交新增
                var isSuccess = await _inStockTaskRepositories.AddRange(add_entitys, isTransaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }

            return Result.ReSuccess();
        }

        /// <summary>
        /// ERP数据同步到WMS数据库-新代码
        /// </summary>
        /// <param name="erp_list"></param>
        /// <param name="isTransaction"></param>
        /// <returns></returns>
        public async Task<Result> SysnDataNew(List<ErpInStockResultDto> erp_list, bool isTransaction)
        {

            //1.通过单据编号找到wms系统现有的任务单；并修改
            var erp_removeList = new List<ErpInStockResultDto>();
            var SourceBillNo_list = erp_list.GroupBy(x => x.BillNo).Select(x => x.Key).ToList();
            var data_list = await _inStockTaskRepositories.GetListBy(SourceBillNo_list);

            //要新增的明细
            var erp_addDetailsList = new List<ErpInStockResultDto>();
            //2.遍历已有的任务单
            if (data_list.Count != 0)
            {
                //2.1遍历任务单明细：改变已有的值和要添加的明细
                data_list.SelectMany(s => s.Details).ToList().ForEach(det =>
                {
                    //2.1去当前erp的明细
                    var erp_data = erp_list.Where(x => x.ErpDetailId == det.ErpDetailId).FirstOrDefault();
                    if (erp_data != null)
                    {
                       
                        //2.1.2物料相同的，就改变数值
                        if (det.MaterialId == erp_data.MaterialId)
                        {
                            //物料相同的，就改变数值
                            det.Remark = erp_data.Remark;
                            det.AccruedQty = erp_data.Qty;
                            det.FactoryPrice = erp_data.FactoryPrice;
                            det.DeliveredQty = erp_data.DeliveredQty;

                        }
                        else
                        {
                            //老物料，应收数量修改为0
                            det.AccruedQty = 0;                            
                        }
                        //操作完后剔除
                        erp_removeList.Add(erp_data);
                    }
                });

                //2.1.1当物料相同，仓库不同或者物料不同，就新增一条明细
                foreach (var erp_data in erp_list)
                {
                    // if (det.MaterialId != erp_data.MaterialId || (det.MaterialId == erp_data.MaterialId && det.StockCode != erp_data.StockCode))
                    var IsHaveNewMaterial = data_list.SelectMany(s => s.Details).Where(x => x.ErpDetailId == erp_data.ErpDetailId && erp_data.MaterialId==x.MaterialId).Any();
                    if(!IsHaveNewMaterial)
                        //当物料相同，仓库不同或者物料不同，就新增一条明细
                        erp_addDetailsList.Add(erp_data);
                }

                //2.2遍历任务单：添加新的明细
                data_list.ForEach(order => 
                {
                    //2.1.任务单添加明细
                    var addErpDetails= erp_addDetailsList.Where(x => x.BillNo == order.SourceBillNo).ToList();
                    if (addErpDetails.Count != 0) 
                    {
                        var addDetails = _mapper.Map<List<InStockTaskDetails>>(addErpDetails);
                        order.Details.AddRange(addDetails);
                    }                       
                });

                //2.3遍历任务单：改变任务单的状态
                data_list.ForEach(order => 
                {
                    //当应入库数量大于实际入库数量：状态就部分入库
                    //当应入库数量小于等于实际入库数量：状态就已入库
                    var AccruedQtyTotal = order.Details.Sum(x => x.AccruedQty);
                    var RealityQtyTotal = order.Details.Sum(x => x.RealityQty);
                    if(RealityQtyTotal!=0 && AccruedQtyTotal > RealityQtyTotal)
                        order.Status = InstockStatus.Part;
                    else if(AccruedQtyTotal<= RealityQtyTotal)
                        order.Status = InstockStatus.Already;                    
                });
            }

            //2.3.提交任务单的修改
            var isSuccess = await _inStockTaskRepositories.UpdateRange(data_list, isTransaction);
            if (!isSuccess)
                return Result.ReFailure(ResultCodes.DateWriteError);

            //2.4剔除:已修改的单据
            foreach (var item in erp_removeList)
                erp_list.Remove(item);

            //3.wms任务单的来源单据编号不存在于erp中，那么就新增
            if (erp_list.Count != 0)
            {
                var add_entitys = new List<InStockTask>();
                var current_billNos = erp_list.GroupBy(x => x.BillNo).Select(x => x.Key).ToList();

                foreach (var item in current_billNos)
                {
                    var current_order = erp_list.Where(x => x.BillNo == item).FirstOrDefault();
                    var dto = new InStockTask();
                    dto.Create((InstockType)current_order.Type, current_order.BillNo, current_order.CreateTime);

                    //找到当前对应来源单据编号的集合数据
                    var current_erp_details = erp_list.Where(x => x.BillNo == item).ToList();
                    //给到dto的实体明细中
                    dto.Details = _mapper.Map<List<InStockTaskDetails>>(current_erp_details);
                    add_entitys.Add(dto);
                }
                //3.1提交新增
                isSuccess = await _inStockTaskRepositories.AddRange(add_entitys, isTransaction);
                if (!isSuccess)
                    return Result.ReFailure(ResultCodes.DateWriteError);
            }

            return Result.ReSuccess();

        }


        /// <summary>
        /// 作废
        /// </summary>
        /// <param name="dto"></param>
        /// <param name="loginInfo"></param>
        /// <returns></returns>
        public async Task<Result> Repeal(OperateRequest dto, LoginInDto loginInfo)
        {
            var list = await _inStockTaskRepositories.GetList(dto.Ids);
            foreach (var entity in list)
            {
                //作废
                entity.Repeal(loginInfo.UserInfo.StaffId);
            }
            var isSuccess = await _inStockTaskRepositories.UpdateRange(list, true);
            if (!isSuccess) return Result.ReFailure(ResultCodes.DateWriteError);

            return Result.ReSuccess();
        }

        /// <summary>
        /// 打印日志
        /// </summary>
        /// <param name="type"></param>
        /// <param name="totalCount"></param>
        /// <param name="updateCount"></param>
        /// <param name="addCount"></param>
        public void LogInfomation(InstockType type, int totalCount, int updateCount, int addCount)
        {
            _logger.LogInformation($"《{type.GetRemark()}总条数：" + totalCount + "，修改条数：" + updateCount + "，新增条数：" + addCount + "》");
        }
    }
}