using Furion.DatabaseAccessor;
using Furion.FriendlyException;
using iWare.Wms.Core.Util;
using iWare.Wms.Core;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using System.Text;
using iWare.Wms.Core.Enum;

namespace iWare.Wms.Application.Service.Pda
{
    /// <summary>
    /// 设备基础信息管理服务
    /// </summary>
    //[Route("api")]
    [ApiDescriptionSettings("Pda相关接口", Name = "PdaService", Order = 100)]
    [Route("api/[Controller]")]
    public class PdaService : IDynamicApiController, ITransient
    {
        private readonly IRepository<EquipmentBaseInfo, MasterDbContextLocator> _equipmentBaseInfoRep;
        private readonly IRepository<V_GetEquipmentAlert, MasterDbContextLocator> _v_GetEquipmentAlertRep;
        private readonly IRepository<EquipmentCurrentMonitor, MasterDbContextLocator> _equipmentCurrentMonitorRep;
        private readonly IRepository<WorkPieceProcess, MasterDbContextLocator> _workPieceProcessRep;
        private readonly IRepository<WorkPieceInfo, MasterDbContextLocator> _workPieceInfo;
        private readonly IRepository<WorkPieceInfo, MasterDbContextLocator> _workPieceInfoRep;
        private readonly IRepository<SysDictData, MasterDbContextLocator> _sysDictDataRep;
        private readonly IRepository<SysDictType, MasterDbContextLocator> _sysDictTypeRep;
        private readonly IRepository<WorkPieceInfoLog, MasterDbContextLocator> _workPieceInfoLogRep;
        private readonly IRepository<WorkPieceOutbound, MasterDbContextLocator> _workPieceOutboundRep;

        /// <summary>
        /// 设备基础信息构造函数
        /// </summary>
        /// <param name="equipmentBaseInfoRep"></param>
        public PdaService(
            IRepository<EquipmentBaseInfo, MasterDbContextLocator> equipmentBaseInfoRep,
            IRepository<V_GetEquipmentAlert, MasterDbContextLocator> v_GetEquipmentAlert,
            IRepository<EquipmentCurrentMonitor, MasterDbContextLocator> equipmentCurrentMonitorRep,
            IRepository<WorkPieceProcess, MasterDbContextLocator> workPieceProcess,
            IRepository<WorkPieceInfo, MasterDbContextLocator> workPieceInfo,
            IRepository<WorkPieceInfo, MasterDbContextLocator> workPieceInfoRep,
            IRepository<SysDictData, MasterDbContextLocator> sysDictDataRep,
            IRepository<SysDictType, MasterDbContextLocator> sysDictTypeRep,
            IRepository<WorkPieceInfoLog, MasterDbContextLocator> workPieceInfoLogRep,
            IRepository<WorkPieceOutbound, MasterDbContextLocator> workPieceOutboundRep
            )
        {
            _equipmentBaseInfoRep = equipmentBaseInfoRep;
            _v_GetEquipmentAlertRep = v_GetEquipmentAlert;
            _equipmentCurrentMonitorRep = equipmentCurrentMonitorRep;
            _workPieceProcessRep = workPieceProcess;
            _workPieceInfo = workPieceInfo;
            _workPieceInfoRep = workPieceInfoRep;
            _sysDictDataRep = sysDictDataRep;
            _sysDictTypeRep = sysDictTypeRep;
            _workPieceInfoLogRep = workPieceInfoLogRep;
            _workPieceOutboundRep = workPieceOutboundRep;
        }


        /// <summary>
        /// 查询工件号获取工件信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("getOneWorkPiece")]
        public async Task<WorkPieceInfoOutput> getOneWorkPiece([FromQuery] WorkPieceProcessPdaSearch input) 
        {
            if (string.IsNullOrEmpty(input.WorkPieceID))
            {
                throw Oops.Oh($"请输入待查询工件号！");
            }
            var workPieceInfo = await _workPieceInfoRep.DetachedEntities
               .Join(_equipmentBaseInfoRep.DetachedEntities, a => a.EquipmentID, b => b.EquipmentId, (a, b) => new { a, b })
               .Join(_equipmentCurrentMonitorRep.DetachedEntities, c => c.a.EquipmentID, d => d.EquipmentID, (c, d) => new { c, d })
               //.Join(_sysDictDataRep.DetachedEntities, e => e.d.EquipmentCurrentState, f => f.Code, (e, f) => new { e, f })
               //.Join(_sysDictTypeRep.DetachedEntities, g => g.f.TypeId, h => h.Id, (f, g) => new { f, g })
               //.Where(x => (x.g.Code.Equals("equipment_state")))
               .Where(!string.IsNullOrEmpty(input.WorkPieceID), u => u.c.a.WorkPieceID == input.WorkPieceID)
               //.Where(u => u.f.e.c.a.IsDeleted == false)
               .Select(s => new WorkPieceInfoOutput
               {
                   Id = s.c.a.Id,
                   WorkPieceID = s.c.a.WorkPieceID,
                   WorkPieceState = s.c.a.WorkPieceState,
                   WorkingProcedureCurrent = s.c.a.WorkingProcedureCurrent,
                   WorkingProcedureStartTime = s.c.a.WorkingProcedureStartTime,
                   WorkingProcedureEndTime = s.c.a.WorkingProcedureEndTime,
                   QualityState = s.c.a.QualityState,
                   QualityErrorInfo = s.c.a.QualityErrorInfo,
                   EquipmentID = s.c.a.EquipmentID,
                   EquipmentName = s.c.b.EquipmentName,
                   EquipmentCurrentState = s.d.EquipmentCurrentState,
                   //EquipmentCurrentStateName = s.f.f.Value,
                   WorkPieceCurrentPosition = s.c.a.WorkPieceCurrentPosition,
                   WorkPieceinitOnlineTime = s.c.a.WorkPieceinitOnlineTime,
                   WorkPieceLastOfflineTime = s.c.a.WorkPieceLastOfflineTime,
                   WorkingProcedureCompleted= s.c.a.WorkingProcedureCompleted,
                   OP80NewCode=s.c.a.OP80NewCode,
               })
               .ProjectToType<WorkPieceInfoOutput>().FirstOrDefaultAsync();
            if (workPieceInfo == null)
            {
                throw Oops.Oh($"工件号【{input.WorkPieceID}】没有找到相关信息！");
            }
            return workPieceInfo;
        }
        /// <summary>
        /// 查询非合格工件信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("getNoOkWorkPiece")]
        public async Task<List<WorkPieceInfoOutput>> Page(string queryStr)
        {
            var workPieceInfos = await _workPieceInfoRep.DetachedEntities
               .Join(_equipmentBaseInfoRep.DetachedEntities, a => a.EquipmentID, b => b.EquipmentId, (a, b) => new { a, b })
                ////.Join(_equipmentCurrentMonitorRep.DetachedEntities, c => c.a.EquipmentID, d => d.EquipmentID, (c, d) => new { c, d })
                // //.Join(_sysDictDataRep.DetachedEntities, e => e.d.EquipmentCurrentState, f => f.Code, (e, f) => new { e, f })
                // //.Join(_sysDictTypeRep.DetachedEntities, g => g.f.TypeId, h => h.Id, (f, g) => new { f, g })
                // //.Where(x => (x.g.Code.Equals("equipment_state")))
                .Where(u => u.a.QualityState != (int)EnumQualityState.OK)
                  .Where(u => u.a.IsDeleted == false)
                  .Where(o => o.a.WorkPieceID.Contains(queryStr ?? "")|| o.a.QualityErrorInfo.Contains(queryStr ?? ""))
                 //.Where(o => (o.a.QualityStateUpdateTime.HasValue ? o.a.QualityStateUpdateTime.Value : DateTime.MinValue) > DateTime.Now.AddDays(-7))
                 .Where(o => !string.IsNullOrEmpty(o.a.WorkPieceID))
                 .Select(s => new WorkPieceInfoOutput
                 {
                     Id = s.a.Id,
                     WorkPieceID = s.a.WorkPieceID,
                     WorkPieceState = s.a.WorkPieceState,
                     WorkingProcedureCurrent = s.a.WorkingProcedureCurrent,
                     WorkPieceCurrentPosition = s.a.WorkPieceCurrentPosition,
                     WorkingProcedureStartTime = s.a.WorkingProcedureStartTime,
                     WorkingProcedureEndTime = s.a.WorkingProcedureEndTime,
                     WorkingProcedureCompleted = s.a.WorkingProcedureCompleted,
                     WorkPieceinitOnlineTime = s.a.WorkPieceinitOnlineTime,
                     QualityState = s.a.QualityState,
                     QualityErrorInfo= s.a.QualityErrorInfo,
                     QualityStateUpdateTime=(s.a.QualityStateUpdateTime.HasValue? s.a.QualityStateUpdateTime.Value:DateTime.MinValue),
                     EquipmentID = s.a.EquipmentID,
                     EquipmentName = s.b.EquipmentName,
                     //EquipmentCurrentState = s.d.EquipmentCurrentState,
                     //EquipmentCurrentStateName = s.f.f.Value,
                     WorkPieceLastOfflineTime = s.a.WorkPieceLastOfflineTime,
                 })
                 .OrderByDescending(o => o.QualityStateUpdateTime)
                 .ProjectToType<WorkPieceInfoOutput>().ToListAsync();
            return workPieceInfos;
        }
        /// <summary>
        /// 关闭设备告警信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("UpdateAlertStatus")]
        public async Task<int> UpdateAlertStatus(EquipmentAlertClose input)
        {
            var equipmentBaseInfo = await _equipmentBaseInfoRep.FirstOrDefaultAsync(u => u.EquipmentId == input.EquipmentId && u.IsDeleted == false);

            if (equipmentBaseInfo == null)
            {
                throw Oops.Oh($"设备{input.EquipmentId}不存在,不能关闭！");
            }
            if (string.IsNullOrEmpty(input.AlertType))
            {
                throw Oops.Oh($"未传入需关闭的告警类型,不能关闭！");
            }
            if (input.AlertType.Equals("1"))
            {
                equipmentBaseInfo.Detergentchangetime = DateTime.Now;
            }
            else if (input.AlertType.Equals("2"))
            {
                equipmentBaseInfo.KnifeToolChangeTime = DateTime.Now;
            }
            else if (input.AlertType.Equals("3"))
            {
                equipmentBaseInfo.CuttingFluidChangeTime = DateTime.Now;
            }
            else if (input.AlertType.Equals("4"))
            {
                var equipmentCurrentMonitor = await _equipmentCurrentMonitorRep.FirstOrDefaultAsync(u => u.EquipmentID == input.EquipmentId && u.IsDeleted == false);
                if (equipmentCurrentMonitor != null)
                {
                    equipmentCurrentMonitor.IsCloseAlert = true;
                }
            }
            else
            {
                throw Oops.Oh($"设备{input.EquipmentId}传入告警类型{input.AlertType}不存在,不能关闭！");
            }
            return 0;
        }

        /// <summary>
        /// 查询设备告警信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("getAlert")]
        public async Task<List<EquipmentAlertInfoOutput>> Page([FromQuery] EquipmentAlertSearch input)
        {
            var equipmentAlertInfos = await _v_GetEquipmentAlertRep.DetachedEntities
                                     .Where(!string.IsNullOrEmpty(input.EquipmentId), u => u.EquipmentId == input.EquipmentId)
                                     .Where(!string.IsNullOrEmpty(input.EquipmentName), u => EF.Functions.Like(u.EquipmentName, $"%{input.EquipmentName.Trim()}%"))
                                     .Where(!string.IsNullOrEmpty(input.WorkingProcedure), u => u.WorkingProcedure.Equals(input.WorkingProcedure))
                                     .Where(!string.IsNullOrEmpty(input.AlertType), u => (input.AlertType.Equals("1") && u.IsAlertDetergent)
                                     || (input.AlertType.Equals("2") && u.IsAlertKnifeTool)
                                     || (input.AlertType.Equals("3") && u.IsAlertCuttingFluid)
                                     || (input.AlertType.Equals("4") && u.IsAlert))
                                     .ProjectToType<EquipmentAlertInfoOutput>().ToListAsync();
            return equipmentAlertInfos;
        }


        /// <summary>
        /// 查询工件加工追溯
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet("getWorkPieceProcess")]
        public async Task<WorkPieceProcessPdaOutput> getWorkPieceProcess([FromQuery] WorkPieceProcessPdaSearch input)
        {
            var workPieceProcesss = await _workPieceProcessRep.DetachedEntities
                .Join(_equipmentBaseInfoRep.DetachedEntities, a => a.EquipmentID, b => b.EquipmentId, (a, b) => new { a, b })
              .Where(!string.IsNullOrEmpty(input.WorkPieceID), u => u.a.WorkPieceID.Equals(input.WorkPieceID))
              .Where(o => !string.IsNullOrEmpty(o.a.WorkPieceID))
               .Select(s => new WorkPieceProcessOutput
               {
                   Id = s.a.Id,
                   WorkPieceID = s.a.WorkPieceID,
                   WorkingProcedureCurrent = s.a.WorkingProcedureCurrent,
                   EquipmentID = s.a.EquipmentID,
                   EquipmentName = s.b.EquipmentName,
                   StartTime = s.a.StartTime,
                   EndTime = s.a.EndTime,
                   QualityState = s.a.QualityState,
                   OperationType = s.a.OperationType,
                   //QualityStateName = s.f.f.Value
               })
                                     .OrderByDescending(o => o.StartTime)
                                     .ProjectToType<WorkPieceProcessOutput>()
                                     .ToListAsync();
            WorkPieceProcessPdaOutput returenlist = new WorkPieceProcessPdaOutput();
            returenlist.WorkPieceID = workPieceProcesss.FirstOrDefault()?.WorkPieceID;
            returenlist.WorkPieceProcessList = workPieceProcesss;
            if (workPieceProcesss == null || workPieceProcesss.Count == 0)
            {
                throw Oops.Oh($"工件号【{input.WorkPieceID}】没有找到相关信息！");
            }
            return returenlist;
        }


        /// <summary>
        /// 修改工件质量状态
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("updateWorkPieceQualityState")]
        public async Task<string> updateWorkPieceQualityState([FromBody] UpdateQualityStateInput input)
        {
            if (input == null || input.WorkPieceIDList.Count == 0 || input.QualityState == null || input.Password == null)
            {
                throw Oops.Oh("修改工件质量状态失败：数据不能为空！");
            }
            if (!input.Password.Equals("123456"))
            {
                throw Oops.Oh("修改工件质量状态失败：密码输入错误！");
            }
            if (!(input.QualityState.Equals("1") || input.QualityState.Equals("2") || input.QualityState.Equals("3")))
            {
                throw Oops.Oh($"修改工件质量状态失败：传入待修改质量状态不对！");
            }

            List<WorkPieceInfo> workPieceInfolist = await _workPieceInfo.DetachedEntities.Where(w => input.WorkPieceIDList.Contains(w.WorkPieceID) && w.IsDeleted == false).ToListAsync();
            List<WorkPieceInfo> updateworkPieceInfo = new List<WorkPieceInfo>();
            List<WorkPieceInfoLog> addloglist = new List<WorkPieceInfoLog>();

            foreach (var item in input.WorkPieceIDList)
            {
                WorkPieceInfo workPieceInfo = workPieceInfolist.Where(w => w.WorkPieceID == item).FirstOrDefault();
                if (workPieceInfo is null)
                {
                    throw Oops.Oh($"修改工件质量状态失败：工件{item}不存在！");
                }

                if(int.Parse(input.QualityState)==(int)EnumQualityState.OK)
                {
                    workPieceInfo.QualityErrorInfo = "";
                }
                else
                {
                    workPieceInfo.QualityErrorInfo = input.QualityErrorInfo;
                }
                workPieceInfo.QualityState = int.Parse(input.QualityState);
                workPieceInfo.QualityStateUpdateMode = EnumQualityStateUpdateMode.Manual.ToString();
                workPieceInfo.QualityStateUpdateUser = CurrentUserInfo.Name;
                workPieceInfo.QualityStateUpdateTime = DateTime.Now;
                updateworkPieceInfo.Add(workPieceInfo);
                WorkPieceInfoLog infolog = EntityPropHelper.Mapper<WorkPieceInfoLog, WorkPieceInfo>(workPieceInfo);
                infolog.LogAddRemark = $"【{CurrentUserInfo.Name}】 PDA端手动修改质量信息[{workPieceInfo.QualityState ?? 0}]到[{input.QualityState}]";
                infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                infolog.WorkPieceInfoID = workPieceInfo.Id;
                infolog.LogAddTime = DateTime.Now;
                addloglist.Add(infolog);
            }
            await _workPieceInfoLogRep.InsertAsync(addloglist);
            await _workPieceInfo.UpdateAsync(updateworkPieceInfo);
            return "修改成功";
        }


        /// <summary>
        /// 修改工件信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("updateWorkPieceInfo")]
        public async Task<string> updateWorkPieceInfo([FromBody] UpdateQualityStateInput input)
        {
            if (input == null || input.WorkPieceIDList.Count == 0  || input.Password == null)
            {
                throw Oops.Oh("修改工件信息失败：传参不能为空！");
            }
            if (string.IsNullOrEmpty(input.QualityState) || string.IsNullOrEmpty(input.WorkPieceState) || string.IsNullOrEmpty(input.WorkingProcedure))
            {
                throw Oops.Oh("修改工件信息失败：质量状态、工件状态、工序信息 必须传值！");
            }
            if (!input.Password.Equals("123456"))
            {
                throw Oops.Oh("修改工件信息失败：密码输入错误！");
            }
            if (!(input.QualityState.Equals("1") || input.QualityState.Equals("2") || input.QualityState.Equals("3")))
            {
                throw Oops.Oh($"修改工件信息失败：传入质量状态[{input.QualityState}]不对！");
            }
            if (!(input.WorkPieceState.Equals("1") || input.WorkPieceState.Equals("2") || input.WorkPieceState.Equals("3") || input.WorkPieceState.Equals("4") || input.WorkPieceState.Equals("10")))
            {
                throw Oops.Oh($"修改工件信息失败：传入工件状态[{input.WorkPieceState}]不对！");
            }
            if (input.WorkingProcedure.Length!=4|| !input.WorkingProcedure.Contains("OP"))
            {
                throw Oops.Oh($"修改工件信息失败：传入工序[{input.WorkingProcedure}]不对！");
            }

            List<WorkPieceInfo> workPieceInfolist = await _workPieceInfo.DetachedEntities.Where(w => input.WorkPieceIDList.Contains(w.WorkPieceID) && w.IsDeleted == false).ToListAsync();
            List<WorkPieceInfo> updateworkPieceInfo = new List<WorkPieceInfo>();
            List<WorkPieceInfoLog> addloglist = new List<WorkPieceInfoLog>();

            foreach (var item in input.WorkPieceIDList)
            {
                WorkPieceInfo workPieceInfo = workPieceInfolist.Where(w => w.WorkPieceID == item).FirstOrDefault();
                if (workPieceInfo is null)
                {
                    throw Oops.Oh($"修改工件质量状态失败：工件{item}不存在！");
                }
                string LogAddRemark = "";
                if (workPieceInfo.QualityState!= int.Parse(input.QualityState))
                {
                    LogAddRemark += $"质量信息[{workPieceInfo.QualityState ?? 0}]到[{input.QualityState}]";
                    workPieceInfo.QualityState = int.Parse(input.QualityState);
                    workPieceInfo.QualityStateUpdateMode = EnumQualityStateUpdateMode.Manual.ToString();
                    workPieceInfo.QualityStateUpdateUser = CurrentUserInfo.Name;
                    workPieceInfo.QualityStateUpdateTime = DateTime.Now;
                    if (int.Parse(input.QualityState) == (int)EnumQualityState.OK)
                    {
                        workPieceInfo.QualityErrorInfo = "";
                    }
                    else
                    {
                        workPieceInfo.QualityErrorInfo = input.QualityErrorInfo;
                    }
                }
                if (workPieceInfo.WorkingProcedureCurrent != input.WorkingProcedure)
                {
                    LogAddRemark += $"工序 [{workPieceInfo.WorkingProcedureCurrent}]到[{input.WorkingProcedure}]";
                    workPieceInfo.WorkingProcedureCurrent = input.WorkingProcedure;
                }
                if (workPieceInfo.WorkPieceState != int.Parse(input.WorkPieceState))
                {
                    LogAddRemark += $"工件状态 [{workPieceInfo.WorkPieceState}]到[{input.WorkPieceState}]";
                    workPieceInfo.WorkPieceState = int.Parse(input.WorkPieceState);
                    if(workPieceInfo.WorkPieceState==(int)EnumWorkPieceState.FinishedProducts)
                    {
                        workPieceInfo.WorkPieceLastOfflineTime = DateTime.Now;
                    }
                    else
                    {
                        workPieceInfo.WorkPieceLastOfflineTime = null;
                    }
                }

                WorkPieceInfoLog infolog = EntityPropHelper.Mapper<WorkPieceInfoLog, WorkPieceInfo>(workPieceInfo);
                infolog.LogAddRemark = $"【{CurrentUserInfo.Name}】 PDA端手动修改工件信息: {LogAddRemark}";
                infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                infolog.WorkPieceInfoID = workPieceInfo.Id;
                infolog.LogAddTime = DateTime.Now;
                addloglist.Add(infolog);
                updateworkPieceInfo.Add(workPieceInfo);
            }
            await _workPieceInfo.UpdateAsync(updateworkPieceInfo);
            await _workPieceInfoLogRep.InsertAsync(addloglist);
            return "修改成功";
        }

        /// <summary>
        /// 查询OP80工件号获取工件信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("getWorkPieceByOP80NewCode")]
        public async Task<WorkPieceInfoOutput> getWorkPieceByOP80NewCode([FromQuery] WorkPieceByOP80NewCodeInputSearch input)
        {

            if (string.IsNullOrEmpty(input.OP80NewCode))
            {
                throw Oops.Oh($"请输入OP80打印成品码或二维码！");
            }
            string OP80NewCode = input.OP80NewCode.Trim();
            var workPieceInfo = await _workPieceInfoRep.DetachedEntities
               .Where(!string.IsNullOrEmpty(OP80NewCode), u => u.OP80NewCode == OP80NewCode||u.WorkPieceID== OP80NewCode)
               .Select(s => new WorkPieceInfoOutput
               {
                   Id = s.Id,
                   WorkPieceID = s.WorkPieceID,
                   OP80NewCode = s.OP80NewCode,
                   WorkPieceState = s.WorkPieceState,
                   WorkingProcedureCurrent = s.WorkingProcedureCurrent,
                   WorkingProcedureStartTime = s.WorkingProcedureStartTime,
                   WorkingProcedureEndTime = s.WorkingProcedureEndTime,
                   QualityState = s.QualityState,
                   QualityErrorInfo = s.QualityErrorInfo,
                   EquipmentID = s.EquipmentID,
                   WorkPieceCurrentPosition = s.WorkPieceCurrentPosition,
                   WorkPieceinitOnlineTime = s.WorkPieceinitOnlineTime,
                   WorkPieceLastOfflineTime = s.WorkPieceLastOfflineTime,
                   WorkingProcedureCompleted = s.WorkingProcedureCompleted,
               }).FirstOrDefaultAsync();
            if (workPieceInfo == null)
            {
                throw Oops.Oh($"OP80打印成品码或工件二维码【{OP80NewCode}】没有找到相关工件信息！");
            }
            return workPieceInfo;
        }

        /// <summary>
        /// 出库执行
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("outBoundWorkPiece")]
        public async Task<string> outBoundWorkPiece([FromBody] OutBoundInput input)
        {

            if (input.Password == null || !input.Password.Equals("123456"))
            {
                throw Oops.Oh("修改工件质量状态失败：密码输入错误！");
            }
            if (input.WorkPieceInfoLst.Count < 1)
            {
                throw Oops.Oh("工件出库失败：数据不能为空！");
            }

            List<WorkPieceInfoOutput> WorkPieceInfoLst = input.WorkPieceInfoLst;

            var addOutBoundList = new List<WorkPieceOutbound>();

            foreach (var item in WorkPieceInfoLst)
            {
                WorkPieceOutbound itemModel=await _workPieceOutboundRep.FirstOrDefaultAsync(w=>w.WorkPieceID==item.WorkPieceID);
                if (itemModel != null) {
                    itemModel.IsDeleted = true;
                    itemModel.Remark = itemModel.Remark ?? "" + "二次发货自动撤销发货";
                    await _workPieceOutboundRep.UpdateAsync(itemModel);
                }
                var outBoundLog = new WorkPieceOutbound
                {
                    WorkPieceID = item.WorkPieceID,
                    OP80NewCode = item.OP80NewCode,
                    WorkPieceOutboundTime = DateTime.Now,
                    WorkPieceOutboundUserId = CurrentUserInfo.UserId,
                    WorkPieceOutboundUserName = CurrentUserInfo.Name,
                    CreatedUserId = CurrentUserInfo.UserId,
                    CreatedUserName = CurrentUserInfo.Name,
                };
                addOutBoundList.Add(outBoundLog);
            }
            await _workPieceOutboundRep.InsertAsync(addOutBoundList);
            return "出库成功";
        }

    }
}