iWare_RawMaterialWarehouse.git

using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
using DocumentFormat.OpenXml.Drawing;
using DocumentFormat.OpenXml.Vml.Spreadsheet;
using AngleSharp.Css;
using AngleSharp.Dom;
using NPOI.POIFS.Storage;
using DocumentFormat.OpenXml.Spreadsheet;
using NPOI.Util;
 
namespace Admin.NET.Application;
/// <summary>
/// 下架策略服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsSystemConfigGroupName, Order = 100)]
public class WmsConfigUnshelveStrategyService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsConfigUnshelveStrategy> _rep;
    private readonly SqlSugarRepository<WmsConfigUnshelveStrategyChoose> _repWmsConfigUnshelveStrategyChoose;
    private readonly SqlSugarRepository<WmsConfigUnshelveStrategyRange> _repWmsConfigUnshelveStrategyRange;
 
 
    public WmsConfigUnshelveStrategyService(SqlSugarRepository<WmsConfigUnshelveStrategy> rep, SqlSugarRepository<WmsConfigUnshelveStrategyChoose> repWmsConfigUnshelveStrategyChoose, SqlSugarRepository<WmsConfigUnshelveStrategyRange> repWmsConfigUnshelveStrategyRange)
    {
        _rep = rep;
        _repWmsConfigUnshelveStrategyChoose = repWmsConfigUnshelveStrategyChoose;
        _repWmsConfigUnshelveStrategyRange = repWmsConfigUnshelveStrategyRange;
    }
 
    /// <summary>
    /// 分页查询下架策略
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    [Description("WmsConfigUnshelveStrategy/Page")]
    public async Task<SqlSugarPagedList<WmsConfigUnshelveStrategyOutput>> Page(WmsConfigUnshelveStrategyInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").ToPagedListAsync(input.Page, input.PageSize);
    }
 
    /// <summary>
    /// 不分页查询下架策略
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    [Description("WmsConfigUnshelveStrategy/List")]
    public async Task<List<WmsConfigUnshelveStrategyOutput>> List([FromQuery] WmsConfigUnshelveStrategyInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").Select<WmsConfigUnshelveStrategyOutput>().ToListAsync();
    }
 
    /// <summary>
    /// 增加下架策略
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [Description("WmsConfigUnshelveStrategy/Add")]
    public async Task<long> Add(AddWmsConfigUnshelveStrategyInput input)
    {
        var entity = input.Adapt<WmsConfigUnshelveStrategy>();
 
        //重复性验证
        await CheckExist(entity);
 
        await _rep.InsertAsync(entity);
        return entity.Id;
    }
 
 
 
    /// <summary>
    /// 增加下架策略，下架范围，下架方式
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "AddConfigUnshelveStrategy")]
    [Description("WmsConfigUnshelveStrategy/AddConfigUnshelveStrategy")]
    public async Task AddConfigUnshelveStrategy([FromBody] AllConfigUnshelveStrategyInput input)
    {
 
        var wmsConfigUnshelveStrategyChooseList = new List<WmsConfigUnshelveStrategyChoose>();
        var wmsConfigUnshelveStrategyRangeList = new List<WmsConfigUnshelveStrategyRange>();
        var WmsConfigUnshelveStrategyModel = await _rep.AsQueryable().FirstAsync(p => p.StrategyCode == input.StrategyCode|| p.StrategyName == input.StrategyName);
        if (WmsConfigUnshelveStrategyModel != null) throw Oops.Oh("该下架策略已存在！");
 
 
 
        //下架策略列表数据判断
 
 
        CheckInput(input);
 
        var materialCodeList = input.WmsConfigUnshelveStrategyRange.Select(p => p.MaterialCode).ToList();
        var materialList = await _repWmsConfigUnshelveStrategyRange.AsQueryable().Where(p => materialCodeList.Contains(p.MaterialCode)).ToListAsync();
        if (materialList.Count != 0)
        {
 
            //获取生效的策略  update by liuwq 20240804
            //生效、失效时间 均可以为空
            var wmsConfigUnshelveStrategyList = await _rep.AsQueryable().Where(p =>p.IsDisabled==false&&p.IsDelete==false&&
            (p.StartTime ==null|| p.StartTime <= DateTime.Now) &&(p.EndTime==null|| DateTime.Now<=p.EndTime)&&materialList.Select(s=>s.StrategyCode).ToList().Contains(p.StrategyCode)).ToListAsync();
            var materialCode = "";
            int index = 1;
            foreach (var item in materialList)
            {
                var wmsConfigUnshelveStrategy = wmsConfigUnshelveStrategyList.Where(p => p.StrategyCode == item.StrategyCode).FirstOrDefault();
 
                if (wmsConfigUnshelveStrategy == null)
                {
                    continue;//所选物料存在的下架策略未生效 
                }
                if (index < materialList.Count()) { materialCode += item.MaterialCode + ","; } else { materialCode += item.MaterialCode; }
                index++;
            }
            //update by liuwq 20240804
            if (string.IsNullOrWhiteSpace(materialCode))
            {
                throw Oops.Oh("所选物料"+ materialCode+"下架策略未生效");
            }
            //
           // throw Oops.Oh("所选择的物料"+ materialCode+"已有下架策略");
 
        }
 
 
        var wmsConfigUnshelveStrategyMain = new WmsConfigUnshelveStrategy()
        {
            StrategyCode = input.StrategyCode,
            StrategyName = input.StrategyName,
            StartTime = input.StartTime,
            EndTime = input.EndTime,
            IsDisabled = input.IsDisabled
        };
        foreach (var item in input.WmsConfigUnshelveStrategyChoose)
        {
 
 
            var ConfigUnshelveStrategyChoose = new WmsConfigUnshelveStrategyChoose()
            {
                StrategyCode = input.StrategyCode,
                StrategyOption = (StrategyOptionEnum)item.StrategyOption,
                Priority = item.Priority,
            };
            wmsConfigUnshelveStrategyChooseList.Add(ConfigUnshelveStrategyChoose);
        }
        foreach (var item in input.WmsConfigUnshelveStrategyRange)
        {
 
 
 
            var ConfigUnshelveStrategyRange = new WmsConfigUnshelveStrategyRange()
            {
                StrategyCode = input.StrategyCode,
                MaterialCode = item.MaterialCode,
                MaterialName = item.MaterialName,
                MaterialUnit = item.MaterialUnit
            };
            wmsConfigUnshelveStrategyRangeList.Add(ConfigUnshelveStrategyRange);
        }
 
        var _tenant = _rep.AsTenant();
        try
        {
            await _tenant.BeginTranAsync();
            await _rep.InsertAsync(wmsConfigUnshelveStrategyMain);
            await _repWmsConfigUnshelveStrategyChoose.InsertRangeAsync(wmsConfigUnshelveStrategyChooseList);
            await _repWmsConfigUnshelveStrategyRange.InsertRangeAsync(wmsConfigUnshelveStrategyRangeList);
 
 
            await _tenant.CommitTranAsync();
        }
        catch
        {
            await _tenant.RollbackTranAsync();
            throw;
        }
 
    }
 
 
 
    /// <summary>
    /// 搜索下架策略，下架范围，下架方式
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "QueryConfigUnshelveStrategyInfo")]
    [Description("WmsConfigUnshelveStrategy/QueryConfigUnshelveStrategyInfo")]
    public async Task<AllConfigUnshelveStrategyOutput> QueryConfigUnshelveStrategyInfo([FromQuery] QueryConfigUnshelveStrategyInfoInput input)
    {
        var returnModel = new AllConfigUnshelveStrategyOutput();
        //主表内容
        var main = await _rep.AsQueryable().FirstAsync(p => p.Id == input.StrategyId);
        if (main == null) throw Oops.Oh("当前下架策略暂无数据");
        var ChooseList = await _repWmsConfigUnshelveStrategyChoose.AsQueryable().Where(p => p.StrategyCode == main.StrategyCode).ToListAsync();
        var RangeList = await _repWmsConfigUnshelveStrategyRange.AsQueryable().Where(p => p.StrategyCode == main.StrategyCode).ToListAsync();
 
        returnModel.WmsConfigUnshelveStrategyChooseList = ChooseList;
        returnModel.WmsConfigUnshelveStrategyModel = main;
        returnModel.WmsConfigUnshelveStrategyRangeList = RangeList;
 
        return returnModel;
    }
 
 
    /// <summary>
    /// 更新下架策略，下架范围，下架方式
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "UpdateConfigUnshelveStrategy")]
    [Description("WmsConfigUnshelveStrategy/UpdateConfigUnshelveStrategy")]
    public async Task UpdateConfigUnshelveStrategy([FromBody] AllConfigUnshelveStrategyInput input)
    {
 
 
 
        var deleteConfigUnshelveStrategyChooseList = new List<WmsConfigUnshelveStrategyChoose>();
        var deleteConfigUnshelveStrategyRangeList = new List<WmsConfigUnshelveStrategyRange>();
        //先删除对应主表的范围和策略
        var ChooseList = await _repWmsConfigUnshelveStrategyChoose.AsQueryable().Where(p => p.StrategyCode == input.StrategyCode).ToListAsync();
        var RangeList = await _repWmsConfigUnshelveStrategyRange.AsQueryable().Where(p => p.StrategyCode == input.StrategyCode).ToListAsync();
        if (ChooseList.Count != 0 || RangeList.Count != 0)
        {
            //await _repWmsConfigUnshelveStrategyChoose.DeleteAsync(ChooseList);
            //await _repWmsConfigUnshelveStrategyRange.DeleteAsync(RangeList);
            //这里直接执行了删除 如果抛异常 编辑的没执行，数据也已经删除了
 
            deleteConfigUnshelveStrategyChooseList.AddRange(ChooseList);
            deleteConfigUnshelveStrategyRangeList.AddRange(RangeList);
 
        }
 
        var entity = input.Adapt<WmsConfigUnshelveStrategy>();
        //重复性验证
        await CheckExist(entity, true);
 
 
 
        var wmsConfigUnshelveStrategyChooseList = new List<WmsConfigUnshelveStrategyChoose>();
        var wmsConfigUnshelveStrategyRangeList = new List<WmsConfigUnshelveStrategyRange>();
 
        CheckInput(input);
 
        //var ortherWmsConfigUnshelveStrategyList = await _rep.GetListAsync(s => s.StartTime >= DateTime.Now && (s.EndTime <= DateTime.Now || s.EndTime == null) && s.StrategyCode != entity.StrategyCode);
        //var ortherStrategyCodeList = ortherWmsConfigUnshelveStrategyList.Select(s => s.StrategyCode).ToList();//生效的下架策略
 
        var materialCodeList = input.WmsConfigUnshelveStrategyRange.Select(p => p.MaterialCode).ToList();
       // var materialList = await _repWmsConfigUnshelveStrategyRange.AsQueryable().Where(p => ortherStrategyCodeList.Contains(p.StrategyCode) && materialCodeList.Contains(p.MaterialCode)).ToListAsync();
          var materialList = await _repWmsConfigUnshelveStrategyRange.AsQueryable().Where(p => p.StrategyCode != entity.StrategyCode && materialCodeList.Contains(p.MaterialCode)).ToListAsync();
 
 
        if (materialList.Count != 0)
        {
            var materialCode = "";
            int index = 1;
            foreach (var item in materialList)
            {
                if (index < materialList.Count()) { materialCode += item.MaterialCode + ","; } else { materialCode += item.MaterialCode; }
                index++;
            }
 
            throw Oops.Oh("所选择的物料" + materialCode + "已有下架策略");
 
        }
 
        foreach (var item in input.WmsConfigUnshelveStrategyChoose)
        {
            var ConfigUnshelveStrategyChoose = new WmsConfigUnshelveStrategyChoose()
            {
                StrategyCode = input.StrategyCode,
                StrategyOption = (StrategyOptionEnum)item.StrategyOption,
                Priority = item.Priority,
            };
            wmsConfigUnshelveStrategyChooseList.Add(ConfigUnshelveStrategyChoose);
        }
        foreach (var item in input.WmsConfigUnshelveStrategyRange)
        {
            var ConfigUnshelveStrategyRange = new WmsConfigUnshelveStrategyRange()
            {
                StrategyCode = input.StrategyCode,
                MaterialCode = item.MaterialCode,
                MaterialName = item.MaterialName,
                MaterialUnit = item.MaterialUnit
            };
            wmsConfigUnshelveStrategyRangeList.Add(ConfigUnshelveStrategyRange);
        }
 
        var _tenant = _rep.AsTenant();
        try
        {
            await _tenant.BeginTranAsync();
 
            if (deleteConfigUnshelveStrategyChooseList?.Count > 0)
            {
                await _repWmsConfigUnshelveStrategyChoose.DeleteAsync(deleteConfigUnshelveStrategyChooseList);
            }
            if (deleteConfigUnshelveStrategyRangeList?.Count > 0)
            {
                await _repWmsConfigUnshelveStrategyRange.DeleteAsync(deleteConfigUnshelveStrategyRangeList);
            }
 
            await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: false).ExecuteCommandAsync();//策略失效时间允许为空
            await _repWmsConfigUnshelveStrategyChoose.InsertRangeAsync(wmsConfigUnshelveStrategyChooseList);
            await _repWmsConfigUnshelveStrategyRange.InsertRangeAsync(wmsConfigUnshelveStrategyRangeList);
 
 
            await _tenant.CommitTranAsync();
        }
        catch
        {
            await _tenant.RollbackTranAsync();
            throw;
        }
    }
 
    /// <summary>
    /// 校验策略入参
    /// </summary>
    /// <param name="input"></param>
    /// <exception cref="Exception"></exception>
    private static void CheckInput(AllConfigUnshelveStrategyInput input)
    {
        //下架策略列表数据判断
 
        if (input.StartTime.HasValue && input.EndTime.HasValue && input.StartTime.Value > input.EndTime.Value)
        {
            throw Oops.Oh("下架策略生效时间不能晚于策略失效时间");
        }
        if (input.WmsConfigUnshelveStrategyChoose?.Count <= 0)
        {
            throw Oops.Oh("下架策略选项类型不能为空");
        }
 
        ////TODO 暂时 只能支持 一个下架策略
        //if (input.WmsConfigUnshelveStrategyChoose.Count > 1)
        //{
        //    throw Oops.Oh("下架策略选项类型只能选一个");
        //}
 
        if (input.WmsConfigUnshelveStrategyChoose.Any(a => a.StrategyOption == null))
        {
            throw Oops.Oh("下架策略必须选择策略选项");
        }
        if (input.WmsConfigUnshelveStrategyChoose.Any(a => a.Priority == 0))
        {
            throw Oops.Oh("下架策略必须选择优先级");
        }
        if (input.WmsConfigUnshelveStrategyChoose.GroupBy(x => x.Priority).Any(g => g.Count() > 1))
        {
            throw Oops.Oh("下架策略优先级选择重复");
        }
        if (input.WmsConfigUnshelveStrategyChoose.GroupBy(x => x.StrategyOption).Any(g => g.Count() > 1))
        {
            throw Oops.Oh("下架策略选项类型重复");
        }
 
 
 
        // 统计枚举值的出现次数
        int countValue1 = input.WmsConfigUnshelveStrategyChoose.Count(item => item.StrategyOption == StrategyOptionEnum.先进先出_天);
        //int countValue2 = input.WmsConfigUnshelveStrategyChoose.Count(item => item.StrategyOption == StrategyOptionEnum.先进先出_小时);
        int countValue3 = input.WmsConfigUnshelveStrategyChoose.Count(item => item.StrategyOption == StrategyOptionEnum.整拖优先);
        int countValue4 = input.WmsConfigUnshelveStrategyChoose.Count(item => item.StrategyOption == StrategyOptionEnum.零散优先);
        //if (countValue1 > 0 && countValue2 > 0)
        //{
        //    throw new Exception("“先进先出_天”不能和“先进先出_小时”同时选择");
        //}
        if (countValue3 > 0 && countValue4 > 0)
        {
            throw new Exception("“满托推荐”不能和“半满推荐”同时选择");
        }
 
        if (input.WmsConfigUnshelveStrategyRange?.Count() <= 0)
        {
            throw Oops.Oh("下架范围物料不能为空");
        }
 
        //下架范围列表数据判断
        if (input.WmsConfigUnshelveStrategyRange.GroupBy(x => x.MaterialCode).Any(g => g.Count() > 1))
        {
            throw Oops.Oh("下架范围物料选择重复");
        }
    }
 
 
 
    /// <summary>
    /// 删除下架策略
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    [Description("WmsConfigUnshelveStrategy/Delete")]
    public async Task Delete(DeleteWmsConfigUnshelveStrategyInput input)
    {
        var entity = await _rep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
 
        var ChooseList = await _repWmsConfigUnshelveStrategyChoose.AsQueryable().Where(p => p.StrategyCode == entity.StrategyCode).ToListAsync();
        var RangeList = await _repWmsConfigUnshelveStrategyRange.AsQueryable().Where(p => p.StrategyCode == entity.StrategyCode).ToListAsync();
 
        await _repWmsConfigUnshelveStrategyChoose.DeleteAsync(ChooseList);
        await _repWmsConfigUnshelveStrategyRange.DeleteAsync(RangeList);
        //await _rep.FakeDeleteAsync(entity);   //假删除
        await _rep.DeleteAsync(entity);   //真删除
    }
 
    /// <summary>
    /// 更新下架策略
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [Description("WmsConfigUnshelveStrategy/Update")]
    public async Task Update(UpdateWmsConfigUnshelveStrategyInput input)
    {
        var entity = input.Adapt<WmsConfigUnshelveStrategy>();
 
        //重复性验证
        await CheckExist(entity, true);
 
        await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
    }
 
    /// <summary>
    /// 获取下架策略
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    [Description("WmsConfigUnshelveStrategy/Detail")]
    public async Task<WmsConfigUnshelveStrategy> Detail([FromQuery] QueryByIdWmsConfigUnshelveStrategyInput input)
    {
        return await _rep.GetFirstAsync(u => u.Id == input.Id);
    }
 
 
 
 
 
 
    #region 私有方法
 
    /// <summary>
    /// 公共查询下架策略条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<WmsConfigUnshelveStrategyOutput> CommonPageFilter(WmsConfigUnshelveStrategyInput input)
    {
        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.StrategyCode.Contains(input.SearchKey.Trim())
                || u.StrategyName.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
            )
            .WhereIF(!string.IsNullOrWhiteSpace(input.StrategyCode), u => u.StrategyCode.Contains(input.StrategyCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.StrategyName), u => u.StrategyName.Contains(input.StrategyName.Trim()))
            .WhereIF(input.IsDisabled.HasValue, u => u.IsDisabled == input.IsDisabled)
            .Select<WmsConfigUnshelveStrategyOutput>();
        if (input.StartTimeRange != null && input.StartTimeRange.Count > 0)
        {
            DateTime? start = input.StartTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.StartTime > start);
            if (input.StartTimeRange.Count > 1 && input.StartTimeRange[1].HasValue)
            {
                var end = input.StartTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.StartTime < end);
            }
        }
        if (input.EndTimeRange != null && input.EndTimeRange.Count > 0)
        {
            DateTime? start = input.EndTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.EndTime > start);
            if (input.EndTimeRange.Count > 1 && input.EndTimeRange[1].HasValue)
            {
                var end = input.EndTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.EndTime < end);
            }
        }
        return query;
    }
 
    /// <summary>
    /// 重复性验证
    /// </summary>
    /// <param name="input">验证对象</param>
    /// <param name="isEdit">是否是编辑</param>
    /// <returns></returns>
    private async Task CheckExist(WmsConfigUnshelveStrategy input, bool isEdit = false)
    {
 
 
 
        //没有配置组合校验，不需要验重
 
 
        bool isExistForSingle_StrategyCode = false;
        if (!isEdit)//新增
        {
            //数据是否单独存在重复-策略代码
            isExistForSingle_StrategyCode = await _rep.AsQueryable().AnyAsync(u =>
                            u.StrategyCode.Equals(input.StrategyCode));
        }
        else//编辑 
        {
            //当前编辑数据以外是否单独存在重复-策略代码
            isExistForSingle_StrategyCode = await _rep.AsQueryable().AnyAsync(u =>
                              u.Id != input.Id
                              && u.StrategyCode.Equals(input.StrategyCode));
        }
        if (isExistForSingle_StrategyCode) throw Oops.Oh($"验证失败,策略代码[" + input.StrategyCode + "]已存在");
 
        bool isExistForSingle_StrategyName = false;
        if (!isEdit)//新增
        {
            //数据是否单独存在重复-策略名称
            isExistForSingle_StrategyName = await _rep.AsQueryable().AnyAsync(u =>
                            u.StrategyName.Equals(input.StrategyName));
        }
        else//编辑 
        {
            //当前编辑数据以外是否单独存在重复-策略名称
            isExistForSingle_StrategyName = await _rep.AsQueryable().AnyAsync(u =>
                              u.Id != input.Id
                              && u.StrategyName.Equals(input.StrategyName));
        }
        //if (isExistForSingle_StrategyName) throw Oops.Oh($"验证失败,策略名称[" + input.StrategyName + "]已存在");
 
    }
 
    /// <summary>
    /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
    /// </summary>
    /// <param name="inputs"></param>
    /// <returns></returns>
    private async Task CheckExisitForImport(List<WmsConfigUnshelveStrategy> inputs)
    {
        if (inputs?.Count <= 0)
        {
            throw Oops.Oh($"导入数据不能为空");
        }
        //根据组合校验验证表格中中是否已存在相同数据  
 
 
 
 
 
 
 
 
        //根据单独校验验证表格中中是否已存在相同数据  
        var existExcelItemForSingle_StrategyCode = inputs.GroupBy(g => new { g.StrategyCode }).Where(g => g.Count() > 1).ToList();
        if (existExcelItemForSingle_StrategyCode != null && existExcelItemForSingle_StrategyCode.Count > 0)
        {
            var item = existExcelItemForSingle_StrategyCode.First().ToList().First();
            throw Oops.Oh($"验证失败,导入的表格中,策略代码[" + item.StrategyCode + "]已重复存在");
        }
        var existExcelItemForSingle_StrategyName = inputs.GroupBy(g => new { g.StrategyName }).Where(g => g.Count() > 1).ToList();
        if (existExcelItemForSingle_StrategyName != null && existExcelItemForSingle_StrategyName.Count > 0)
        {
            var item = existExcelItemForSingle_StrategyName.First().ToList().First();
            throw Oops.Oh($"验证失败,导入的表格中,策略名称[" + item.StrategyName + "]已重复存在");
        }
 
        //根据单独校验验证数据库中是否已存在相同数据
        var existDBItemList = await _rep.GetListAsync(w =>
                    inputs.Select(s => s.StrategyCode).ToList().Contains(w.StrategyCode) ||
                    inputs.Select(s => s.StrategyName).ToList().Contains(w.StrategyName)
   );
        var db_ForSingle_StrategyCode = existDBItemList.FirstOrDefault(g => inputs.Select(s => s.StrategyCode).ToList().Contains(g.StrategyCode));
        if (db_ForSingle_StrategyCode != null) throw Oops.Oh($"验证失败,系统中,策略代码[" + db_ForSingle_StrategyCode.StrategyCode + "]已重复存在");
 
        var db_ForSingle_StrategyName = existDBItemList.FirstOrDefault(g => inputs.Select(s => s.StrategyName).ToList().Contains(g.StrategyName));
        if (db_ForSingle_StrategyName != null) throw Oops.Oh($"验证失败,系统中,策略名称[" + db_ForSingle_StrategyName.StrategyName + "]已重复存在");
 
 
 
    }
    #endregion
 
}