using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using AngleSharp.Dom;
using Furion.DatabaseAccessor;
using DocumentFormat.OpenXml.Vml.Spreadsheet;
using System.Web;
using System.Data;
using System.Text;

namespace Admin.NET.Application;
/// <summary>
/// 物料信息表服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsBaseGroupName, Order = 100)]
public class WmsMaterialService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsBaseMaterial> _wmsMaterialRep;
    private readonly SqlSugarRepository<WmsBaseMaterialType> _wmsMaterialTypeRep;
    private readonly SqlSugarRepository<WmsBaseMaterialCustomer> _wmsMaterialCustomerRep;
    private readonly SqlSugarRepository<WmsBaseSubstituteGood> _wmsSubstituteGoodRep;
    private readonly SqlSugarRepository<WmsBaseCustomer> _baseCustomerRep;
    private readonly SqlSugarRepository<WmsConfigSerialRule> _repRuleDetailRep;
    private readonly SqlSugarRepository<WmsConfigSerialSN> _repSNRep;
    private readonly SqlSugarRepository<WmsBaseControlRule> _wmsControlRuleDetailrep;
    private readonly SqlSugarRepository<WmsBaseBatchRule> _wmsBatchRuleDetailRep;
    private readonly SqlSugarRepository<WmsBaseContainerPackaging> _wmsContainerPackagingRep;
    private readonly SqlSugarRepository<WmsBaseContainerType> _wmsContainerTypeRep;
    public WmsMaterialService(
        SqlSugarRepository<WmsBaseMaterial> wmsMaterialRep, 
        SqlSugarRepository<WmsBaseMaterialType> wmsMaterialTypeRep, 
        SqlSugarRepository<WmsBaseMaterialCustomer> wmsMaterialCustomerRep, 
        SqlSugarRepository<WmsBaseSubstituteGood> wmsSubstituteGoodRep,
        SqlSugarRepository<WmsBaseCustomer> baseCustomerRep,
         SqlSugarRepository<WmsConfigSerialRule> repRuleDetailRep,
         SqlSugarRepository<WmsBaseBatchRule> wmsBatchRuleDetailRep,
         SqlSugarRepository<WmsConfigSerialSN> repSNRep, 
         SqlSugarRepository<WmsBaseControlRule> wmsControlRuleDetailrep,
          SqlSugarRepository<WmsBaseContainerPackaging> wmsContainerPackagingRep,
          SqlSugarRepository<WmsBaseContainerType> wmsContainerTypeRep)
    {
        _wmsMaterialRep = wmsMaterialRep;
        _wmsMaterialTypeRep = wmsMaterialTypeRep;
        _wmsMaterialCustomerRep = wmsMaterialCustomerRep;
        _wmsSubstituteGoodRep = wmsSubstituteGoodRep;
        _baseCustomerRep = baseCustomerRep;
        _repRuleDetailRep = repRuleDetailRep;
        _repSNRep = repSNRep;
        _wmsBatchRuleDetailRep= wmsBatchRuleDetailRep;
        _wmsControlRuleDetailrep = wmsControlRuleDetailrep;
        _wmsContainerPackagingRep = wmsContainerPackagingRep;
        _wmsContainerTypeRep = wmsContainerTypeRep;
    }

    /// <summary>
    /// 分页查询物料信息表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    public async Task<SqlSugarPagedList<WmsMaterialOutput>> Page(WmsMaterialInput input)
    {
        var query = _wmsMaterialRep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.MaterialName.Contains(input.SearchKey.Trim())
                || u.MaterialCode.Contains(input.SearchKey.Trim())
                || u.ErpCode.Contains(input.SearchKey.Trim())
                || u.MaterialGroup.Contains(input.SearchKey.Trim())
            )
            .WhereIF(input.IsDisabled != null, u => u.IsDisabled == input.IsDisabled)
            .WhereIF(input.IsCheck.HasValue, u => u.IsCheck == input.IsCheck)
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialName), u => u.MaterialName.Contains(input.MaterialName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialCode), u => u.MaterialCode.Contains(input.MaterialCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpCode), u => u.ErpCode.Contains(input.ErpCode.Trim()))
            .WhereIF(input.MaterialType > 0, u => u.MaterialType == input.MaterialType)
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialGroup), u => u.MaterialGroup.Contains(input.MaterialGroup.Trim()))
            .WhereIF(input.ABCClass>0, u => u.ABCClass == input.ABCClass)
            .Select<WmsMaterialOutput>();
        return await query
            .OrderBy(x => x.MaterialCode)
            //.OrderBuilder(input)
            .ToPagedListAsync(input.Page, input.PageSize);
    }

    /// <summary>
    /// 增加物料信息表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [UnitOfWork]
    public async Task<long> Add(AddWmsMaterialInfoInput input)
    {
        var wmsMaterialId = Yitter.IdGenerator.YitIdHelper.NextId();
        //物料信息
        var wmsMaterial = input.MaterialInput.Adapt<WmsBaseMaterial>();
        wmsMaterial.Id= wmsMaterialId;
        //验证是否已存在相同物料号、物料名称的数据
        await CheckExisit(wmsMaterial);

        //ABCClassName赋值
        if (wmsMaterial.ABCClass != null)
        {
            wmsMaterial.ABCClassName = GetEnumDescriptionUtil.GetEnumDescription(wmsMaterial.ABCClass); //ly-0718 ABC分类 修改描述，所有页面展示描述 ，不再展示ABC
            //wmsMaterial.ABCClassName = wmsMaterial.ABCClass.ToString();
        }

        if (wmsMaterial.POUnit != wmsMaterial.MaterialUnit && !wmsMaterial.TranslateRate.HasValue)
        {
            throw Oops.Oh($"采购单位{wmsMaterial.POUnit}跟库存单位{wmsMaterial.MaterialUnit}不一致，换算率不能为空");
        }


        //批次规则信息
        List<WmsBaseBatchRule> batchRuleDetailList = null;
        if (!string.IsNullOrWhiteSpace(input.BatchRuleCode))
        {
            batchRuleDetailList = await _wmsBatchRuleDetailRep.GetListAsync(u => u.RuleCode == input.BatchRuleCode&&u.IsDelete==false&& u.IsDisabled == false);
            if (batchRuleDetailList?.Count<=0)
            {
                throw Oops.Oh(@$"编号{input.BatchRuleCode}可用批次规则信息不存在！");
            }
           
            wmsMaterial.BatchRuleCode = input.BatchRuleCode;

        }
        //控制规则信息
        WmsBaseControlRule controlRuleDetail = null;
        if (input.ControlRuleDetailInput != null)
        {

            //控制规则信息
            controlRuleDetail = input.ControlRuleDetailInput.Adapt<WmsBaseControlRule>();
            controlRuleDetail.MaterialCode = wmsMaterial.MaterialCode;
            if (controlRuleDetail.Id > 0)
            {
                //存在就更新
                await _wmsControlRuleDetailrep.AsUpdateable(controlRuleDetail).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
            }
            else
            {
                controlRuleDetail.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                //不存在就新增
                await _wmsControlRuleDetailrep.InsertAsync(controlRuleDetail);
            }
        }
        //根据控制属性赋值是否质检
        if (controlRuleDetail==null)
        {
            wmsMaterial.IsCheck = false;
        }
        else
        {
            if (controlRuleDetail.IsCheck != true)//免检
            {
                wmsMaterial.IsCheck = false;
            }
            else
            {
                wmsMaterial.IsCheck = true;
            }
        }
    


        //获取物料类型
        var wmsMaterialType = (await _wmsMaterialTypeRep.GetFirstAsync(u => u.Id == wmsMaterial.MaterialType && u.IsDelete == false));
        if (wmsMaterialType == null) throw Oops.Oh($"ID{wmsMaterial.MaterialType}没有获取到物料类型");
        wmsMaterial.MaterialTypeCode = wmsMaterialType.MaterialTypeCode;
        wmsMaterial.MaterialTypeName = wmsMaterialType.MaterialTypeName;
        var materialCustomerList = new List<WmsBaseMaterialCustomer>();
        //往来单位
        if (input.BaseCustomerList?.Count > 0)
        {
            var wmsBaseCustomerList = await _baseCustomerRep.AsQueryable().Where(u => input.BaseCustomerList.Contains(u.Id) && u.IsDelete == false).Select<BaseCustomerOutput>().ToListAsync();
            if (wmsBaseCustomerList?.Count() <= 0)
            {
                throw Oops.Oh($"往来单位不存在");
            }
            if (wmsBaseCustomerList?.Count > 0)
            {

                //物料客户关联关系
                foreach (var item in input.BaseCustomerList)
                {
                    var baseCustomer = wmsBaseCustomerList.FirstOrDefault(f => f.Id == item);
                    if (baseCustomer == null)
                    {
                        throw Oops.Oh(errorMessage: @$"ID{item}往来单位不存在！");
                    }
                    if (baseCustomer.IsDisabled == true)
                    {
                        throw Oops.Oh($"不能使用已禁用的往来单位");
                    }

                   
                    materialCustomerList.Add(new WmsBaseMaterialCustomer()
                    {

                        CustChinaName = baseCustomer.CustChinaName,
                        CustCode = baseCustomer.CustCode,
                        CustEnglishName = baseCustomer.CustEnglishName,
                        CustId = baseCustomer.Id,
                        MaterialCode = wmsMaterial.MaterialCode,
                        MaterialId = wmsMaterial.Id,
                        MaterialName = wmsMaterial.MaterialName,

                    });
                }
            }
        }
       


        //替代品信息
        var substituteGoodList = input.SubstituteGoodList.Adapt<List<WmsBaseSubstituteGood>>();
        List<string> materialCodes = substituteGoodList.Select(s => s.SubstituteMaterialCode).ToList();
        if (materialCodes?.Count > 0)
        {
            var wmsSubstituteMaterialInfoList = await _wmsMaterialRep.AsQueryable().Where(u => materialCodes.Contains(u.MaterialCode) && u.IsDelete == false).Select<WmsMaterialOutput>().ToListAsync();
            if (wmsSubstituteMaterialInfoList?.Count <= 0)
            {
                throw Oops.Oh($"替代品物料不存在");
            }

            foreach (var item in substituteGoodList)
            {
               

                var substituteMaterialInfo = wmsSubstituteMaterialInfoList.FirstOrDefault(f => f.MaterialCode == item.SubstituteMaterialCode);
                if (substituteMaterialInfo == null)
                {
                    throw Oops.Oh(errorMessage: @$"替代品物料{item.SubstituteMaterialCode}不存在！");
                }
                if (substituteMaterialInfo.IsDisabled == true)
                {
                    throw Oops.Oh($"不能使用已禁用的替代品物料");
                }
                item.SubstituteCode = await SerialUtil.GetSerial(SerialTypeEnum.替代品编号, _repRuleDetailRep, _repSNRep);
                item.SubstituteMaterialName = substituteMaterialInfo.MaterialName;//替代品物料名称
                item.MaterialCode = wmsMaterial.MaterialCode;//原物料编号
                item.MaterialName= wmsMaterial.MaterialName;//原物料名称
            }
        }

        //物料容器关系

        var containerPackagingList = input.ContainerPackagingList.Adapt<List<WmsBaseContainerPackaging>>();
        List<long> wmsContainerTypeIds= containerPackagingList.Where(w => w.ContainerTypeId > 0).Select(x => x.ContainerTypeId).ToList();
        if (wmsContainerTypeIds?.Count > 0)
        {
            var wmsContainerTypeList = await _wmsContainerTypeRep.AsQueryable().Where(u => wmsContainerTypeIds.Contains(u.Id) && u.IsDelete == false).Select<WmsContainerTypeOutput>().ToListAsync();
            if (wmsContainerTypeList?.Count <= 0)
            {
                throw Oops.Oh($"容器类型不存在");
            }
            foreach (var item in containerPackagingList)
            {


                var wmsContainerType = wmsContainerTypeList.FirstOrDefault(f => f.Id == item.ContainerTypeId);
                if (wmsContainerType == null)
                {
                    throw Oops.Oh($"容器类型不存在");
                }
                if (wmsContainerType.IsDisabled == true)
                {
                    throw Oops.Oh($"不能使用已禁用的容器类型");
                }


                item.ContainerTypeId = wmsContainerType.Id;
                item.ContainerTypeCode = wmsContainerType.TypeCode;
                item.ContainerTypeName = wmsContainerType.TypeName;
                item.MaterialId = wmsMaterial.Id;
                item.MaterialCode = wmsMaterial.MaterialCode;
                item.MaterialName = wmsMaterial.MaterialName;

            }

        }


        //新增物料
        await _wmsMaterialRep.InsertAsync(wmsMaterial);
        //新增 物料客户关系
        if (materialCustomerList?.Count > 0)
        {
            await _wmsMaterialCustomerRep.InsertRangeAsync(materialCustomerList);
        }
        //新增替代品
        if (substituteGoodList?.Count > 0)
        {
            await _wmsSubstituteGoodRep.InsertRangeAsync(substituteGoodList);
        }
        //新增物料容器类型关系
        if (containerPackagingList?.Count > 0)
        {
            await _wmsContainerPackagingRep.InsertRangeAsync(containerPackagingList);
        }

        return wmsMaterial.Id;
    }

    /// <summary>
    /// 删除物料信息表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    public async Task Delete(DeleteWmsMaterialInput input)
    {

        var entity = await _wmsMaterialRep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
        //删除物料容器关系
        var oldContainerPackagingList = await _wmsContainerPackagingRep.AsQueryable().Where(w => w.MaterialId == input.Id).ToListAsync();

        //物料客户关联
        var wmsMaterialCustomerList = await _wmsMaterialCustomerRep.AsQueryable().Where(u => u.MaterialId == entity.Id).ToListAsync();

        //删除替代品信息
        var oldSubstituteGoodList = await _wmsSubstituteGoodRep.AsQueryable().Where(w => w.MaterialCode == entity.MaterialCode).ToListAsync();

        //删除控制属性

        var oldControlRuleDetailList = await _wmsControlRuleDetailrep.AsQueryable().Where(w => w.MaterialCode == entity.MaterialCode).ToListAsync();

        try
        {
            await _wmsMaterialRep.AsTenant().BeginTranAsync();

            if (oldContainerPackagingList?.Count > 0)
            {
                await _wmsContainerPackagingRep.DeleteAsync(oldContainerPackagingList);
            }
           // 物料客户关联关系
            if (wmsMaterialCustomerList?.Count > 0)
            {
                await _wmsMaterialCustomerRep.DeleteAsync(wmsMaterialCustomerList);
            }
            //删除替代品信息
            if (oldSubstituteGoodList?.Count > 0)
            {
                await _wmsSubstituteGoodRep.DeleteAsync(oldSubstituteGoodList);
            }
            //删除控制属性
            if (oldControlRuleDetailList?.Count > 0)
            {
                await _wmsControlRuleDetailrep.DeleteAsync(oldControlRuleDetailList);
            }
            await _wmsMaterialRep.DeleteAsync(entity);   //真删除

            await _wmsMaterialRep.AsTenant().CommitTranAsync();
        }
        catch
        {
            await _wmsMaterialRep.AsTenant().RollbackTranAsync();
            throw;
        }
        
    }

    /// <summary>
    /// 更新物料信息表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [UnitOfWork]
    public async Task Update(UpdateWmsMaterialInfoInput input)
    { 
        //物料信息
        var wmsMaterial = input.MaterialInput.Adapt<WmsBaseMaterial>();
        //验证要修改的物料信息是否存在
        var existWmsMaterial = await _wmsMaterialRep.GetFirstAsync(u => u.Id == wmsMaterial.Id && u.IsDelete == false);
        if (existWmsMaterial==null) throw Oops.Oh($"物料编号[{wmsMaterial.MaterialCode}]物料信息不存在");

        //验证是否已存在相同物料号、物料名称的数据
        await CheckExisit(wmsMaterial, true);
        //ABCClassName赋值
        if (wmsMaterial.ABCClass != null)
        {
            //wmsMaterial.ABCClassName = wmsMaterial.ABCClass.ToString();
            wmsMaterial.ABCClassName = GetEnumDescriptionUtil.GetEnumDescription(wmsMaterial.ABCClass); //ly-0718 ABC分类 修改描述，所有页面展示描述 ，不再展示ABC
        }

        if (wmsMaterial.POUnit != wmsMaterial.MaterialUnit && !wmsMaterial.TranslateRate.HasValue)
        {
            throw Oops.Oh($"采购单位{wmsMaterial.POUnit}跟库存单位{wmsMaterial.MaterialUnit}不一致，换算率不能为空");
        }



        //批次规则信息
        List<WmsBaseBatchRule> batchRuleDetailList = null;
        if (!string.IsNullOrWhiteSpace(input.BatchRuleCode))
        {
            batchRuleDetailList = await _wmsBatchRuleDetailRep.GetListAsync(u => u.RuleCode == input.BatchRuleCode && u.IsDelete == false && u.IsDisabled == false);
            if (batchRuleDetailList?.Count <= 0)
            {
                throw Oops.Oh(@$"编号{input.BatchRuleCode}可用批次规则信息不存在！");
            }

        }
        //批次编号赋值
        wmsMaterial.BatchRuleCode = input.BatchRuleCode;
        //控制规则信息
        WmsBaseControlRule controlRuleDetail = null;
        if (input.ControlRuleDetailInput != null)
        {
         
            //控制规则信息
             controlRuleDetail = input.ControlRuleDetailInput.Adapt<WmsBaseControlRule>();
             controlRuleDetail.MaterialCode = wmsMaterial.MaterialCode;
            if (controlRuleDetail.Id > 0)
            {
                //存在就更新
                await _wmsControlRuleDetailrep.AsUpdateable(controlRuleDetail).ExecuteCommandAsync();
            }
            else
            {
                controlRuleDetail.Id =Yitter.IdGenerator.YitIdHelper.NextId();
                //不存在就新增
                await _wmsControlRuleDetailrep.InsertAsync(controlRuleDetail);
            }
        }
      

        //根据控制属性赋值是否质检
        if (controlRuleDetail == null)
        {
            wmsMaterial.IsCheck = false;
        }
        else
        {
            if (controlRuleDetail.IsCheck != true)//免检
            {
                wmsMaterial.IsCheck = false;
            }
            else
            {
                wmsMaterial.IsCheck = true;
            }
        }


        //获取物料类型
        var wmsMaterialType = (await _wmsMaterialTypeRep.GetFirstAsync(u => u.Id == wmsMaterial.MaterialType && u.IsDelete == false));
        if (wmsMaterialType == null) throw Oops.Oh($"ID{wmsMaterial.MaterialType}没有获取到物料类型");
        wmsMaterial.MaterialTypeCode = wmsMaterialType.MaterialTypeCode;
        wmsMaterial.MaterialTypeName = wmsMaterialType.MaterialTypeName;

        //删除物料客户关联关系_rep.AsQueryable().Select<WmsMaterialCustomerOutput>().ToListAsync();
        var oldaterialCustomerList = await _wmsMaterialCustomerRep.AsQueryable().Where(w => w.MaterialId == wmsMaterial.Id).ToListAsync();
        if (oldaterialCustomerList?.Count > 0)
        {
            await _wmsMaterialCustomerRep.DeleteAsync(oldaterialCustomerList);
        }

        var materialCustomerList = new List<WmsBaseMaterialCustomer>();
        if (input.BaseCustomerList?.Count > 0)
        {
            //往来单位
            var wmsBaseCustomerList = await _baseCustomerRep.AsQueryable().Where(u => input.BaseCustomerList.Contains(u.Id) && u.IsDelete== false).ToListAsync();
            if (wmsBaseCustomerList?.Count() <= 0)
            {
                throw Oops.Oh($"往来单位不存在");
            }

            if (wmsBaseCustomerList?.Count > 0)
            {

                //物料客户关联关系
                foreach (var item in input.BaseCustomerList)
                {
                    var baseCustomer = wmsBaseCustomerList.FirstOrDefault(f => f.Id == item);
                    if (baseCustomer == null)
                    {
                        throw Oops.Oh(errorMessage: @$"ID{item}往来单位不存在！");
                    }
                    if (baseCustomer.IsDisabled == true)
                    {
                        throw Oops.Oh($"不能使用已禁用的往来单位");
                    }
                    materialCustomerList.Add(new WmsBaseMaterialCustomer()
                    {

                        CustChinaName = baseCustomer.CustChinaName,
                        CustCode = baseCustomer.CustCode,
                        CustEnglishName = baseCustomer.CustEnglishName,
                        CustId = baseCustomer.Id,
                        MaterialCode = wmsMaterial.MaterialCode,
                        MaterialId = wmsMaterial.Id,
                        MaterialName = wmsMaterial.MaterialName,

                    });
                }
            }
        }


        //删除替代品信息
        var oldSubstituteGoodList = await _wmsSubstituteGoodRep.AsQueryable().Where(w => w.MaterialCode == wmsMaterial.MaterialCode).ToListAsync();
        if (oldSubstituteGoodList?.Count > 0)
        {
            await _wmsSubstituteGoodRep.DeleteAsync(oldSubstituteGoodList);
        }


        //替代品信息
        var substituteGoodList = input.SubstituteGoodList.Adapt<List<WmsBaseSubstituteGood>>();
        List<string> materialCodes = substituteGoodList.Select(s => s.SubstituteMaterialCode).ToList();

        if (materialCodes?.Count > 0)
        {
            var wmsSubstituteMaterialInfoList = await _wmsMaterialRep.AsQueryable().Where(u => materialCodes.Contains(u.MaterialCode) && u.IsDelete == false).ToListAsync();
            if (wmsSubstituteMaterialInfoList?.Count <= 0)
            {
                throw Oops.Oh($"替代品物料不存在");
            }
            foreach (var item in substituteGoodList)
            {
               
                var substituteMaterialInfo = wmsSubstituteMaterialInfoList.FirstOrDefault(f => f.MaterialCode == item.SubstituteMaterialCode);
                if (substituteMaterialInfo.IsDisabled == true)
                {
                    throw Oops.Oh($"替代品物料{substituteMaterialInfo.MaterialCode}已禁用");
                }
                item.SubstituteCode = await SerialUtil.GetSerial(SerialTypeEnum.替代品编号,_repRuleDetailRep,_repSNRep);
                item.SubstituteMaterialName = substituteMaterialInfo.MaterialName;//替代品物料名称
                item.MaterialCode = wmsMaterial.MaterialCode;//原物料编号
                item.MaterialName = wmsMaterial.MaterialName;//原物料名称
            }
        }

        //删除物料容器关系
        var oldContainerPackagingList = await _wmsContainerPackagingRep.AsQueryable().Where(w => w.MaterialId == wmsMaterial.Id).ToListAsync();
        if (oldContainerPackagingList?.Count > 0)
        {
            await _wmsContainerPackagingRep.DeleteAsync(oldContainerPackagingList);
        }

        //物料容器关系

        var containerPackagingList = input.ContainerPackagingList.Adapt<List<WmsBaseContainerPackaging>>();
        List<long> wmsContainerTypeIds = containerPackagingList.Where(w=>w.ContainerTypeId>0).Select(x => x.ContainerTypeId).ToList();
        if (wmsContainerTypeIds?.Count > 0)
        {
            var wmsContainerTypeList = await _wmsContainerTypeRep.AsQueryable().Where(u => wmsContainerTypeIds.Contains(u.Id) && u.IsDelete == false).Select<WmsContainerTypeOutput>().ToListAsync();
            if (wmsContainerTypeList?.Count <= 0)
            {
                throw Oops.Oh($"容器类型不存在");
            }
            foreach (var item in containerPackagingList)
            {


                var wmsContainerType = wmsContainerTypeList.FirstOrDefault(f => f.Id == item.ContainerTypeId);
                if (wmsContainerType == null)
                {
                    throw Oops.Oh($"容器类型不存在");
                }
                if (wmsContainerType.IsDisabled == true)
                {
                    throw Oops.Oh($"不能使用已禁用的容器类型");
                }


                item.ContainerTypeId = wmsContainerType.Id;
                item.ContainerTypeCode = wmsContainerType.TypeCode;
                item.ContainerTypeName = wmsContainerType.TypeName;
                item.MaterialId = wmsMaterial.Id;
                item.MaterialCode = wmsMaterial.MaterialCode;
                item.MaterialName = wmsMaterial.MaterialName;

            }

        }
        //新增物料客户关联关系
        if (materialCustomerList?.Count > 0)
        {
            await _wmsMaterialCustomerRep.InsertRangeAsync(materialCustomerList);
        }
        //新增替代品信息
        if (substituteGoodList?.Count > 0)
        {
            await _wmsSubstituteGoodRep.InsertRangeAsync(substituteGoodList);
        }
        //新增物料容器类型关系
        if (containerPackagingList?.Count > 0)
        {
            await _wmsContainerPackagingRep.InsertRangeAsync(containerPackagingList);
        }
        await _wmsMaterialRep.AsUpdateable(wmsMaterial).IgnoreColumns(ignoreAllNullColumns: false).ExecuteCommandAsync();
    }

    /// <summary>
    /// 获取物料信息表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    public async Task<WmsMaterialInfoOutput> Detail([FromQuery] QueryByIdWmsMaterialInput input)
    {

        WmsMaterialInfoOutput resultInfo = new WmsMaterialInfoOutput();
        //获取物料信息
        var wmsMaterialInfo = (await _wmsMaterialRep.GetFirstAsync(u => u.Id == input.Id)).Adapt<WmsMaterialOutput>();
        //获取替换物料信息
        var wmsSubstituteGoods = await _wmsSubstituteGoodRep.AsQueryable()
                                     .Where(u => u.MaterialCode == wmsMaterialInfo.MaterialCode)
                                     .Where(u => u.IsDelete == false)
                                     .Where(u => u.IsDisabled == false)
                                     .OrderBy(o => o.CreateTime)
                                     .Select<WmsSubstituteGoodOutput>()
                                     .ToListAsync();


        //批次规则信息
        List<WmsBaseBatchRule> batchRuleDetailList  = await _wmsBatchRuleDetailRep.AsQueryable()
                                          .Where(u => u.RuleCode == wmsMaterialInfo.BatchRuleCode)
                                           .Where(u => u.IsDelete == false)
                                           .Where(u => u.IsDisabled == false)
                                          .OrderBy(o => o.CreateTime)
                                          .Select<WmsBaseBatchRule>()
                                          .ToListAsync();


        //获取控制属性规则
        var wmsControlRuleDetailList = await _wmsControlRuleDetailrep.AsQueryable()
                                          .Where(u => u.MaterialCode == wmsMaterialInfo.MaterialCode)
                                           .Where(u => u.IsDelete == false)
                                           .Where(u => u.IsDisabled == false)
                                          .OrderBy(o => o.CreateTime)
                                          .Select<WmsControlRuleDetailOutput>()
                                          .ToListAsync();

        //物料客户关联
        var wmsMaterialCustomerList = await _wmsMaterialCustomerRep.AsQueryable()
                                          .Where(u => u.MaterialId == wmsMaterialInfo.Id)
                                          .Where(u => u.IsDelete == false)
                                          .OrderBy(o => o.CreateTime)
                                          .Select<WmsMaterialCustomerOutput>()
                                          .ToListAsync();
        List<long> custIds = wmsMaterialCustomerList.Select(s => s.CustId).ToList();
        //根据物料客户关联表获取往来信息
        var baseCustomers = await _baseCustomerRep.AsQueryable()
                                  .Where(p => custIds.Contains(p.Id))
                                  .OrderBy(o => o.CreateTime)
                                  .Select<BaseCustomerOutput>()
                                  .ToListAsync();

        var containerPackagingList = await _wmsContainerPackagingRep.AsQueryable().Where(w => w.MaterialId == wmsMaterialInfo.Id).ToListAsync();

        resultInfo.MaterialInfo = wmsMaterialInfo;
        resultInfo.SubstituteGoodList = wmsSubstituteGoods;
        resultInfo.BatchRuleDetailList = batchRuleDetailList;
        resultInfo.ControlRuleDetailList = wmsControlRuleDetailList;
        resultInfo.BaseCustomerList = baseCustomers;
        resultInfo.ContainerPackagingList = containerPackagingList;
        return resultInfo;

    }

    /// <summary>
    /// 获取物料信息表列表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    public async Task<List<WmsMaterialOutput>> List([FromQuery] WmsMaterialInput input)
    {
        return await _wmsMaterialRep.AsQueryable().Select<WmsMaterialOutput>().ToListAsync();
    }


    #region 导入

    /// <summary>
    /// Excel模板导入物料信息表功能
    /// </summary>
    /// <param name="file">Excel模板文件</param>
    /// <returns>导入的记录数</returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "ImportExcel")]
    [Description("WmsMaterial/ImportExcel")]
    public async Task<int> ImportExcelAsync(IFormFile file)
    {
        int _HeadStartLine = 2;//第1行是说明,第2行是列名
        int _DataStartLine = 3;//第3行开始是数据
        DataTable importDataTable = ExcelUtil.ImportExcelToDataTable(file, _HeadStartLine, _DataStartLine);
        var addList = await CommonImport(importDataTable, _DataStartLine);
        await _wmsMaterialRep.InsertRangeAsync(addList);
        return addList.Count;
    }

    /// <summary>
    ///  DataTable转换实体对象列表
    /// </summary>
    /// <param name="dataTable"></param>
    /// <param name="dataStartLine">模版列名开始行</param>
    /// <returns></returns>
    private async Task<List<WmsBaseMaterial>> CommonImport(DataTable dataTable, int dataStartLine)
    {
        var details = new List<WmsBaseMaterial>();
        int index = dataStartLine;//模版列名开始行
        foreach (System.Data.DataRow row in dataTable.Rows)
        {
            index++;
            //导入模版定制化代码（替换模版使用）

            var addItem = new WmsBaseMaterial();
            #region 定义变量
            var _MaterialName = "";//物料名称
            var _MaterialCode = "";//物料编号
            var _ErpCode = "";//ERP编号
            var _ABCClassName = "";//ABC分类名称

            var _MaterialUnit = "";//库存单位
            var _POUnit = "";//采购单位
            var _Color = "";//颜色
            var _SNP = "";//标包数量
            var _TranslateRate = "";//换算率
            var _IsDisabled = "";//是否禁用
            var _MaterialDesc = "";//描述
            var _IsCheck = "";//是否质检

            #endregion


            #region 取值
            _MaterialName = row["物料名称"]?.ToString();
            _MaterialCode = row["物料编号"]?.ToString();
            _ErpCode = row["ERP编号"]?.ToString();
            //_MaterialTypeName = row["物料类型名称"]?.ToString();
            //_MaterialTypeDescr = row["物料类型描述"]?.ToString();
            //_MaterialTypeCode = row["物料类型编号"]?.ToString();
            //_MaterialType = row["物料类型ID"]?.ToString();
            //_MaterialGroup = row["物料组"]?.ToString();
            _ABCClassName = row["ABC分类名称"]?.ToString();
            //_ABCClass = row["ABC分类"]?.ToString();
            //_MaterialSpec = row["物料规格"]?.ToString();
            //_InPlaceCode = row["默认上架库位"]?.ToString();
            _MaterialUnit = row["库存单位"]?.ToString();
            _POUnit = row["采购单位"]?.ToString();
            _Color = row["颜色"]?.ToString();
            //_Weight = row["重量"]?.ToString();
            _SNP = row["标包数量"]?.ToString();
            _TranslateRate = row["换算率"]?.ToString();
            //_BatchRuleId = row["批次属性规则"]?.ToString();
            //_ControlRuleId = row["控制属性规则"]?.ToString();
            _IsDisabled = row["是否禁用"]?.ToString();
            _MaterialDesc = row["描述"]?.ToString();
            _IsCheck = row["是否质检"]?.ToString();
            //_BatchRuleCode = row["批次属性规则编号"]?.ToString();
            //_ControlRuleCode = row["控制属性规则编号"]?.ToString();
            #endregion


            #region 验证

            if (string.IsNullOrEmpty(_MaterialName))
            {
                throw Oops.Oh($"第{index}行[物料名称]{_MaterialName}不能为空！");
            }

            if (!string.IsNullOrEmpty(_MaterialName))
            {
                addItem.MaterialName = (string)(_MaterialName.Trim());
            }

            if (string.IsNullOrEmpty(_MaterialCode))
            {
                throw Oops.Oh($"第{index}行[物料编号]{_MaterialCode}不能为空！");
            }

            if (!string.IsNullOrEmpty(_MaterialCode))
            {
                var isExist = await _wmsMaterialRep.AsQueryable().FirstAsync(p =>p.MaterialCode == _MaterialCode);
                if (isExist != null) throw Oops.Oh("该物料编号"+_MaterialCode+"已存在");
                addItem.MaterialCode = (string)(_MaterialCode.Trim());
            }
            if (!string.IsNullOrEmpty(_ErpCode))
            {
                addItem.ErpCode = (string)(_ErpCode.Trim());
            }
            addItem.MaterialTypeName = "原材料";
            addItem.MaterialTypeCode = "YCL";
            addItem.MaterialType = 546896760045637;

            //if (string.IsNullOrEmpty(_MaterialTypeName))
            //{
            //    throw Oops.Oh($"第{index}行[物料类型名称]{_MaterialTypeName}不能为空！");
            //}

            //if (!string.IsNullOrEmpty(_MaterialTypeName))
            //{
            //    addItem.MaterialTypeName = (string)(_MaterialTypeName.Trim());
            //}
            //if (!string.IsNullOrEmpty(_MaterialTypeDescr))
            //{
            //    addItem.MaterialTypeDescr = (string)(_MaterialTypeDescr.Trim());
            //}
            //if (!string.IsNullOrEmpty(_MaterialTypeCode))
            //{
            //    addItem.MaterialTypeCode = (string)(_MaterialTypeCode.Trim());
            //}

            //if (string.IsNullOrEmpty(_MaterialType))
            //{
            //    throw Oops.Oh($"第{index}行[物料类型ID]{_MaterialType}不能为空！");
            //}

            //if (!string.IsNullOrEmpty(_MaterialType))
            //{
            //    if (!long.TryParse(_MaterialType, out long outMaterialType) && !string.IsNullOrEmpty(_MaterialType))
            //    {
            //        throw Oops.Oh($"第{index}行[物料类型ID]{_MaterialType}值不正确！");
            //    }
            //    if (outMaterialType <= 0 && !string.IsNullOrEmpty(_MaterialType))
            //    {
            //        throw Oops.Oh($"第{index}行[物料类型ID]{_MaterialType}值不能小于等于0！");
            //    }
            //    else
            //    {
            //        addItem.MaterialType = outMaterialType;
            //    }

            //}
            //if (!string.IsNullOrEmpty(_MaterialGroup))
            //{
            //    addItem.MaterialGroup = (string)(_MaterialGroup.Trim());
            //}

            if (!string.IsNullOrEmpty(_ABCClassName))
            {
                addItem.ABCClassName = (string)(_ABCClassName.Trim());
            }
            if (addItem.ABCClassName== "单件高/品类少")
            {
                addItem.ABCClass = ABCClassEnum.A;
            }else if (addItem.ABCClassName == "单件低于A/品类多")
            {
                addItem.ABCClass = ABCClassEnum.B;
            }else if (addItem.ABCClassName == "单价低于B/品类多")
            {
                addItem.ABCClass = ABCClassEnum.C;
            }
            //if (!string.IsNullOrEmpty(_ABCClass))
            //{
            //    Admin.NET.Application.ABCClassEnum enumABCClass = default(Admin.NET.Application.ABCClassEnum);

            //    if (!Enum.TryParse<Admin.NET.Application.ABCClassEnum>(_ABCClass, out enumABCClass) && !string.IsNullOrEmpty(_ABCClass))
            //    {
            //        throw Oops.Oh($"第{index}行[ABC分类]{_ABCClass}值不正确！");
            //    }
            //    else
            //    {
            //        addItem.ABCClass = enumABCClass;
            //    }

            //}
            //if (!string.IsNullOrEmpty(_MaterialSpec))
            //{
            //    addItem.MaterialSpec = (string)(_MaterialSpec.Trim());
            //}
            //if (!string.IsNullOrEmpty(_InPlaceCode))
            //{
            //    addItem.InPlaceCode = (string)(_InPlaceCode.Trim());
            //}

            if (string.IsNullOrEmpty(_MaterialUnit))
            {
                throw Oops.Oh($"第{index}行[库存单位]{_MaterialUnit}不能为空！");
            }

            if (!string.IsNullOrEmpty(_MaterialUnit))
            {
                addItem.MaterialUnit = (string)(_MaterialUnit.Trim());
            }

            if (string.IsNullOrEmpty(_POUnit))
            {
                throw Oops.Oh($"第{index}行[采购单位]{_POUnit}不能为空！");
            }

            if (!string.IsNullOrEmpty(_POUnit))
            {
                addItem.POUnit = (string)(_POUnit.Trim());
            }
            if (!string.IsNullOrEmpty(_Color))
            {
                addItem.Color = (string)(_Color.Trim());
            }

            //if (!string.IsNullOrEmpty(_Weight))
            //{
            //    addItem.Weight = (string)(_Weight.Trim());
            //}
            if (!string.IsNullOrEmpty(_SNP))
            {
                if (!decimal.TryParse(_SNP, out decimal outSNP) && !string.IsNullOrEmpty(_SNP))
                {
                    throw Oops.Oh($"第{index}行[标包数量]{_SNP}值不正确！");
                }
                if (outSNP <= 0 && !string.IsNullOrEmpty(_SNP))
                {
                    throw Oops.Oh($"第{index}行[标包数量]{_SNP}值不能小于等于0！");
                }
                else
                {
                    addItem.SNP = outSNP;
                }

            }
            if (string.IsNullOrEmpty(_TranslateRate))
            {
                throw Oops.Oh($"第{index}行[换算率]{_TranslateRate}不能为空！");
            }
            if (!string.IsNullOrEmpty(_TranslateRate))
            {
                if (!decimal.TryParse(_TranslateRate, out decimal outTranslateRate) && !string.IsNullOrEmpty(_TranslateRate))
                {
                    throw Oops.Oh($"第{index}行[换算率]{_TranslateRate}值不正确！");
                }
                if (outTranslateRate <= 0 && !string.IsNullOrEmpty(_TranslateRate))
                {
                    throw Oops.Oh($"第{index}行[换算率]{_TranslateRate}值不能小于等于0！");
                }
                else
                {
                    addItem.TranslateRate = outTranslateRate;
                }

            }
            //if (!string.IsNullOrEmpty(_BatchRuleId))
            //{
            //    if (!long.TryParse(_BatchRuleId, out long outBatchRuleId) && !string.IsNullOrEmpty(_BatchRuleId))
            //    {
            //        throw Oops.Oh($"第{index}行[批次属性规则]{_BatchRuleId}值不正确！");
            //    }
            //    if (outBatchRuleId <= 0 && !string.IsNullOrEmpty(_BatchRuleId))
            //    {
            //        throw Oops.Oh($"第{index}行[批次属性规则]{_BatchRuleId}值不能小于等于0！");
            //    }
            //    else
            //    {
            //        addItem.BatchRuleId = outBatchRuleId;
            //    }

            //}
            //if (!string.IsNullOrEmpty(_ControlRuleId))
            //{
            //    if (!long.TryParse(_ControlRuleId, out long outControlRuleId) && !string.IsNullOrEmpty(_ControlRuleId))
            //    {
            //        throw Oops.Oh($"第{index}行[控制属性规则]{_ControlRuleId}值不正确！");
            //    }
            //    if (outControlRuleId <= 0 && !string.IsNullOrEmpty(_ControlRuleId))
            //    {
            //        throw Oops.Oh($"第{index}行[控制属性规则]{_ControlRuleId}值不能小于等于0！");
            //    }
            //    else
            //    {
            //        addItem.ControlRuleId = outControlRuleId;
            //    }

            //}

            if (string.IsNullOrEmpty(_IsDisabled))
            {
                throw Oops.Oh($"第{index}行[是否禁用]{_IsDisabled}不能为空！");
            }

            if (!string.IsNullOrEmpty(_IsDisabled))
            {
                if (!_IsDisabled.Equals("是") && !_IsDisabled.Equals("否"))
                {
                    throw Oops.Oh($"第{index}行[是否禁用]{_IsDisabled}值不正确！");
                }
                else
                {
                    bool outIsDisabled = _IsDisabled.Equals("是") ? true : false;
                    addItem.IsDisabled = outIsDisabled;
                }
            }

            if (!string.IsNullOrEmpty(_MaterialDesc))
            {
                addItem.MaterialDesc = (string)(_MaterialDesc.Trim());
            }

            if (string.IsNullOrEmpty(_IsCheck))
            {
                throw Oops.Oh($"第{index}行[是否质检]{_IsCheck}不能为空！");
            }

            if (!string.IsNullOrEmpty(_IsCheck))
            {
                if (!_IsCheck.Equals("是") && !_IsCheck.Equals("否"))
                {
                    throw Oops.Oh($"第{index}行[是否质检]{_IsCheck}值不正确！");
                }
                else
                {
                    bool outIsCheck = _IsCheck.Equals("是") ? true : false;
                    addItem.IsCheck = outIsCheck;
                }
            }

            //if (!string.IsNullOrEmpty(_BatchRuleCode))
            //{
            //    addItem.BatchRuleCode = (string)(_BatchRuleCode.Trim());
            //}
            //if (!string.IsNullOrEmpty(_ControlRuleCode))
            //{
            //    addItem.ControlRuleCode = (string)(_ControlRuleCode.Trim());
            //}
            #endregion


            details.Add(addItem);
        }
        //验重
        await CheckExisitForImport(details);
        return details;
    }

    /// <summary>
    /// 根据版本下载物料信息表的Excel导入模板
    /// </summary>
    /// <returns>下载的模板文件</returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "DownloadExcelTemplate")]
    [Description("WmsMaterial/DownloadExcelTemplate")]
    public IActionResult DownloadExcelTemplate()
    {
        string _path = TemplateConst.EXCEL_TEMPLATEFILE_导入模版路径 + $"\\物料信息表{TemplateConst.EXCEL_TEMPLATEFILE_导入模版名称后缀}.xlsx";
        var fileName = HttpUtility.UrlEncode($"导入模板(物料信息表).xlsx", Encoding.GetEncoding("UTF-8"));
        return new FileStreamResult(new FileStream(_path, FileMode.Open), "application/octet-stream") { FileDownloadName = fileName };
    }

    /// <summary>
    /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
    /// </summary>
    /// <param name="inputs"></param>
    /// <returns></returns>
    private async Task CheckExisitForImport(List<WmsBaseMaterial> inputs)
    {
        if (inputs?.Count <= 0)
        {
            throw Oops.Oh($"导入数据不能为空");
        }
        //根据组合校验验证表格中中是否已存在相同数据  








        //根据单独校验验证表格中中是否已存在相同数据  



    }

    #endregion

    #region 私有方法

    /// <summary>
    /// 根据联合主键验证数据是否已存在-数据库
    /// </summary>
    /// <param name="input"></param>
    /// <param name="isEdit"></param>
    /// <returns></returns>
    private async Task CheckExisit(WmsBaseMaterial input, bool isEdit = false)
    {
        //输出数据已存在错误
        ErrorCodeItemMetadataAttribute metadata = ErrorCodeEnum.D1006.GetErrorCodeItemMetadata();

        WmsBaseMaterial _existItem = null;
        if (!isEdit)//新增
        {
            _existItem = await _wmsMaterialRep.GetFirstAsync(u => u.MaterialCode.Equals(input.MaterialCode));
            if (_existItem != null) throw Oops.Oh($"物料编号[{input.MaterialCode}]{metadata.ErrorMessage}");

            _existItem = await _wmsMaterialRep.GetFirstAsync(u => u.MaterialName.Equals(input.MaterialName));
            if (_existItem != null) throw Oops.Oh($"物料名称[{input.MaterialName}]{metadata.ErrorMessage}");

        }
        else//编辑 
        {

            //当前编辑数据以外是否存在重复
            _existItem = await _wmsMaterialRep.GetFirstAsync(u => u.Id != input.Id && u.MaterialCode.Equals(input.MaterialCode));
            if (_existItem != null) throw Oops.Oh($"物料编号[{input.MaterialCode}]{metadata.ErrorMessage}");

            _existItem = await _wmsMaterialRep.GetFirstAsync(u => u.Id != input.Id && u.MaterialName.Equals(input.MaterialName));
            if (_existItem != null) throw Oops.Oh($"物料名称[{input.MaterialName}]{metadata.ErrorMessage}");


        }

    }

    #endregion


}