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

Compare commits

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

No commits in common. "57b96384ab02a434fe8dcdebd7208b52eef20a3c" and "59e71a0752ed672b497c4ec1cef5cc7192b23524" have entirely different histories.
57b96384ab ... 59e71a0752

20 changed files with 47399 additions and 50075 deletions
Show Stats Expand all files Collapse all files

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

File diff suppressed because it is too large Load Diff

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

@ -1,4 +1,4 @@
<#@ template debug="false" hostspecific="true" language="C#" #>
<#@ template debug="true" hostspecific="true" language="C#" #>
<#@ assembly name="System.Core" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Linq" #>
@ -19,16 +19,17 @@ 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>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
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> ();
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);
@ -102,10 +103,10 @@ namespace APT.BD.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +128,132 @@ namespace APT.BD.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

File diff suppressed because it is too large Load Diff

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

@ -19,16 +19,17 @@ 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>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
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> ();
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);
@ -53,7 +54,7 @@ namespace APT.FM.WebApi.Controllers.Api
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
if(tableT4.BaseName.Contains("TreeEntityBase")){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -102,10 +103,10 @@ namespace APT.FM.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +128,132 @@ namespace APT.FM.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

File diff suppressed because it is too large Load Diff

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

@ -19,16 +19,17 @@ 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>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
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> ();
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);
@ -53,7 +54,7 @@ namespace APT.FO.WebApi.Controllers.Api
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
if(tableT4.BaseName.Contains("TreeEntityBase")){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -102,10 +103,10 @@ namespace APT.FO.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +128,132 @@ namespace APT.FO.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

File diff suppressed because it is too large Load Diff

259
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 @@ namespace APT.HM.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +127,132 @@ namespace APT.HM.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

@ -2,12 +2,6 @@
//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
@ -19,119 +13,113 @@ 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
{
using APT.BaseData.Domain.Entities.LG;
#region Oprate-表单操作日志表
/// <summary>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_LG_OPRATE entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_LG_OPRATE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<T_LG_OPRATE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
}
#endregion
}
/// <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
}

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

@ -19,16 +19,17 @@ 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>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
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> ();
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);
@ -53,7 +54,7 @@ namespace APT.LG.WebApi.Controllers.Api
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
if(tableT4.BaseName.Contains("TreeEntityBase")){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -102,10 +103,10 @@ namespace APT.LG.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +128,132 @@ namespace APT.LG.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

@ -2,12 +2,6 @@
//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
@ -19,352 +13,333 @@ 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
{
using APT.BaseData.Domain.Entities.NW;
#region Enterprise-子企业表
/// <summary>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ENTERPRISE entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ENTERPRISE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<T_NW_ENTERPRISE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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);
}
/// <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>
}
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_DATA_PERM entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="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="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("OrderPaged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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);
}
/// <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>
}
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_MENU entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="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="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("OrderPaged")]
public PagedActionResult<T_NW_ROLE_MENU> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
}
#endregion
}
/// <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
}

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

@ -19,16 +19,17 @@ 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>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
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> ();
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);
@ -53,7 +54,7 @@ namespace APT.NW.WebApi.Controllers.Api
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
if(tableT4.BaseName.Contains("TreeEntityBase")){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -102,10 +103,10 @@ namespace APT.NW.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +128,132 @@ namespace APT.NW.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

File diff suppressed because it is too large Load Diff

263
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.OP.WebApi.Controllers.Api
{
namespace APT.LG.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>();
//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> ();
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 @@ namespace APT.OP.WebApi.Controllers.Api
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
if(tableT4.BaseName.Contains("TreeEntityBase")){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -102,10 +102,10 @@ namespace APT.OP.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +127,132 @@ namespace APT.OP.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

File diff suppressed because it is too large Load Diff

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

@ -19,16 +19,17 @@ 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>();
List<TableT4> tables = new List<TableT4>();
List<string> modules=new List<string> ();
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> ();
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);
@ -53,7 +54,7 @@ namespace APT.PF.WebApi.Controllers.Api
TableT4 tableT4 = new TableT4();
tableT4.BaseName = baseClassTxt;
tableT4.BaseApiName="AuthorizeApiController";
if(tableT4.BaseName.IndexOf("TreeEntityBase<")>-1){
if(tableT4.BaseName.Contains("TreeEntityBase")){
tableT4.BaseApiName="AuthorizeTreeApiController";
}
tableT4.TableNameSpace = space;
@ -102,10 +103,10 @@ namespace APT.PF.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +128,132 @@ namespace APT.PF.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

@ -2,12 +2,6 @@
//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
@ -19,7 +13,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
{
}
}

259
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 @@ namespace APT.PP.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +127,132 @@ namespace APT.PP.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4

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

File diff suppressed because it is too large Load Diff

259
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 @@ namespace APT.SK.WebApi.Controllers.Api
}
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var space in modules)
{
WriteLine("using "+space +";");
}
foreach(var t4 in tables)
@ -127,135 +127,132 @@ namespace APT.SK.WebApi.Controllers.Api
}
}
#>
#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);
}
[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);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]<#= t4.Name#> entity)
{
return WitUpdate(entity);
}
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<<#= t4.Name#>>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <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="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<<#= t4.Name#>> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <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("OrderPaged")]
public PagedActionResult<<#= t4.Name#>> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(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="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
<#}
}
#endregion
<#}
#>
}
<#+
class TableT4