wyw/mh_jy_safe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: wyw:59e71a0752ed672b497c4ec1cef5cc7192b23524
Branches Tags
wyw:master
..
compare: wyw:57b96384ab02a434fe8dcdebd7208b52eef20a3c
Branches Tags
wyw:master

2 Commits
59e71a0752 ... 57b96384ab

Author SHA1 Message Date
何美荣
57b96384ab 冲突 2025-09-23 15:56:57 +08:00
何美荣
14ab7472cc T4 2025-09-23 15:56:16 +08:00
20 changed files with 50075 additions and 47399 deletions
Show Stats Expand all files Collapse all files

1453
APT.MicroApi/APT.BD.WebApi/Controllers/Api/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

264
APT.MicroApi/APT.BD.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -1,4 +1,4 @@
<#@ template debug="true" hostspecific="true" language="C#" #> <#@ template debug="false" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #> <#@ assembly name="System.Core" #>
<#@ import namespace="System" #> <#@ import namespace="System" #>
<#@ import namespace="System.Linq" #> <#@ import namespace="System.Linq" #>
@ -19,17 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.BD.WebApi.Controllers.Api namespace APT.BD.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs"); List<TableT4> tables = new List<TableT4>();
List<TableT4> tables = new List<TableT4>(); List<string> modules=new List<string> ();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="BD"; var moduleFix="BD";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 根据主键删除数据
<#} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

11036
APT.MicroApi/APT.FM.WebApi/Controllers/Api/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

266
APT.MicroApi/APT.FM.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -19,17 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.FM.WebApi.Controllers.Api namespace APT.FM.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs"); List<TableT4> tables = new List<TableT4>();
List<TableT4> tables = new List<TableT4>(); List<string> modules=new List<string> ();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="FM"; var moduleFix="FM";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4(); TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt; tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController"; tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){ if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController"; tableT4.BaseApiName="AuthorizeTreeApiController";
} }
tableT4.TableNameSpace = space; tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary> /// <summary>
/// 获得单条实体数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("Paged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 排序分页查询数据
<#} /// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

11238
APT.MicroApi/APT.FO.WebApi/Controllers/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

266
APT.MicroApi/APT.FO.WebApi/Controllers/T4/T4Control.tt
View File

@ -19,17 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.FO.WebApi.Controllers.Api namespace APT.FO.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs"); List<TableT4> tables = new List<TableT4>();
List<TableT4> tables = new List<TableT4>(); List<string> modules=new List<string> ();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="FO"; var moduleFix="FO";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4(); TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt; tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController"; tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){ if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController"; tableT4.BaseApiName="AuthorizeTreeApiController";
} }
tableT4.TableNameSpace = space; tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary> /// <summary>
/// 获得单条实体数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("Paged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 排序分页查询数据
<#} /// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

28925
APT.MicroApi/APT.HM.WebApi/Controllers/Api/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

261
APT.MicroApi/APT.HM.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -19,16 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.HM.WebApi.Controllers.Api namespace APT.HM.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>(); List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> (); List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="HM"; var moduleFix="HM";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -102,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -127,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 根据主键删除数据
<#} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -353,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

220
APT.MicroApi/APT.LG.WebApi/Controllers/Api/T4/T4Control.cs
View File

@ -1,7 +1,13 @@
 
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// T4模板文件：基础接口类 // T4模板文件：基础接口类
// 此代码由T4模板自动生成 // 此代码由T4模板自动生成
@ -13,113 +19,119 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.LG.WebApi.Controllers.Api namespace APT.LG.WebApi.Controllers.Api
{ {
using APT.BaseData.Domain.Entities.LG; using APT.BaseData.Domain.Entities.LG;
#region Oprate-表单操作日志表
/// <summary> #region Oprate-表单操作日志表
/// <summary>
/// 表单操作日志表 /// 表单操作日志表
/// </summary> /// </summary>
[Route("api/LG/Oprate")] [Route("api/LG/Oprate")]
public partial class OprateController : AuthorizeApiController<T_LG_OPRATE> public partial class OprateController : AuthorizeApiController<T_LG_OPRATE>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<T_LG_OPRATE>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_LG_OPRATE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_LG_OPRATE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_LG_OPRATE entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<T_LG_OPRATE>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_LG_OPRATE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<T_LG_OPRATE> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<T_LG_OPRATE> Get([FromBody] KeywordFilter filter) public PagedActionResult<T_LG_OPRATE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
} /// <summary>
#endregion /// 根据主键删除数据
} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_LG_OPRATE entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_LG_OPRATE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_LG_OPRATE> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
}

264
APT.MicroApi/APT.LG.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -19,17 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.LG.WebApi.Controllers.Api namespace APT.LG.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs"); List<TableT4> tables = new List<TableT4>();
List<TableT4> tables = new List<TableT4>(); List<string> modules=new List<string> ();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="LG"; var moduleFix="LG";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4(); TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt; tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController"; tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){ if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController"; tableT4.BaseApiName="AuthorizeTreeApiController";
} }
tableT4.TableNameSpace = space; tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 根据主键删除数据
<#} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

645
APT.MicroApi/APT.NW.WebApi/Controllers/Api/T4/T4Control.cs
View File

@ -1,7 +1,13 @@
 
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// T4模板文件：基础接口类 // T4模板文件：基础接口类
// 此代码由T4模板自动生成 // 此代码由T4模板自动生成
@ -13,333 +19,352 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.NW.WebApi.Controllers.Api namespace APT.NW.WebApi.Controllers.Api
{ {
using APT.BaseData.Domain.Entities.NW; using APT.BaseData.Domain.Entities.NW;
#region Enterprise-子企业表
/// <summary> #region Enterprise-子企业表
/// <summary>
/// 子企业表 /// 子企业表
/// </summary> /// </summary>
[Route("api/NW/Enterprise")] [Route("api/NW/Enterprise")]
public partial class EnterpriseController : AuthorizeTreeApiController<T_NW_ENTERPRISE> public partial class EnterpriseController : AuthorizeTreeApiController<T_NW_ENTERPRISE>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ENTERPRISE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ENTERPRISE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ENTERPRISE entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ENTERPRISE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<T_NW_ENTERPRISE> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<T_NW_ENTERPRISE> Get([FromBody] KeywordFilter filter) public PagedActionResult<T_NW_ENTERPRISE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
/// <summary>
/// 获得树形实体数据 /// <summary>
/// </summary> /// 根据主键删除数据
/// <param name="filter"></param> /// </summary>
/// <returns></returns> /// <param name="id">主键ID</param>
[HttpPost, Route("TreeData")] /// <returns></returns>
public JsonActionResult<IEnumerable<TreeNode<T_NW_ENTERPRISE>>> TreeData([FromBody] KeywordFilter filter) [HttpGet, Route("Delete")]
{ public JsonActionResult<bool> Delete(string id)
return WitTreeOrderEntities(null, filter); {
} return WitRealDelete(id);
}
}
#endregion /// <summary>
#region RoleDataPerm-子企业数据权限表 /// 更新或新增数据
/// <summary> /// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ENTERPRISE entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ENTERPRISE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ENTERPRISE> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<T_NW_ENTERPRISE>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
}
#endregion
#region RoleDataPerm-子企业数据权限表
/// <summary>
/// 子企业数据权限表 /// 子企业数据权限表
/// </summary> /// </summary>
[Route("api/NW/RoleDataPerm")] [Route("api/NW/RoleDataPerm")]
public partial class RoleDataPermController : AuthorizeApiController<T_NW_ROLE_DATA_PERM> public partial class RoleDataPermController : AuthorizeApiController<T_NW_ROLE_DATA_PERM>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_DATA_PERM entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_DATA_PERM> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<T_NW_ROLE_DATA_PERM> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<T_NW_ROLE_DATA_PERM> Get([FromBody] KeywordFilter filter) public PagedActionResult<T_NW_ROLE_DATA_PERM> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
} /// <summary>
#endregion /// 根据主键删除数据
#region RoleMenu-子企业权限表 /// </summary>
/// <summary> /// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_DATA_PERM entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_DATA_PERM> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_DATA_PERM> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
#region RoleMenu-子企业权限表
/// <summary>
/// 子企业权限表 /// 子企业权限表
/// </summary> /// </summary>
[Route("api/NW/RoleMenu")] [Route("api/NW/RoleMenu")]
public partial class RoleMenuController : AuthorizeApiController<T_NW_ROLE_MENU> public partial class RoleMenuController : AuthorizeApiController<T_NW_ROLE_MENU>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ROLE_MENU> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ROLE_MENU> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_MENU entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_MENU> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<T_NW_ROLE_MENU> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<T_NW_ROLE_MENU> Get([FromBody] KeywordFilter filter) public PagedActionResult<T_NW_ROLE_MENU> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
} /// <summary>
#endregion /// 根据主键删除数据
} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_MENU entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_MENU> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_MENU> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
}

264
APT.MicroApi/APT.NW.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -19,17 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.NW.WebApi.Controllers.Api namespace APT.NW.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs"); List<TableT4> tables = new List<TableT4>();
List<TableT4> tables = new List<TableT4>(); List<string> modules=new List<string> ();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="NW"; var moduleFix="NW";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4(); TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt; tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController"; tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){ if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController"; tableT4.BaseApiName="AuthorizeTreeApiController";
} }
tableT4.TableNameSpace = space; tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 根据主键删除数据
<#} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

5292
APT.MicroApi/APT.OP.WebApi/Controllers/Api/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

265
APT.MicroApi/APT.OP.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -17,18 +17,18 @@ using APT.Infrastructure.Core;
using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic; using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.LG.WebApi.Controllers.Api namespace APT.OP.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs"); List<TableT4> tables = new List<TableT4>();
List<TableT4> tables = new List<TableT4>(); List<string> modules=new List<string> ();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="OP"; var moduleFix="OP";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -53,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4(); TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt; tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController"; tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){ if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController"; tableT4.BaseApiName="AuthorizeTreeApiController";
} }
tableT4.TableNameSpace = space; tableT4.TableNameSpace = space;
@ -102,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -127,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 根据主键删除数据
<#} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -353,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

7088
APT.MicroApi/APT.PF.WebApi/Controllers/Api/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

264
APT.MicroApi/APT.PF.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -19,17 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.PF.WebApi.Controllers.Api namespace APT.PF.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs"); List<TableT4> tables = new List<TableT4>();
List<TableT4> tables = new List<TableT4>(); List<string> modules=new List<string> ();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="PF"; var moduleFix="PF";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4(); TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt; tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController"; tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){ if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController"; tableT4.BaseApiName="AuthorizeTreeApiController";
} }
tableT4.TableNameSpace = space; tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 根据主键删除数据
<#} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

16
APT.MicroApi/APT.PP.WebApi/Controllers/Api/T4/T4Control.cs
View File

@ -1,7 +1,13 @@
 
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// T4模板文件：基础接口类 // T4模板文件：基础接口类
// 此代码由T4模板自动生成 // 此代码由T4模板自动生成
@ -13,7 +19,7 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.PP.WebApi.Controllers.Api namespace APT.PP.WebApi.Controllers.Api
{ {
}
}

261
APT.MicroApi/APT.PP.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -19,16 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.PP.WebApi.Controllers.Api namespace APT.PP.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>(); List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> (); List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="PP"; var moduleFix="PP";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -102,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -127,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 根据主键删除数据
<#} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -353,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>

28925
APT.MicroApi/APT.SK.WebApi/Controllers/Api/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

261
APT.MicroApi/APT.SK.WebApi/Controllers/Api/T4/T4Control.tt
View File

@ -19,16 +19,16 @@ using System.Collections.Generic;
using APT.Utility; using APT.Utility;
using APT.Infrastructure.Api; using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF; using APT.BaseData.Domain.ApiModel.PF;
namespace APT.SK.WebApi.Controllers.Api namespace APT.SK.WebApi.Controllers.Api
{ {
<# <#
List<string> dlls=new List<string>(); List<string> dlls=new List<string>();
List<string> filePaths=new List<string>(); List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>(); List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> (); List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\")); dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="SK"; var moduleFix="SK";
foreach(var dll in dlls){ foreach(var dll in dlls){
GetFileName(filePaths,dll); GetFileName(filePaths,dll);
@ -102,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
foreach(var space in modules) foreach(var space in modules)
{ {
WriteLine("using "+space +";"); WriteLine("using "+space +";");
} }
foreach(var t4 in tables) foreach(var t4 in tables)
@ -127,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
} }
} }
#> #>
#region <#= t4.FixName#>-<#= tableDesc#> #region <#= t4.FixName#>-<#= tableDesc#>
/// <summary> /// <summary>
/// <#= tableDesc#> /// <#= tableDesc#>
/// </summary> /// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")] [Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>> public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{ {
/// <summary> /// <summary>
/// 查询所有数据 /// 查询所有数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Entities")] [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter) public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{ {
return WitEntities(null, filter); return WitEntities(null, filter);
} }
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary> /// <summary>
/// 更新或新增数据 /// 排序查询所有数据
/// </summary> /// </summary>
/// <param name="entity">对象实体</param> /// <param name="filter">过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary> [HttpPost, Route("OrderEntities")]
/// 批量更新 public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="entity">对象实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary> /// <summary>
/// 批量删除数据 /// 分页查询数据
/// </summary> /// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpGet, Route("BatchDelete")] [HttpPost, Route("Paged")]
public JsonActionResult<bool> BatchDelete(string ids) public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitRealBatchDelete(ids); return WitPaged(null, pageFilter);
} }
/// <summary> /// <summary>
/// 获得单条实体数据 /// 排序分页查询数据
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <returns></returns>
[HttpPost, Route("Get")] [HttpPost, Route("OrderPaged")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter) public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{ {
return WitEntity(null, filter); return WitOrderPaged(null, pageFilter);
} }
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
} /// <summary>
#endregion /// 根据主键删除数据
<#} /// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<<#= t4.Name#>> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
<#
if(t4.BaseApiName=="AuthorizeTreeApiController"){
#>
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<<#= t4.Name#>>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
<#
}
#>
}
#endregion
<#}
#> #>
} }
<#+ <#+
class TableT4 class TableT4
@ -353,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName); GetFileName(filePaths, d.FullName);
} }
} }
#> #>