using Admin.NET.Core.Service;
using @(@Model.NameSpace).Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
@{
    string joinTableName = "u";
    Dictionary<string, int> definedObjects = new Dictionary<string, int>();
    string my_message_tree = string.Empty;
    bool haveLikeCdt = false;
    string queryOrderStr=string.Empty;
    foreach (var column in Model.TableField){
        if (column.QueryWhether == "Y" && column.WhetherKeyQuery == "Y"){
            haveLikeCdt = true;
        }
        if (column.EffectType == "fk" || column.EffectType == "ApiTreeSelect"){
            queryOrderStr = "u.";
        }
    }
}
namespace @Model.NameSpace;
/// <summary>
/// @(@Model.BusName)服务
/// </summary>
[ApiDescriptionSettings(@(@Model.ProjectLastName)Const.@(@Model.ModuleName)GroupName, Order = 100)]
public class @(@Model.ClassName)Service : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<@(@Model.ClassName)> _rep;
    public @(@Model.ClassName)Service(SqlSugarRepository<@(@Model.ClassName)> rep)
    {
        _rep = rep;
    }

    /// <summary>
    /// 分页查询@(@Model.BusName)
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    [Description("@(@Model.ClassName)/Page")]
    public async Task<SqlSugarPagedList<@(@Model.ClassName)Output>> Page(@(@Model.ClassName)Input input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "@(@queryOrderStr)Id").ToPagedListAsync(input.Page, input.PageSize);
    }

    /// <summary>
    /// 不分页查询@(@Model.BusName)
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    [Description("@(@Model.ClassName)/List")]
    public async Task<List<@(@Model.ClassName)Output>> List([FromQuery] @(@Model.ClassName)Input input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "@(@queryOrderStr)Id").Select<@(@Model.ClassName)Output>().ToListAsync();
    }

    /// <summary>
    /// 增加@(@Model.BusName)
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [Description("@(@Model.ClassName)/Add")]
    public async Task<long> Add(Add@(@Model.ClassName)Input input)
    {
        var entity = input.Adapt<@(@Model.ClassName)>();

        //重复性验证
        await CheckExist(entity);

        await _rep.InsertAsync(entity);
        return entity.Id;
    }

    /// <summary>
    /// 删除@(@Model.BusName)
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    [Description("@(@Model.ClassName)/Delete")]
    public async Task Delete(Delete@(@Model.ClassName)Input input)
    {
@foreach (var column in Model.TableField){
if (@column.ColumnKey == "True"){
        @:var entity = await _rep.GetFirstAsync(u => u.@(@column.PropertyName) == input.@(@column.PropertyName)) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
}
}
      @if(@Model.TableType=="实体表"){
        @://await _rep.FakeDeleteAsync(entity);   //假删除
        @:await _rep.DeleteAsync(entity);   //真删除
      }else{
        @:return;
      }
    }

    /// <summary>
    /// 更新@(@Model.BusName)
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [Description("@(@Model.ClassName)/Update")]
    public async Task Update(Update@(@Model.ClassName)Input input)
    {
        var entity = input.Adapt<@(@Model.ClassName)>();

        //重复性验证
        await CheckExist(entity,true);

        await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
    }

    /// <summary>
    /// 获取@(@Model.BusName)
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    [Description("@(@Model.ClassName)/Detail")]
    public async Task<@(@Model.ClassName)> Detail([FromQuery] QueryById@(@Model.ClassName)Input input)
    {
@foreach (var column in Model.TableField){
if (@column.ColumnKey == "True"){
        @:return await _rep.GetFirstAsync(u => u.@(@column.PropertyName) == input.@(@column.PropertyName));
}   
}   
     @if(@Model.TableType=="视图"){
        @:return null;
      }else{
      }
    }


@foreach (var column in Model.TableField){
if(@column.EffectType == "fk" && (@column.WhetherAddUpdate == "Y" || column.QueryWhether == "Y")){  
    @:/// <summary>
    @:/// 获取@(@column.ColumnComment)列表
    @:/// </summary>
    @:/// <param name="input"></param>
    @:/// <returns></returns>
    @:[ApiDescriptionSettings(Name = "@(@column.FkEntityName)@(@column.PropertyName)Dropdown"), HttpGet]
    @:[Description("@(@Model.ClassName)/@(@column.FkEntityName)@(@column.PropertyName)Dropdown")]
    @:public async Task<dynamic> @(@column.FkEntityName)@(@column.PropertyName)Dropdown()
    @:{
        @:return await _rep.Context.Queryable<@(@column.FkEntityName)>()
                @:.Select(u => new
                @:{
                    @:Label = u.@(@column.FkColumnName),
                    @:Value = u.@(@column.FkSetValueColumnName)
                @:}
                @:).ToListAsync();
    @:}
}
}

@foreach (var column in Model.TableField){
if(@column.EffectType == "Upload"){  
    @:/// <summary>
    @:/// 上传@(@column.ColumnComment)
    @:/// </summary>
    @:/// <param name="file"></param>
    @:/// <returns></returns>
    @:[ApiDescriptionSettings(Name = "Upload@(@column.PropertyName)"), HttpPost]
    @:public async Task<SysFile> Upload@(@column.PropertyName)([Required] IFormFile file)
    @:{
            @:var service = App.GetRequiredService<SysFileService>();
            @:return await service.UploadFile(file, "upload/@(@column.PropertyName)"); 
    @:} 
}
}


@foreach (var column in Model.TableField){
my_message_tree=@column.FkEntityName+"Tree";
if(@column.EffectType == "ApiTreeSelect" && !definedObjects.ContainsKey(@my_message_tree)){
    @{definedObjects.Add(@my_message_tree, 1);}
    @:[HttpGet("@(@column.FkEntityName)Tree")]
    @:public async Task<dynamic> @(@column.FkEntityName)Tree()
    @:{
        @:return await _rep.Context.Queryable<@(@column.FkEntityName)>().ToTreeAsync(u => u.Children, u => u.@(@column.PidColumn), 0);
    @:}
}
}
@if(@Model.Buttons.Contains("导入")){  
    @:#region 导入
    @:
    @:/// <summary>
    @:/// Excel模板导入@(@Model.BusName)功能
    @:/// </summary>
    @:/// <param name="file">Excel模板文件</param>
    @:/// <returns>导入的记录数</returns>
    @:[HttpPost]
    @:[ApiDescriptionSettings(Name = "ImportExcel")]
    @:[Description("@(@Model.ClassName)/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 _rep.InsertRangeAsync(addList);
        @:return addList.Count;
    @:}
    @:
    @:/// <summary>
    @:///  DataTable转换实体对象列表
    @:/// </summary>
    @:/// <param name="dataTable"></param>
    @:/// <param name="dataStartLine">模版列名开始行</param>
    @:/// <returns></returns>
    @:private async Task<List<@(@Model.ClassName)>> CommonImport(DataTable dataTable, int dataStartLine)
    @:{

        @:var details = new List<@(@Model.ClassName)>();
        @:int index = dataStartLine;//模版列名开始行
        @:foreach (System.Data.DataRow row in dataTable.Rows)
        @:{
            @:index++;

            @://导入模版定制化代码（替换模版使用）
            @:@Model.ImportExcelCustomizationContent
              
            @:details.Add(addItem);
        @:}
        @://验重
        @:await CheckExisitForImport(details);
            
        @:return details;
    @:}
    @:
    @:/// <summary>
    @:/// 根据版本下载@(@Model.BusName)的Excel导入模板
    @:/// </summary>
    @:/// <returns>下载的模板文件</returns>
    @:[HttpGet]
    @:[ApiDescriptionSettings(Name = "DownloadExcelTemplate")]
    @:[Description("@(@Model.ClassName)/DownloadExcelTemplate")]
    @:public IActionResult DownloadExcelTemplate()
    @:{
        @:string _path = TemplateConst.EXCEL_TEMPLATEFILE_导入模版路径 + $"\\@Model.BusName{TemplateConst.EXCEL_TEMPLATEFILE_导入模版名称后缀}.xlsx";
        @:var fileName = HttpUtility.UrlEncode($"导入模板(@Model.BusName).xlsx", Encoding.GetEncoding("UTF-8"));
        @:return new FileStreamResult(new FileStream(_path, FileMode.Open), "application/octet-stream") { FileDownloadName = fileName };
    @:}
    @:
    @:#endregion
}

    #region 私有方法

    /// <summary>
    /// 公共查询@(@Model.BusName)条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<@(@Model.ClassName)Output> CommonPageFilter(@(@Model.ClassName)Input input)
    {
        var query = _rep.AsQueryable()
@{string conditionFlag = "";}
@if (haveLikeCdt) {
            @:.WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
    @foreach (var column in Model.TableField){
        if (@column.WhetherKeyQuery == "Y"){
                @:@(conditionFlag)u.@(@column.PropertyName).Contains(input.SearchKey.Trim())
            conditionFlag="|| ";
        }
    }
            @:)
}
@foreach (var column in Model.TableField){
if (@column.QueryWhether == "Y"){
    if (@column.NetType?.TrimEnd('?') == "string"){
        if(@column.QueryType == "like"){
            @:.WhereIF(!string.IsNullOrWhiteSpace(input.@column.PropertyName), u => u.@(@column.PropertyName).Contains(input.@(@column.PropertyName).Trim()))
        }else{
            @:.WhereIF(!string.IsNullOrWhiteSpace(input.@column.PropertyName), u => u.@(@column.PropertyName) @column.QueryType input.@(@column.PropertyName))
        }
    }else if(@column.NetType?.TrimEnd('?') == "int" || @column.NetType?.TrimEnd('?') == "long"){
            @:.WhereIF(input.@column.PropertyName>0, u => u.@(@column.PropertyName) @column.QueryType input.@(@column.PropertyName))
    }else if(@column.NetType?.TrimEnd('?') == "DateTime" && @column.QueryType == "~"){
    }else if(@column.NetType?.TrimEnd('?').EndsWith("Enum") == true  || @column.NetType?.TrimEnd('?') == "bool") {
            @:.WhereIF(input.@(@column.PropertyName).HasValue, u => u.@(@column.PropertyName) @column.QueryType input.@(@column.PropertyName))
    }
} 
}
@if(Model.IsJoinTable){
            @://处理外键和TreeSelector相关字段的连接
    @foreach (var column in Model.TableField){
        if(@column.EffectType == "fk"){
            joinTableName += ", " + column.PropertyName.ToLower();
            @:.LeftJoin<@(@column.FkEntityName)>((@(@joinTableName)) => u.@(@column.PropertyName) == @(@column.PropertyName.ToLower()).@(@column.FkSetValueColumnName) )
        } else if(@column.EffectType == "ApiTreeSelect"){
            joinTableName += ", " + column.PropertyName.ToLower();
            @:.LeftJoin<@(@column.FkEntityName)>((@(@joinTableName)) => u.@(@column.PropertyName) == @(@column.PropertyName.ToLower()).@(@column.ValueColumn) )
        }
    }
            @:.Select((@(@joinTableName)) => new @(@Model.ClassName)Output
            @:{
@foreach (var column in Model.TableField){
                if(@column.EffectType == "fk"){   
                @:@(@column.PropertyName) = u.@(@column.PropertyName), 
                @:@(@column.PropertyName)_@(@column.FkColumnName) = @(@column.PropertyName.ToLower()).@(@column.FkColumnName),
                } else if(@column.EffectType == "ApiTreeSelect"){  
                @:@(@column.PropertyName) = u.@(@column.PropertyName),  
                @:@(@column.PropertyName)@(@column.DisplayColumn) = @(@column.PropertyName.ToLower()).@(@column.DisplayColumn),
                } else if(@column.NetType?.TrimEnd('?').EndsWith("Enum") == true){
                @:@(@column.PropertyName) = (@(@column.NetType))u.@(@column.PropertyName),
                } else {
                @:@(@column.PropertyName) = u.@(@column.PropertyName),
                }
}
            @:});
@foreach (var column in Model.TableField){
    if(@column.EffectType == "fk"){   
 
    }else if(@column.EffectType == "Upload"){
            @://.Mapper(c => c.@(@column.PropertyName)Attachment, c => c.@(@column.PropertyName))
    }
}
} else {
            @:.Select<@(@Model.ClassName)Output>();
}
@foreach (var column in Model.TableField){
if (@column.QueryWhether == "Y"){
    if(@column.NetType?.TrimEnd('?') == "DateTime" && @column.QueryType == "~" &&  @column.EffectType == "DateTimePicker"){
        @:if(input.@(@column.PropertyName)Range != null && input.@(@column.PropertyName)Range.Count >0)
        @:{
            @:DateTime? start= input.@(@column.PropertyName)Range[0].Value;
            @:query = query.WhereIF(start.HasValue, u => u.@column.PropertyName >= start);
            @:if (input.@(@column.PropertyName)Range.Count >1 && input.@(@column.PropertyName)Range[1].HasValue)
            @:{
                @:var end = input.@(@column.PropertyName)Range[1].Value;
                @:query = query.Where(u => u.@(@column.PropertyName) <= end);
            @:}
        @:} 
    }else  if(@column.NetType?.TrimEnd('?') == "DateTime" && @column.QueryType == "~" &&  @column.EffectType == "DatePicker"){
        @:if(input.@(@column.PropertyName)Range != null && input.@(@column.PropertyName)Range.Count >0)
        @:{
            @:DateTime? start= input.@(@column.PropertyName)Range[0].Value.AddDays(-1);
            @:query = query.WhereIF(start.HasValue, u => u.@column.PropertyName > start);
            @:if (input.@(@column.PropertyName)Range.Count >1 && input.@(@column.PropertyName)Range[1].HasValue)
            @:{
                @:var end = input.@(@column.PropertyName)Range[1].Value.AddDays(1);
                @:query = query.Where(u => u.@(@column.PropertyName) < end);
            @:}
        @:} 
    }
}
}
        return query;
       }

        /// <summary>
        /// 重复性验证
        /// </summary>
        /// <param name="input">验证对象</param>
        /// <param name="isEdit">是否是编辑</param>
        /// <returns></returns>
        private async Task CheckExist( @(@Model.ClassName) input,bool isEdit=false)
        {
            @{
                var columnIndex = 0;
                string my_message = string.Empty;
             }
           
                                      @foreach (var column in Model.TableField)
                                      {
                                           if (@column.RepCheckType == "组合校验")
                {
                    my_message += "," + @column.ColumnComment + "[{input." + @column.ColumnName + "}]";
                }
                                          if (@column.RepCheckType == "组合校验")
                                          {   
                                              columnIndex++;
                                              if (@columnIndex == 1)
                                              {
           @:bool isExist = false;
           @:if (!isEdit)//新增
           @:{
                   @://数据是否存在重复
                   @:isExist = await _rep.AsQueryable().AnyAsync(u =>
                                   @:u.@(@column.ColumnName).Equals(input.@column.ColumnName)
                                              }
                                              else
                                              {
                                   @:&& u.@(@column.ColumnName).Equals(input.@column.ColumnName)
                                              }
                                          }
                                      }
                @if(columnIndex>0){
                   @:);
          @:}
           @:else//编辑 
          @:{
                 }

                @{
                  columnIndex=0;//初始化索引 下面编辑的逻辑使用
                }
                                      @foreach (var column in Model.TableField)
                                      {
                                          if (@column.RepCheckType == "组合校验")
                                          {  
                                              columnIndex++;
                                              if (@columnIndex == 1)
                                              {
                 @://当前编辑数据以外是否存在重复
                 @: isExist = await _rep.AsQueryable().AnyAsync(u => 
                                    @:u.Id != input.Id
                                    @:&& u.@(@column.ColumnName).Equals(input.@column.ColumnName)
                                              }
                                              else
                                              {
                                    @:&& u.@(@column.ColumnName).Equals(input.@column.ColumnName)
                                              }
                                            }
                                       }
                    @if(columnIndex>0)
                    {
                    @:);
               @:}
                    }

      @if(columnIndex>0){
            @:if (isExist) throw Oops.Oh($"验证失败@(@my_message)已存在");
       }else{
            @://没有配置组合校验，不需要验重
       }

       @{
                var columnIndex2 = 0;
                string my_message2 = string.Empty;
             }
           
              @foreach (var column in Model.TableField)
              {
                 if (@column.RepCheckType == "单独校验")
                {
                    my_message2 += "," + @column.ColumnComment + "[{input." + @column.ColumnName + "}]";
                }
                                          if (@column.RepCheckType == "单独校验")
                                          {   
                                              columnIndex2++;
           @:bool isExistForSingle_@column.ColumnName = false;
           @:if (!isEdit)//新增
           @:{
                   @://数据是否单独存在重复-@(@column.ColumnComment)
                   @:isExistForSingle_@column.ColumnName = await _rep.AsQueryable().AnyAsync(u =>
                                   @:u.@(@column.ColumnName).Equals(input.@column.ColumnName));
           @:}
           @:else//编辑 
           @:{
                   @://当前编辑数据以外是否单独存在重复-@(@column.ColumnComment)
                 @: isExistForSingle_@column.ColumnName = await _rep.AsQueryable().AnyAsync(u => 
                                    @:u.Id != input.Id
                                    @:&& u.@(@column.ColumnName).Equals(input.@column.ColumnName));
           @:}
           @:if (isExistForSingle_@column.ColumnName) throw Oops.Oh($"验证失败,@(@column.ColumnComment)[" + input.@column.ColumnName + "]已存在");
             @:
              }
             }
               @if(columnIndex2==0){
            @://没有配置单独校验，不需要验重
       }
       }

       /// <summary>
        /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
        /// </summary>
        /// <param name="inputs"></param>
        /// <returns></returns>
        private async Task CheckExisitForImport(List<@(@Model.ClassName)> inputs)
        { 
            @{
                var index = 0;
                bool isCheck = false;
                string message = string.Empty;
            }
            if (inputs?.Count <= 0)
            {
                throw Oops.Oh($"导入数据不能为空");
            }
            //根据组合校验验证表格中中是否已存在相同数据  
            @foreach (var column in Model.TableField)
            {
                if (@column.RepCheckType == "组合校验")
                {
                    isCheck = true;
                    message += "," + @column.ColumnComment + "[{item." + @column.ColumnName + "}]";
                }
            }
            @if (isCheck)
            {
                 @:var existExcelItem = inputs.GroupBy(g => new {
            }
           @foreach (var column in Model.TableField)
           {

               if (@column.RepCheckType == "组合校验")
               {   
                   index++;
                   if (@index == 1)
                   { 
                                               @:g.@(@column.ColumnName)
                   }
                   else
                   {
                                               @:,g.@(@column.ColumnName)
                   }
                                       
                                                                                                                    }
           }
           @if (isCheck)
          {
            index=0;
                                               @:})
                                               @:.Where(g => g.Count() > 1)
                                               @:.Select(s => new {
           }
          @foreach (var column in Model.TableField)
          {

              if (@column.RepCheckType == "组合校验")
              {
                  index++;
                  if (@index == 1)
                  {
                                               @:s.Key.@(@column.ColumnName)
                  }
                  else
                  {
                                               @:,s.Key.@(@column.ColumnName)
                  }

              }
          }
           @if (isCheck)
           {
                                               @:}).FirstOrDefault();
                 @:if (existExcelItem != null)
                 @:{
                   @:var item= existExcelItem.Adapt<@(@Model.ClassName)>();
                   @:throw Oops.Oh($"导入的表格中@(@message)已重复存在");
                 @:}
           }
                      



             @if (isCheck)
            {    @://根据组合校验验证数据库中是否已存在相同数据
                 @:var existDBItem = await _rep.GetFirstAsync(w=> 
                 @:                                                        inputs.Select(s=>""
            }
           @foreach (var column in Model.TableField)
           {

               if (@column.RepCheckType == "组合校验")
               {  
                                                                          @: +s.@(@column.ColumnName)
                                                                      
               }
           }
           @if (isCheck)
          {
                                                                        @:)
                                                                        @:.Contains(""
           }
          @foreach (var column in Model.TableField)
          {
              if (@column.RepCheckType == "组合校验")
              {
                                                                        @: +w.@(@column.ColumnName)
                  
              }
          }
             @if (isCheck)
           {
                 @: ));
                 @: if (existDBItem != null)
                 @:{
                   @:var item= existDBItem.Adapt<@(@Model.ClassName)>();
                   @:throw Oops.Oh($"系统中@(@message)已存在");
                 @:}
           }



          
           @{
                 index = 0;
                 isCheck = false;
                 int count_Single=0;
           }
           //根据单独校验验证表格中中是否已存在相同数据  
           @foreach (var column in Model.TableField)
            {
                if (@column.RepCheckType == "单独校验")
                {
                   @:var existExcelItemForSingle_@(@column.ColumnName) = inputs.GroupBy(g => new { g.@(@column.ColumnName)}).Where(g => g.Count() > 1).ToList();
                   @:if(existExcelItemForSingle_@(@column.ColumnName) != null && existExcelItemForSingle_@(@column.ColumnName).Count > 0){
                        @:var item= existExcelItemForSingle_@(@column.ColumnName).First().ToList().First();
                        @:throw Oops.Oh($"验证失败,导入的表格中,@(@column.ColumnComment)[" + item.@column.ColumnName + "]已重复存在");
                   @:}
                   isCheck = true;
                }
            }
           
            @if (isCheck)
            {    @://根据单独校验验证数据库中是否已存在相同数据
                 @:var existDBItemList = await _rep.GetListAsync(w=> 
            }
           @{
            count_Single=Model.TableField.Count(w=>w.RepCheckType=="单独校验");
           }
           @foreach (var column in Model.TableField)
           {
               if (@column.RepCheckType == "单独校验")
               {  
                          index++;
                          @if(index == count_Single){
                            @: inputs.Select(s=>s.@(@column.ColumnName)).ToList().Contains(w.@(@column.ColumnName)) 
                          }else{
                            @: inputs.Select(s=>s.@(@column.ColumnName)).ToList().Contains(w.@(@column.ColumnName)) ||  
                          }
               }
           }
        @if (isCheck)
        {   
            @:);
        }
         @foreach (var column in Model.TableField)
          {
              if (@column.RepCheckType == "单独校验")
              {
                   @:var db_ForSingle_@column.ColumnName = existDBItemList.FirstOrDefault(g => inputs.Select(s=>s.@(@column.ColumnName)).ToList().Contains(g.@(@column.ColumnName)));
                   @:if(db_ForSingle_@column.ColumnName != null)  throw Oops.Oh($"验证失败,系统中,@(@column.ColumnComment)[" + db_ForSingle_@column.ColumnName.@column.ColumnName + "]已重复存在");
                   @:
              }
          }
           
           
        }
     #endregion

}