using AutoMapper;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_BasicRepository;
using WIDESEA_Common.MaterielEnum;
using WIDESEA_Common.OrderEnum;
using WIDESEA_Common.WareHouseEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Const;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO;
using WIDESEA_DTO.Basic;
using WIDESEA_DTO.ERP;
using WIDESEA_IBasicRepository;
using WIDESEA_IInboundRepository;
using WIDESEA_IInboundService;
using WIDESEA_InboundRepository;
using WIDESEA_Model.Models;

namespace WIDESEA_InboundService
{
    public class PurchaseOrderService : ServiceBase<Dt_PurchaseOrder, IPurchaseOrderRepository>, IPurchaseOrderService
    {
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IPurchaseOrderDetailRepository _purchaseOrderDetailRepository;
        private readonly IBasicRepository _basicRepository;
        private readonly ISupplierInfoRepository _supplierInfoRepository;
        private readonly IMaterielInfoRepository _materielInfoRepository;
        private readonly IMapper _mapper;

        public PurchaseOrderService(IPurchaseOrderRepository BaseDal, IPurchaseOrderDetailRepository purchaseOrderDetailRepository, IUnitOfWorkManage unitOfWorkManage, IBasicRepository basicRepository, ISupplierInfoRepository supplierInfoRepository, IMaterielInfoRepository materielInfoRepository,IMapper mapper) : base(BaseDal)
        {
            _purchaseOrderDetailRepository = purchaseOrderDetailRepository;
            _unitOfWorkManage = unitOfWorkManage;
            _basicRepository = basicRepository;
            _supplierInfoRepository = supplierInfoRepository;
            _materielInfoRepository = materielInfoRepository;
            _mapper = mapper;
        }

        //public override PageGridData<Dt_PurchaseOrder> GetPageData(PageDataOptions options)
        //{
        //    PageGridData<Dt_PurchaseOrder> pageGridData = base.GetPageData(options);

        //    ISugarQueryable<Dt_PurchaseOrder> sugarQueryable1 = BaseDal.Db.Queryable<Dt_PurchaseOrder>().Includes(x => x.Details);
        //    if (!string.IsNullOrEmpty(options.Wheres))
        //    {

        //        List<SearchParameters> searchParametersList = options.Wheres.DeserializeObject<List<SearchParameters>>();
        //        int totalCount = 0;
        //        if (searchParametersList.Count > 0)
        //        {
        //            {
        //                SearchParameters? searchParameters = searchParametersList.FirstOrDefault(x => x.Name == nameof(Dt_PurchaseOrderDetail.MaterielCode).FirstLetterToLower());
        //                if (searchParameters != null)
        //                {
        //                    sugarQueryable1 = sugarQueryable1.Where(x => x.Details.Any(v => v.MaterielCode.Contains(searchParameters.Value)));
        //                    List<Dt_PurchaseOrder> dataList = sugarQueryable1.ToPageList(options.Page, options.Rows, ref totalCount);
        //                    return new PageGridData<Dt_PurchaseOrder>(totalCount, dataList);
        //                }
        //            }

        //            {
        //                SearchParameters? searchParameters = searchParametersList.FirstOrDefault(x => x.Name == nameof(Dt_PurchaseOrderDetail.WarehouseId).FirstLetterToLower());
        //                if (searchParameters != null && int.TryParse(searchParameters.Value, out int warehouseId))
        //                {
        //                    sugarQueryable1 = sugarQueryable1.Where(x =>x.Details.Any(v => v.WarehouseId == warehouseId));
        //                    List<Dt_PurchaseOrder> dataList = sugarQueryable1.ToPageList(options.Page, options.Rows, ref totalCount);
        //                    return new PageGridData<Dt_PurchaseOrder>(totalCount, dataList);
        //                }
        //            }
        //        }
        //    }
        //    return pageGridData;
        //}
        /// <summary>
        /// 接收ERP采购入库信息
        /// </summary>
        /// <returns></returns>
        public WebResponseContent ReceivePurchaseOrder(ERPPurchaseOrderDTO eRPPurchaseOrderDTO)
        {
            WebResponseContent content=new WebResponseContent();
            try
            {
                if (eRPPurchaseOrderDTO == null)
                {
                    return content.Error("采购信息不能传入为空");
                }
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x=>x.WarehouseCode==eRPPurchaseOrderDTO.WarehouseCode);
                if (warehouse==null)
                {
                    return content.Error($"仓库信息不存在{eRPPurchaseOrderDTO.WarehouseCode}");
                }
                //获取所有物料 
                List<Dt_MaterielInfo> materielInfos = _basicRepository.MaterielInfoRepository.QueryData(x => x.WarehouseId == warehouse.WarehouseId && x.MaterielInvOrgId == MaterielInvOrgEnum.新厂.ObjToInt() );
                //获取所有供应商
                List<Dt_SupplierInfo> supplierInfos = _basicRepository.SupplierInfoRepository.QueryData(x => x.InvOrgId == MaterielInvOrgEnum.新厂.ObjToInt());
                //判断供应商
                Dt_SupplierInfo? supplierInfo = supplierInfos.FirstOrDefault(x => x.SupplierCode==eRPPurchaseOrderDTO.SupplierCode);
                if (supplierInfo == null)
                {
                    return content.Error($"采购{nameof(ERPPurchaseOrderDTO.PurchaseInCode)}:{eRPPurchaseOrderDTO.PurchaseInCode}供应商:{eRPPurchaseOrderDTO.SupplierCode}不存在");
                }
                //判断是否存在物料
                PurchaseInDetailItem? purchaseInDetailItem = eRPPurchaseOrderDTO.PurchaseInDetail.FirstOrDefault(x => !materielInfos.Select(x => x.MaterielCode).Contains(x.MaterialCode));
                if (purchaseInDetailItem != null)
                {
                    return content.Error($"采购条码{nameof(purchaseInDetailItem.Barcode)}:{purchaseInDetailItem.Barcode}物料:{purchaseInDetailItem.MaterialCode}不存在");
                }
                //获取所有采购信息
                List<Dt_PurchaseOrder> purchaseOrdersOld = BaseDal.Db.Queryable<Dt_PurchaseOrder>().Includes(x=>x.Details).ToList();

                if (eRPPurchaseOrderDTO.OperateType == 1)
                {
                    //判断重复插入
                    Dt_PurchaseOrder? purchaseOrderOld = purchaseOrdersOld.FirstOrDefault(x => x.PurchaseOrderNo == eRPPurchaseOrderDTO.PurchaseInCode);
                    if (purchaseOrderOld != null)
                    {
                        return content.Error($"采购单单号{purchaseOrderOld.PurchaseOrderNo}信息已存在");
                    }
                    List<Dt_PurchaseOrderDetail> purchaseOrderDetails = eRPPurchaseOrderDTO.PurchaseInDetail.Select(x => _mapper.Map<Dt_PurchaseOrderDetail>(x)).ToList();
                    Dt_PurchaseOrder purchaseOrder = _mapper.Map<Dt_PurchaseOrder>(eRPPurchaseOrderDTO);
                    purchaseOrderDetails.ForEach(x =>
                    {
                        Dt_MaterielInfo? materielInfo = materielInfos.FirstOrDefault(t => t.MaterielCode == x.MaterialCode);
                        x.MaterielName = materielInfo?.MaterielName;
                        x.Unit = materielInfo?.MaterielUnit;
                        x.MaterielSpec=  materielInfo?.MaterielSpec;
                    });
                    purchaseOrder.Details = purchaseOrderDetails;
                    purchaseOrder.WarehouseId = warehouse.WarehouseId;
                    //新增
                    BaseDal.Db.InsertNav(purchaseOrder).Include(x=>x.Details).ExecuteCommand();

                }
                //else if (eRPPurchaseOrderDTO.OperateType == 2)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    Dt_UserInfo userInfo = _mapper.Map<Dt_UserInfo>(eRPUserInfoDTO);
                //    userInfo.Id = userInfoOld.Id;
                //    Sys_User user = _userRepository.QueryFirst(x => x.UserName == userInfo.Code);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}，WMS账号不存在");
                //    }
                //    user.Enable = (byte)userInfo.State;
                //    user.UserTrueName = userInfo.Name;
                //    //更新
                //    BaseDal.UpdateData(userInfo);
                //    _userRepository.UpdateData(user);
                //}
                //else if (eRPPurchaseOrderDTO.OperateType == 3)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    BaseDal.DeleteData(userInfoOld);
                //}
                else
                {
                    return content.Error("未找到操作类型");
                }
                //更新数据
                return content.OK("接收成功");
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 接收ERP采购退货信息
        /// </summary>
        /// <returns></returns>
        public WebResponseContent ReceivePurchaseReturn(ERPReturnOrderDTO eRPReturnOrderDTO)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                if (eRPReturnOrderDTO == null)
                {
                    return content.Error("退料信息不能为空");
                }
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == eRPReturnOrderDTO.WarehouseCode);
                if (warehouse == null)
                {
                    return content.Error($"仓库信息不存在{eRPReturnOrderDTO.WarehouseCode}");
                }
                //获取所有物料 
                List<Dt_MaterielInfo> materielInfos = _basicRepository.MaterielInfoRepository.QueryData(x => x.WarehouseId == warehouse.WarehouseId && x.MaterielInvOrgId == MaterielInvOrgEnum.新厂.ObjToInt());
                //判断是否存在物料
                ReturnDetailItem? returnDetailItem = eRPReturnOrderDTO.ReturnDetail.FirstOrDefault(x => !materielInfos.Select(x => x.MaterielCode).Contains(x.MaterialCode));
                if (returnDetailItem != null)
                {
                    return content.Error($"采购条码{nameof(returnDetailItem.BarCode)}:{returnDetailItem.BarCode}物料:{returnDetailItem.MaterialCode}不存在");
                }
                //获取所有退货信息
                List<Dt_ReturnOutOrder> returnOutOrdersOld = BaseDal.Db.Queryable<Dt_ReturnOutOrder>().Includes(x => x.Details).ToList();

                if (eRPReturnOrderDTO.OperateType == 1)
                {
                    //判断重复插入
                    Dt_ReturnOutOrder? returnOutOrderOld = returnOutOrdersOld.FirstOrDefault(x => x.ReturnNo == eRPReturnOrderDTO.ReturnCode);
                    if (returnOutOrderOld != null)
                    {
                        return content.Error($"退货   单号{returnOutOrderOld.ReturnNo}信息已存在");
                    }
                    List<Dt_ReturnOutOrderDetail> returnOutOrderDetails = eRPReturnOrderDTO.ReturnDetail.Select(x => _mapper.Map<Dt_ReturnOutOrderDetail>(x)).ToList();
                    Dt_ReturnOutOrder returnOutOrderAdd = _mapper.Map<Dt_ReturnOutOrder>(eRPReturnOrderDTO);
                    returnOutOrderDetails.ForEach(x =>
                    {
                        Dt_MaterielInfo? materielInfo = materielInfos.FirstOrDefault(t => t.MaterielCode == x.MaterialCode);
                        x.MaterielName = materielInfo?.MaterielName;
                        x.Unit = materielInfo?.MaterielUnit;
                    });
                    returnOutOrderAdd.Details = returnOutOrderDetails;
                    returnOutOrderAdd.WarehouseId = warehouse.WarehouseId;
                    //新增
                    BaseDal.Db.InsertNav(returnOutOrderAdd).Include(x => x.Details).ExecuteCommand();

                }
                //else if (eRPPurchaseOrderDTO.OperateType == 2)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    Dt_UserInfo userInfo = _mapper.Map<Dt_UserInfo>(eRPUserInfoDTO);
                //    userInfo.Id = userInfoOld.Id;
                //    Sys_User user = _userRepository.QueryFirst(x => x.UserName == userInfo.Code);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}，WMS账号不存在");
                //    }
                //    user.Enable = (byte)userInfo.State;
                //    user.UserTrueName = userInfo.Name;
                //    //更新
                //    BaseDal.UpdateData(userInfo);
                //    _userRepository.UpdateData(user);
                //}
                //else if (eRPPurchaseOrderDTO.OperateType == 3)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    BaseDal.DeleteData(userInfoOld);
                //}
                else
                {
                    return content.Error("未找到操作类型");
                }
                //更新数据
                return content.OK("接收成功");
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 接收ERP成品销售出库信息
        /// </summary>
        /// <returns></returns>
        public WebResponseContent ReceiveProDeliveryOrder(ERPProDeliveryDTO eRPProDeliveryDTO)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                if (eRPProDeliveryDTO == null)
                {
                    return content.Error("销售出库信息不能为空");
                }
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == eRPProDeliveryDTO.WarehouseCode);
                if (warehouse == null)
                {
                    return content.Error($"仓库信息不存在{eRPProDeliveryDTO.WarehouseCode}");
                }
                //获取所有物料 
                List<Dt_MaterielInfo> materielInfos = _basicRepository.MaterielInfoRepository.QueryData(x => x.WarehouseId == warehouse.WarehouseId && x.MaterielInvOrgId == MaterielInvOrgEnum.新厂.ObjToInt());

                //获取所有客户
                List<Dt_CustomerInfo> customerInfos  = _basicRepository.CustomerInfoRepository.QueryData();

                //判断是否存在物料
                DeliveryDetailItem? deliveryDetailItem = eRPProDeliveryDTO.DeliveryDetail.FirstOrDefault(x => !materielInfos.Select(x => x.MaterielCode).Contains(x.MaterialCode));
                if (deliveryDetailItem != null)
                {
                    return content.Error($"物料信息{deliveryDetailItem.MaterialCode}不存在");
                }

                //判断是否存在客户
                DeliveryDetailItem? deliveryDetailCustom = eRPProDeliveryDTO.DeliveryDetail.FirstOrDefault(x => !customerInfos.Select(x => x.CustomerCode).Contains(x.Customer));

                if (deliveryDetailCustom != null)
                {
                    return content.Error($"客户信息{deliveryDetailCustom.Customer}不存在");
                }

                //获取所有销售出库信息
                List<Dt_ProDeliveryOrder> proDeliveryOrdersOld = BaseDal.Db.Queryable<Dt_ProDeliveryOrder>().Includes(x => x.Details).ToList();

                if (eRPProDeliveryDTO.OperateType == 1)
                {
                    //判断重复插入
                    Dt_ProDeliveryOrder? proDeliveryOrderOld = proDeliveryOrdersOld.FirstOrDefault(x => x.DeliveryCode == eRPProDeliveryDTO.DeliveryCode);
                    if (proDeliveryOrderOld != null)
                    {
                        return content.Error($"销售出库单号{proDeliveryOrderOld.DeliveryCode}信息已存在");
                    }
                    List<Dt_ProDeliveryOrderDetail> proDeliveryOrderDetails = eRPProDeliveryDTO.DeliveryDetail.Select(x => _mapper.Map<Dt_ProDeliveryOrderDetail>(x)).ToList();
                    Dt_ProDeliveryOrder proDeliveryOrderAdd = _mapper.Map<Dt_ProDeliveryOrder>(eRPProDeliveryDTO);
                    proDeliveryOrderDetails.ForEach(x =>
                    {
                        Dt_MaterielInfo? materielInfo = materielInfos.FirstOrDefault(t => t.MaterielCode == x.MaterialCode);
                        x.MaterielName = materielInfo?.MaterielName;
                        x.Unit = materielInfo?.MaterielUnit;
                    });
                    proDeliveryOrderAdd.Details = proDeliveryOrderDetails;
                    proDeliveryOrderAdd.WarehouseId = warehouse.WarehouseId;
                    //新增
                    BaseDal.Db.InsertNav(proDeliveryOrderAdd).Include(x => x.Details).ExecuteCommand();

                }
                //else if (eRPPurchaseOrderDTO.OperateType == 2)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    Dt_UserInfo userInfo = _mapper.Map<Dt_UserInfo>(eRPUserInfoDTO);
                //    userInfo.Id = userInfoOld.Id;
                //    Sys_User user = _userRepository.QueryFirst(x => x.UserName == userInfo.Code);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}，WMS账号不存在");
                //    }
                //    user.Enable = (byte)userInfo.State;
                //    user.UserTrueName = userInfo.Name;
                //    //更新
                //    BaseDal.UpdateData(userInfo);
                //    _userRepository.UpdateData(user);
                //}
                //else if (eRPPurchaseOrderDTO.OperateType == 3)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    BaseDal.DeleteData(userInfoOld);
                //}
                else
                {
                    return content.Error("未找到操作类型");
                }
                //更新数据
                return content.OK("接收成功");
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 接收ERP非生产领料信息
        /// </summary>
        /// <returns></returns>
        public WebResponseContent ReceiveOutOrder(ERPPickOutOrderDTO eRPPickOutOrderDTO)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                if (eRPPickOutOrderDTO == null)
                {
                    return content.Error("出库信息不能为空");
                }
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == eRPPickOutOrderDTO.WarehouseCode);
                if (warehouse == null)
                {
                    return content.Error($"仓库信息不存在{eRPPickOutOrderDTO.WarehouseCode}");
                }
                //获取所有物料 
                List<Dt_MaterielInfo> materielInfos = _basicRepository.MaterielInfoRepository.QueryData(x => x.WarehouseId == warehouse.WarehouseId && x.MaterielInvOrgId == MaterielInvOrgEnum.新厂.ObjToInt());

                //判断是否存在物料
                PickDetailItem? deliveryDetailItem = eRPPickOutOrderDTO.PickDetail.FirstOrDefault(x => !materielInfos.Select(x => x.MaterielCode).Contains(x.MaterialCode));
                if (deliveryDetailItem != null)
                {
                    return content.Error($"物料信息{deliveryDetailItem.MaterialCode}不存在");
                }

                //获取所有信息
                List<Dt_PickOutOrder> outOrders = BaseDal.Db.Queryable<Dt_PickOutOrder>().Includes(x => x.Details).ToList();

                if (eRPPickOutOrderDTO.OperateType == 1)
                {
                    //判断重复插入
                    Dt_PickOutOrder? pickOutOrderOld = outOrders.FirstOrDefault(x => x.PickCode == eRPPickOutOrderDTO.PickCode);
                    if (pickOutOrderOld != null)
                    {
                        return content.Error($"单号{pickOutOrderOld.PickCode}信息已存在");
                    }
                    List<Dt_PickOutOrderDetail> pickOutOrderDetails = eRPPickOutOrderDTO.PickDetail.Select(x => _mapper.Map<Dt_PickOutOrderDetail>(x)).ToList();
                    Dt_PickOutOrder pickOutOrderAdd = _mapper.Map<Dt_PickOutOrder>(eRPPickOutOrderDTO);
                    pickOutOrderDetails.ForEach(x =>
                    {
                        Dt_MaterielInfo? materielInfo = materielInfos.FirstOrDefault(t => t.MaterielCode == x.MaterialCode);
                        x.MaterielName = materielInfo?.MaterielName;
                        x.Unit = materielInfo?.MaterielUnit;
                    });
                    pickOutOrderAdd.Details = pickOutOrderDetails;
                    pickOutOrderAdd.WarehouseId = warehouse.WarehouseId;
                    //新增
                    BaseDal.Db.InsertNav(pickOutOrderAdd).Include(x => x.Details).ExecuteCommand();

                }
                //else if (eRPPurchaseOrderDTO.OperateType == 2)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    Dt_UserInfo userInfo = _mapper.Map<Dt_UserInfo>(eRPUserInfoDTO);
                //    userInfo.Id = userInfoOld.Id;
                //    Sys_User user = _userRepository.QueryFirst(x => x.UserName == userInfo.Code);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}，WMS账号不存在");
                //    }
                //    user.Enable = (byte)userInfo.State;
                //    user.UserTrueName = userInfo.Name;
                //    //更新
                //    BaseDal.UpdateData(userInfo);
                //    _userRepository.UpdateData(user);
                //}
                //else if (eRPPurchaseOrderDTO.OperateType == 3)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    BaseDal.DeleteData(userInfoOld);
                //}
                else
                {
                    return content.Error("未找到操作类型");
                }
                //更新数据
                return content.OK("接收成功");
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
        /// <summary>
        /// 接收ERP成品销售退货信息
        /// </summary>
        /// <returns></returns>
        public WebResponseContent ReceiveProDeliveryBackOrder(ERPProDeliverBackDTO eRPProDeliverBackDTO)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                if (eRPProDeliverBackDTO == null)
                {
                    return content.Error("销售退货信息不能为空");
                }
                Dt_Warehouse warehouse = _basicRepository.WarehouseRepository.QueryFirst(x => x.WarehouseCode == eRPProDeliverBackDTO.WarehouseCode);
                if (warehouse == null)
                {
                    return content.Error($"仓库信息不存在{eRPProDeliverBackDTO.WarehouseCode}");
                }
                //获取所有物料 
                List<Dt_MaterielInfo> materielInfos = _basicRepository.MaterielInfoRepository.QueryData(x => x.WarehouseId == warehouse.WarehouseId && x.MaterielInvOrgId == MaterielInvOrgEnum.新厂.ObjToInt());

                //判断是否存在物料
                DeliveryBackDetailItem? deliveryBackDetailItem = eRPProDeliverBackDTO.DeliveryBackDetail.FirstOrDefault(x => !materielInfos.Select(x => x.MaterielCode).Contains(x.MaterialCode));
                if (deliveryBackDetailItem != null)
                {
                    return content.Error($"物料信息{deliveryBackDetailItem.MaterialCode}不存在");
                }

                //获取所有客户
                List<Dt_CustomerInfo> customerInfos = _basicRepository.CustomerInfoRepository.QueryData();
                //判断是否存在客户
                DeliveryBackDetailItem? CheckCustomerCode = eRPProDeliverBackDTO.DeliveryBackDetail.FirstOrDefault(x => !customerInfos.Select(x => x.CustomerCode).Contains(x.Customer));

                if (CheckCustomerCode != null)
                {
                    return content.Error($"客户信息{CheckCustomerCode.Customer}不存在");
                }
                //获取所有销售出库信息
                List<Dt_ProDeliveryOrder> proDeliveryOrdersOld = BaseDal.Db.Queryable<Dt_ProDeliveryOrder>().Includes(x => x.Details).ToList();
                //判断是否存在销售发货单号
                DeliveryBackDetailItem? CheckDeliveryCode = eRPProDeliverBackDTO.DeliveryBackDetail.FirstOrDefault(x => !customerInfos.Select(x => x.CustomerCode).Contains(x.Customer));
                if (CheckDeliveryCode != null)
                {
                    return content.Error($"客户信息{CheckDeliveryCode.DeliveryCode}不存在");
                }
                //获取所有信息
                List<Dt_ProDeliverBackOrder> outOrders = BaseDal.Db.Queryable<Dt_ProDeliverBackOrder>().Includes(x => x.Details).ToList();

                if (eRPProDeliverBackDTO.OperateType == 1)
                {
                    //判断重复插入
                    Dt_ProDeliverBackOrder? proDeliverBackOrderOld = outOrders.FirstOrDefault(x => x.DeliveryBackCode == eRPProDeliverBackDTO.DeliveryBackCode);
                    if (proDeliverBackOrderOld != null)
                    {
                        return content.Error($"单号{proDeliverBackOrderOld.DeliveryBackCode}信息已存在");
                    }
                    List<Dt_ProDeliverBackOrderDetail> proDeliverBackOrderDetails = eRPProDeliverBackDTO.DeliveryBackDetail.Select(x => _mapper.Map<Dt_ProDeliverBackOrderDetail>(x)).ToList();
                    Dt_ProDeliverBackOrder proDeliverBackOrderAdd = _mapper.Map<Dt_ProDeliverBackOrder>(eRPProDeliverBackDTO);
                    proDeliverBackOrderDetails.ForEach(x =>
                    {
                        Dt_MaterielInfo? materielInfo = materielInfos.FirstOrDefault(t => t.MaterielCode == x.MaterialCode);
                        x.MaterielName = materielInfo?.MaterielName;
                        x.Unit = materielInfo?.MaterielUnit;
                    });
                    proDeliverBackOrderAdd.Details = proDeliverBackOrderDetails;
                    proDeliverBackOrderAdd.WarehouseId = warehouse.WarehouseId;
                    //新增
                    BaseDal.Db.InsertNav(proDeliverBackOrderAdd).Include(x => x.Details).ExecuteCommand();

                }
                //else if (eRPPurchaseOrderDTO.OperateType == 2)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    Dt_UserInfo userInfo = _mapper.Map<Dt_UserInfo>(eRPUserInfoDTO);
                //    userInfo.Id = userInfoOld.Id;
                //    Sys_User user = _userRepository.QueryFirst(x => x.UserName == userInfo.Code);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}，WMS账号不存在");
                //    }
                //    user.Enable = (byte)userInfo.State;
                //    user.UserTrueName = userInfo.Name;
                //    //更新
                //    BaseDal.UpdateData(userInfo);
                //    _userRepository.UpdateData(user);
                //}
                //else if (eRPPurchaseOrderDTO.OperateType == 3)
                //{
                //    //判断是否存在
                //    Dt_UserInfo? userInfoOld = OlduserInfos.FirstOrDefault(x => x.Code == eRPUserInfoDTO.StaffCode);
                //    if (userInfoOld == null)
                //    {
                //        return content.Error($"更新工号{eRPUserInfoDTO.StaffCode}，员工{eRPUserInfoDTO.StaffName}不存在");
                //    }
                //    BaseDal.DeleteData(userInfoOld);
                //}
                else
                {
                    return content.Error("未找到操作类型");
                }
                //更新数据
                return content.OK("接收成功");
            }
            catch (Exception ex)
            {
                content.Error(ex.Message);
            }
            return content;
        }
    }
}