using JiepeiWMS.Common.Config;
using JiepeiWMS.Common.Enums;
using JiepeiWMS.Common.Helper;
using JiepeiWMS.Common.HttpContextUser;
using JiepeiWMS.Extends;
using JiepeiWMS.IRepository.UnitOfWork;
using JiepeiWMS.IServices;
using JiepeiWMS.Model;
using JiepeiWMS.Model.Models;
using JiepeiWMS.Model.ViewModels;
using JiepeiWMS.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using SqlSugar;
using StackExchange.Profiling.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Security.Claims;
using System.Threading.Tasks;


namespace JiepeiWMS.Api.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    [Authorize(Permissions.Name)]
    public class WMPurchaseInfoController : ControllerBase
    {
        /// <summary>
        /// 服务器接口，因为是模板生成，所以首字母是大写的，自己可以重构下
        /// </summary>
        private readonly IWMPurchaseInfoServices _wMPurchaseInfoServices;
        private readonly IUser _user;
        private readonly IWMWareHouseServices _WMWareHouseServices;
        private readonly IDepartmentServices _DepartmentServices;
        private readonly ISysUserInfoServices _sysUserInfoServices;
        private readonly ILogger<WMPurchaseInfoController> _logger;
        private readonly IWMPurchaseQuoteDetailServices _WMPurchaseQuoteDetailServices;
        private readonly IWMProductListServices _WMProductListServices;
        private readonly IWMCheckInfoServices _BllCheckInfo;
        private readonly IRoleServices _roleServices;
        private readonly IWMProductInfoServices _WMProductInfoServices;
        private readonly IWMStockLogServices _WMStockLogServices;
        private readonly IWMProductSpecServices _WMProductSpecServices;
        private readonly IUnitOfWork _unitOfWork;
        private readonly IWMPurchaseInfoLogServices _WMPurchaseInfoLogServices;
        private readonly IWMProductUnitServices _WMProductUnitServices;

        #region 视图

        public WMPurchaseInfoController(IWMPurchaseInfoServices WMPurchaseInfoServices
            , IUser user
            , ISysUserInfoServices sysUserInfoServices
            , IDepartmentServices DepartmentServices
            , ILogger<WMPurchaseInfoController> logger
            , IWMPurchaseQuoteDetailServices WMPurchaseQuoteDetailServices
            , IWMProductListServices WMProductListServices
            , IWMCheckInfoServices BllCheckInfo
            , IRoleServices roleServices
            , IWMProductInfoServices WMProductInfoServices
            , IWMStockLogServices WMStockLogServices
            , IWMWareHouseServices WMWareHouseServices
            , IWMProductSpecServices WMProductSpecServices
            , IUnitOfWork unitOfWork
            , IWMPurchaseInfoLogServices WMPurchaseInfoLogServices
            , IWMProductUnitServices WMProductUnitServices)
        {
            _wMPurchaseInfoServices = WMPurchaseInfoServices;
            _user = user;
            _sysUserInfoServices = sysUserInfoServices;
            _DepartmentServices = DepartmentServices;
            _logger = logger;
            _WMPurchaseQuoteDetailServices = WMPurchaseQuoteDetailServices;
            _WMProductListServices = WMProductListServices;
            _BllCheckInfo = BllCheckInfo;
            _roleServices = roleServices;
            _WMProductInfoServices = WMProductInfoServices;
            _WMStockLogServices = WMStockLogServices;
            _WMWareHouseServices = WMWareHouseServices;
            _WMProductSpecServices = WMProductSpecServices;
            _unitOfWork = unitOfWork;
            _WMPurchaseInfoLogServices = WMPurchaseInfoLogServices;
            _WMProductUnitServices = WMProductUnitServices;
        }

        /// <summary>
        /// 采购列表
        /// </summary>
        /// <param name="page">默认显示第几页</param>
        /// <param name="key">入库编号</param>
        /// <param name="StatusOptions">状态查询</param>
        /// <param name="startdate">开始时间</param>
        /// <param name="enddate">结束时间</param>
        /// <param name="intPageSize">一页多少条数据</param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<PageModel<WMPurchaseInfo>>> Get(int page = 1, string key = "", string StatusOptions = "", DateTime? startdate = null, DateTime? enddate = null, int intPageSize = 20)
        {
            Expression<Func<WMPurchaseInfo, bool>> whereExpression = w => w.Id > 0;
            //int Status = -1;
            if (string.IsNullOrEmpty(key) || string.IsNullOrWhiteSpace(key))
            {
                key = "";

            }
            whereExpression = whereExpression.And(w => w.PurchaseCode.Contains(key.Trim()));
            //var b = await _sysUserInfoServices.IsUserIdIntoRoleName(_user.ID, RoleConfig.SaleCangKuStaff);

            //if (b) { Status = EnumWMPurchaseStatus.CheckedPass.GetHashCode(); }
            //状态筛选
            if (!string.IsNullOrWhiteSpace(StatusOptions))
            {
                whereExpression = whereExpression.And(w => w.Status == StatusOptions.ObjToInt());
            }
            whereExpression = whereExpression.And(w => w.Status != -1);
            //开始时间
            if (startdate != null)
            {
                whereExpression = whereExpression.And(w => w.CreateTime >= startdate);
            }
            //结束时间
            if (enddate != null)
            {
                whereExpression = whereExpression.And(w => w.CreateTime <= enddate);
            }
            //获取角色信息,判断是否数据展示
            var role = string.Join(",", _user.GetClaimValueByType(ClaimTypes.Role));
            if (role.Contains("SuperAdmin") || role.Contains("仓库管理员") || role.Contains("超级管理员"))
            {
                whereExpression = whereExpression.And(w => w.Id > 0);
            }
            if (role.Contains("审批人员"))
            {
                //显示对应审批人对应数据
                whereExpression = whereExpression.And(w => w.CheckAdminId == _user.ID);
            }
            if (role.Contains("生产人员"))
            {
                //根据采购申请人能看到自己发起的采购单
                whereExpression = whereExpression.And(w => w.EmployeeId == _user.ID);
            }
            //显示当前操作人的主体ID
            whereExpression = whereExpression.And(w => w.SysOrgId == _user.SysOrgId);


            //var data = await _wMPurchaseInfoServices.QueryPage(a => a.Type >= 0 && ((a.PurchaseCode != null && a.PurchaseCode.Contains(key))), page, intPageSize, " Id desc ");
            //var a = _wMPurchaseInfoServices.QueryTable("");
            //var WmpurchaseUserDeparment = await _wMPurchaseInfoServices.QueryMuchTablePurchaseInfo();

            //分页加多表查询
            var PageList = await _wMPurchaseInfoServices.QueryTabsPage<WMPurchaseInfo, sysUserInfo, sysUserInfo, Department, WMWareHouse, WMPurchaseInfo>(
                    (w, su, su2, dp, wm) => new object[]
                {
                 JoinType.Left,su.uID==w.EmployeeId,
                  JoinType.Left,su2.uID==w.CheckAdminId,
                 JoinType.Left,su.DepartmentId==dp.Id,
                 JoinType.Left,w.WareHouseId==wm.Id,


                },
                (w, su, su2, dp, wm) => new WMPurchaseInfo()
                {
                    Id = w.Id,
                    Type = w.Type,
                    CheckAdminId = w.CheckAdminId,
                    WareHouseId = w.WareHouseId,
                    CheckKey = w.CheckKey,
                    EmployeeId = w.EmployeeId,
                    CheckRank = w.CheckRank,
                    CheckRemark = w.CheckRemark,
                    PurchaseCode = w.PurchaseCode,
                    Status = w.Status,
                    CreateTime = w.CreateTime,
                    UpdateTime = w.UpdateTime,
                    UName = su.uRealName,
                    DName = dp.Name,
                    Remark = w.Remark,
                    ProductUse = w.ProductUse,
                    WareHouseName = wm.Name,
                    CheckName = su2.uRealName,
                    SysOrgId = w.SysOrgId

                },
              whereExpression,
                page,
                intPageSize,
                " w.Id desc"
                );
            //获取审批枚举状态
            var dicStatus = typeof(EnumWMPurchaseStatus)._GetValueDescriptionDicFromEnumType<EnumWMPurchaseStatus>();
            foreach (var item in PageList.data)
            {
                string name;
                item.StatusName = dicStatus.TryGetValue((EnumWMPurchaseStatus)item.Status, out name) ? name : string.Empty;
            }
            //获取采购枚举状态
            var dicType = typeof(EnumWMPurchaseType)._GetValueDescriptionDicFromEnumType<EnumWMPurchaseType>();
            foreach (var item in PageList.data)
            {
                string name;
                item.TypeName = dicType.TryGetValue((EnumWMPurchaseType)item.Type, out name) ? name : string.Empty;

                item.PurchaseQuoteDetailList = await _WMPurchaseQuoteDetailServices.Query(w => w.PurchaseId == item.Id);
                foreach (var item1 in item.PurchaseQuoteDetailList)
                {
                    //商品信息表
                    var ProductModel = await _WMProductListServices.GetModel(w => w.Id == item1.ProductId);
                    if (ProductModel != null)
                    {
                        item1.ProductName = ProductModel.Name;
                        //商品单位信息
                        var ProductSpecModel = await _WMProductSpecServices.GetModel(w => w.Id == ProductModel.SpecIds);
                        if (ProductSpecModel != null)
                        {
                            item1.ProductSpec = ProductSpecModel.Name;
                        }
                    }
                }
            }
            //data.data = WmpurchaseUserDeparment;

            return new MessageModel<PageModel<WMPurchaseInfo>>()
            {
                msg = "获取成功",
                success = PageList.dataCount > 0,
                response = PageList
            };

        }

        /// <summary>
        /// 采购详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<WMPurchaseInfo>> Detail(int Id = 0)
        {
            try
            {
                var model = await _wMPurchaseInfoServices.GetModel(w => w.Id == Id);
                model.PurchaseQuoteDetailList = await _WMPurchaseQuoteDetailServices.Query(w => w.PurchaseId == Id);
                //查出仓库模型
                var WMWareHouseModel = await _WMWareHouseServices.GetModel(w => w.Id == model.WareHouseId);
                //查出用户模型
                var UserModel = await _sysUserInfoServices.GetModel(u => u.uID == model.EmployeeId);
                if (UserModel != null)
                    model.UName = UserModel.uRealName;
                model.CheckName = UserModel.uRealName;
                //当前操作人
                model.currentID = _user.ID;
                //将当前时间赋值给扩展字段在前台展示出来
                model.Time = DateTime.Now;
                //部门名称
                var DepartmentModel = await _DepartmentServices.GetModel(d => d.Id == UserModel.DepartmentId);
                if (DepartmentModel != null)
                    model.DName = DepartmentModel.Name;

                if (WMWareHouseModel != null)
                    model.WareHouseName = WMWareHouseModel.Name;
                //获取审批枚举状态
                var dicStatus = typeof(EnumWMPurchaseStatus)._GetValueDescriptionDicFromEnumType<EnumWMPurchaseStatus>();
                string name;
                model.StatusName = dicStatus.TryGetValue((EnumWMPurchaseStatus)model.Status, out name) ? name : string.Empty;
                //获取采购枚举状态
                var dicType = typeof(EnumWMPurchaseType)._GetValueDescriptionDicFromEnumType<EnumWMPurchaseType>();
                model.TypeName = dicType.TryGetValue((EnumWMPurchaseType)model.Type, out name) ? name : string.Empty;

                //获取审批流
                var checkModel = await _BllCheckInfo.GetModel(w => w.SysOrgId == _user.SysOrgId && w.Key == model.CheckKey);

                if (checkModel != null)
                {
                    var rankList = JsonHelper.DeserializeObject<CheckRankList>(checkModel.Json);
                    var checkarr = rankList.checkRankList.Select(w => w.AdminName).ToArray();

                    model.CheckStrStep = checkarr.ToList();
                    model.CheckRankStep = model.CheckRank == 0 ? checkarr.Count() : (model.CheckRank - 1);
                }
                else
                {
                    model.CheckStrStep = new List<string>();
                    model.CheckRankStep = 0;
                }

                foreach (var item in model.PurchaseQuoteDetailList)
                {

                    //商品信息表
                    var ProductModel = await _WMProductListServices.GetModel(w => w.Id == item.ProductId);
                    if (ProductModel != null)
                    {
                        item.ProductName = ProductModel.Name;
                        item.ProductCode = ProductModel.Code;
                        //计算总价
                        item.ActualAmount = item.ActualAmount + (item.Quantity * ProductModel.Price);
                    }
                    else
                    {
                        item.ActualAmount = item.ActualAmount + item.Amount.Value;
                    }
                    //商品关联表
                    var _productInfo = await _WMProductInfoServices.GetModel(w => w.ProductListId == item.ProductId && w.WareHouseId == item.WareHouseId);
                    if (_productInfo != null)
                    {
                        item.StockNum = _productInfo.Quantity != null ? _productInfo.Quantity.Value : 0;
                        item.WeekNum = await _WMStockLogServices.GetStockNumByDateDay(item.ProductId, _productInfo.Id, 7, 1);

                        item.MonthNum = await _WMStockLogServices.GetStockNumByDateDay(item.ProductId, _productInfo.Id, 30, 1);

                        //商品单位信息
                        var ProductSpecModel = await _WMProductSpecServices.GetModel(w => w.Id == _productInfo.ProductSpecId);
                        if (ProductSpecModel != null)
                        {
                            item.ProductSpec = ProductSpecModel.Name;
                        }
                    }
                    if (model.Type == 1)
                    {

                        item.ActualAmount = item.ActualAmount + item.Amount.Value;
                    }
                    item.Quantity = item.Quantity;
                    item.CheckNum = item.Quantity;
                    item.PurchaseQUoteDetailRemark = item.Remark;
                    item.Checked = 1;

                    var dicQUoteDetailStatus = typeof(EnumWMPurchaseDetailStatus)._GetValueDescriptionDicFromEnumType<EnumWMPurchaseDetailStatus>();
                    string Qname;
                    item.PurchaseQUoteDetailStatusName = dicQUoteDetailStatus.TryGetValue((EnumWMPurchaseDetailStatus)item.Status, out Qname) ? Qname : string.Empty;

                }
                return new MessageModel<WMPurchaseInfo>()
                {
                    msg = "获取成功",
                    success = true,
                    response = model
                };
            }
            catch (Exception e)
            {
                _logger.LogError(e, e.Message);
                return new MessageModel<WMPurchaseInfo>()
                {
                    msg = e.Message,
                    success = false
                };
            }
        }

        /// <summary>
        /// 采购申请操作日志
        /// </summary>
        /// <param name="page"></param>
        /// <param name="intPageSize"></param>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<PageModel<WMPurchaseInfoLog>>> GetPurchaseInfoLog(int page = 1, int intPageSize = 20, int Id = 0)
        {

            Expression<Func<WMPurchaseInfoLog, bool>> whereExpression = wlog => wlog.OrderId == Id;

            whereExpression = whereExpression.And(wlog => wlog.OrderId == Id);

            var PageList = await _WMPurchaseInfoLogServices.QueryTabsPage<WMPurchaseInfoLog, sysUserInfo, WMPurchaseInfo, WMPurchaseInfoLog>
                (
                (wlog, s, w) => new object[]
                {
                        JoinType.Left,wlog.AdminId==s.uID,
                        JoinType.Left,wlog.OrderId==w.Id,
                },
                (wlog, s, w) => new WMPurchaseInfoLog
                {
                    AdminId = wlog.AdminId,
                    Content = wlog.Content,
                    CreateTime = wlog.CreateTime,
                    OrderId = wlog.OrderId,
                    Type = wlog.Type,
                    UName = s.uRealName,


                },
                whereExpression,
                page,
                intPageSize,
                "wlog.Id desc"
                );
            return new MessageModel<PageModel<WMPurchaseInfoLog>>()
            {

                msg = "获取成功",
                success = PageList.dataCount > 0,
                response = PageList
            };




        }
        #endregion

        #region 操作

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<MessageModel<string>> Post([FromBody] WMPurchaseInfo Model)
        {
            var msg = string.Empty;
            var data = new MessageModel<string>();
            try
            {
                //创建事务
                _unitOfWork.BeginTran();
                int PurchaseId = 0;
                //根据当前操作人查出用户的model
                var UserModel = await _sysUserInfoServices.GetModel(u => u.uID == _user.ID);
                //查出审批流
                var checkModel = await _BllCheckInfo.GetModel(w => w.SysOrgId == _user.SysOrgId && w.Key == "CGB");

                if (checkModel != null)
                {
                    Model.CheckKey = checkModel.Key;
                }
                else
                {
                    data.msg = "无法获取审批流，请联系管理员!";
                    throw new Exception("无法获取审批流，请联系管理员!");
                }
                if (string.IsNullOrEmpty(checkModel.Json))
                {
                    data.msg = "审批流为空，请联系管理员!";
                    throw new Exception("审批流为空，请联系管理员!");
                }
                var rankList = JsonHelper.DeserializeObject<CheckRankList>(checkModel.Json);
                var CheckRankModel = rankList.checkRankList.Where(w => w.CheckRank == 1).FirstOrDefault();
                if (CheckRankModel == null)
                {
                    data.msg = "无法获取审批人员信息，请联系管理员!";
                    throw new Exception("无法获取审批人员信息，请联系管理员！");
                }
                Model.CheckAdminId = CheckRankModel.AdminId;
                Model.CheckRank = 1;
                if (Model.Type == 1)
                    Model.Status = EnumWMPurchaseStatus.WaitCheck.GetHashCode();
                else
                {
                    var rolemodel = await _roleServices.GetModel(r => r.CreateId == _user.ID);
                    if (rolemodel != null && rolemodel.Name == RoleConfig.SaleCangKuStaff)

                        Model.Status = EnumWMPurchaseStatus.Storageing.GetHashCode();
                }
                Model.EmployeeId = _user.ID;
                //赋值主体
                Model.SysOrgId = _user.SysOrgId;
                int code = await _wMPurchaseInfoServices.GetMaxId();
                Model.PurchaseCode = "WIN000" + (code + 1);
                if (Model.noMatchData.Count <= 0)
                {
                    data.msg = "请选择商品信息！";
                    throw new Exception("请选择商品信息！");
                }
                if (Model.ProductUse == null)
                {
                    data.msg = "请填写产品用途！";
                    throw new Exception("请填写产品用途！");
                }
                //获取所有商品
                var tablePDData = Model.noMatchData;

                foreach (var item in tablePDData)
                {
                    if (item.WNum <= 0)
                    {
                        data.msg = "请填写物料数量！";
                        throw new Exception("请填写物料数量！");
                    }
                    WMPurchaseQuoteDetail PurchaseQuoteDetail = new WMPurchaseQuoteDetail();
                    PurchaseQuoteDetail.PurchaseId = code;
                    PurchaseQuoteDetail.ProductId = item.Id;
                    PurchaseQuoteDetail.TypeId = 1;
                    //添加采购单以当前主体id为主
                    PurchaseQuoteDetail.SysOrgId = _user.SysOrgId;

                    //判断表示是否需要审核
                    var modeProductList = await _WMProductListServices.GetModel(w => w.Id == item.Id);

                    var ProductUnitModel = await _WMProductUnitServices.GetModel(w => w.Id == modeProductList.Unit);
                    if (modeProductList != null && modeProductList.IsChecked == false)
                    {
                        Model.Status = EnumWMPurchaseStatus.CheckedPass.GetHashCode();
                        Model.Remark = Model.Remark;
                        Model.CheckAdminId = 0;
                        PurchaseQuoteDetail.Status = EnumWMPurchaseDetailStatus.CheckedPass.GetHashCode();
                        PurchaseQuoteDetail.PurchaseId = 0;
                        PurchaseQuoteDetail.CheckNum = item.WNum;
                        PurchaseQuoteDetail.Price = 0;
                        PurchaseQuoteDetail.Amount = 0;
                        PurchaseQuoteDetail.CreateTime = DateTime.Now;
                        PurchaseQuoteDetail.Remark = Model.Remark;
                        PurchaseQuoteDetail.PurchaseUnit = ProductUnitModel.Unit;
                        PurchaseQuoteDetail.WareHouseId = Model.WareHouseId;
                        PurchaseQuoteDetail.DepartmentId = UserModel.DepartmentId.Value;

                    }
                    else
                    {
                        PurchaseQuoteDetail.Status = EnumWMPurchaseDetailStatus.WaitCheck.GetHashCode();
                        PurchaseQuoteDetail.PurchaseId = 0;
                        PurchaseQuoteDetail.Price = 0;
                        PurchaseQuoteDetail.Amount = 0;
                        PurchaseQuoteDetail.CreateTime = DateTime.Now;
                        PurchaseQuoteDetail.Quantity = item.WNum;
                        PurchaseQuoteDetail.WareHouseId = Model.WareHouseId;
                        PurchaseQuoteDetail.DepartmentId = UserModel.DepartmentId.Value;
                        if (ProductUnitModel != null)
                        {
                            PurchaseQuoteDetail.PurchaseUnit = ProductUnitModel.Unit;
                        }
                        else
                        {
                            PurchaseQuoteDetail.PurchaseUnit = "";
                        }

                    }

                    PurchaseQuoteDetail.WareHouseId = Model.WareHouseId;
                    PurchaseQuoteDetail.DepartmentId = UserModel.DepartmentId.Value;
                    PurchaseQuoteDetail.CreateTime = DateTime.Now;
                    PurchaseQuoteDetail.PurchaseId = code + 1;
                    PurchaseQuoteDetail.ProductId = item.Id;
                    var pid = await _WMPurchaseQuoteDetailServices.Add(PurchaseQuoteDetail);

                }
                //添加操作日志
                _wMPurchaseInfoServices.AddLog(1, _user.ID, code + 1, "【添加采购】设置状态为" + ((EnumWMPurchaseStatus)Model.Status)._GetDescriptionByEnumValue());

                var id = await _wMPurchaseInfoServices.Add(Model);

                data.success = id > 0;
                _unitOfWork.CommitTran();
                if (data.success)
                {
                    data.response = id.ObjToString();
                    data.msg = "采购单添加成功!";
                }

            }
            catch (Exception e)
            {
                _unitOfWork.RollbackTran();
                _logger.LogError(e, e.Message);
                return data;
            }


            return data;
        }

        /// <summary>
        /// 审核
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        [HttpPut]
        public async Task<MessageModel<string>> Put([FromBody] WMPurchaseInfo request)
        {
            bool flag = false;
            var NewPurchaseQuoteDetailList = new List<WMPurchaseQuoteDetail>();
            var data = new MessageModel<string>();
            try
            {
                _unitOfWork.BeginTran();
                if (request.Id > 0)
                {
                    var model = await _wMPurchaseInfoServices.GetModel(w => w.Id == request.Id);
                    if (model.Status == EnumWMPurchaseStatus.CheckedNoPass.GetHashCode())
                    {
                        data.msg = "当前订单已审核，为审核不通过！";
                        throw new Exception("当前订单已审核，为审核不通过！");
                    }
                    if (model != null)
                    {
                        var checkModel = await _BllCheckInfo.GetModel(w => w.SysOrgId == _user.SysOrgId && w.Key == model.CheckKey);
                        if (checkModel == null)
                        {
                            data.msg = "暂无该部门审批流，请先申请配置";
                            throw new Exception("暂无该部门审批流，请先申请配置");
                        }
                        if (_user.ID != model.CheckAdminId)
                        {
                            data.msg = "非审批人，审批失败！";
                            throw new Exception("非审批人，审批失败！");
                        }
                        //审批数量判断
                        var rankList = JsonHelper.DeserializeObject<CheckRankList>(checkModel.Json);
                        foreach (var item in rankList.checkRankList)
                        {
                            //审批人跟审批级别是否一一对应
                            if (!flag)
                            {
                                if (model.CheckRank == item.CheckRank)
                                {
                                    flag = true;
                                    //设置下次审批
                                    int index = rankList.checkRankList.IndexOf(item) + 1; //index为索引值
                                    if (rankList.checkRankList.Count > 1 && rankList.checkRankList.Count > index)
                                    {
                                        model.CheckRank = rankList.checkRankList[index].CheckRank;
                                        model.CheckAdminId = rankList.checkRankList[index].AdminId;
                                    }
                                    //获取所有商品
                                    var tablePDData = request.PurchaseQuoteDetailList;
                                    if (tablePDData.Count <= 0)
                                    {
                                        data.msg = "暂无待审核得商品";
                                        throw new Exception("暂无待审核得商品");
                                    }
                                    foreach (var _tableItem in tablePDData)
                                    {
                                        if (_tableItem.Checked == 0)
                                        {
                                            data.msg = "请选择审核状态";
                                            throw new Exception("请选择审核状态");
                                        }
                                        if (_tableItem.CheckNum <= 0)
                                        {
                                            data.msg = "审批数量不能小于0";
                                            throw new Exception("审批数量不能小于0");
                                        }

                                        var ProductListMdoel = await _WMProductListServices.QueryById(_tableItem.ProductId);
                                        var PurchaseQuoteDetailInfo = await _WMPurchaseQuoteDetailServices.GetModel(w => w.Id == _tableItem.Id);
                                        if (PurchaseQuoteDetailInfo == null || PurchaseQuoteDetailInfo.Status == EnumWMPurchaseDetailStatus.CheckedNoPass.GetHashCode())
                                            continue;
                                        #region 采购数量审批
                                        if (_tableItem.Checked == 2 || ProductListMdoel.IsUse == false)
                                        {
                                            PurchaseQuoteDetailInfo.Remark = _tableItem.PurchaseQUoteDetailRemark;
                                            PurchaseQuoteDetailInfo.Status = EnumWMPurchaseDetailStatus.CheckedNoPass.GetHashCode();
                                            model.CheckAdminId = 0;//审核不通过将审批id设置为0
                                        }
                                        else
                                        {
                                            if (rankList.checkRankList.Count > 1 && rankList.checkRankList.Count > index)
                                                PurchaseQuoteDetailInfo.Status = EnumWMPurchaseDetailStatus.Checking.GetHashCode();
                                            else
                                                PurchaseQuoteDetailInfo.Status = EnumWMPurchaseDetailStatus.CheckedPass.GetHashCode();

                                            PurchaseQuoteDetailInfo.Quantity = _tableItem.CheckNum.Value;
                                            PurchaseQuoteDetailInfo.CheckNum = _tableItem.CheckNum.Value;
                                            PurchaseQuoteDetailInfo.Remark += _tableItem.PurchaseQUoteDetailRemark;
                                        }
                                        #endregion
                                        NewPurchaseQuoteDetailList.Add(PurchaseQuoteDetailInfo);
                                        var pid = await _WMPurchaseQuoteDetailServices.Update(PurchaseQuoteDetailInfo);
                                    }
                                    #region 修改审批订单状态
                                    //审核中
                                    var CheckingList = NewPurchaseQuoteDetailList.Where(p => p.Status == EnumWMPurchaseDetailStatus.Checking.GetHashCode()).ToList<WMPurchaseQuoteDetail>();
                                    //审核不通过
                                    var CheckedNoPassList = NewPurchaseQuoteDetailList.Where(p => p.Status == EnumWMPurchaseDetailStatus.CheckedNoPass.GetHashCode()).ToList<WMPurchaseQuoteDetail>();
                                    //审核通过
                                    var CheckedPassList = NewPurchaseQuoteDetailList.Where(p => p.Status == EnumWMPurchaseDetailStatus.CheckedPass.GetHashCode()).ToList<WMPurchaseQuoteDetail>();
                                    var listCount = CheckingList.Count + CheckedNoPassList.Count + CheckedPassList.Count;
                                    if (CheckingList.Count > 0)
                                        model.Status = EnumWMPurchaseStatus.Checking.GetHashCode();
                                    else
                                    {
                                        if ((listCount == NewPurchaseQuoteDetailList.Count) && CheckedPassList.Count > 0)
                                        {
                                            model.Status = EnumWMPurchaseStatus.CheckedPass.GetHashCode();
                                            model.CheckAdminId = 0;
                                            model.CheckRank = 0;
                                        }
                                        else
                                        {
                                            if (listCount == NewPurchaseQuoteDetailList.Count)
                                            {
                                                model.Status = EnumWMPurchaseStatus.CheckedNoPass.GetHashCode();
                                                model.CheckAdminId = 0;
                                                //model.CheckRank = 0;
                                            }


                                        }
                                    }
                                    #endregion

                                }

                            }

                        }
                    }
                    _wMPurchaseInfoServices.AddLog(1, _user.ID, model.Id, "【采购审批】设置状态为" + ((EnumWMPurchaseStatus)model.Status)._GetDescriptionByEnumValue());
                    data.success = await _wMPurchaseInfoServices.Update(model);
                    _unitOfWork.CommitTran();
                    if (data.success)
                    {
                        data.msg = "审核成功";
                        data.response = model?.Id.ObjToString();
                    }
                }

            }
            catch (Exception e)
            {
                _unitOfWork.RollbackTran();
                _logger.LogError(e, e.Message);
                return data;
            }


            return data;
        }

        [HttpDelete("{id}")]
        public async Task<MessageModel<string>> Delete(int id = 0)
        {
            var data = new MessageModel<string>();
            if (id > 0)
            {
                var detail = await _wMPurchaseInfoServices.QueryById(id);

                //detail.IsDeleted = true;

                if (detail != null)
                {
                    data.success = await _wMPurchaseInfoServices.Update(detail);
                    if (data.success)
                    {
                        data.msg = "删除成功";
                        data.response = detail?.Id.ObjToString();
                    }
                }
            }

            return data;
        }

        /// <summary>
        /// 删除商品
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete]
        [AllowAnonymous]
        public async Task<MessageModel<string>> DeleteProductList(int id = 0)
        {
            var data = new MessageModel<string>();
            if (id > 0)
            {
                var PurchaseQuoteDetailModel = await _WMPurchaseQuoteDetailServices.QueryById(id);
                if (PurchaseQuoteDetailModel == null)
                {
                    data.msg = "未获取到该出库商品";
                    return data;
                }

                data.success = await _WMPurchaseQuoteDetailServices.DeleteById(id);
                if (data.success)
                {
                    var PurchaseInfoModel = await _wMPurchaseInfoServices.QueryById(PurchaseQuoteDetailModel.PurchaseId);
                    if (PurchaseInfoModel.EmployeeId != _user.ID)
                    {
                        data.msg = "不是当前采购人将无法删除商品";
                        return data;
                    }

                    var SaleDetailList = await _WMPurchaseQuoteDetailServices.Query(x => x.PurchaseId == PurchaseInfoModel.Id);
                    if (SaleDetailList.Count() == 0)
                    {
                        PurchaseInfoModel.Status = EnumWMPurchaseStatus.Cancellation.GetHashCode();
                        await _wMPurchaseInfoServices.Update(PurchaseInfoModel);
                    }

                    data.msg = "删除商品成功";
                    data.response = PurchaseQuoteDetailModel?.Id.ObjToString();
                }
            }
            return data;
        }
        #endregion

    }
}