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" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Linq" #>
@ -19,17 +19,16 @@ using System.Collections.Generic;
using APT.Utility;
using APT.Infrastructure.Api;
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> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs");
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="BD";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
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.Infrastructure.Api;
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> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs");
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="FM";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <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);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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>
/// <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
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
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.Infrastructure.Api;
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> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs");
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="FO";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <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);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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>
/// <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
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
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.Infrastructure.Api;
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> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="HM";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -102,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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
@ -353,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName);
}
}
#>
#>

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

@ -1,7 +1,13 @@


//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
@ -13,113 +19,119 @@ using System.Collections.Generic;
using APT.Utility;
using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF;
namespace APT.LG.WebApi.Controllers.Api
{
using APT.BaseData.Domain.Entities.LG;
#region Oprate-表单操作日志表
/// <summary>
namespace APT.LG.WebApi.Controllers.Api
{
using APT.BaseData.Domain.Entities.LG;
#region Oprate-表单操作日志表
/// <summary>
/// 表单操作日志表
/// </summary>
[Route("api/LG/Oprate")]
public partial class OprateController : AuthorizeApiController<T_LG_OPRATE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/LG/Oprate")]
public partial class OprateController : AuthorizeApiController<T_LG_OPRATE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_LG_OPRATE entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <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);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_LG_OPRATE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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
}
/// <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>
/// <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.Infrastructure.Api;
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> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs");
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="LG";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName);
}
}
#>
#>

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

@ -1,7 +1,13 @@


//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
@ -13,333 +19,352 @@ using System.Collections.Generic;
using APT.Utility;
using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF;
namespace APT.NW.WebApi.Controllers.Api
{
using APT.BaseData.Domain.Entities.NW;
#region Enterprise-子企业表
/// <summary>
namespace APT.NW.WebApi.Controllers.Api
{
using APT.BaseData.Domain.Entities.NW;
#region Enterprise-子企业表
/// <summary>
/// 子企业表
/// </summary>
[Route("api/NW/Enterprise")]
public partial class EnterpriseController : AuthorizeTreeApiController<T_NW_ENTERPRISE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/NW/Enterprise")]
public partial class EnterpriseController : AuthorizeTreeApiController<T_NW_ENTERPRISE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ENTERPRISE entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <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);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ENTERPRISE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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>
/// <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>
/// <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>
[Route("api/NW/RoleDataPerm")]
public partial class RoleDataPermController : AuthorizeApiController<T_NW_ROLE_DATA_PERM>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/NW/RoleDataPerm")]
public partial class RoleDataPermController : AuthorizeApiController<T_NW_ROLE_DATA_PERM>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <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>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <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);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="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="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>
/// <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>
/// <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>
[Route("api/NW/RoleMenu")]
public partial class RoleMenuController : AuthorizeApiController<T_NW_ROLE_MENU>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/NW/RoleMenu")]
public partial class RoleMenuController : AuthorizeApiController<T_NW_ROLE_MENU>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <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>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <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);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="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="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_MENU> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
}
/// <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>
/// <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.Infrastructure.Api;
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> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs");
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="NW";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
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 System.Collections.Generic;
using APT.Utility;
using APT.Infrastructure.Api;
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> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs");
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="OP";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -53,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -102,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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
@ -353,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
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.Infrastructure.Api;
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> filePaths=new List<string>();
//filePaths.Add(@"C:\Users\luxiaoyuan\source\repos\ConsoleApp15\ConsoleApp15\T_MM_SN.cs");
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="PF";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -54,7 +53,7 @@ using APT.BaseData.Domain.ApiModel.PF;
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.Contains("TreeEntityBase")){
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -103,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -128,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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
@ -354,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName);
}
}
#>
#>

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

@ -1,7 +1,13 @@


//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
@ -13,7 +19,7 @@ using System.Collections.Generic;
using APT.Utility;
using APT.Infrastructure.Api;
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.Infrastructure.Api;
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> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="PP";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -102,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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
@ -353,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
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.Infrastructure.Api;
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> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
List<string> dlls=new List<string>();
List<string> filePaths=new List<string>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.MS.Domain\\"));
dlls.Add(Host.ResolveAssemblyReference("$(SolutionDir)"+"APT.BaseData.Domain\\"));
var moduleFix="SK";
foreach(var dll in dlls){
GetFileName(filePaths,dll);
@ -102,10 +102,10 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,132 +127,135 @@ using APT.BaseData.Domain.ApiModel.PF;
}
}
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
#>
#region <#= t4.FixName#>-<#= tableDesc#>
/// <summary>
/// <#= tableDesc#>
/// </summary>
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter 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);
}
[Route("api/<#= t4.ModuleName#>/<#= t4.FixName#>")]
public partial class <#= t4.FixName#>Controller : <#=t4.BaseApiName#><<#= t4.Name#>>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<<#= t4.Name#>> entity)
{
return WitBantchUpdate(entity?.Data);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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);
}
<#
}
#>
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
}
#endregion
<#}
/// <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
@ -353,4 +356,4 @@ public static void GetFileName(List<string> filePaths, string path)
GetFileName(filePaths, d.FullName);
}
}
#>
#>