//------------------------------------------------------------------------------
//     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.SK.WebApi.Controllers.Api
{
	using APT.MS.Domain.Entities.SK;
	#region  BasicLibrary-基础库
	/// <summary>
    ///  基础库
    /// </summary>
	[Route("api/SK/BasicLibrary")]
    public partial class BasicLibraryController : AuthorizeApiController<T_SK_BASIC_LIBRARY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY> 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_SK_BASIC_LIBRARY entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY> 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_SK_BASIC_LIBRARY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryDetail-基础库管控措施明细表
	/// <summary>
    ///  基础库管控措施明细表
    /// </summary>
	[Route("api/SK/BasicLibraryDetail")]
    public partial class BasicLibraryDetailController : AuthorizeApiController<T_SK_BASIC_LIBRARY_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_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_SK_BASIC_LIBRARY_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_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_SK_BASIC_LIBRARY_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryDetailContent-基础库检查内容表
	/// <summary>
    ///  基础库检查内容表
    /// </summary>
	[Route("api/SK/BasicLibraryDetailContent")]
    public partial class BasicLibraryDetailContentController : AuthorizeApiController<T_SK_BASIC_LIBRARY_DETAIL_CONTENT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_DETAIL_CONTENT>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_DETAIL_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_DETAIL_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_DETAIL_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_SK_BASIC_LIBRARY_DETAIL_CONTENT entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_DETAIL_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_SK_BASIC_LIBRARY_DETAIL_CONTENT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryDetailContentBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/BasicLibraryDetailContentBasic")]
    public partial class BasicLibraryDetailContentBasicController : AuthorizeApiController<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_BASIC> 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_SK_BASIC_LIBRARY_DETAIL_CONTENT_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_BASIC> 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_SK_BASIC_LIBRARY_DETAIL_CONTENT_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryDetailContentHidden-基础库检查内容隐患表
	/// <summary>
    ///  基础库检查内容隐患表
    /// </summary>
	[Route("api/SK/BasicLibraryDetailContentHidden")]
    public partial class BasicLibraryDetailContentHiddenController : AuthorizeApiController<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_HIDDEN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_HIDDEN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_HIDDEN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_HIDDEN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_HIDDEN> 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_SK_BASIC_LIBRARY_DETAIL_CONTENT_HIDDEN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_DETAIL_CONTENT_HIDDEN> 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_SK_BASIC_LIBRARY_DETAIL_CONTENT_HIDDEN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryTemp-基础库
	/// <summary>
    ///  基础库
    /// </summary>
	[Route("api/SK/BasicLibraryTemp")]
    public partial class BasicLibraryTempController : AuthorizeApiController<T_SK_BASIC_LIBRARY_TEMP>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_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_SK_BASIC_LIBRARY_TEMP entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_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_SK_BASIC_LIBRARY_TEMP> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryTempContent-检查内容
	/// <summary>
    ///  检查内容
    /// </summary>
	[Route("api/SK/BasicLibraryTempContent")]
    public partial class BasicLibraryTempContentController : AuthorizeApiController<T_SK_BASIC_LIBRARY_TEMP_CONTENT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP_CONTENT>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP_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_SK_BASIC_LIBRARY_TEMP_CONTENT entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_TEMP_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_SK_BASIC_LIBRARY_TEMP_CONTENT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryTempHidden-隐患描述
	/// <summary>
    ///  隐患描述
    /// </summary>
	[Route("api/SK/BasicLibraryTempHidden")]
    public partial class BasicLibraryTempHiddenController : AuthorizeApiController<T_SK_BASIC_LIBRARY_TEMP_HIDDEN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP_HIDDEN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP_HIDDEN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP_HIDDEN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP_HIDDEN> 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_SK_BASIC_LIBRARY_TEMP_HIDDEN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_TEMP_HIDDEN> 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_SK_BASIC_LIBRARY_TEMP_HIDDEN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryTempMeasure-基础库管控措施明细表
	/// <summary>
    ///  基础库管控措施明细表
    /// </summary>
	[Route("api/SK/BasicLibraryTempMeasure")]
    public partial class BasicLibraryTempMeasureController : AuthorizeApiController<T_SK_BASIC_LIBRARY_TEMP_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP_MEASURE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP_MEASURE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP_MEASURE> 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_SK_BASIC_LIBRARY_TEMP_MEASURE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_TEMP_MEASURE> 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_SK_BASIC_LIBRARY_TEMP_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  BasicLibraryTempMeasureLevel-管控层级
	/// <summary>
    ///  管控层级
    /// </summary>
	[Route("api/SK/BasicLibraryTempMeasureLevel")]
    public partial class BasicLibraryTempMeasureLevelController : AuthorizeApiController<T_SK_BASIC_LIBRARY_TEMP_MEASURE_LEVEL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP_MEASURE_LEVEL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_BASIC_LIBRARY_TEMP_MEASURE_LEVEL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP_MEASURE_LEVEL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_BASIC_LIBRARY_TEMP_MEASURE_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_SK_BASIC_LIBRARY_TEMP_MEASURE_LEVEL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_BASIC_LIBRARY_TEMP_MEASURE_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_SK_BASIC_LIBRARY_TEMP_MEASURE_LEVEL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckContents-检查内容
	/// <summary>
    ///  检查内容
    /// </summary>
	[Route("api/SK/CheckContents")]
    public partial class CheckContentsController : AuthorizeApiController<T_SK_CHECK_CONTENTS>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_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_SK_CHECK_CONTENTS>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_CONTENTS> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_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_SK_CHECK_CONTENTS entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_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_SK_CHECK_CONTENTS> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckContentsBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/CheckContentsBasic")]
    public partial class CheckContentsBasicController : AuthorizeApiController<T_SK_CHECK_CONTENTS_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_CONTENTS_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_CONTENTS_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_CONTENTS_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_CHECK_CONTENTS_BASIC> 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_SK_CHECK_CONTENTS_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_CHECK_CONTENTS_BASIC> 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_SK_CHECK_CONTENTS_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckCycle-
	/// <summary>
    ///  
    /// </summary>
	[Route("api/SK/CheckCycle")]
    public partial class CheckCycleController : AuthorizeApiController<T_SK_CHECK_CYCLE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_CYCLE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_CYCLE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_CYCLE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_CHECK_CYCLE> 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_SK_CHECK_CYCLE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_CHECK_CYCLE> 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_SK_CHECK_CYCLE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckQuestion-检查问题
	/// <summary>
    ///  检查问题
    /// </summary>
	[Route("api/SK/CheckQuestion")]
    public partial class CheckQuestionController : AuthorizeApiController<T_SK_CHECK_QUESTION>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_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_SK_CHECK_QUESTION>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_QUESTION> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_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_SK_CHECK_QUESTION entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_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_SK_CHECK_QUESTION> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckSet-检查内容风险辨识配置表
	/// <summary>
    ///  检查内容风险辨识配置表
    /// </summary>
	[Route("api/SK/CheckSet")]
    public partial class CheckSetController : AuthorizeApiController<T_SK_CHECK_SET>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_SET> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_CHECK_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_SK_CHECK_SET entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_CHECK_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_SK_CHECK_SET> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckSetContents-检查内容风险辨识配置明细表
	/// <summary>
    ///  检查内容风险辨识配置明细表
    /// </summary>
	[Route("api/SK/CheckSetContents")]
    public partial class CheckSetContentsController : AuthorizeApiController<T_SK_CHECK_SET_CONTENTS>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_CHECK_SET_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_SK_CHECK_SET_CONTENTS entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_CHECK_SET_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_SK_CHECK_SET_CONTENTS> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckSetContentsArea-检查内容关联区域
	/// <summary>
    ///  检查内容关联区域
    /// </summary>
	[Route("api/SK/CheckSetContentsArea")]
    public partial class CheckSetContentsAreaController : AuthorizeApiController<T_SK_CHECK_SET_CONTENTS_AREA>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS_AREA>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS_AREA>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS_AREA> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS_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_SK_CHECK_SET_CONTENTS_AREA entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_CHECK_SET_CONTENTS_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_SK_CHECK_SET_CONTENTS_AREA> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckSetContentsAreaRisk-检查内容关联风险
	/// <summary>
    ///  检查内容关联风险
    /// </summary>
	[Route("api/SK/CheckSetContentsAreaRisk")]
    public partial class CheckSetContentsAreaRiskController : AuthorizeApiController<T_SK_CHECK_SET_CONTENTS_AREA_RISK>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS_AREA_RISK>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS_AREA_RISK>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS_AREA_RISK> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS_AREA_RISK> 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_SK_CHECK_SET_CONTENTS_AREA_RISK entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_CHECK_SET_CONTENTS_AREA_RISK> 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_SK_CHECK_SET_CONTENTS_AREA_RISK> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckSetContentsBasic-检查依据表
	/// <summary>
    ///  检查依据表
    /// </summary>
	[Route("api/SK/CheckSetContentsBasic")]
    public partial class CheckSetContentsBasicController : AuthorizeApiController<T_SK_CHECK_SET_CONTENTS_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS_BASIC> 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_SK_CHECK_SET_CONTENTS_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_CHECK_SET_CONTENTS_BASIC> 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_SK_CHECK_SET_CONTENTS_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckSetContentsHidden-隐患表
	/// <summary>
    ///  隐患表
    /// </summary>
	[Route("api/SK/CheckSetContentsHidden")]
    public partial class CheckSetContentsHiddenController : AuthorizeApiController<T_SK_CHECK_SET_CONTENTS_HIDDEN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS_HIDDEN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_CHECK_SET_CONTENTS_HIDDEN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS_HIDDEN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_CHECK_SET_CONTENTS_HIDDEN> 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_SK_CHECK_SET_CONTENTS_HIDDEN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_CHECK_SET_CONTENTS_HIDDEN> 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_SK_CHECK_SET_CONTENTS_HIDDEN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  CheckType-
	/// <summary>
    ///  
    /// </summary>
	[Route("api/SK/CheckType")]
    public partial class CheckTypeController : AuthorizeApiController<T_SK_CHECK_TYPE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_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_SK_CHECK_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_CHECK_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_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_SK_CHECK_TYPE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_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_SK_CHECK_TYPE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanism-双重预防机制
	/// <summary>
    ///  双重预防机制
    /// </summary>
	[Route("api/SK/DoublePreventMechanism")]
    public partial class DoublePreventMechanismController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM> 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_SK_DOUBLE_PREVENT_MECHANISM entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM> 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_SK_DOUBLE_PREVENT_MECHANISM> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetail-明细
	/// <summary>
    ///  明细
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetail")]
    public partial class DoublePreventMechanismDetailController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailDepart-辨识岗位
	/// <summary>
    ///  辨识岗位
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailDepart")]
    public partial class DoublePreventMechanismDetailDepartController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailDepartDetail-辨识岗位
	/// <summary>
    ///  辨识岗位
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailDepartDetail")]
    public partial class DoublePreventMechanismDetailDepartDetailController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART_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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART_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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_DEPART_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailMeasures-管控措施
	/// <summary>
    ///  管控措施
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailMeasures")]
    public partial class DoublePreventMechanismDetailMeasuresController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailMeasuresContent-检查内容
	/// <summary>
    ///  检查内容
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailMeasuresContent")]
    public partial class DoublePreventMechanismDetailMeasuresContentController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailMeasuresContentBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailMeasuresContentBasic")]
    public partial class DoublePreventMechanismDetailMeasuresContentBasicController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_BASIC> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_BASIC> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailMeasuresContentDepart-检查岗位
	/// <summary>
    ///  检查岗位
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailMeasuresContentDepart")]
    public partial class DoublePreventMechanismDetailMeasuresContentDepartController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_DEPART> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_DEPART> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailMeasuresContentHidden-检查内容隐患表
	/// <summary>
    ///  检查内容隐患表
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailMeasuresContentHidden")]
    public partial class DoublePreventMechanismDetailMeasuresContentHiddenController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_HIDDEN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_HIDDEN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_HIDDEN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_HIDDEN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_HIDDEN> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_HIDDEN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_HIDDEN> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_HIDDEN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailMeasuresContentPost-管控部门岗位
	/// <summary>
    ///  管控部门岗位
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailMeasuresContentPost")]
    public partial class DoublePreventMechanismDetailMeasuresContentPostController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_POST> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_POST> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_MEASURES_CONTENT_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismDetailPost-管控部门岗位
	/// <summary>
    ///  管控部门岗位
    /// </summary>
	[Route("api/SK/DoublePreventMechanismDetailPost")]
    public partial class DoublePreventMechanismDetailPostController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_POST> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_POST> 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_SK_DOUBLE_PREVENT_MECHANISM_DETAIL_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  DoublePreventMechanismFile-附件
	/// <summary>
    ///  附件
    /// </summary>
	[Route("api/SK/DoublePreventMechanismFile")]
    public partial class DoublePreventMechanismFileController : AuthorizeApiController<T_SK_DOUBLE_PREVENT_MECHANISM_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_DOUBLE_PREVENT_MECHANISM_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_DOUBLE_PREVENT_MECHANISM_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_SK_DOUBLE_PREVENT_MECHANISM_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_DOUBLE_PREVENT_MECHANISM_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_SK_DOUBLE_PREVENT_MECHANISM_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibrary-企业库
	/// <summary>
    ///  企业库
    /// </summary>
	[Route("api/SK/EnterpriseLibrary")]
    public partial class EnterpriseLibraryController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY> 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_SK_ENTERPRISE_LIBRARY entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY> 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_SK_ENTERPRISE_LIBRARY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryDepart-管控层级
	/// <summary>
    ///  管控层级
    /// </summary>
	[Route("api/SK/EnterpriseLibraryDepart")]
    public partial class EnterpriseLibraryDepartController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DEPART> 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_SK_ENTERPRISE_LIBRARY_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_DEPART> 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_SK_ENTERPRISE_LIBRARY_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryDetail-企业库管控措施明细表
	/// <summary>
    ///  企业库管控措施明细表
    /// </summary>
	[Route("api/SK/EnterpriseLibraryDetail")]
    public partial class EnterpriseLibraryDetailController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_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_SK_ENTERPRISE_LIBRARY_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_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_SK_ENTERPRISE_LIBRARY_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryDetailContent-企业库检查内容表
	/// <summary>
    ///  企业库检查内容表
    /// </summary>
	[Route("api/SK/EnterpriseLibraryDetailContent")]
    public partial class EnterpriseLibraryDetailContentController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_DETAIL_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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryDetailContentBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/EnterpriseLibraryDetailContentBasic")]
    public partial class EnterpriseLibraryDetailContentBasicController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_BASIC> 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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_BASIC> 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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryDetailContentDepart-检查部门
	/// <summary>
    ///  检查部门
    /// </summary>
	[Route("api/SK/EnterpriseLibraryDetailContentDepart")]
    public partial class EnterpriseLibraryDetailContentDepartController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART> 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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART> 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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryDetailContentHidden-企业库检查内容隐患表
	/// <summary>
    ///  企业库检查内容隐患表
    /// </summary>
	[Route("api/SK/EnterpriseLibraryDetailContentHidden")]
    public partial class EnterpriseLibraryDetailContentHiddenController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN> 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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN> 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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryDetailContentPost-检查岗位
	/// <summary>
    ///  检查岗位
    /// </summary>
	[Route("api/SK/EnterpriseLibraryDetailContentPost")]
    public partial class EnterpriseLibraryDetailContentPostController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_POST> 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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_POST> 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_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryPost-辨识岗位
	/// <summary>
    ///  辨识岗位
    /// </summary>
	[Route("api/SK/EnterpriseLibraryPost")]
    public partial class EnterpriseLibraryPostController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_POST> 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_SK_ENTERPRISE_LIBRARY_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_POST> 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_SK_ENTERPRISE_LIBRARY_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryPostDetail-
	/// <summary>
    ///  
    /// </summary>
	[Route("api/SK/EnterpriseLibraryPostDetail")]
    public partial class EnterpriseLibraryPostDetailController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_POST_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_POST_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_POST_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_POST_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_POST_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_SK_ENTERPRISE_LIBRARY_POST_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_POST_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_SK_ENTERPRISE_LIBRARY_POST_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryTemp-企业库
	/// <summary>
    ///  企业库
    /// </summary>
	[Route("api/SK/EnterpriseLibraryTemp")]
    public partial class EnterpriseLibraryTempController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_TEMP>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_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_SK_ENTERPRISE_LIBRARY_TEMP entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_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_SK_ENTERPRISE_LIBRARY_TEMP> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryTempContent-检查内容
	/// <summary>
    ///  检查内容
    /// </summary>
	[Route("api/SK/EnterpriseLibraryTempContent")]
    public partial class EnterpriseLibraryTempContentController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_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_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_TEMP_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_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryTempContentDepart-检查部门
	/// <summary>
    ///  检查部门
    /// </summary>
	[Route("api/SK/EnterpriseLibraryTempContentDepart")]
    public partial class EnterpriseLibraryTempContentDepartController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_DEPART> 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_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_DEPART> 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_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryTempContentPost-检查类型
	/// <summary>
    ///  检查类型
    /// </summary>
	[Route("api/SK/EnterpriseLibraryTempContentPost")]
    public partial class EnterpriseLibraryTempContentPostController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_POST> 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_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_POST> 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_SK_ENTERPRISE_LIBRARY_TEMP_CONTENT_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryTempHidden-隐患描述
	/// <summary>
    ///  隐患描述
    /// </summary>
	[Route("api/SK/EnterpriseLibraryTempHidden")]
    public partial class EnterpriseLibraryTempHiddenController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_TEMP_HIDDEN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_HIDDEN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_HIDDEN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_HIDDEN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_HIDDEN> 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_SK_ENTERPRISE_LIBRARY_TEMP_HIDDEN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_TEMP_HIDDEN> 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_SK_ENTERPRISE_LIBRARY_TEMP_HIDDEN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryTempMeasure-管控措施
	/// <summary>
    ///  管控措施
    /// </summary>
	[Route("api/SK/EnterpriseLibraryTempMeasure")]
    public partial class EnterpriseLibraryTempMeasureController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE> 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_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE> 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_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  EnterpriseLibraryTempMeasureDepart-管控部门
	/// <summary>
    ///  管控部门
    /// </summary>
	[Route("api/SK/EnterpriseLibraryTempMeasureDepart")]
    public partial class EnterpriseLibraryTempMeasureDepartController : AuthorizeApiController<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE_DEPART> 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_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE_DEPART> 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_SK_ENTERPRISE_LIBRARY_TEMP_MEASURE_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  Evaluation-评价要求
	/// <summary>
    ///  评价要求
    /// </summary>
	[Route("api/SK/Evaluation")]
    public partial class EvaluationController : AuthorizeApiController<T_SK_EVALUATION>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_EVALUATION>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_EVALUATION>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_EVALUATION> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_EVALUATION> 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_SK_EVALUATION entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_EVALUATION> 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_SK_EVALUATION> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerConfirm-隐患确认单
	/// <summary>
    ///  隐患确认单
    /// </summary>
	[Route("api/SK/HiddenDangerConfirm")]
    public partial class HiddenDangerConfirmController : AuthorizeApiController<T_SK_HIDDEN_DANGER_CONFIRM>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_CONFIRM>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_CONFIRM>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_CONFIRM> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_CONFIRM> 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_SK_HIDDEN_DANGER_CONFIRM entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_CONFIRM> 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_SK_HIDDEN_DANGER_CONFIRM> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerConfirmBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/HiddenDangerConfirmBasic")]
    public partial class HiddenDangerConfirmBasicController : AuthorizeApiController<T_SK_HIDDEN_DANGER_CONFIRM_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_CONFIRM_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_CONFIRM_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_CONFIRM_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_CONFIRM_BASIC> 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_SK_HIDDEN_DANGER_CONFIRM_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_CONFIRM_BASIC> 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_SK_HIDDEN_DANGER_CONFIRM_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerConfirmFile-隐患附件表
	/// <summary>
    ///  隐患附件表
    /// </summary>
	[Route("api/SK/HiddenDangerConfirmFile")]
    public partial class HiddenDangerConfirmFileController : AuthorizeApiController<T_SK_HIDDEN_DANGER_CONFIRM_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_CONFIRM_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_CONFIRM_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_CONFIRM_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_CONFIRM_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_SK_HIDDEN_DANGER_CONFIRM_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_CONFIRM_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_SK_HIDDEN_DANGER_CONFIRM_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerConfirmPhoto-隐患照片表
	/// <summary>
    ///  隐患照片表
    /// </summary>
	[Route("api/SK/HiddenDangerConfirmPhoto")]
    public partial class HiddenDangerConfirmPhotoController : AuthorizeApiController<T_SK_HIDDEN_DANGER_CONFIRM_PHOTO>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_CONFIRM_PHOTO>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_CONFIRM_PHOTO>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_CONFIRM_PHOTO> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_CONFIRM_PHOTO> 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_SK_HIDDEN_DANGER_CONFIRM_PHOTO entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_CONFIRM_PHOTO> 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_SK_HIDDEN_DANGER_CONFIRM_PHOTO> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerHandReport-手动隐患上报表
	/// <summary>
    ///  手动隐患上报表
    /// </summary>
	[Route("api/SK/HiddenDangerHandReport")]
    public partial class HiddenDangerHandReportController : AuthorizeApiController<T_SK_HIDDEN_DANGER_HAND_REPORT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_HAND_REPORT>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_HAND_REPORT>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_HAND_REPORT> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_HAND_REPORT> 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_SK_HIDDEN_DANGER_HAND_REPORT entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_HAND_REPORT> 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_SK_HIDDEN_DANGER_HAND_REPORT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerHandReportFile-隐患照片表
	/// <summary>
    ///  隐患照片表
    /// </summary>
	[Route("api/SK/HiddenDangerHandReportFile")]
    public partial class HiddenDangerHandReportFileController : AuthorizeApiController<T_SK_HIDDEN_DANGER_HAND_REPORT_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_HAND_REPORT_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_HAND_REPORT_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_HAND_REPORT_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_HAND_REPORT_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_SK_HIDDEN_DANGER_HAND_REPORT_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_HAND_REPORT_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_SK_HIDDEN_DANGER_HAND_REPORT_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyDelayApply-隐患整改延期申请
	/// <summary>
    ///  隐患整改延期申请
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyDelayApply")]
    public partial class HiddenDangerRectifyDelayApplyController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_DELAY_APPLY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_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_SK_HIDDEN_DANGER_RECTIFY_DELAY_APPLY>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_DELAY_APPLY> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_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_SK_HIDDEN_DANGER_RECTIFY_DELAY_APPLY entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_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_SK_HIDDEN_DANGER_RECTIFY_DELAY_APPLY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyNotice-隐患整改通知
	/// <summary>
    ///  隐患整改通知
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyNotice")]
    public partial class HiddenDangerRectifyNoticeController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyNoticeDetail-隐患整改通知明细
	/// <summary>
    ///  隐患整改通知明细
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyNoticeDetail")]
    public partial class HiddenDangerRectifyNoticeDetailController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyNoticeDetailBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyNoticeDetailBasic")]
    public partial class HiddenDangerRectifyNoticeDetailBasicController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_BASIC> 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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_BASIC> 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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyNoticeDetailFile-隐患照片表
	/// <summary>
    ///  隐患照片表
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyNoticeDetailFile")]
    public partial class HiddenDangerRectifyNoticeDetailFileController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_DETAIL_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyNoticeFile-隐患整改通知附件
	/// <summary>
    ///  隐患整改通知附件
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyNoticeFile")]
    public partial class HiddenDangerRectifyNoticeFileController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_NOTICE_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_SK_HIDDEN_DANGER_RECTIFY_NOTICE_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyRecord-隐患整改记录
	/// <summary>
    ///  隐患整改记录
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyRecord")]
    public partial class HiddenDangerRectifyRecordController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_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_SK_HIDDEN_DANGER_RECTIFY_RECORD entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_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_SK_HIDDEN_DANGER_RECTIFY_RECORD> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyRecordBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyRecordBasic")]
    public partial class HiddenDangerRectifyRecordBasicController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_BASIC> 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_SK_HIDDEN_DANGER_RECTIFY_RECORD_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_BASIC> 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_SK_HIDDEN_DANGER_RECTIFY_RECORD_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyRecordFile-预案或方案
	/// <summary>
    ///  预案或方案
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyRecordFile")]
    public partial class HiddenDangerRectifyRecordFileController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_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_SK_HIDDEN_DANGER_RECTIFY_RECORD_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_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_SK_HIDDEN_DANGER_RECTIFY_RECORD_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyRecordPhotoa-整改前照片
	/// <summary>
    ///  整改前照片
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyRecordPhotoa")]
    public partial class HiddenDangerRectifyRecordPhotoaController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOA>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOA>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOA>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOA> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOA> 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_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOA entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOA> 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_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOA> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerRectifyRecordPhotob-整改后照片
	/// <summary>
    ///  整改后照片
    /// </summary>
	[Route("api/SK/HiddenDangerRectifyRecordPhotob")]
    public partial class HiddenDangerRectifyRecordPhotobController : AuthorizeApiController<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOB>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOB>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOB>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOB> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOB> 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_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOB entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOB> 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_SK_HIDDEN_DANGER_RECTIFY_RECORD_PHOTOB> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerReport-隐患上报表
	/// <summary>
    ///  隐患上报表
    /// </summary>
	[Route("api/SK/HiddenDangerReport")]
    public partial class HiddenDangerReportController : AuthorizeApiController<T_SK_HIDDEN_DANGER_REPORT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT> 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_SK_HIDDEN_DANGER_REPORT entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_REPORT> 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_SK_HIDDEN_DANGER_REPORT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerReportDetail-隐患上报明细表
	/// <summary>
    ///  隐患上报明细表
    /// </summary>
	[Route("api/SK/HiddenDangerReportDetail")]
    public partial class HiddenDangerReportDetailController : AuthorizeApiController<T_SK_HIDDEN_DANGER_REPORT_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT_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_SK_HIDDEN_DANGER_REPORT_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_REPORT_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_SK_HIDDEN_DANGER_REPORT_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerReportDetailBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/HiddenDangerReportDetailBasic")]
    public partial class HiddenDangerReportDetailBasicController : AuthorizeApiController<T_SK_HIDDEN_DANGER_REPORT_DETAIL_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT_DETAIL_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT_DETAIL_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT_DETAIL_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT_DETAIL_BASIC> 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_SK_HIDDEN_DANGER_REPORT_DETAIL_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_REPORT_DETAIL_BASIC> 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_SK_HIDDEN_DANGER_REPORT_DETAIL_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerReportDetailFile-隐患上报照片
	/// <summary>
    ///  隐患上报照片
    /// </summary>
	[Route("api/SK/HiddenDangerReportDetailFile")]
    public partial class HiddenDangerReportDetailFileController : AuthorizeApiController<T_SK_HIDDEN_DANGER_REPORT_DETAIL_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT_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_SK_HIDDEN_DANGER_REPORT_DETAIL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT_DETAIL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT_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_SK_HIDDEN_DANGER_REPORT_DETAIL_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_REPORT_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_SK_HIDDEN_DANGER_REPORT_DETAIL_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  HiddenDangerReportFile-隐患上报附件表
	/// <summary>
    ///  隐患上报附件表
    /// </summary>
	[Route("api/SK/HiddenDangerReportFile")]
    public partial class HiddenDangerReportFileController : AuthorizeApiController<T_SK_HIDDEN_DANGER_REPORT_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_HIDDEN_DANGER_REPORT_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_HIDDEN_DANGER_REPORT_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_SK_HIDDEN_DANGER_REPORT_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_HIDDEN_DANGER_REPORT_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_SK_HIDDEN_DANGER_REPORT_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  IdentifyEvaluationPlan-辨识评估计划
	/// <summary>
    ///  辨识评估计划
    /// </summary>
	[Route("api/SK/IdentifyEvaluationPlan")]
    public partial class IdentifyEvaluationPlanController : AuthorizeApiController<T_SK_IDENTIFY_EVALUATION_PLAN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_IDENTIFY_EVALUATION_PLAN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_IDENTIFY_EVALUATION_PLAN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_IDENTIFY_EVALUATION_PLAN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_IDENTIFY_EVALUATION_PLAN> 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_SK_IDENTIFY_EVALUATION_PLAN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_IDENTIFY_EVALUATION_PLAN> 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_SK_IDENTIFY_EVALUATION_PLAN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  IdentifyEvaluationPlanDetail-辨识评估计划明细
	/// <summary>
    ///  辨识评估计划明细
    /// </summary>
	[Route("api/SK/IdentifyEvaluationPlanDetail")]
    public partial class IdentifyEvaluationPlanDetailController : AuthorizeApiController<T_SK_IDENTIFY_EVALUATION_PLAN_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_IDENTIFY_EVALUATION_PLAN_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_IDENTIFY_EVALUATION_PLAN_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_IDENTIFY_EVALUATION_PLAN_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_IDENTIFY_EVALUATION_PLAN_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_SK_IDENTIFY_EVALUATION_PLAN_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_IDENTIFY_EVALUATION_PLAN_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_SK_IDENTIFY_EVALUATION_PLAN_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  IdentifyEvaluationPlanDetailUser-辨识人员
	/// <summary>
    ///  辨识人员
    /// </summary>
	[Route("api/SK/IdentifyEvaluationPlanDetailUser")]
    public partial class IdentifyEvaluationPlanDetailUserController : AuthorizeApiController<T_SK_IDENTIFY_EVALUATION_PLAN_DETAIL_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_IDENTIFY_EVALUATION_PLAN_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_SK_IDENTIFY_EVALUATION_PLAN_DETAIL_USER>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_IDENTIFY_EVALUATION_PLAN_DETAIL_USER> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_IDENTIFY_EVALUATION_PLAN_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_SK_IDENTIFY_EVALUATION_PLAN_DETAIL_USER entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_IDENTIFY_EVALUATION_PLAN_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_SK_IDENTIFY_EVALUATION_PLAN_DETAIL_USER> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  IdentifyEvaluationPlanFile-辨识评估计划附件
	/// <summary>
    ///  辨识评估计划附件
    /// </summary>
	[Route("api/SK/IdentifyEvaluationPlanFile")]
    public partial class IdentifyEvaluationPlanFileController : AuthorizeApiController<T_SK_IDENTIFY_EVALUATION_PLAN_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_IDENTIFY_EVALUATION_PLAN_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_IDENTIFY_EVALUATION_PLAN_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_IDENTIFY_EVALUATION_PLAN_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_IDENTIFY_EVALUATION_PLAN_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_SK_IDENTIFY_EVALUATION_PLAN_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_IDENTIFY_EVALUATION_PLAN_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_SK_IDENTIFY_EVALUATION_PLAN_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  LibraryImportMain-企业库导入主表
	/// <summary>
    ///  企业库导入主表
    /// </summary>
	[Route("api/SK/LibraryImportMain")]
    public partial class LibraryImportMainController : AuthorizeApiController<T_SK_LIBRARY_IMPORT_MAIN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_MAIN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_MAIN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_MAIN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_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_SK_LIBRARY_IMPORT_MAIN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_LIBRARY_IMPORT_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_SK_LIBRARY_IMPORT_MAIN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  LibraryImportMainHidden-企业库导入隐患描述表
	/// <summary>
    ///  企业库导入隐患描述表
    /// </summary>
	[Route("api/SK/LibraryImportMainHidden")]
    public partial class LibraryImportMainHiddenController : AuthorizeApiController<T_SK_LIBRARY_IMPORT_MAIN_HIDDEN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_MAIN_HIDDEN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_MAIN_HIDDEN>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_MAIN_HIDDEN> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_MAIN_HIDDEN> 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_SK_LIBRARY_IMPORT_MAIN_HIDDEN entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_LIBRARY_IMPORT_MAIN_HIDDEN> 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_SK_LIBRARY_IMPORT_MAIN_HIDDEN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  LibraryImportMainMeasures-企业库导入管控措施表
	/// <summary>
    ///  企业库导入管控措施表
    /// </summary>
	[Route("api/SK/LibraryImportMainMeasures")]
    public partial class LibraryImportMainMeasuresController : AuthorizeApiController<T_SK_LIBRARY_IMPORT_MAIN_MEASURES>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_MAIN_MEASURES>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_MAIN_MEASURES>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_MAIN_MEASURES> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_MAIN_MEASURES> 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_SK_LIBRARY_IMPORT_MAIN_MEASURES entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_LIBRARY_IMPORT_MAIN_MEASURES> 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_SK_LIBRARY_IMPORT_MAIN_MEASURES> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  LibraryImportMainPost-企业库导入辨识岗位表
	/// <summary>
    ///  企业库导入辨识岗位表
    /// </summary>
	[Route("api/SK/LibraryImportMainPost")]
    public partial class LibraryImportMainPostController : AuthorizeApiController<T_SK_LIBRARY_IMPORT_MAIN_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_MAIN_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_MAIN_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_MAIN_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_MAIN_POST> 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_SK_LIBRARY_IMPORT_MAIN_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_LIBRARY_IMPORT_MAIN_POST> 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_SK_LIBRARY_IMPORT_MAIN_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  LibraryImportPost-辨识岗位导入
	/// <summary>
    ///  辨识岗位导入
    /// </summary>
	[Route("api/SK/LibraryImportPost")]
    public partial class LibraryImportPostController : AuthorizeApiController<T_SK_LIBRARY_IMPORT_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_POST> 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_SK_LIBRARY_IMPORT_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_LIBRARY_IMPORT_POST> 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_SK_LIBRARY_IMPORT_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  LibraryImportTemp-双控库导入
	/// <summary>
    ///  双控库导入
    /// </summary>
	[Route("api/SK/LibraryImportTemp")]
    public partial class LibraryImportTempController : AuthorizeApiController<T_SK_LIBRARY_IMPORT_TEMP>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_TEMP>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_TEMP>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_TEMP> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_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_SK_LIBRARY_IMPORT_TEMP entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_LIBRARY_IMPORT_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_SK_LIBRARY_IMPORT_TEMP> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  LibraryImportTempNew-双控库导入
	/// <summary>
    ///  双控库导入
    /// </summary>
	[Route("api/SK/LibraryImportTempNew")]
    public partial class LibraryImportTempNewController : AuthorizeApiController<T_SK_LIBRARY_IMPORT_TEMP_NEW>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_TEMP_NEW>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_LIBRARY_IMPORT_TEMP_NEW>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_TEMP_NEW> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_LIBRARY_IMPORT_TEMP_NEW> 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_SK_LIBRARY_IMPORT_TEMP_NEW entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_LIBRARY_IMPORT_TEMP_NEW> 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_SK_LIBRARY_IMPORT_TEMP_NEW> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  Measure-管控措施
	/// <summary>
    ///  管控措施
    /// </summary>
	[Route("api/SK/Measure")]
    public partial class MeasureController : AuthorizeApiController<T_SK_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_MEASURE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_MEASURE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_MEASURE> 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_SK_MEASURE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_MEASURE> 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_SK_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  PlanSet-制定任务
	/// <summary>
    ///  制定任务
    /// </summary>
	[Route("api/SK/PlanSet")]
    public partial class PlanSetController : AuthorizeApiController<T_SK_PLAN_SET>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_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_SK_PLAN_SET>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_PLAN_SET> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_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_SK_PLAN_SET entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_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_SK_PLAN_SET> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  PlanSetArea-制定任务区域
	/// <summary>
    ///  制定任务区域
    /// </summary>
	[Route("api/SK/PlanSetArea")]
    public partial class PlanSetAreaController : AuthorizeApiController<T_SK_PLAN_SET_AREA>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_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_SK_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_SK_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_SK_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_SK_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_SK_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_SK_PLAN_SET_AREA> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  PlanSetDepartmentOut-制定任务排除组织
	/// <summary>
    ///  制定任务排除组织
    /// </summary>
	[Route("api/SK/PlanSetDepartmentOut")]
    public partial class PlanSetDepartmentOutController : AuthorizeApiController<T_SK_PLAN_SET_DEPARTMENT_OUT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_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_SK_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_SK_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_SK_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_SK_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_SK_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_SK_PLAN_SET_DEPARTMENT_OUT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  PlanSetDepObject-制定任务部门触发范围
	/// <summary>
    ///  制定任务部门触发范围
    /// </summary>
	[Route("api/SK/PlanSetDepObject")]
    public partial class PlanSetDepObjectController : AuthorizeApiController<T_SK_PLAN_SET_DEP_OBJECT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_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_SK_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_SK_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_SK_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_SK_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_SK_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_SK_PLAN_SET_DEP_OBJECT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  Request-辨识要求
	/// <summary>
    ///  辨识要求
    /// </summary>
	[Route("api/SK/Request")]
    public partial class RequestController : AuthorizeApiController<T_SK_REQUEST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_REQUEST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_REQUEST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_REQUEST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_REQUEST> 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_SK_REQUEST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_REQUEST> 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_SK_REQUEST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskArea-辨识区域
	/// <summary>
    ///  辨识区域
    /// </summary>
	[Route("api/SK/RiskArea")]
    public partial class RiskAreaController : AuthorizeTreeApiController<T_SK_RISK_AREA>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_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_SK_RISK_AREA>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_AREA> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_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_SK_RISK_AREA entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_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_SK_RISK_AREA> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
                     	/// <summary>
	/// 获得树形实体数据
	/// </summary>
	/// <param name="filter"></param>
	/// <returns></returns>
	[HttpPost, Route("TreeData")]
	public JsonActionResult<IEnumerable<TreeNode<T_SK_RISK_AREA>>> TreeData([FromBody] KeywordFilter filter)
	{
		return WitTreeOrderEntities(null, filter);
	}
               
    }
	#endregion
	#region  RiskEvaluation-安全风险评估表
	/// <summary>
    ///  安全风险评估表
    /// </summary>
	[Route("api/SK/RiskEvaluation")]
    public partial class RiskEvaluationController : AuthorizeApiController<T_SK_RISK_EVALUATION>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION> 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_SK_RISK_EVALUATION entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION> 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_SK_RISK_EVALUATION> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationDetail-安全风险评估明细表
	/// <summary>
    ///  安全风险评估明细表
    /// </summary>
	[Route("api/SK/RiskEvaluationDetail")]
    public partial class RiskEvaluationDetailController : AuthorizeApiController<T_SK_RISK_EVALUATION_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_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_SK_RISK_EVALUATION_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_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_SK_RISK_EVALUATION_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationDetailDepart-辨识部门
	/// <summary>
    ///  辨识部门
    /// </summary>
	[Route("api/SK/RiskEvaluationDetailDepart")]
    public partial class RiskEvaluationDetailDepartController : AuthorizeApiController<T_SK_RISK_EVALUATION_DETAIL_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_DETAIL_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_DETAIL_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_DETAIL_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_DETAIL_DEPART> 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_SK_RISK_EVALUATION_DETAIL_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_DETAIL_DEPART> 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_SK_RISK_EVALUATION_DETAIL_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationDetailMeasure-管控措施
	/// <summary>
    ///  管控措施
    /// </summary>
	[Route("api/SK/RiskEvaluationDetailMeasure")]
    public partial class RiskEvaluationDetailMeasureController : AuthorizeApiController<T_SK_RISK_EVALUATION_DETAIL_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_DETAIL_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_DETAIL_MEASURE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_DETAIL_MEASURE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_DETAIL_MEASURE> 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_SK_RISK_EVALUATION_DETAIL_MEASURE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_DETAIL_MEASURE> 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_SK_RISK_EVALUATION_DETAIL_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationDetailPost-管控部门岗位
	/// <summary>
    ///  管控部门岗位
    /// </summary>
	[Route("api/SK/RiskEvaluationDetailPost")]
    public partial class RiskEvaluationDetailPostController : AuthorizeApiController<T_SK_RISK_EVALUATION_DETAIL_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_DETAIL_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_DETAIL_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_DETAIL_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_DETAIL_POST> 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_SK_RISK_EVALUATION_DETAIL_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_DETAIL_POST> 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_SK_RISK_EVALUATION_DETAIL_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationFile-安全风险评估附件表
	/// <summary>
    ///  安全风险评估附件表
    /// </summary>
	[Route("api/SK/RiskEvaluationFile")]
    public partial class RiskEvaluationFileController : AuthorizeApiController<T_SK_RISK_EVALUATION_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_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_SK_RISK_EVALUATION_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_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_SK_RISK_EVALUATION_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationSummary-安全风险评估汇总表
	/// <summary>
    ///  安全风险评估汇总表
    /// </summary>
	[Route("api/SK/RiskEvaluationSummary")]
    public partial class RiskEvaluationSummaryController : AuthorizeApiController<T_SK_RISK_EVALUATION_SUMMARY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY> 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_SK_RISK_EVALUATION_SUMMARY entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_SUMMARY> 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_SK_RISK_EVALUATION_SUMMARY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationSummaryDetail-安全风险评估明细表
	/// <summary>
    ///  安全风险评估明细表
    /// </summary>
	[Route("api/SK/RiskEvaluationSummaryDetail")]
    public partial class RiskEvaluationSummaryDetailController : AuthorizeApiController<T_SK_RISK_EVALUATION_SUMMARY_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_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_SK_RISK_EVALUATION_SUMMARY_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_SUMMARY_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_SK_RISK_EVALUATION_SUMMARY_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationSummaryDetailDepart-管控部门
	/// <summary>
    ///  管控部门
    /// </summary>
	[Route("api/SK/RiskEvaluationSummaryDetailDepart")]
    public partial class RiskEvaluationSummaryDetailDepartController : AuthorizeApiController<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_DEPART> 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_SK_RISK_EVALUATION_SUMMARY_DETAIL_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_DEPART> 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_SK_RISK_EVALUATION_SUMMARY_DETAIL_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationSummaryDetailMeasure-管控措施
	/// <summary>
    ///  管控措施
    /// </summary>
	[Route("api/SK/RiskEvaluationSummaryDetailMeasure")]
    public partial class RiskEvaluationSummaryDetailMeasureController : AuthorizeApiController<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_MEASURE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_MEASURE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_MEASURE> 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_SK_RISK_EVALUATION_SUMMARY_DETAIL_MEASURE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_MEASURE> 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_SK_RISK_EVALUATION_SUMMARY_DETAIL_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationSummaryDetailPost-管控部门岗位
	/// <summary>
    ///  管控部门岗位
    /// </summary>
	[Route("api/SK/RiskEvaluationSummaryDetailPost")]
    public partial class RiskEvaluationSummaryDetailPostController : AuthorizeApiController<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_POST> 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_SK_RISK_EVALUATION_SUMMARY_DETAIL_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_SUMMARY_DETAIL_POST> 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_SK_RISK_EVALUATION_SUMMARY_DETAIL_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskEvaluationSummaryFile-安全风险评估附件表
	/// <summary>
    ///  安全风险评估附件表
    /// </summary>
	[Route("api/SK/RiskEvaluationSummaryFile")]
    public partial class RiskEvaluationSummaryFileController : AuthorizeApiController<T_SK_RISK_EVALUATION_SUMMARY_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_EVALUATION_SUMMARY_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_EVALUATION_SUMMARY_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_SK_RISK_EVALUATION_SUMMARY_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_EVALUATION_SUMMARY_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_SK_RISK_EVALUATION_SUMMARY_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentify-安全风险辨识表
	/// <summary>
    ///  安全风险辨识表
    /// </summary>
	[Route("api/SK/RiskIdentify")]
    public partial class RiskIdentifyController : AuthorizeApiController<T_SK_RISK_IDENTIFY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY> 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_SK_RISK_IDENTIFY entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY> 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_SK_RISK_IDENTIFY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyDetail-安全风险辨识明细表
	/// <summary>
    ///  安全风险辨识明细表
    /// </summary>
	[Route("api/SK/RiskIdentifyDetail")]
    public partial class RiskIdentifyDetailController : AuthorizeApiController<T_SK_RISK_IDENTIFY_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_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_SK_RISK_IDENTIFY_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_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_SK_RISK_IDENTIFY_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyDetailMeasure-管控措施
	/// <summary>
    ///  管控措施
    /// </summary>
	[Route("api/SK/RiskIdentifyDetailMeasure")]
    public partial class RiskIdentifyDetailMeasureController : AuthorizeApiController<T_SK_RISK_IDENTIFY_DETAIL_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL_MEASURE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL_MEASURE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL_MEASURE> 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_SK_RISK_IDENTIFY_DETAIL_MEASURE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_DETAIL_MEASURE> 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_SK_RISK_IDENTIFY_DETAIL_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyDetailResultDepart-辨识部门
	/// <summary>
    ///  辨识部门
    /// </summary>
	[Route("api/SK/RiskIdentifyDetailResultDepart")]
    public partial class RiskIdentifyDetailResultDepartController : AuthorizeApiController<T_SK_RISK_IDENTIFY_DETAIL_RESULT_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL_RESULT_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL_RESULT_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL_RESULT_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL_RESULT_DEPART> 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_SK_RISK_IDENTIFY_DETAIL_RESULT_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_DETAIL_RESULT_DEPART> 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_SK_RISK_IDENTIFY_DETAIL_RESULT_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyDetailResultMeasure-管控措施
	/// <summary>
    ///  管控措施
    /// </summary>
	[Route("api/SK/RiskIdentifyDetailResultMeasure")]
    public partial class RiskIdentifyDetailResultMeasureController : AuthorizeApiController<T_SK_RISK_IDENTIFY_DETAIL_RESULT_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL_RESULT_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL_RESULT_MEASURE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL_RESULT_MEASURE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL_RESULT_MEASURE> 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_SK_RISK_IDENTIFY_DETAIL_RESULT_MEASURE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_DETAIL_RESULT_MEASURE> 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_SK_RISK_IDENTIFY_DETAIL_RESULT_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyDetailResultPost-辨识岗位
	/// <summary>
    ///  辨识岗位
    /// </summary>
	[Route("api/SK/RiskIdentifyDetailResultPost")]
    public partial class RiskIdentifyDetailResultPostController : AuthorizeApiController<T_SK_RISK_IDENTIFY_DETAIL_RESULT_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL_RESULT_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_DETAIL_RESULT_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL_RESULT_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_DETAIL_RESULT_POST> 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_SK_RISK_IDENTIFY_DETAIL_RESULT_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_DETAIL_RESULT_POST> 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_SK_RISK_IDENTIFY_DETAIL_RESULT_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyFile-安全风险辨识附件表
	/// <summary>
    ///  安全风险辨识附件表
    /// </summary>
	[Route("api/SK/RiskIdentifyFile")]
    public partial class RiskIdentifyFileController : AuthorizeApiController<T_SK_RISK_IDENTIFY_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_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_SK_RISK_IDENTIFY_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_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_SK_RISK_IDENTIFY_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResult-安全风险辨识结果表
	/// <summary>
    ///  安全风险辨识结果表
    /// </summary>
	[Route("api/SK/RiskIdentifyResult")]
    public partial class RiskIdentifyResultController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT> 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_SK_RISK_IDENTIFY_RESULT entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT> 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_SK_RISK_IDENTIFY_RESULT> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResultDetail-安全风险辨识结果明细表
	/// <summary>
    ///  安全风险辨识结果明细表
    /// </summary>
	[Route("api/SK/RiskIdentifyResultDetail")]
    public partial class RiskIdentifyResultDetailController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_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_SK_RISK_IDENTIFY_RESULT_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT_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_SK_RISK_IDENTIFY_RESULT_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResultFile-安全风险辨识结果附件表
	/// <summary>
    ///  安全风险辨识结果附件表
    /// </summary>
	[Route("api/SK/RiskIdentifyResultFile")]
    public partial class RiskIdentifyResultFileController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_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_SK_RISK_IDENTIFY_RESULT_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT_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_SK_RISK_IDENTIFY_RESULT_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResultSummary-安全风险辨识结果汇总表
	/// <summary>
    ///  安全风险辨识结果汇总表
    /// </summary>
	[Route("api/SK/RiskIdentifyResultSummary")]
    public partial class RiskIdentifyResultSummaryController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT_SUMMARY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY> 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_SK_RISK_IDENTIFY_RESULT_SUMMARY entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT_SUMMARY> 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_SK_RISK_IDENTIFY_RESULT_SUMMARY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResultSummaryDepart-辨识部门
	/// <summary>
    ///  辨识部门
    /// </summary>
	[Route("api/SK/RiskIdentifyResultSummaryDepart")]
    public partial class RiskIdentifyResultSummaryDepartController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DEPART>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DEPART>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DEPART>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DEPART> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DEPART> 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_SK_RISK_IDENTIFY_RESULT_SUMMARY_DEPART entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DEPART> 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_SK_RISK_IDENTIFY_RESULT_SUMMARY_DEPART> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResultSummaryDetail-安全风险辨识结果汇总明细表
	/// <summary>
    ///  安全风险辨识结果汇总明细表
    /// </summary>
	[Route("api/SK/RiskIdentifyResultSummaryDetail")]
    public partial class RiskIdentifyResultSummaryDetailController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_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_SK_RISK_IDENTIFY_RESULT_SUMMARY_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_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_SK_RISK_IDENTIFY_RESULT_SUMMARY_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResultSummaryFile-安全风险辨识结果汇总附件表
	/// <summary>
    ///  安全风险辨识结果汇总附件表
    /// </summary>
	[Route("api/SK/RiskIdentifyResultSummaryFile")]
    public partial class RiskIdentifyResultSummaryFileController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_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_SK_RISK_IDENTIFY_RESULT_SUMMARY_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_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_SK_RISK_IDENTIFY_RESULT_SUMMARY_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResultSummaryMeasure-管控措施
	/// <summary>
    ///  管控措施
    /// </summary>
	[Route("api/SK/RiskIdentifyResultSummaryMeasure")]
    public partial class RiskIdentifyResultSummaryMeasureController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_MEASURE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_MEASURE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_MEASURE> 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_SK_RISK_IDENTIFY_RESULT_SUMMARY_MEASURE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_MEASURE> 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_SK_RISK_IDENTIFY_RESULT_SUMMARY_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskIdentifyResultSummaryPost-辨识岗位
	/// <summary>
    ///  辨识岗位
    /// </summary>
	[Route("api/SK/RiskIdentifyResultSummaryPost")]
    public partial class RiskIdentifyResultSummaryPostController : AuthorizeApiController<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_POST>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_POST> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_POST> 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_SK_RISK_IDENTIFY_RESULT_SUMMARY_POST entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_IDENTIFY_RESULT_SUMMARY_POST> 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_SK_RISK_IDENTIFY_RESULT_SUMMARY_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskName-风险名称
	/// <summary>
    ///  风险名称
    /// </summary>
	[Route("api/SK/RiskName")]
    public partial class RiskNameController : AuthorizeApiController<T_SK_RISK_NAME>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_NAME>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_NAME>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_NAME> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_NAME> OrderPaged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitOrderPaged(null, pageFilter);
       }

       /// <summary>
       /// 根据主键删除数据
       /// </summary>
       /// <param name="id">主键ID</param>
       /// <returns></returns>
       [HttpGet, Route("Delete")]
       public JsonActionResult<bool> Delete(string id)
       {
           return WitRealDelete(id);
       }

       /// <summary>
       /// 更新或新增数据
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("Update")]
       public JsonActionResult<bool> Update([FromBody]T_SK_RISK_NAME entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_NAME> entity)
       {
             return WitBantchUpdate(entity?.Data);
       }

       /// <summary>
       /// 批量删除数据
       /// </summary>
       /// <param name="ids">id字符串（id用逗号分隔）</param>
       /// <returns></returns>
       [HttpGet, Route("BatchDelete")]
       public JsonActionResult<bool> BatchDelete(string ids)
       {
           return WitRealBatchDelete(ids);
       }

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_SK_RISK_NAME> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  RiskType-风险类别
	/// <summary>
    ///  风险类别
    /// </summary>
	[Route("api/SK/RiskType")]
    public partial class RiskTypeController : AuthorizeApiController<T_SK_RISK_TYPE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_TYPE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_RISK_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_RISK_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_RISK_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_SK_RISK_TYPE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_RISK_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_SK_RISK_TYPE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  Scorec-SCOREC
	/// <summary>
    ///  SCOREC
    /// </summary>
	[Route("api/SK/Scorec")]
    public partial class ScorecController : AuthorizeApiController<T_SK_SCOREC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SCOREC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SCOREC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SCOREC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SCOREC> 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_SK_SCOREC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SCOREC> 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_SK_SCOREC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  Scoree-SCOREE
	/// <summary>
    ///  SCOREE
    /// </summary>
	[Route("api/SK/Scoree")]
    public partial class ScoreeController : AuthorizeApiController<T_SK_SCOREE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SCOREE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SCOREE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SCOREE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SCOREE> 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_SK_SCOREE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SCOREE> 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_SK_SCOREE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  Scorel-SCOREL
	/// <summary>
    ///  SCOREL
    /// </summary>
	[Route("api/SK/Scorel")]
    public partial class ScorelController : AuthorizeApiController<T_SK_SCOREL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SCOREL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SCOREL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SCOREL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SCOREL> 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_SK_SCOREL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SCOREL> 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_SK_SCOREL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionNotice-安全检查
	/// <summary>
    ///  安全检查
    /// </summary>
	[Route("api/SK/SecurityInspectionNotice")]
    public partial class SecurityInspectionNoticeController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_NOTICE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_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_SK_SECURITY_INSPECTION_NOTICE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_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_SK_SECURITY_INSPECTION_NOTICE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionNoticeDetail-检查明细表
	/// <summary>
    ///  检查明细表
    /// </summary>
	[Route("api/SK/SecurityInspectionNoticeDetail")]
    public partial class SecurityInspectionNoticeDetailController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE_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_SK_SECURITY_INSPECTION_NOTICE_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_NOTICE_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_SK_SECURITY_INSPECTION_NOTICE_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionNoticeDetailBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/SecurityInspectionNoticeDetailBasic")]
    public partial class SecurityInspectionNoticeDetailBasicController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC> 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_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC> 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_SK_SECURITY_INSPECTION_NOTICE_DETAIL_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionNoticeDetailUser-检查明细人员表
	/// <summary>
    ///  检查明细人员表
    /// </summary>
	[Route("api/SK/SecurityInspectionNoticeDetailUser")]
    public partial class SecurityInspectionNoticeDetailUserController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE_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_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE_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_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_NOTICE_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_SK_SECURITY_INSPECTION_NOTICE_DETAIL_USER> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionNoticeFile-检查通知附件表
	/// <summary>
    ///  检查通知附件表
    /// </summary>
	[Route("api/SK/SecurityInspectionNoticeFile")]
    public partial class SecurityInspectionNoticeFileController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_NOTICE_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_NOTICE_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_NOTICE_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_SK_SECURITY_INSPECTION_NOTICE_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_NOTICE_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_SK_SECURITY_INSPECTION_NOTICE_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecord-安全检查记录
	/// <summary>
    ///  安全检查记录
    /// </summary>
	[Route("api/SK/SecurityInspectionRecord")]
    public partial class SecurityInspectionRecordController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_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_SK_SECURITY_INSPECTION_RECORD entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_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_SK_SECURITY_INSPECTION_RECORD> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordDetail-检查明细表
	/// <summary>
    ///  检查明细表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordDetail")]
    public partial class SecurityInspectionRecordDetailController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_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_SK_SECURITY_INSPECTION_RECORD_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_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_SK_SECURITY_INSPECTION_RECORD_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_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_SK_SECURITY_INSPECTION_RECORD_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordDetailBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordDetailBasic")]
    public partial class SecurityInspectionRecordDetailBasicController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_BASIC> 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_SK_SECURITY_INSPECTION_RECORD_DETAIL_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_BASIC> 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_SK_SECURITY_INSPECTION_RECORD_DETAIL_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordDetailFile-隐患照片表
	/// <summary>
    ///  隐患照片表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordDetailFile")]
    public partial class SecurityInspectionRecordDetailFileController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_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_SK_SECURITY_INSPECTION_RECORD_DETAIL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_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_SK_SECURITY_INSPECTION_RECORD_DETAIL_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_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_SK_SECURITY_INSPECTION_RECORD_DETAIL_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordDetailUser-检查明细人员表
	/// <summary>
    ///  检查明细人员表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordDetailUser")]
    public partial class SecurityInspectionRecordDetailUserController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_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_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_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_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_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_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordFile-检查记录附件表
	/// <summary>
    ///  检查记录附件表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordFile")]
    public partial class SecurityInspectionRecordFileController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_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_SK_SECURITY_INSPECTION_RECORD_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_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_SK_SECURITY_INSPECTION_RECORD_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordSummary-安全检查记录汇总表
	/// <summary>
    ///  安全检查记录汇总表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordSummary")]
    public partial class SecurityInspectionRecordSummaryController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY> 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_SK_SECURITY_INSPECTION_RECORD_SUMMARY entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY> 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_SK_SECURITY_INSPECTION_RECORD_SUMMARY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordSummaryDetail-检查明细表
	/// <summary>
    ///  检查明细表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordSummaryDetail")]
    public partial class SecurityInspectionRecordSummaryDetailController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordSummaryDetailBasic-检查依据
	/// <summary>
    ///  检查依据
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordSummaryDetailBasic")]
    public partial class SecurityInspectionRecordSummaryDetailBasicController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_BASIC>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_BASIC>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_BASIC>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_BASIC> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_BASIC> 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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_BASIC entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_BASIC> 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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_BASIC> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordSummaryDetailFile-隐患照片表
	/// <summary>
    ///  隐患照片表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordSummaryDetailFile")]
    public partial class SecurityInspectionRecordSummaryDetailFileController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordSummaryDetailUser-检查明细人员表
	/// <summary>
    ///  检查明细人员表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordSummaryDetailUser")]
    public partial class SecurityInspectionRecordSummaryDetailUserController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_USER>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_USER> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_USER entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_DETAIL_USER> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  SecurityInspectionRecordSummaryFile-检查记录附件表
	/// <summary>
    ///  检查记录附件表
    /// </summary>
	[Route("api/SK/SecurityInspectionRecordSummaryFile")]
    public partial class SecurityInspectionRecordSummaryFileController : AuthorizeApiController<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_FILE entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_SECURITY_INSPECTION_RECORD_SUMMARY_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_SK_SECURITY_INSPECTION_RECORD_SUMMARY_FILE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  TimeSet-触发时间配置表
	/// <summary>
    ///  触发时间配置表
    /// </summary>
	[Route("api/SK/TimeSet")]
    public partial class TimeSetController : AuthorizeApiController<T_SK_TIME_SET>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_TIME_SET>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_TIME_SET>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_TIME_SET> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_TIME_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_SK_TIME_SET entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_TIME_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_SK_TIME_SET> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
	#region  VideoArea-区域视频
	/// <summary>
    ///  区域视频
    /// </summary>
	[Route("api/SK/VideoArea")]
    public partial class VideoAreaController : AuthorizeApiController<T_SK_VIDEO_AREA>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_SK_VIDEO_AREA>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

        /// <summary>
       /// 排序查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>

       [HttpPost, Route("OrderEntities")]
       public JsonActionResult<IEnumerable<T_SK_VIDEO_AREA>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

       /// <summary>
       /// 分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Paged")]
       public PagedActionResult<T_SK_VIDEO_AREA> Paged([FromBody]KeywordPageFilter pageFilter)
       {
           return WitPaged(null, pageFilter);
       }

       /// <summary>
       /// 排序分页查询数据
       /// </summary>
       /// <param name="pageFilter">分页过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("OrderPaged")]
       public PagedActionResult<T_SK_VIDEO_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_SK_VIDEO_AREA entity)
       {
           return WitUpdate(entity);
       }

       /// <summary>
       /// 批量更新
       /// </summary>
       /// <param name="entity">对象实体</param>
       /// <returns></returns>
       [HttpPost, Route("BatchUpdate")]
       public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SK_VIDEO_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_SK_VIDEO_AREA> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       
    }
	#endregion
 }