6809 lines
211 KiB
C#
6809 lines
211 KiB
C#
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
//------------------------------------------------------------------------------
|
||
// T4模板文件：基础接口类
|
||
// 此代码由T4模板自动生成
|
||
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
|
||
//------------------------------------------------------------------------------
|
||
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.BS.WebApi.Controllers.Api
|
||
{
|
||
using APT.MS.Domain.Entities.BS;
|
||
|
||
#region CheckContent-检查内容表
|
||
/// <summary>
|
||
/// 检查内容表
|
||
/// </summary>
|
||
[Route("api/BS/CheckContent")]
|
||
public partial class CheckContentController : AuthorizeApiController<T_BS_CHECK_CONTENT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_CONTENT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_CONTENT> 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_BS_CHECK_CONTENT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckContents-检查内容
|
||
/// <summary>
|
||
/// 检查内容
|
||
/// </summary>
|
||
[Route("api/BS/CheckContents")]
|
||
public partial class CheckContentsController : AuthorizeApiController<T_BS_CHECK_CONTENTS>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENTS>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENTS>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENTS> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENTS> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_CONTENTS entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_CONTENTS> 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_BS_CHECK_CONTENTS> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckContentCheckType-检查类型
|
||
/// <summary>
|
||
/// 检查类型
|
||
/// </summary>
|
||
[Route("api/BS/CheckContentCheckType")]
|
||
public partial class CheckContentCheckTypeController : AuthorizeApiController<T_BS_CHECK_CONTENT_CHECK_TYPE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_CHECK_TYPE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_CHECK_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_CHECK_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_CHECK_TYPE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_CONTENT_CHECK_TYPE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_CONTENT_CHECK_TYPE> 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_BS_CHECK_CONTENT_CHECK_TYPE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckContentCheckTypeLevel-检查内容检查类型子表(关联层级)
|
||
/// <summary>
|
||
/// 检查内容检查类型子表(关联层级)
|
||
/// </summary>
|
||
[Route("api/BS/CheckContentCheckTypeLevel")]
|
||
public partial class CheckContentCheckTypeLevelController : AuthorizeApiController<T_BS_CHECK_CONTENT_CHECK_TYPE_LEVEL>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_CHECK_TYPE_LEVEL>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_CHECK_TYPE_LEVEL>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_CHECK_TYPE_LEVEL> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_CHECK_TYPE_LEVEL> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_CONTENT_CHECK_TYPE_LEVEL entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_CONTENT_CHECK_TYPE_LEVEL> 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_BS_CHECK_CONTENT_CHECK_TYPE_LEVEL> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckContentHmRiskArea-检查区域
|
||
/// <summary>
|
||
/// 检查区域
|
||
/// </summary>
|
||
[Route("api/BS/CheckContentHmRiskArea")]
|
||
public partial class CheckContentHmRiskAreaController : AuthorizeApiController<T_BS_CHECK_CONTENT_HM_RISK_AREA>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_HM_RISK_AREA>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_HM_RISK_AREA>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_HM_RISK_AREA> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_HM_RISK_AREA> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_CONTENT_HM_RISK_AREA entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_CONTENT_HM_RISK_AREA> 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_BS_CHECK_CONTENT_HM_RISK_AREA> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckMain-安全检查库
|
||
/// <summary>
|
||
/// 安全检查库
|
||
/// </summary>
|
||
[Route("api/BS/CheckMain")]
|
||
public partial class CheckMainController : AuthorizeApiController<T_BS_CHECK_MAIN>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_MAIN>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_MAIN>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_MAIN> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_MAIN> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_MAIN entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_MAIN> 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_BS_CHECK_MAIN> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckContentMainDepartment-安全检查库责任部门
|
||
/// <summary>
|
||
/// 安全检查库责任部门
|
||
/// </summary>
|
||
[Route("api/BS/CheckContentMainDepartment")]
|
||
public partial class CheckContentMainDepartmentController : AuthorizeApiController<T_BS_CHECK_CONTENT_MAIN_DEPARTMENT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_MAIN_DEPARTMENT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_MAIN_DEPARTMENT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_MAIN_DEPARTMENT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_MAIN_DEPARTMENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_CONTENT_MAIN_DEPARTMENT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_CONTENT_MAIN_DEPARTMENT> 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_BS_CHECK_CONTENT_MAIN_DEPARTMENT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckContentQuestion-检查问题
|
||
/// <summary>
|
||
/// 检查问题
|
||
/// </summary>
|
||
[Route("api/BS/CheckContentQuestion")]
|
||
public partial class CheckContentQuestionController : AuthorizeApiController<T_BS_CHECK_CONTENT_QUESTION>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_QUESTION>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_CONTENT_QUESTION>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_QUESTION> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_CONTENT_QUESTION> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_CONTENT_QUESTION entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_CONTENT_QUESTION> 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_BS_CHECK_CONTENT_QUESTION> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckMainLaw-检查库法规
|
||
/// <summary>
|
||
/// 检查库法规
|
||
/// </summary>
|
||
[Route("api/BS/CheckMainLaw")]
|
||
public partial class CheckMainLawController : AuthorizeApiController<T_BS_CHECK_MAIN_LAW>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_MAIN_LAW>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_MAIN_LAW>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_MAIN_LAW> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_MAIN_LAW> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_MAIN_LAW entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_MAIN_LAW> 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_BS_CHECK_MAIN_LAW> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckProject-检查项目
|
||
/// <summary>
|
||
/// 检查项目
|
||
/// </summary>
|
||
[Route("api/BS/CheckProject")]
|
||
public partial class CheckProjectController : AuthorizeApiController<T_BS_CHECK_PROJECT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_PROJECT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_PROJECT> 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_BS_CHECK_PROJECT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckProjectCategory-检查项目分类表
|
||
/// <summary>
|
||
/// 检查项目分类表
|
||
/// </summary>
|
||
[Route("api/BS/CheckProjectCategory")]
|
||
public partial class CheckProjectCategoryController : AuthorizeApiController<T_BS_CHECK_PROJECT_CATEGORY>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT_CATEGORY>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT_CATEGORY>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT_CATEGORY> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT_CATEGORY> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_PROJECT_CATEGORY entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_PROJECT_CATEGORY> 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_BS_CHECK_PROJECT_CATEGORY> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckProjectCategoryChecktype-检查项目分类_检查类型
|
||
/// <summary>
|
||
/// 检查项目分类_检查类型
|
||
/// </summary>
|
||
[Route("api/BS/CheckProjectCategoryChecktype")]
|
||
public partial class CheckProjectCategoryChecktypeController : AuthorizeApiController<T_BS_CHECK_PROJECT_CATEGORY_CHECKTYPE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT_CATEGORY_CHECKTYPE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT_CATEGORY_CHECKTYPE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT_CATEGORY_CHECKTYPE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT_CATEGORY_CHECKTYPE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_PROJECT_CATEGORY_CHECKTYPE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_PROJECT_CATEGORY_CHECKTYPE> 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_BS_CHECK_PROJECT_CATEGORY_CHECKTYPE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckProjectCategoryObject-检查项目分类_检查区域
|
||
/// <summary>
|
||
/// 检查项目分类_检查区域
|
||
/// </summary>
|
||
[Route("api/BS/CheckProjectCategoryObject")]
|
||
public partial class CheckProjectCategoryObjectController : AuthorizeApiController<T_BS_CHECK_PROJECT_CATEGORY_OBJECT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT_CATEGORY_OBJECT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT_CATEGORY_OBJECT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT_CATEGORY_OBJECT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT_CATEGORY_OBJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_PROJECT_CATEGORY_OBJECT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_PROJECT_CATEGORY_OBJECT> 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_BS_CHECK_PROJECT_CATEGORY_OBJECT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckProjectProjectCategory-检查项目分类
|
||
/// <summary>
|
||
/// 检查项目分类
|
||
/// </summary>
|
||
[Route("api/BS/CheckProjectProjectCategory")]
|
||
public partial class CheckProjectProjectCategoryController : AuthorizeApiController<T_BS_CHECK_PROJECT_PROJECT_CATEGORY>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT_PROJECT_CATEGORY>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_PROJECT_PROJECT_CATEGORY>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT_PROJECT_CATEGORY> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_PROJECT_PROJECT_CATEGORY> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_PROJECT_PROJECT_CATEGORY entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_PROJECT_PROJECT_CATEGORY> 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_BS_CHECK_PROJECT_PROJECT_CATEGORY> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckQuestion-检查问题
|
||
/// <summary>
|
||
/// 检查问题
|
||
/// </summary>
|
||
[Route("api/BS/CheckQuestion")]
|
||
public partial class CheckQuestionController : AuthorizeApiController<T_BS_CHECK_QUESTION>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_QUESTION>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_QUESTION>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_QUESTION> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_QUESTION> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_QUESTION entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_QUESTION> 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_BS_CHECK_QUESTION> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckType-检查类型表
|
||
/// <summary>
|
||
/// 检查类型表
|
||
/// </summary>
|
||
[Route("api/BS/CheckType")]
|
||
public partial class CheckTypeController : AuthorizeTreeApiController<T_BS_CHECK_TYPE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_TYPE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_TYPE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_TYPE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_TYPE> 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_BS_CHECK_TYPE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获得树形实体数据
|
||
/// </summary>
|
||
/// <param name="filter"></param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("TreeData")]
|
||
public JsonActionResult<IEnumerable<TreeNode<T_BS_CHECK_TYPE>>> TreeData([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitTreeOrderEntities(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckTypeLevel-检查层级
|
||
/// <summary>
|
||
/// 检查层级
|
||
/// </summary>
|
||
[Route("api/BS/CheckTypeLevel")]
|
||
public partial class CheckTypeLevelController : AuthorizeApiController<T_BS_CHECK_TYPE_LEVEL>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_TYPE_LEVEL>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_TYPE_LEVEL>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_TYPE_LEVEL> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_TYPE_LEVEL> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_TYPE_LEVEL entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_TYPE_LEVEL> 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_BS_CHECK_TYPE_LEVEL> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region CheckTypeMinetype-检查类型生产单元
|
||
/// <summary>
|
||
/// 检查类型生产单元
|
||
/// </summary>
|
||
[Route("api/BS/CheckTypeMinetype")]
|
||
public partial class CheckTypeMinetypeController : AuthorizeApiController<T_BS_CHECK_TYPE_MINETYPE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_TYPE_MINETYPE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_CHECK_TYPE_MINETYPE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_CHECK_TYPE_MINETYPE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_CHECK_TYPE_MINETYPE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_CHECK_TYPE_MINETYPE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_CHECK_TYPE_MINETYPE> 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_BS_CHECK_TYPE_MINETYPE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region DepartmentAreaobject-部门范围
|
||
/// <summary>
|
||
/// 部门范围
|
||
/// </summary>
|
||
[Route("api/BS/DepartmentAreaobject")]
|
||
public partial class DepartmentAreaobjectController : AuthorizeApiController<T_BS_DEPARTMENT_AREAOBJECT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_DEPARTMENT_AREAOBJECT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_DEPARTMENT_AREAOBJECT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_DEPARTMENT_AREAOBJECT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_DEPARTMENT_AREAOBJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_DEPARTMENT_AREAOBJECT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_DEPARTMENT_AREAOBJECT> 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_BS_DEPARTMENT_AREAOBJECT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region OperateLog-操作日志
|
||
/// <summary>
|
||
/// 操作日志
|
||
/// </summary>
|
||
[Route("api/BS/OperateLog")]
|
||
public partial class OperateLogController : AuthorizeApiController<T_BS_OPERATE_LOG>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_OPERATE_LOG>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_OPERATE_LOG>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_OPERATE_LOG> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_OPERATE_LOG> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_OPERATE_LOG entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_OPERATE_LOG> 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_BS_OPERATE_LOG> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region PlanSet-制定任务
|
||
/// <summary>
|
||
/// 制定任务
|
||
/// </summary>
|
||
[Route("api/BS/PlanSet")]
|
||
public partial class PlanSetController : AuthorizeApiController<T_BS_PLAN_SET>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_PLAN_SET> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_PLAN_SET> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_PLAN_SET entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_PLAN_SET> 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_BS_PLAN_SET> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region PlanSetArea-制定任务区域
|
||
/// <summary>
|
||
/// 制定任务区域
|
||
/// </summary>
|
||
[Route("api/BS/PlanSetArea")]
|
||
public partial class PlanSetAreaController : AuthorizeApiController<T_BS_PLAN_SET_AREA>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET_AREA>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET_AREA>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_PLAN_SET_AREA> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_PLAN_SET_AREA> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_PLAN_SET_AREA entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_PLAN_SET_AREA> 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_BS_PLAN_SET_AREA> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region PlanSetDepartmentOut-制定任务排除组织
|
||
/// <summary>
|
||
/// 制定任务排除组织
|
||
/// </summary>
|
||
[Route("api/BS/PlanSetDepartmentOut")]
|
||
public partial class PlanSetDepartmentOutController : AuthorizeApiController<T_BS_PLAN_SET_DEPARTMENT_OUT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET_DEPARTMENT_OUT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET_DEPARTMENT_OUT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_PLAN_SET_DEPARTMENT_OUT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_PLAN_SET_DEPARTMENT_OUT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_PLAN_SET_DEPARTMENT_OUT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_PLAN_SET_DEPARTMENT_OUT> 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_BS_PLAN_SET_DEPARTMENT_OUT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region PlanSetDepObject-制定任务部门触发范围
|
||
/// <summary>
|
||
/// 制定任务部门触发范围
|
||
/// </summary>
|
||
[Route("api/BS/PlanSetDepObject")]
|
||
public partial class PlanSetDepObjectController : AuthorizeApiController<T_BS_PLAN_SET_DEP_OBJECT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET_DEP_OBJECT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET_DEP_OBJECT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_PLAN_SET_DEP_OBJECT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_PLAN_SET_DEP_OBJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_PLAN_SET_DEP_OBJECT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_PLAN_SET_DEP_OBJECT> 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_BS_PLAN_SET_DEP_OBJECT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region PlanSetObject-制定任务触发范围
|
||
/// <summary>
|
||
/// 制定任务触发范围
|
||
/// </summary>
|
||
[Route("api/BS/PlanSetObject")]
|
||
public partial class PlanSetObjectController : AuthorizeApiController<T_BS_PLAN_SET_OBJECT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET_OBJECT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_PLAN_SET_OBJECT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_PLAN_SET_OBJECT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_PLAN_SET_OBJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_PLAN_SET_OBJECT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_PLAN_SET_OBJECT> 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_BS_PLAN_SET_OBJECT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskCategory-隐患类别
|
||
/// <summary>
|
||
/// 隐患类别
|
||
/// </summary>
|
||
[Route("api/BS/RiskCategory")]
|
||
public partial class RiskCategoryController : AuthorizeApiController<T_BS_RISK_CATEGORY>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_CATEGORY>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_CATEGORY>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_CATEGORY> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_CATEGORY> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_CATEGORY entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_CATEGORY> 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_BS_RISK_CATEGORY> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskLevelDelayDays-隐患等级最长延期整改天数
|
||
/// <summary>
|
||
/// 隐患等级最长延期整改天数
|
||
/// </summary>
|
||
[Route("api/BS/RiskLevelDelayDays")]
|
||
public partial class RiskLevelDelayDaysController : AuthorizeApiController<T_BS_RISK_LEVEL_DELAY_DAYS>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_LEVEL_DELAY_DAYS>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_LEVEL_DELAY_DAYS>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_LEVEL_DELAY_DAYS> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_LEVEL_DELAY_DAYS> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_LEVEL_DELAY_DAYS entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_LEVEL_DELAY_DAYS> 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_BS_RISK_LEVEL_DELAY_DAYS> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskReason-隐患原因表
|
||
/// <summary>
|
||
/// 隐患原因表
|
||
/// </summary>
|
||
[Route("api/BS/RiskReason")]
|
||
public partial class RiskReasonController : AuthorizeApiController<T_BS_RISK_REASON>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_REASON>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_REASON>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_REASON> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_REASON> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_REASON entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_REASON> 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_BS_RISK_REASON> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmit-隐患上报表
|
||
/// <summary>
|
||
/// 隐患上报表
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmit")]
|
||
public partial class RiskSubmitController : AuthorizeApiController<T_BS_RISK_SUBMIT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT> 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_BS_RISK_SUBMIT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContent-隐患上报明细
|
||
/// <summary>
|
||
/// 隐患上报明细
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContent")]
|
||
public partial class RiskSubmitContentController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT> 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_BS_RISK_SUBMIT_CONTENT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentBack-隐患上报明细退回
|
||
/// <summary>
|
||
/// 隐患上报明细退回
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentBack")]
|
||
public partial class RiskSubmitContentBackController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_BACK>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_BACK>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_BACK>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_BACK> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_BACK> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_BACK entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_BACK> 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_BS_RISK_SUBMIT_CONTENT_BACK> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentDeal-隐患整改记录
|
||
/// <summary>
|
||
/// 隐患整改记录
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentDeal")]
|
||
public partial class RiskSubmitContentDealController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_DEAL>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_DEAL entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_DEAL> 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_BS_RISK_SUBMIT_CONTENT_DEAL> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentDealAfterFile-检查任务附件表
|
||
/// <summary>
|
||
/// 检查任务附件表
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentDealAfterFile")]
|
||
public partial class RiskSubmitContentDealAfterFileController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_DEAL_AFTER_FILE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL_AFTER_FILE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL_AFTER_FILE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL_AFTER_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL_AFTER_FILE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_DEAL_AFTER_FILE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_DEAL_AFTER_FILE> 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_BS_RISK_SUBMIT_CONTENT_DEAL_AFTER_FILE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentDealFile-检查任务附件表
|
||
/// <summary>
|
||
/// 检查任务附件表
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentDealFile")]
|
||
public partial class RiskSubmitContentDealFileController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_DEAL_FILE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL_FILE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL_FILE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_DEAL_FILE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_DEAL_FILE> 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_BS_RISK_SUBMIT_CONTENT_DEAL_FILE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentDealUserchecksign-隐患整改验收人签名
|
||
/// <summary>
|
||
/// 隐患整改验收人签名
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentDealUserchecksign")]
|
||
public partial class RiskSubmitContentDealUserchecksignController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERCHECKSIGN>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERCHECKSIGN>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERCHECKSIGN>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERCHECKSIGN> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERCHECKSIGN> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_DEAL_USERCHECKSIGN entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERCHECKSIGN> 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_BS_RISK_SUBMIT_CONTENT_DEAL_USERCHECKSIGN> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentDealUsersign-隐患整改责任人签名
|
||
/// <summary>
|
||
/// 隐患整改责任人签名
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentDealUsersign")]
|
||
public partial class RiskSubmitContentDealUsersignController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERSIGN>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERSIGN>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERSIGN>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERSIGN> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERSIGN> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_DEAL_USERSIGN entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_DEAL_USERSIGN> 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_BS_RISK_SUBMIT_CONTENT_DEAL_USERSIGN> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentFile-检查任务明细附件表
|
||
/// <summary>
|
||
/// 检查任务明细附件表
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentFile")]
|
||
public partial class RiskSubmitContentFileController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_FILE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_FILE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_FILE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_FILE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_FILE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_FILE> 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_BS_RISK_SUBMIT_CONTENT_FILE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentReason-隐患上报明细原因
|
||
/// <summary>
|
||
/// 隐患上报明细原因
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentReason")]
|
||
public partial class RiskSubmitContentReasonController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_REASON>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_REASON>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_REASON>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_REASON> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_REASON> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_REASON entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_REASON> 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_BS_RISK_SUBMIT_CONTENT_REASON> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitContentTemp-隐患上报详情待入库
|
||
/// <summary>
|
||
/// 隐患上报详情待入库
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitContentTemp")]
|
||
public partial class RiskSubmitContentTempController : AuthorizeApiController<T_BS_RISK_SUBMIT_CONTENT_TEMP>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_TEMP>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_CONTENT_TEMP>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_TEMP> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_CONTENT_TEMP> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_CONTENT_TEMP entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_CONTENT_TEMP> 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_BS_RISK_SUBMIT_CONTENT_TEMP> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitDelayApply-延期整改申请
|
||
/// <summary>
|
||
/// 延期整改申请
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitDelayApply")]
|
||
public partial class RiskSubmitDelayApplyController : AuthorizeApiController<T_BS_RISK_SUBMIT_DELAY_APPLY>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_DELAY_APPLY>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_DELAY_APPLY>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_DELAY_APPLY> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_DELAY_APPLY> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_DELAY_APPLY entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_DELAY_APPLY> 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_BS_RISK_SUBMIT_DELAY_APPLY> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitDelayApplyDetail-延期整改申请详情
|
||
/// <summary>
|
||
/// 延期整改申请详情
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitDelayApplyDetail")]
|
||
public partial class RiskSubmitDelayApplyDetailController : AuthorizeApiController<T_BS_RISK_SUBMIT_DELAY_APPLY_DETAIL>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_DELAY_APPLY_DETAIL>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_DELAY_APPLY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_DELAY_APPLY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_DELAY_APPLY_DETAIL> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_DELAY_APPLY_DETAIL entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_DELAY_APPLY_DETAIL> 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_BS_RISK_SUBMIT_DELAY_APPLY_DETAIL> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitFile-检查任务附件表
|
||
/// <summary>
|
||
/// 检查任务附件表
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitFile")]
|
||
public partial class RiskSubmitFileController : AuthorizeApiController<T_BS_RISK_SUBMIT_FILE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_FILE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_FILE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_FILE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_FILE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_FILE> 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_BS_RISK_SUBMIT_FILE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitNotice-隐患通知
|
||
/// <summary>
|
||
/// 隐患通知
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitNotice")]
|
||
public partial class RiskSubmitNoticeController : AuthorizeApiController<T_BS_RISK_SUBMIT_NOTICE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_NOTICE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_NOTICE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_NOTICE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_NOTICE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_NOTICE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_NOTICE> 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_BS_RISK_SUBMIT_NOTICE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskSubmitNoticePerson-隐患通知
|
||
/// <summary>
|
||
/// 隐患通知
|
||
/// </summary>
|
||
[Route("api/BS/RiskSubmitNoticePerson")]
|
||
public partial class RiskSubmitNoticePersonController : AuthorizeApiController<T_BS_RISK_SUBMIT_NOTICE_PERSON>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_NOTICE_PERSON>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_SUBMIT_NOTICE_PERSON>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_NOTICE_PERSON> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_SUBMIT_NOTICE_PERSON> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_SUBMIT_NOTICE_PERSON entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_SUBMIT_NOTICE_PERSON> 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_BS_RISK_SUBMIT_NOTICE_PERSON> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region RiskTpm-TPM对接数据
|
||
/// <summary>
|
||
/// TPM对接数据
|
||
/// </summary>
|
||
[Route("api/BS/RiskTpm")]
|
||
public partial class RiskTpmController : AuthorizeApiController<T_BS_RISK_TPM>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_TPM>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_RISK_TPM>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_RISK_TPM> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_RISK_TPM> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_RISK_TPM entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_RISK_TPM> 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_BS_RISK_TPM> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheck-安全检查
|
||
/// <summary>
|
||
/// 安全检查
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheck")]
|
||
public partial class SafeCheckController : AuthorizeApiController<T_BS_SAFE_CHECK>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK> 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_BS_SAFE_CHECK> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckDetail-检查明细
|
||
/// <summary>
|
||
/// 检查明细
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckDetail")]
|
||
public partial class SafeCheckDetailController : AuthorizeApiController<T_BS_SAFE_CHECK_DETAIL>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_DETAIL entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_DETAIL> 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_BS_SAFE_CHECK_DETAIL> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckDetailFile-检查任务明细附件表
|
||
/// <summary>
|
||
/// 检查任务明细附件表
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckDetailFile")]
|
||
public partial class SafeCheckDetailFileController : AuthorizeApiController<T_BS_SAFE_CHECK_DETAIL_FILE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_FILE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_FILE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_DETAIL_FILE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_DETAIL_FILE> 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_BS_SAFE_CHECK_DETAIL_FILE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckDetailLaw-检查依据
|
||
/// <summary>
|
||
/// 检查依据
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckDetailLaw")]
|
||
public partial class SafeCheckDetailLawController : AuthorizeApiController<T_BS_SAFE_CHECK_DETAIL_LAW>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_LAW>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_LAW>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_LAW> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_LAW> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_DETAIL_LAW entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_DETAIL_LAW> 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_BS_SAFE_CHECK_DETAIL_LAW> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckDetailQuestion-检查明细问题
|
||
/// <summary>
|
||
/// 检查明细问题
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckDetailQuestion")]
|
||
public partial class SafeCheckDetailQuestionController : AuthorizeApiController<T_BS_SAFE_CHECK_DETAIL_QUESTION>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_QUESTION>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_QUESTION>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_QUESTION> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_QUESTION> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_DETAIL_QUESTION entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_DETAIL_QUESTION> 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_BS_SAFE_CHECK_DETAIL_QUESTION> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckDetailReason-检查明细隐患原因
|
||
/// <summary>
|
||
/// 检查明细隐患原因
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckDetailReason")]
|
||
public partial class SafeCheckDetailReasonController : AuthorizeApiController<T_BS_SAFE_CHECK_DETAIL_REASON>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_REASON>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_REASON>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_REASON> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_REASON> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_DETAIL_REASON entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_DETAIL_REASON> 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_BS_SAFE_CHECK_DETAIL_REASON> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckDetailReject-检查明细退回
|
||
/// <summary>
|
||
/// 检查明细退回
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckDetailReject")]
|
||
public partial class SafeCheckDetailRejectController : AuthorizeApiController<T_BS_SAFE_CHECK_DETAIL_REJECT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_REJECT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_REJECT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_REJECT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_REJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_DETAIL_REJECT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_DETAIL_REJECT> 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_BS_SAFE_CHECK_DETAIL_REJECT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckDetailRejectFile-检查明细退回附件
|
||
/// <summary>
|
||
/// 检查明细退回附件
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckDetailRejectFile")]
|
||
public partial class SafeCheckDetailRejectFileController : AuthorizeApiController<T_BS_SAFE_CHECK_DETAIL_REJECT_FILE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_REJECT_FILE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_REJECT_FILE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_REJECT_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_REJECT_FILE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_DETAIL_REJECT_FILE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_DETAIL_REJECT_FILE> 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_BS_SAFE_CHECK_DETAIL_REJECT_FILE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckDetailUser-检查明细人员
|
||
/// <summary>
|
||
/// 检查明细人员
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckDetailUser")]
|
||
public partial class SafeCheckDetailUserController : AuthorizeApiController<T_BS_SAFE_CHECK_DETAIL_USER>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_USER>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_DETAIL_USER>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_USER> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_DETAIL_USER> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_DETAIL_USER entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_DETAIL_USER> 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_BS_SAFE_CHECK_DETAIL_USER> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckFile-安全检查文件
|
||
/// <summary>
|
||
/// 安全检查文件
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckFile")]
|
||
public partial class SafeCheckFileController : AuthorizeApiController<T_BS_SAFE_CHECK_FILE>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_FILE>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_FILE>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_FILE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_FILE entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_FILE> 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_BS_SAFE_CHECK_FILE> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckProject-安全检查文件
|
||
/// <summary>
|
||
/// 安全检查文件
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckProject")]
|
||
public partial class SafeCheckProjectController : AuthorizeApiController<T_BS_SAFE_CHECK_PROJECT>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_PROJECT>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_PROJECT>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_PROJECT> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_PROJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_PROJECT entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_PROJECT> 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_BS_SAFE_CHECK_PROJECT> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckProjectCategory-安全检查文件
|
||
/// <summary>
|
||
/// 安全检查文件
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckProjectCategory")]
|
||
public partial class SafeCheckProjectCategoryController : AuthorizeApiController<T_BS_SAFE_CHECK_PROJECT_CATEGORY>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_PROJECT_CATEGORY>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_PROJECT_CATEGORY>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_PROJECT_CATEGORY> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_PROJECT_CATEGORY> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_PROJECT_CATEGORY entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_PROJECT_CATEGORY> 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_BS_SAFE_CHECK_PROJECT_CATEGORY> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckRecord-检查记录确认
|
||
/// <summary>
|
||
/// 检查记录确认
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckRecord")]
|
||
public partial class SafeCheckRecordController : AuthorizeApiController<T_BS_SAFE_CHECK_RECORD>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_RECORD>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_RECORD> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_RECORD entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_RECORD> 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_BS_SAFE_CHECK_RECORD> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckRecordDetail-检查记录确认明细
|
||
/// <summary>
|
||
/// 检查记录确认明细
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckRecordDetail")]
|
||
public partial class SafeCheckRecordDetailController : AuthorizeApiController<T_BS_SAFE_CHECK_RECORD_DETAIL>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_RECORD_DETAIL>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_RECORD_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_RECORD_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_RECORD_DETAIL> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_RECORD_DETAIL entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_RECORD_DETAIL> 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_BS_SAFE_CHECK_RECORD_DETAIL> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckRiskArea-检查区域
|
||
/// <summary>
|
||
/// 检查区域
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckRiskArea")]
|
||
public partial class SafeCheckRiskAreaController : AuthorizeApiController<T_BS_SAFE_CHECK_RISK_AREA>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_RISK_AREA>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_RISK_AREA>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_RISK_AREA> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_RISK_AREA> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_RISK_AREA entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_RISK_AREA> 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_BS_SAFE_CHECK_RISK_AREA> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region SafeCheckUsersign-检查签名
|
||
/// <summary>
|
||
/// 检查签名
|
||
/// </summary>
|
||
[Route("api/BS/SafeCheckUsersign")]
|
||
public partial class SafeCheckUsersignController : AuthorizeApiController<T_BS_SAFE_CHECK_USERSIGN>
|
||
{
|
||
/// <summary>
|
||
/// 查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Entities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_USERSIGN>> Entities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序查询所有数据
|
||
/// </summary>
|
||
/// <param name="filter">过滤实体</param>
|
||
/// <returns></returns>
|
||
|
||
[HttpPost, Route("OrderEntities")]
|
||
public JsonActionResult<IEnumerable<T_BS_SAFE_CHECK_USERSIGN>> OrderEntities([FromBody]KeywordFilter filter)
|
||
{
|
||
return WitOrderEntities(null, filter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Paged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_USERSIGN> Paged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 排序分页查询数据
|
||
/// </summary>
|
||
/// <param name="pageFilter">分页过滤实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("OrderPaged")]
|
||
public PagedActionResult<T_BS_SAFE_CHECK_USERSIGN> OrderPaged([FromBody]KeywordPageFilter pageFilter)
|
||
{
|
||
return WitOrderPaged(null, pageFilter);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 根据主键删除数据
|
||
/// </summary>
|
||
/// <param name="id">主键ID</param>
|
||
/// <returns></returns>
|
||
[HttpGet, Route("Delete")]
|
||
public JsonActionResult<bool> Delete(string id)
|
||
{
|
||
return WitRealDelete(id);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新或新增数据
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("Update")]
|
||
public JsonActionResult<bool> Update([FromBody]T_BS_SAFE_CHECK_USERSIGN entity)
|
||
{
|
||
return WitUpdate(entity);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量更新
|
||
/// </summary>
|
||
/// <param name="entity">对象实体</param>
|
||
/// <returns></returns>
|
||
[HttpPost, Route("BatchUpdate")]
|
||
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BS_SAFE_CHECK_USERSIGN> 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_BS_SAFE_CHECK_USERSIGN> Get([FromBody] KeywordFilter filter)
|
||
{
|
||
return WitEntity(null, filter);
|
||
}
|
||
|
||
|
||
}
|
||
#endregion
|
||
|
||
}
|