 
 
 
  
//------------------------------------------------------------------------------
//     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.SC.WebApi.Controllers.Api
 {
	using APT.MS.Domain.Entities.BI;
using APT.MS.Domain.Entities.SC.BI;
using APT.MS.Domain.Entities.CM;
using APT.MS.Domain.Entities.SC;
using APT.MS.Domain.Entities.OG;
using APT.MS.Domain.Entities.SC.PT;
using APT.MS.Domain.Entities.SC.SC;
using APT.MS.Domain.Entities.SE;
			#region  SafetaskFinish-安全任务完成分析
	 /// <summary>
    ///  安全任务完成分析
    /// </summary>
	 [Route("api/BI/SafetaskFinish")]
     public partial class SafetaskFinishController : AuthorizeApiController<T_BI_SAFETASK_FINISH>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_SAFETASK_FINISH>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_SAFETASK_FINISH>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_SAFETASK_FINISH> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_SAFETASK_FINISH> 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_BI_SAFETASK_FINISH entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_SAFETASK_FINISH> 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_BI_SAFETASK_FINISH> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ActiveUserRecord-活跃用户记录表
	 /// <summary>
    ///  活跃用户记录表
    /// </summary>
	 [Route("api/BI/ActiveUserRecord")]
     public partial class ActiveUserRecordController : AuthorizeApiController<T_BI_ACTIVE_USER_RECORD>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_ACTIVE_USER_RECORD>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_ACTIVE_USER_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_ACTIVE_USER_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_ACTIVE_USER_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_BI_ACTIVE_USER_RECORD entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_ACTIVE_USER_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_BI_ACTIVE_USER_RECORD> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  LoginRecord-登录记录表
	 /// <summary>
    ///  登录记录表
    /// </summary>
	 [Route("api/BI/LoginRecord")]
     public partial class LoginRecordController : AuthorizeApiController<T_BI_LOGIN_RECORD>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_LOGIN_RECORD>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_LOGIN_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_LOGIN_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_LOGIN_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_BI_LOGIN_RECORD entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_LOGIN_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_BI_LOGIN_RECORD> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Bschecktype-安全检查情况占比
	 /// <summary>
    ///  安全检查情况占比
    /// </summary>
	 [Route("api/BI/Bschecktype")]
     public partial class BschecktypeController : AuthorizeApiController<T_BI_BSCHECKTYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_BSCHECKTYPE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_BSCHECKTYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_BSCHECKTYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_BSCHECKTYPE> 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_BI_BSCHECKTYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_BSCHECKTYPE> 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_BI_BSCHECKTYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  BschecktypeYear-安全检查情况综合统计分析
	 /// <summary>
    ///  安全检查情况综合统计分析
    /// </summary>
	 [Route("api/BI/BschecktypeYear")]
     public partial class BschecktypeYearController : AuthorizeApiController<T_BI_BSCHECKTYPE_YEAR>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_BSCHECKTYPE_YEAR>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_BSCHECKTYPE_YEAR>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_BSCHECKTYPE_YEAR> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_BSCHECKTYPE_YEAR> 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_BI_BSCHECKTYPE_YEAR entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_BSCHECKTYPE_YEAR> 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_BI_BSCHECKTYPE_YEAR> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  BsriskInfo-安全检查情况综合统计分析
	 /// <summary>
    ///  安全检查情况综合统计分析
    /// </summary>
	 [Route("api/BI/BsriskInfo")]
     public partial class BsriskInfoController : AuthorizeApiController<T_BI_BSRISK_INFO>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_BSRISK_INFO>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_BSRISK_INFO>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_BSRISK_INFO> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_BSRISK_INFO> 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_BI_BSRISK_INFO entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_BSRISK_INFO> 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_BI_BSRISK_INFO> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Bssafecheck-班组安全检查完成率分析
	 /// <summary>
    ///  班组安全检查完成率分析
    /// </summary>
	 [Route("api/BI/Bssafecheck")]
     public partial class BssafecheckController : AuthorizeApiController<T_BI_BSSAFECHECK>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_BSSAFECHECK>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_BSSAFECHECK>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_BSSAFECHECK> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_BSSAFECHECK> 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_BI_BSSAFECHECK entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_BSSAFECHECK> 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_BI_BSSAFECHECK> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  BssafechecktypeYear-部门级年度安全检查情况综合统计分析
	 /// <summary>
    ///  部门级年度安全检查情况综合统计分析
    /// </summary>
	 [Route("api/BI/BssafechecktypeYear")]
     public partial class BssafechecktypeYearController : AuthorizeApiController<T_BI_BSSAFECHECKTYPE_YEAR>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_BSSAFECHECKTYPE_YEAR>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_BSSAFECHECKTYPE_YEAR>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_BSSAFECHECKTYPE_YEAR> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_BSSAFECHECKTYPE_YEAR> 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_BI_BSSAFECHECKTYPE_YEAR entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_BSSAFECHECKTYPE_YEAR> 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_BI_BSSAFECHECKTYPE_YEAR> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  BssafecheckYear-年度安全检查情况综合统计分析
	 /// <summary>
    ///  年度安全检查情况综合统计分析
    /// </summary>
	 [Route("api/BI/BssafecheckYear")]
     public partial class BssafecheckYearController : AuthorizeApiController<T_BI_BSSAFECHECK_YEAR>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_BSSAFECHECK_YEAR>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_BSSAFECHECK_YEAR>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_BSSAFECHECK_YEAR> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_BSSAFECHECK_YEAR> 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_BI_BSSAFECHECK_YEAR entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_BSSAFECHECK_YEAR> 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_BI_BSSAFECHECK_YEAR> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  CloseTasks-教育模块统计
	 /// <summary>
    ///  教育模块统计
    /// </summary>
	 [Route("api/BI/CloseTasks")]
     public partial class CloseTasksController : AuthorizeApiController<T_BI_CLOSE_TASKS>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_CLOSE_TASKS>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_CLOSE_TASKS>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_CLOSE_TASKS> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_CLOSE_TASKS> 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_BI_CLOSE_TASKS entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_CLOSE_TASKS> 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_BI_CLOSE_TASKS> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DepartmentMonthRun-矿山部选矿部月份折线图
	 /// <summary>
    ///  矿山部选矿部月份折线图
    /// </summary>
	 [Route("api/BI/DepartmentMonthRun")]
     public partial class DepartmentMonthRunController : AuthorizeApiController<T_BI_DEPARTMENT_MONTH_RUN>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_DEPARTMENT_MONTH_RUN>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_DEPARTMENT_MONTH_RUN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_DEPARTMENT_MONTH_RUN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_DEPARTMENT_MONTH_RUN> 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_BI_DEPARTMENT_MONTH_RUN entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_DEPARTMENT_MONTH_RUN> 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_BI_DEPARTMENT_MONTH_RUN> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  FormCheckItem-检查项目配置表
	 /// <summary>
    ///  检查项目配置表
    /// </summary>
	 [Route("api/BI/FormCheckItem")]
     public partial class FormCheckItemController : AuthorizeApiController<T_BI_FORM_CHECK_ITEM>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_FORM_CHECK_ITEM>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_FORM_CHECK_ITEM>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_FORM_CHECK_ITEM> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_FORM_CHECK_ITEM> 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_BI_FORM_CHECK_ITEM entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_FORM_CHECK_ITEM> 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_BI_FORM_CHECK_ITEM> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  FormRunAnalysis-表单运行情况分析
	 /// <summary>
    ///  表单运行情况分析
    /// </summary>
	 [Route("api/BI/FormRunAnalysis")]
     public partial class FormRunAnalysisController : AuthorizeApiController<T_BI_FORM_RUN_ANALYSIS>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_FORM_RUN_ANALYSIS>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_FORM_RUN_ANALYSIS>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_FORM_RUN_ANALYSIS> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_FORM_RUN_ANALYSIS> 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_BI_FORM_RUN_ANALYSIS entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_FORM_RUN_ANALYSIS> 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_BI_FORM_RUN_ANALYSIS> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  HomeBsriskreason-首页隐患原因
	 /// <summary>
    ///  首页隐患原因
    /// </summary>
	 [Route("api/BI/HomeBsriskreason")]
     public partial class HomeBsriskreasonController : AuthorizeApiController<T_BI_HOME_BSRISKREASON>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_HOME_BSRISKREASON>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_HOME_BSRISKREASON>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_HOME_BSRISKREASON> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_HOME_BSRISKREASON> 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_BI_HOME_BSRISKREASON entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_HOME_BSRISKREASON> 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_BI_HOME_BSRISKREASON> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  HriskchangePec-各部门隐患整改率
	 /// <summary>
    ///  各部门隐患整改率
    /// </summary>
	 [Route("api/BI/HriskchangePec")]
     public partial class HriskchangePecController : AuthorizeApiController<T_BI_HRISKCHANGE_PEC>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_HRISKCHANGE_PEC>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_HRISKCHANGE_PEC>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_HRISKCHANGE_PEC> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_HRISKCHANGE_PEC> 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_BI_HRISKCHANGE_PEC entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_HRISKCHANGE_PEC> 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_BI_HRISKCHANGE_PEC> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  HriskCount-各部门隐患数量
	 /// <summary>
    ///  各部门隐患数量
    /// </summary>
	 [Route("api/BI/HriskCount")]
     public partial class HriskCountController : AuthorizeApiController<T_BI_HRISK_COUNT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_HRISK_COUNT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_HRISK_COUNT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_HRISK_COUNT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_HRISK_COUNT> 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_BI_HRISK_COUNT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_HRISK_COUNT> 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_BI_HRISK_COUNT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  HriskTop-高频隐患
	 /// <summary>
    ///  高频隐患
    /// </summary>
	 [Route("api/BI/HriskTop")]
     public partial class HriskTopController : AuthorizeApiController<T_BI_HRISK_TOP>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_HRISK_TOP>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_HRISK_TOP>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_HRISK_TOP> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_HRISK_TOP> 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_BI_HRISK_TOP entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_JOB_PROFILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_JOB_PROFILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_JOB_PROFILE> 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_BI_JOB_PROFILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_JOB_PROFILE> 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_BI_JOB_PROFILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MouldRunSummary-安全生产模块运行情况汇总
	 /// <summary>
    ///  安全生产模块运行情况汇总
    /// </summary>
	 [Route("api/BI/MouldRunSummary")]
     public partial class MouldRunSummaryController : AuthorizeApiController<T_BI_MOULD_RUN_SUMMARY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_MOULD_RUN_SUMMARY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_MOULD_RUN_SUMMARY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_MOULD_RUN_SUMMARY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_MOULD_RUN_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_BI_MOULD_RUN_SUMMARY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_MOULD_RUN_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_BI_MOULD_RUN_SUMMARY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  NotificationTask-待办汇总表
	 /// <summary>
    ///  待办汇总表
    /// </summary>
	 [Route("api/BI/NotificationTask")]
     public partial class NotificationTaskController : AuthorizeApiController<T_BI_NOTIFICATION_TASK>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_NOTIFICATION_TASK>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_NOTIFICATION_TASK>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_NOTIFICATION_TASK> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_NOTIFICATION_TASK> 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_BI_NOTIFICATION_TASK entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_NOTIFICATION_TASK> 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_BI_NOTIFICATION_TASK> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  NotificationTaskNew-消息中间表
	 /// <summary>
    ///  消息中间表
    /// </summary>
	 [Route("api/BI/NotificationTaskNew")]
     public partial class NotificationTaskNewController : AuthorizeApiController<T_BI_NOTIFICATION_TASK_NEW>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_NOTIFICATION_TASK_NEW>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_NOTIFICATION_TASK_NEW>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_NOTIFICATION_TASK_NEW> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_NOTIFICATION_TASK_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_BI_NOTIFICATION_TASK_NEW entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_NOTIFICATION_TASK_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_BI_NOTIFICATION_TASK_NEW> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RiskLevel1-风险统计1
	 /// <summary>
    ///  风险统计1
    /// </summary>
	 [Route("api/BI/RiskLevel1")]
     public partial class RiskLevel1Controller : AuthorizeApiController<T_BI_RISK_LEVEL1>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_RISK_LEVEL1>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_RISK_LEVEL1>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_RISK_LEVEL1> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_RISK_LEVEL1> 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_BI_RISK_LEVEL1 entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_RISK_LEVEL1> 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_BI_RISK_LEVEL1> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RiskLevel2-风险统计2
	 /// <summary>
    ///  风险统计2
    /// </summary>
	 [Route("api/BI/RiskLevel2")]
     public partial class RiskLevel2Controller : AuthorizeApiController<T_BI_RISK_LEVEL2>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_RISK_LEVEL2>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_RISK_LEVEL2>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_RISK_LEVEL2> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_RISK_LEVEL2> 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_BI_RISK_LEVEL2 entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_RISK_LEVEL2> 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_BI_RISK_LEVEL2> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Runlog-统计日志 （按Code更新）
	 /// <summary>
    ///  统计日志 （按Code更新）
    /// </summary>
	 [Route("api/BI/Runlog")]
     public partial class RunlogController : AuthorizeApiController<T_BI_RUNLOG>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_RUNLOG>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_RUNLOG>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_RUNLOG> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_RUNLOG> 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_BI_RUNLOG entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_SUMMARY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_SUMMARY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_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_BI_SUMMARY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_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_BI_SUMMARY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  SystemRunSummary-安全生产系统运行情况汇总
	 /// <summary>
    ///  安全生产系统运行情况汇总
    /// </summary>
	 [Route("api/BI/SystemRunSummary")]
     public partial class SystemRunSummaryController : AuthorizeApiController<T_BI_SYSTEM_RUN_SUMMARY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_SYSTEM_RUN_SUMMARY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_SYSTEM_RUN_SUMMARY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_SYSTEM_RUN_SUMMARY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_SYSTEM_RUN_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_BI_SYSTEM_RUN_SUMMARY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_SYSTEM_RUN_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_BI_SYSTEM_RUN_SUMMARY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainPlanCount-教育模块统计
	 /// <summary>
    ///  教育模块统计
    /// </summary>
	 [Route("api/BI/TrainPlanCount")]
     public partial class TrainPlanCountController : AuthorizeApiController<T_BI_TRAIN_PLAN_COUNT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_BI_TRAIN_PLAN_COUNT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_BI_TRAIN_PLAN_COUNT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_BI_TRAIN_PLAN_COUNT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_BI_TRAIN_PLAN_COUNT> 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_BI_TRAIN_PLAN_COUNT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_BI_TRAIN_PLAN_COUNT> 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_BI_TRAIN_PLAN_COUNT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  AbilityEvaluate-应急能力评估表
	 /// <summary>
    ///  应急能力评估表
    /// </summary>
	 [Route("api/CM/AbilityEvaluate")]
     public partial class AbilityEvaluateController : AuthorizeApiController<T_CM_ABILITY_EVALUATE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_ABILITY_EVALUATE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_ABILITY_EVALUATE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_ABILITY_EVALUATE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_ABILITY_EVALUATE> 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_CM_ABILITY_EVALUATE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_ABILITY_EVALUATE> 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_CM_ABILITY_EVALUATE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  AbilityEvaluateProject-应急能力评估项目中间表
	 /// <summary>
    ///  应急能力评估项目中间表
    /// </summary>
	 [Route("api/CM/AbilityEvaluateProject")]
     public partial class AbilityEvaluateProjectController : AuthorizeApiController<T_CM_ABILITY_EVALUATE_PROJECT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_ABILITY_EVALUATE_PROJECT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_ABILITY_EVALUATE_PROJECT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_ABILITY_EVALUATE_PROJECT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_ABILITY_EVALUATE_PROJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_CM_ABILITY_EVALUATE_PROJECT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  AbilityEvaluateUser-评估人员表
	 /// <summary>
    ///  评估人员表
    /// </summary>
	 [Route("api/CM/AbilityEvaluateUser")]
     public partial class AbilityEvaluateUserController : AuthorizeApiController<T_CM_ABILITY_EVALUATE_USER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_ABILITY_EVALUATE_USER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_ABILITY_EVALUATE_USER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_ABILITY_EVALUATE_USER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_ABILITY_EVALUATE_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_CM_ABILITY_EVALUATE_USER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_ABILITY_EVALUATE_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_CM_ABILITY_EVALUATE_USER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  AbilityProject-评估项目表
	 /// <summary>
    ///  评估项目表
    /// </summary>
	 [Route("api/CM/AbilityProject")]
     public partial class AbilityProjectController : AuthorizeApiController<T_CM_ABILITY_PROJECT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_ABILITY_PROJECT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_ABILITY_PROJECT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_ABILITY_PROJECT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_ABILITY_PROJECT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_CM_ABILITY_PROJECT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Config-应急模块基础配置
	 /// <summary>
    ///  应急模块基础配置
    /// </summary>
	 [Route("api/CM/Config")]
     public partial class ConfigController : AuthorizeApiController<T_CM_CONFIG>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_CONFIG>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_CONFIG>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_CONFIG> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_CONFIG> 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_CM_CONFIG entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_CONFIG> 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_CM_CONFIG> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ContingencyType-预案类型
	 /// <summary>
    ///  预案类型
    /// </summary>
	 [Route("api/CM/ContingencyType")]
     public partial class ContingencyTypeController : AuthorizeApiController<T_CM_CONTINGENCY_TYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_CONTINGENCY_TYPE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_CONTINGENCY_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_CONTINGENCY_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_CONTINGENCY_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_CM_CONTINGENCY_TYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_CONTINGENCY_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_CM_CONTINGENCY_TYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  CoverageInfluence-影响范围表
	 /// <summary>
    ///  影响范围表
    /// </summary>
	 [Route("api/CM/CoverageInfluence")]
     public partial class CoverageInfluenceController : AuthorizeApiController<T_CM_COVERAGE_INFLUENCE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_COVERAGE_INFLUENCE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_COVERAGE_INFLUENCE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_COVERAGE_INFLUENCE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_COVERAGE_INFLUENCE> 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_CM_COVERAGE_INFLUENCE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_COVERAGE_INFLUENCE> 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_CM_COVERAGE_INFLUENCE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillEstimate-应急演练活动评估
	 /// <summary>
    ///  应急演练活动评估
    /// </summary>
	 [Route("api/CM/DrillEstimate")]
     public partial class DrillEstimateController : AuthorizeApiController<T_CM_DRILL_ESTIMATE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_ESTIMATE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_ESTIMATE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_ESTIMATE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_ESTIMATE> 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_CM_DRILL_ESTIMATE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_ESTIMATE> 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_CM_DRILL_ESTIMATE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillEstimateItemType-演练活动记录评估项目类型
	 /// <summary>
    ///  演练活动记录评估项目类型
    /// </summary>
	 [Route("api/CM/DrillEstimateItemType")]
     public partial class DrillEstimateItemTypeController : AuthorizeApiController<T_CM_DRILL_ESTIMATE_ITEM_TYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_ESTIMATE_ITEM_TYPE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_ESTIMATE_ITEM_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_ESTIMATE_ITEM_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_ESTIMATE_ITEM_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_CM_DRILL_ESTIMATE_ITEM_TYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_ESTIMATE_ITEM_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_CM_DRILL_ESTIMATE_ITEM_TYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillEstimateRecord-应急演练活动评估项目
	 /// <summary>
    ///  应急演练活动评估项目
    /// </summary>
	 [Route("api/CM/DrillEstimateRecord")]
     public partial class DrillEstimateRecordController : AuthorizeApiController<T_CM_DRILL_ESTIMATE_RECORD>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_ESTIMATE_RECORD>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_ESTIMATE_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_ESTIMATE_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_ESTIMATE_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_CM_DRILL_ESTIMATE_RECORD entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_ESTIMATE_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_CM_DRILL_ESTIMATE_RECORD> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillName-应急演练名称
	 /// <summary>
    ///  应急演练名称
    /// </summary>
	 [Route("api/CM/DrillName")]
     public partial class DrillNameController : AuthorizeApiController<T_CM_DRILL_NAME>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_NAME>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_NAME>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_NAME> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_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_CM_DRILL_NAME entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_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_CM_DRILL_NAME> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillPlan-年度应急演练计划表
	 /// <summary>
    ///  年度应急演练计划表
    /// </summary>
	 [Route("api/CM/DrillPlan")]
     public partial class DrillPlanController : AuthorizeApiController<T_CM_DRILL_PLAN>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_PLAN>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_PLAN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_PLAN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_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_CM_DRILL_PLAN entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_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_CM_DRILL_PLAN> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillPlanDetail-应急演练计划明细表
	 /// <summary>
    ///  应急演练计划明细表
    /// </summary>
	 [Route("api/CM/DrillPlanDetail")]
     public partial class DrillPlanDetailController : AuthorizeApiController<T_CM_DRILL_PLAN_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_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_CM_DRILL_PLAN_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_PLAN_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_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_CM_DRILL_PLAN_DETAIL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_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_CM_DRILL_PLAN_DETAIL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillPlanStandardCreate-关联应急预案
	 /// <summary>
    ///  关联应急预案
    /// </summary>
	 [Route("api/CM/DrillPlanStandardCreate")]
     public partial class DrillPlanStandardCreateController : AuthorizeApiController<T_CM_DRILL_PLAN_STANDARD_CREATE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_PLAN_STANDARD_CREATE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_PLAN_STANDARD_CREATE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_PLAN_STANDARD_CREATE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_PLAN_STANDARD_CREATE> 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_CM_DRILL_PLAN_STANDARD_CREATE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_PLAN_STANDARD_CREATE> 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_CM_DRILL_PLAN_STANDARD_CREATE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillRecord-应急演练活动记录
	 /// <summary>
    ///  应急演练活动记录
    /// </summary>
	 [Route("api/CM/DrillRecord")]
     public partial class DrillRecordController : AuthorizeApiController<T_CM_DRILL_RECORD>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_RECORD>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_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_CM_DRILL_RECORD entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_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_CM_DRILL_RECORD> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillRecordDepartment-导航属性：内部参与演练单位
	 /// <summary>
    ///  导航属性：内部参与演练单位
    /// </summary>
	 [Route("api/CM/DrillRecordDepartment")]
     public partial class DrillRecordDepartmentController : AuthorizeApiController<T_CM_DRILL_RECORD_DEPARTMENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_RECORD_DEPARTMENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_RECORD_DEPARTMENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_RECORD_DEPARTMENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_RECORD_DEPARTMENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_CM_DRILL_RECORD_DEPARTMENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillRecordFile-导航属性：演练记录文件
	 /// <summary>
    ///  导航属性：演练记录文件
    /// </summary>
	 [Route("api/CM/DrillRecordFile")]
     public partial class DrillRecordFileController : AuthorizeApiController<T_CM_DRILL_RECORD_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_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_CM_DRILL_RECORD_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_RECORD_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_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_CM_DRILL_RECORD_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_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_CM_DRILL_RECORD_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillRecordSummaryFile-导航属性：演练记录报告文件
	 /// <summary>
    ///  导航属性：演练记录报告文件
    /// </summary>
	 [Route("api/CM/DrillRecordSummaryFile")]
     public partial class DrillRecordSummaryFileController : AuthorizeApiController<T_CM_DRILL_RECORD_SUMMARY_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_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_CM_DRILL_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_CM_DRILL_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_CM_DRILL_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_CM_DRILL_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_CM_DRILL_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_CM_DRILL_RECORD_SUMMARY_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillRecordUserEstimate-导航属性：演练记录评估人员
	 /// <summary>
    ///  导航属性：演练记录评估人员
    /// </summary>
	 [Route("api/CM/DrillRecordUserEstimate")]
     public partial class DrillRecordUserEstimateController : AuthorizeApiController<T_CM_DRILL_RECORD_USER_ESTIMATE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_RECORD_USER_ESTIMATE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_RECORD_USER_ESTIMATE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_RECORD_USER_ESTIMATE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_RECORD_USER_ESTIMATE> 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_CM_DRILL_RECORD_USER_ESTIMATE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_RECORD_USER_ESTIMATE> 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_CM_DRILL_RECORD_USER_ESTIMATE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillSummaryRequirement-演练总结要求
	 /// <summary>
    ///  演练总结要求
    /// </summary>
	 [Route("api/CM/DrillSummaryRequirement")]
     public partial class DrillSummaryRequirementController : AuthorizeApiController<T_CM_DRILL_SUMMARY_REQUIREMENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_SUMMARY_REQUIREMENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_SUMMARY_REQUIREMENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_SUMMARY_REQUIREMENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_SUMMARY_REQUIREMENT> 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_CM_DRILL_SUMMARY_REQUIREMENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_SUMMARY_REQUIREMENT> 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_CM_DRILL_SUMMARY_REQUIREMENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DrillSummaryRequirementType-演练总结要求项目
	 /// <summary>
    ///  演练总结要求项目
    /// </summary>
	 [Route("api/CM/DrillSummaryRequirementType")]
     public partial class DrillSummaryRequirementTypeController : AuthorizeApiController<T_CM_DRILL_SUMMARY_REQUIREMENT_TYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_SUMMARY_REQUIREMENT_TYPE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_DRILL_SUMMARY_REQUIREMENT_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_DRILL_SUMMARY_REQUIREMENT_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_DRILL_SUMMARY_REQUIREMENT_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_CM_DRILL_SUMMARY_REQUIREMENT_TYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_DRILL_SUMMARY_REQUIREMENT_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_CM_DRILL_SUMMARY_REQUIREMENT_TYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  EquipmentDemandSurvey-应急装备需求调查表
	 /// <summary>
    ///  应急装备需求调查表
    /// </summary>
	 [Route("api/CM/EquipmentDemandSurvey")]
     public partial class EquipmentDemandSurveyController : AuthorizeApiController<T_CM_EQUIPMENT_DEMAND_SURVEY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY> 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_CM_EQUIPMENT_DEMAND_SURVEY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_EQUIPMENT_DEMAND_SURVEY> 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_CM_EQUIPMENT_DEMAND_SURVEY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  EquipmentDemandSurveyDetail-应急装备需求调查明细
	 /// <summary>
    ///  应急装备需求调查明细
    /// </summary>
	 [Route("api/CM/EquipmentDemandSurveyDetail")]
     public partial class EquipmentDemandSurveyDetailController : AuthorizeApiController<T_CM_EQUIPMENT_DEMAND_SURVEY_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY_DETAIL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY_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_CM_EQUIPMENT_DEMAND_SURVEY_DETAIL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_EQUIPMENT_DEMAND_SURVEY_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_CM_EQUIPMENT_DEMAND_SURVEY_DETAIL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  EquipmentDemandSurveyFile-导航属性：应急装备需求调查表文件
	 /// <summary>
    ///  导航属性：应急装备需求调查表文件
    /// </summary>
	 [Route("api/CM/EquipmentDemandSurveyFile")]
     public partial class EquipmentDemandSurveyFileController : AuthorizeApiController<T_CM_EQUIPMENT_DEMAND_SURVEY_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY_FILE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY_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_CM_EQUIPMENT_DEMAND_SURVEY_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_EQUIPMENT_DEMAND_SURVEY_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_CM_EQUIPMENT_DEMAND_SURVEY_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  EquipmentDemandSurveyMaster-应急装备需求调查汇总表
	 /// <summary>
    ///  应急装备需求调查汇总表
    /// </summary>
	 [Route("api/CM/EquipmentDemandSurveyMaster")]
     public partial class EquipmentDemandSurveyMasterController : AuthorizeApiController<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER> 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_CM_EQUIPMENT_DEMAND_SURVEY_MASTER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER> 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_CM_EQUIPMENT_DEMAND_SURVEY_MASTER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  EquipmentDemandSurveyMasterFile-导航属性：应急装备需求调查表文件
	 /// <summary>
    ///  导航属性：应急装备需求调查表文件
    /// </summary>
	 [Route("api/CM/EquipmentDemandSurveyMasterFile")]
     public partial class EquipmentDemandSurveyMasterFileController : AuthorizeApiController<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER_FILE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER_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_CM_EQUIPMENT_DEMAND_SURVEY_MASTER_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_EQUIPMENT_DEMAND_SURVEY_MASTER_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_CM_EQUIPMENT_DEMAND_SURVEY_MASTER_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  EventType-事件类型表
	 /// <summary>
    ///  事件类型表
    /// </summary>
	 [Route("api/CM/EventType")]
     public partial class EventTypeController : AuthorizeApiController<T_CM_EVENT_TYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_EVENT_TYPE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_EVENT_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_EVENT_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_EVENT_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_CM_EVENT_TYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_EVENT_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_CM_EVENT_TYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MaterialLibrary-应急物资库
	 /// <summary>
    ///  应急物资库
    /// </summary>
	 [Route("api/CM/MaterialLibrary")]
     public partial class MaterialLibraryController : AuthorizeApiController<T_CM_MATERIAL_LIBRARY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_MATERIAL_LIBRARY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_MATERIAL_LIBRARY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_MATERIAL_LIBRARY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_MATERIAL_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_CM_MATERIAL_LIBRARY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_MATERIAL_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_CM_MATERIAL_LIBRARY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MaterialLibraryFile-应急物资库附件表
	 /// <summary>
    ///  应急物资库附件表
    /// </summary>
	 [Route("api/CM/MaterialLibraryFile")]
     public partial class MaterialLibraryFileController : AuthorizeApiController<T_CM_MATERIAL_LIBRARY_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_MATERIAL_LIBRARY_FILE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_MATERIAL_LIBRARY_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_MATERIAL_LIBRARY_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_MATERIAL_LIBRARY_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_CM_MATERIAL_LIBRARY_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_MATERIAL_LIBRARY_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_CM_MATERIAL_LIBRARY_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MaterialType-资源类型表
	 /// <summary>
    ///  资源类型表
    /// </summary>
	 [Route("api/CM/MaterialType")]
     public partial class MaterialTypeController : AuthorizeApiController<T_CM_MATERIAL_TYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_MATERIAL_TYPE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_MATERIAL_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_MATERIAL_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_MATERIAL_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_CM_MATERIAL_TYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_MATERIAL_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_CM_MATERIAL_TYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RspEstimate-应急响应评估表
	 /// <summary>
    ///  应急响应评估表
    /// </summary>
	 [Route("api/CM/RspEstimate")]
     public partial class RspEstimateController : AuthorizeApiController<T_CM_RSP_ESTIMATE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE> 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_CM_RSP_ESTIMATE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_RSP_ESTIMATE> 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_CM_RSP_ESTIMATE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RspEstimateCondition-应急响应评估情况
	 /// <summary>
    ///  应急响应评估情况
    /// </summary>
	 [Route("api/CM/RspEstimateCondition")]
     public partial class RspEstimateConditionController : AuthorizeApiController<T_CM_RSP_ESTIMATE_CONDITION>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_CONDITION>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_CONDITION>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_CONDITION> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_CONDITION> 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_CM_RSP_ESTIMATE_CONDITION entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_RSP_ESTIMATE_CONDITION> 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_CM_RSP_ESTIMATE_CONDITION> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RspEstimateConditions-导航属性： 应急响应情况
	 /// <summary>
    ///  导航属性： 应急响应情况
    /// </summary>
	 [Route("api/CM/RspEstimateConditions")]
     public partial class RspEstimateConditionsController : AuthorizeApiController<T_CM_RSP_ESTIMATE_CONDITIONS>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_CONDITIONS>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_CONDITIONS>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_CONDITIONS> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_CONDITIONS> 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_CM_RSP_ESTIMATE_CONDITIONS entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_RSP_ESTIMATE_CONDITIONS> 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_CM_RSP_ESTIMATE_CONDITIONS> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RspEstimateEstimateUser-导航属性：应急响应评估表评估人员
	 /// <summary>
    ///  导航属性：应急响应评估表评估人员
    /// </summary>
	 [Route("api/CM/RspEstimateEstimateUser")]
     public partial class RspEstimateEstimateUserController : AuthorizeApiController<T_CM_RSP_ESTIMATE_ESTIMATE_USER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_ESTIMATE_USER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_ESTIMATE_USER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_ESTIMATE_USER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_ESTIMATE_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_CM_RSP_ESTIMATE_ESTIMATE_USER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_RSP_ESTIMATE_ESTIMATE_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_CM_RSP_ESTIMATE_ESTIMATE_USER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RspEstimateEventKind-导航属性： 事故/事件种类
	 /// <summary>
    ///  导航属性： 事故/事件种类
    /// </summary>
	 [Route("api/CM/RspEstimateEventKind")]
     public partial class RspEstimateEventKindController : AuthorizeApiController<T_CM_RSP_ESTIMATE_EVENT_KIND>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_EVENT_KIND>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_EVENT_KIND>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_EVENT_KIND> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_EVENT_KIND> 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_CM_RSP_ESTIMATE_EVENT_KIND entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_RSP_ESTIMATE_EVENT_KIND> 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_CM_RSP_ESTIMATE_EVENT_KIND> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RspEstimateJoinUser-导航属性：应急响应评估表人员
	 /// <summary>
    ///  导航属性：应急响应评估表人员
    /// </summary>
	 [Route("api/CM/RspEstimateJoinUser")]
     public partial class RspEstimateJoinUserController : AuthorizeApiController<T_CM_RSP_ESTIMATE_JOIN_USER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_JOIN_USER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_RSP_ESTIMATE_JOIN_USER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_JOIN_USER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_RSP_ESTIMATE_JOIN_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_CM_RSP_ESTIMATE_JOIN_USER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_RSP_ESTIMATE_JOIN_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_CM_RSP_ESTIMATE_JOIN_USER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  UrgentArearInfluence-导航属性：预计影响范围
	 /// <summary>
    ///  导航属性：预计影响范围
    /// </summary>
	 [Route("api/CM/UrgentArearInfluence")]
     public partial class UrgentArearInfluenceController : AuthorizeApiController<T_CM_URGENT_AREAR_INFLUENCE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_URGENT_AREAR_INFLUENCE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_URGENT_AREAR_INFLUENCE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_URGENT_AREAR_INFLUENCE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_URGENT_AREAR_INFLUENCE> 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_CM_URGENT_AREAR_INFLUENCE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_URGENT_AREAR_INFLUENCE> 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_CM_URGENT_AREAR_INFLUENCE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  UrgentEvent-潜在紧急事件
	 /// <summary>
    ///  潜在紧急事件
    /// </summary>
	 [Route("api/CM/UrgentEvent")]
     public partial class UrgentEventController : AuthorizeApiController<T_CM_URGENT_EVENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_URGENT_EVENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_URGENT_EVENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_URGENT_EVENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_URGENT_EVENT> 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_CM_URGENT_EVENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_URGENT_EVENT> 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_CM_URGENT_EVENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  UrgentEventContingencyPlan-预案类型
	 /// <summary>
    ///  预案类型
    /// </summary>
	 [Route("api/CM/UrgentEventContingencyPlan")]
     public partial class UrgentEventContingencyPlanController : AuthorizeApiController<T_CM_URGENT_EVENT_CONTINGENCY_PLAN>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_URGENT_EVENT_CONTINGENCY_PLAN>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_CM_URGENT_EVENT_CONTINGENCY_PLAN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_URGENT_EVENT_CONTINGENCY_PLAN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_URGENT_EVENT_CONTINGENCY_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_CM_URGENT_EVENT_CONTINGENCY_PLAN entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_URGENT_EVENT_CONTINGENCY_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_CM_URGENT_EVENT_CONTINGENCY_PLAN> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  UrgentEventRiskType-导航属性：风险类别
	 /// <summary>
    ///  导航属性：风险类别
    /// </summary>
	 [Route("api/CM/UrgentEventRiskType")]
     public partial class UrgentEventRiskTypeController : AuthorizeApiController<T_CM_URGENT_EVENT_RISK_TYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_CM_URGENT_EVENT_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_CM_URGENT_EVENT_RISK_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_CM_URGENT_EVENT_RISK_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_CM_URGENT_EVENT_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_CM_URGENT_EVENT_RISK_TYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_CM_URGENT_EVENT_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_CM_URGENT_EVENT_RISK_TYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtConfig-会议配置
	 /// <summary>
    ///  会议配置
    /// </summary>
	 [Route("api/SC/MtConfig")]
     public partial class MtConfigController : AuthorizeApiController<T_SC_MT_CONFIG>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_CONFIG>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_CONFIG>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_CONFIG> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_CONFIG> 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_SC_MT_CONFIG entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_CONFIG> 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_SC_MT_CONFIG> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtContent-会议内容
	 /// <summary>
    ///  会议内容
    /// </summary>
	 [Route("api/SC/MtContent")]
     public partial class MtContentController : AuthorizeApiController<T_SC_MT_CONTENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_CONTENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_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_SC_MT_CONTENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_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_SC_MT_CONTENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtContentDeal-会议内容选项
	 /// <summary>
    ///  会议内容选项
    /// </summary>
	 [Route("api/SC/MtContentDeal")]
     public partial class MtContentDealController : AuthorizeApiController<T_SC_MT_CONTENT_DEAL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_CONTENT_DEAL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_CONTENT_DEAL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_CONTENT_DEAL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_CONTENT_DEAL> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_SC_MT_CONTENT_DEAL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtContentName-会议内容
	 /// <summary>
    ///  会议内容
    /// </summary>
	 [Route("api/SC/MtContentName")]
     public partial class MtContentNameController : AuthorizeApiController<T_SC_MT_CONTENT_NAME>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_CONTENT_NAME>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_CONTENT_NAME>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_CONTENT_NAME> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_CONTENT_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_SC_MT_CONTENT_NAME entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_CONTENT_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_SC_MT_CONTENT_NAME> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeeting-会议通知
	 /// <summary>
    ///  会议通知
    /// </summary>
	 [Route("api/SC/MtMeeting")]
     public partial class MtMeetingController : AuthorizeApiController<T_SC_MT_MEETING>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING> 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_SC_MT_MEETING entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING> 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_SC_MT_MEETING> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingBegin-别的模块触发生成会议表单 隔离会议模块
	 /// <summary>
    ///  别的模块触发生成会议表单 隔离会议模块
    /// </summary>
	 [Route("api/SC/MtMeetingBegin")]
     public partial class MtMeetingBeginController : AuthorizeApiController<T_SC_MT_MEETING_BEGIN>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_BEGIN>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_BEGIN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_BEGIN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_BEGIN> 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_SC_MT_MEETING_BEGIN entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_BEGIN> 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_SC_MT_MEETING_BEGIN> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingContent-会议内容题库
	 /// <summary>
    ///  会议内容题库
    /// </summary>
	 [Route("api/SC/MtMeetingContent")]
     public partial class MtMeetingContentController : AuthorizeApiController<T_SC_MT_MEETING_CONTENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_CONTENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_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_SC_MT_MEETING_CONTENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_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_SC_MT_MEETING_CONTENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingEnd-会议结束添加此信息 隔离会议模块
	 /// <summary>
    ///  会议结束添加此信息 隔离会议模块
    /// </summary>
	 [Route("api/SC/MtMeetingEnd")]
     public partial class MtMeetingEndController : AuthorizeApiController<T_SC_MT_MEETING_END>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_END>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_END>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_END> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_END> 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_SC_MT_MEETING_END entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_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_SC_MT_MEETING_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_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_SC_MT_MEETING_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingFileOfficialseal-加盖公章的会议通知
	 /// <summary>
    ///  加盖公章的会议通知
    /// </summary>
	 [Route("api/SC/MtMeetingFileOfficialseal")]
     public partial class MtMeetingFileOfficialsealController : AuthorizeApiController<T_SC_MT_MEETING_FILE_OFFICIALSEAL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_FILE_OFFICIALSEAL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_FILE_OFFICIALSEAL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_FILE_OFFICIALSEAL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_FILE_OFFICIALSEAL> 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_SC_MT_MEETING_FILE_OFFICIALSEAL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_FILE_OFFICIALSEAL> 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_SC_MT_MEETING_FILE_OFFICIALSEAL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingFileRecord-会议记录附件
	 /// <summary>
    ///  会议记录附件
    /// </summary>
	 [Route("api/SC/MtMeetingFileRecord")]
     public partial class MtMeetingFileRecordController : AuthorizeApiController<T_SC_MT_MEETING_FILE_RECORD>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_FILE_RECORD>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_FILE_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_FILE_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_FILE_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_SC_MT_MEETING_FILE_RECORD entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_FILE_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_SC_MT_MEETING_FILE_RECORD> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingMinutes-会议纪要
	 /// <summary>
    ///  会议纪要
    /// </summary>
	 [Route("api/SC/MtMeetingMinutes")]
     public partial class MtMeetingMinutesController : AuthorizeApiController<T_SC_MT_MEETING_MINUTES>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES> 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_SC_MT_MEETING_MINUTES entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_MINUTES> 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_SC_MT_MEETING_MINUTES> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingMinutesContent-会议纪要意见
	 /// <summary>
    ///  会议纪要意见
    /// </summary>
	 [Route("api/SC/MtMeetingMinutesContent")]
     public partial class MtMeetingMinutesContentController : AuthorizeApiController<T_SC_MT_MEETING_MINUTES_CONTENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_CONTENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_CONTENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_CONTENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingMinutesContentDeal-会议纪要意见结果
	 /// <summary>
    ///  会议纪要意见结果
    /// </summary>
	 [Route("api/SC/MtMeetingMinutesContentDeal")]
     public partial class MtMeetingMinutesContentDealController : AuthorizeApiController<T_SC_MT_MEETING_MINUTES_CONTENT_DEAL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_CONTENT_DEAL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_CONTENT_DEAL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_CONTENT_DEAL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_CONTENT_DEAL> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_SC_MT_MEETING_MINUTES_CONTENT_DEAL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingMinutesDetail-会议纪要明细
	 /// <summary>
    ///  会议纪要明细
    /// </summary>
	 [Route("api/SC/MtMeetingMinutesDetail")]
     public partial class MtMeetingMinutesDetailController : AuthorizeApiController<T_SC_MT_MEETING_MINUTES_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_DETAIL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_DETAIL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_DETAIL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingMinutesDetailFile-会议纪要落实明细附件
	 /// <summary>
    ///  会议纪要落实明细附件
    /// </summary>
	 [Route("api/SC/MtMeetingMinutesDetailFile")]
     public partial class MtMeetingMinutesDetailFileController : AuthorizeApiController<T_SC_MT_MEETING_MINUTES_DETAIL_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_DETAIL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_DETAIL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_DETAIL_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_DETAIL_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingMinutesFile-会议纪要附件
	 /// <summary>
    ///  会议纪要附件
    /// </summary>
	 [Route("api/SC/MtMeetingMinutesFile")]
     public partial class MtMeetingMinutesFileController : AuthorizeApiController<T_SC_MT_MEETING_MINUTES_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_FILE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_MINUTES_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_MINUTES_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_SC_MT_MEETING_MINUTES_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingPabsence-缺席人员
	 /// <summary>
    ///  缺席人员
    /// </summary>
	 [Route("api/SC/MtMeetingPabsence")]
     public partial class MtMeetingPabsenceController : AuthorizeApiController<T_SC_MT_MEETING_PABSENCE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PABSENCE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PABSENCE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_PABSENCE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_PABSENCE> 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_SC_MT_MEETING_PABSENCE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_PABSENCE> 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_SC_MT_MEETING_PABSENCE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingPall-应到人员
	 /// <summary>
    ///  应到人员
    /// </summary>
	 [Route("api/SC/MtMeetingPall")]
     public partial class MtMeetingPallController : AuthorizeApiController<T_SC_MT_MEETING_PALL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PALL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PALL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_PALL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_PALL> 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_SC_MT_MEETING_PALL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_PALL> 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_SC_MT_MEETING_PALL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingPaskforleave-请假人员
	 /// <summary>
    ///  请假人员
    /// </summary>
	 [Route("api/SC/MtMeetingPaskforleave")]
     public partial class MtMeetingPaskforleaveController : AuthorizeApiController<T_SC_MT_MEETING_PASKFORLEAVE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PASKFORLEAVE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PASKFORLEAVE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_PASKFORLEAVE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_PASKFORLEAVE> 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_SC_MT_MEETING_PASKFORLEAVE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_PASKFORLEAVE> 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_SC_MT_MEETING_PASKFORLEAVE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingPjoin-参会人员
	 /// <summary>
    ///  参会人员
    /// </summary>
	 [Route("api/SC/MtMeetingPjoin")]
     public partial class MtMeetingPjoinController : AuthorizeApiController<T_SC_MT_MEETING_PJOIN>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PJOIN>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PJOIN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_PJOIN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_PJOIN> 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_SC_MT_MEETING_PJOIN entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_PJOIN> 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_SC_MT_MEETING_PJOIN> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingPreview-评审人员
	 /// <summary>
    ///  评审人员
    /// </summary>
	 [Route("api/SC/MtMeetingPreview")]
     public partial class MtMeetingPreviewController : AuthorizeApiController<T_SC_MT_MEETING_PREVIEW>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PREVIEW>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_PREVIEW>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_PREVIEW> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_PREVIEW> 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_SC_MT_MEETING_PREVIEW entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_PREVIEW> 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_SC_MT_MEETING_PREVIEW> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingTheme-会议主题
	 /// <summary>
    ///  会议主题
    /// </summary>
	 [Route("api/SC/MtMeetingTheme")]
     public partial class MtMeetingThemeController : AuthorizeApiController<T_SC_MT_MEETING_THEME>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_THEME>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_THEME>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_THEME> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_THEME> 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_SC_MT_MEETING_THEME entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_THEME> 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_SC_MT_MEETING_THEME> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMeetingThemes-会议通知主题
	 /// <summary>
    ///  会议通知主题
    /// </summary>
	 [Route("api/SC/MtMeetingThemes")]
     public partial class MtMeetingThemesController : AuthorizeApiController<T_SC_MT_MEETING_THEMES>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_THEMES>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MEETING_THEMES>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MEETING_THEMES> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MEETING_THEMES> 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_SC_MT_MEETING_THEMES entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MEETING_THEMES> 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_SC_MT_MEETING_THEMES> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtMinutesPreview-评审人员
	 /// <summary>
    ///  评审人员
    /// </summary>
	 [Route("api/SC/MtMinutesPreview")]
     public partial class MtMinutesPreviewController : AuthorizeApiController<T_SC_MT_MINUTES_PREVIEW>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MINUTES_PREVIEW>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_MINUTES_PREVIEW>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_MINUTES_PREVIEW> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_MINUTES_PREVIEW> 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_SC_MT_MINUTES_PREVIEW entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_MINUTES_PREVIEW> 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_SC_MT_MINUTES_PREVIEW> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtPlanSet-会议计划
	 /// <summary>
    ///  会议计划
    /// </summary>
	 [Route("api/SC/MtPlanSet")]
     public partial class MtPlanSetController : AuthorizeApiController<T_SC_MT_PLAN_SET>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_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_SC_MT_PLAN_SET>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_PLAN_SET> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_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_SC_MT_PLAN_SET entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_MT_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_SC_MT_PLAN_SET> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  MtPlanSetDepartment-会议计划限制部门
	 /// <summary>
    ///  会议计划限制部门
    /// </summary>
	 [Route("api/SC/MtPlanSetDepartment")]
     public partial class MtPlanSetDepartmentController : AuthorizeApiController<T_SC_MT_PLAN_SET_DEPARTMENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_MT_PLAN_SET_DEPARTMENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_MT_PLAN_SET_DEPARTMENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_MT_PLAN_SET_DEPARTMENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_MT_PLAN_SET_DEPARTMENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_SC_MT_PLAN_SET_DEPARTMENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Agency-机构表
	 /// <summary>
    ///  机构表
    /// </summary>
	 [Route("api/OG/Agency")]
     public partial class AgencyController : AuthorizeTreeApiController<T_OG_AGENCY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_AGENCY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_AGENCY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_AGENCY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_AGENCY> 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_OG_AGENCY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_AGENCY> 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_OG_AGENCY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
                       	/// <summary>
		/// 获得树形实体数据
		/// </summary>
		/// <param name="filter"></param>
		/// <returns></returns>
		[HttpPost, Route("TreeData")]
		public JsonActionResult<IEnumerable<TreeNode<T_OG_AGENCY>>> TreeData([FromBody] KeywordFilter filter)
		{
			return WitTreeOrderEntities(null, filter);
		}
                
     }
	 #endregion
					#region  AgencyUser-机构人员
	 /// <summary>
    ///  机构人员
    /// </summary>
	 [Route("api/OG/AgencyUser")]
     public partial class AgencyUserController : AuthorizeApiController<T_OG_AGENCY_USER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_AGENCY_USER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_AGENCY_USER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_AGENCY_USER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_AGENCY_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_OG_AGENCY_USER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_AGENCY_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_OG_AGENCY_USER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Related-相关方基本信息表
	 /// <summary>
    ///  相关方基本信息表
    /// </summary>
	 [Route("api/OG/Related")]
     public partial class RelatedController : AuthorizeApiController<T_OG_RELATED>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED> 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_OG_RELATED entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED> 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_OG_RELATED> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedAgreement-合同/协议表
	 /// <summary>
    ///  合同/协议表
    /// </summary>
	 [Route("api/OG/RelatedAgreement")]
     public partial class RelatedAgreementController : AuthorizeApiController<T_OG_RELATED_AGREEMENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_AGREEMENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_AGREEMENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_AGREEMENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_AGREEMENT> 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_OG_RELATED_AGREEMENT entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_AGREEMENT_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_AGREEMENT_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_AGREEMENT_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_OG_RELATED_AGREEMENT_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_AGREEMENT_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_OG_RELATED_AGREEMENT_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedQualification-资质情况表
	 /// <summary>
    ///  资质情况表
    /// </summary>
	 [Route("api/OG/RelatedQualification")]
     public partial class RelatedQualificationController : AuthorizeApiController<T_OG_RELATED_QUALIFICATION>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_QUALIFICATION>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_QUALIFICATION>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION> 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_OG_RELATED_QUALIFICATION entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_QUALIFICATION> 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_OG_RELATED_QUALIFICATION> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedQualificationDetail-资质录入页面表
	 /// <summary>
    ///  资质录入页面表
    /// </summary>
	 [Route("api/OG/RelatedQualificationDetail")]
     public partial class RelatedQualificationDetailController : AuthorizeApiController<T_OG_RELATED_QUALIFICATION_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_QUALIFICATION_DETAIL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_QUALIFICATION_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION_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_OG_RELATED_QUALIFICATION_DETAIL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_QUALIFICATION_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_OG_RELATED_QUALIFICATION_DETAIL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedQualificationDetailFile-附件
	 /// <summary>
    ///  附件
    /// </summary>
	 [Route("api/OG/RelatedQualificationDetailFile")]
     public partial class RelatedQualificationDetailFileController : AuthorizeApiController<T_OG_RELATED_QUALIFICATION_DETAIL_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_QUALIFICATION_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_OG_RELATED_QUALIFICATION_DETAIL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION_DETAIL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION_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_OG_RELATED_QUALIFICATION_DETAIL_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_QUALIFICATION_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_OG_RELATED_QUALIFICATION_DETAIL_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedUser-人员信息表
	 /// <summary>
    ///  人员信息表
    /// </summary>
	 [Route("api/OG/RelatedUser")]
     public partial class RelatedUserController : AuthorizeApiController<T_OG_RELATED_USER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_USER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_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_OG_RELATED_USER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_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_OG_RELATED_USER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedUserHealth-健康档案
	 /// <summary>
    ///  健康档案
    /// </summary>
	 [Route("api/OG/RelatedUserHealth")]
     public partial class RelatedUserHealthController : AuthorizeApiController<T_OG_RELATED_USER_HEALTH>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER_HEALTH>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER_HEALTH>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_USER_HEALTH> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_USER_HEALTH> 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_OG_RELATED_USER_HEALTH entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER_SIGN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_USER_SIGN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_USER_SIGN> 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_OG_RELATED_USER_SIGN entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_USER_SIGN> 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_OG_RELATED_USER_SIGN> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedUserInsurance-保险证明
	 /// <summary>
    ///  保险证明
    /// </summary>
	 [Route("api/OG/RelatedUserInsurance")]
     public partial class RelatedUserInsuranceController : AuthorizeApiController<T_OG_RELATED_USER_INSURANCE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER_INSURANCE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER_INSURANCE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_USER_INSURANCE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_USER_INSURANCE> 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_OG_RELATED_USER_INSURANCE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_USER_INSURANCE> 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_OG_RELATED_USER_INSURANCE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedEstimate-相关方安全表现评估表
	 /// <summary>
    ///  相关方安全表现评估表
    /// </summary>
	 [Route("api/OG/RelatedEstimate")]
     public partial class RelatedEstimateController : AuthorizeApiController<T_OG_RELATED_ESTIMATE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_ESTIMATE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_ESTIMATE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_ESTIMATE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_ESTIMATE> 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_OG_RELATED_ESTIMATE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_ESTIMATE> 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_OG_RELATED_ESTIMATE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedEstimateDetail-相关方安全表现评估表估项目中间表
	 /// <summary>
    ///  相关方安全表现评估表估项目中间表
    /// </summary>
	 [Route("api/OG/RelatedEstimateDetail")]
     public partial class RelatedEstimateDetailController : AuthorizeApiController<T_OG_RELATED_ESTIMATE_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_ESTIMATE_DETAIL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_ESTIMATE_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_ESTIMATE_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_ESTIMATE_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_OG_RELATED_ESTIMATE_DETAIL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_ESTIMATE_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_OG_RELATED_ESTIMATE_DETAIL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ExternalContactDetail-外部联系对象清单
	 /// <summary>
    ///  外部联系对象清单
    /// </summary>
	 [Route("api/OG/ExternalContactDetail")]
     public partial class ExternalContactDetailController : AuthorizeApiController<T_OG_EXTERNAL_CONTACT_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_EXTERNAL_CONTACT_DETAIL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_EXTERNAL_CONTACT_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_EXTERNAL_CONTACT_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_EXTERNAL_CONTACT_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_OG_EXTERNAL_CONTACT_DETAIL entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_QUALIFICATION_DETAIL_ITEM>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION_DETAIL_ITEM> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION_DETAIL_ITEM> 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_OG_RELATED_QUALIFICATION_DETAIL_ITEM entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_QUALIFICATION_DETAIL_ITEM> 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_OG_RELATED_QUALIFICATION_DETAIL_ITEM> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ApproveRewardPunishmentReason-奖励惩罚原因表
	 /// <summary>
    ///  奖励惩罚原因表
    /// </summary>
	 [Route("api/OG/ApproveRewardPunishmentReason")]
     public partial class ApproveRewardPunishmentReasonController : AuthorizeApiController<T_OG_APPROVE_REWARD_PUNISHMENT_REASON>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_APPROVE_REWARD_PUNISHMENT_REASON>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_APPROVE_REWARD_PUNISHMENT_REASON>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_APPROVE_REWARD_PUNISHMENT_REASON> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_APPROVE_REWARD_PUNISHMENT_REASON> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_OG_APPROVE_REWARD_PUNISHMENT_REASON> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedEstimateItem-评估项目表
	 /// <summary>
    ///  评估项目表
    /// </summary>
	 [Route("api/OG/RelatedEstimateItem")]
     public partial class RelatedEstimateItemController : AuthorizeApiController<T_OG_RELATED_ESTIMATE_ITEM>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_ESTIMATE_ITEM>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_ESTIMATE_ITEM>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_ESTIMATE_ITEM> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_ESTIMATE_ITEM> 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_OG_RELATED_ESTIMATE_ITEM entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_ESTIMATE_ITEM> 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_OG_RELATED_ESTIMATE_ITEM> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedQualificationLevel-资质等级表
	 /// <summary>
    ///  资质等级表
    /// </summary>
	 [Route("api/OG/RelatedQualificationLevel")]
     public partial class RelatedQualificationLevelController : AuthorizeApiController<T_OG_RELATED_QUALIFICATION_LEVEL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_QUALIFICATION_LEVEL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_QUALIFICATION_LEVEL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION_LEVEL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_QUALIFICATION_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_OG_RELATED_QUALIFICATION_LEVEL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_QUALIFICATION_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_OG_RELATED_QUALIFICATION_LEVEL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RelatedUserType-人员类型
	 /// <summary>
    ///  人员类型
    /// </summary>
	 [Route("api/OG/RelatedUserType")]
     public partial class RelatedUserTypeController : AuthorizeApiController<T_OG_RELATED_USER_TYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER_TYPE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_OG_RELATED_USER_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_OG_RELATED_USER_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_OG_RELATED_USER_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_OG_RELATED_USER_TYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_OG_RELATED_USER_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_OG_RELATED_USER_TYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TimeSet-触发时间配置表
	 /// <summary>
    ///  触发时间配置表
    /// </summary>
	 [Route("api/PT/TimeSet")]
     public partial class TimeSetController : AuthorizeApiController<T_PT_TIME_SET>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_PT_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_PT_TIME_SET>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_PT_TIME_SET> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_PT_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_PT_TIME_SET entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_PT_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_PT_TIME_SET> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Post-责任制岗位
	 /// <summary>
    ///  责任制岗位
    /// </summary>
	 [Route("api/SC/Post")]
     public partial class PostController : AuthorizeApiController<T_SC_POST>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_POST>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_POST>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_POST> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_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_SC_POST entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_POST_DEPOST>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_POST_DEPOST> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_POST_DEPOST> 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_SC_POST_DEPOST entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_POST_DEPOST> 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_SC_POST_DEPOST> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  PostSafePdtTemplateFile-责任制岗位安全生产责任制签订表模板
	 /// <summary>
    ///  责任制岗位安全生产责任制签订表模板
    /// </summary>
	 [Route("api/SC/PostSafePdtTemplateFile")]
     public partial class PostSafePdtTemplateFileController : AuthorizeApiController<T_SC_POST_SAFE_PDT_TEMPLATE_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_POST_SAFE_PDT_TEMPLATE_FILE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_POST_SAFE_PDT_TEMPLATE_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_POST_SAFE_PDT_TEMPLATE_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_POST_SAFE_PDT_TEMPLATE_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_SC_POST_SAFE_PDT_TEMPLATE_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_POST_SAFE_PDT_TEMPLATE_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_SC_POST_SAFE_PDT_TEMPLATE_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Department-责任制组织架构
	 /// <summary>
    ///  责任制组织架构
    /// </summary>
	 [Route("api/SC/Department")]
     public partial class DepartmentController : AuthorizeApiController<T_SC_DEPARTMENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_DEPARTMENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_DEPARTMENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_DEPARTMENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_DEPARTMENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_SC_DEPARTMENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DepartmentPost-责任制部门岗位
	 /// <summary>
    ///  责任制部门岗位
    /// </summary>
	 [Route("api/SC/DepartmentPost")]
     public partial class DepartmentPostController : AuthorizeApiController<T_SC_DEPARTMENT_POST>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_DEPARTMENT_POST>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_DEPARTMENT_POST>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_DEPARTMENT_POST> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_DEPARTMENT_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_SC_DEPARTMENT_POST entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_DEPARTMENT_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_SC_DEPARTMENT_POST> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DocumentLibrary-文件库
	 /// <summary>
    ///  文件库
    /// </summary>
	 [Route("api/SC/DocumentLibrary")]
     public partial class DocumentLibraryController : AuthorizeApiController<T_SC_DOCUMENT_LIBRARY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_DOCUMENT_LIBRARY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_DOCUMENT_LIBRARY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_DOCUMENT_LIBRARY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_DOCUMENT_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_SC_DOCUMENT_LIBRARY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_DOCUMENT_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_SC_DOCUMENT_LIBRARY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DocumentLibraryDetail-文件库
	 /// <summary>
    ///  文件库
    /// </summary>
	 [Route("api/SC/DocumentLibraryDetail")]
     public partial class DocumentLibraryDetailController : AuthorizeApiController<T_SC_DOCUMENT_LIBRARY_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_DOCUMENT_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_SC_DOCUMENT_LIBRARY_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_DOCUMENT_LIBRARY_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_DOCUMENT_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_SC_DOCUMENT_LIBRARY_DETAIL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_DOCUMENT_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_SC_DOCUMENT_LIBRARY_DETAIL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DocumentLibraryDetailFile-文件附件
	 /// <summary>
    ///  文件附件
    /// </summary>
	 [Route("api/SC/DocumentLibraryDetailFile")]
     public partial class DocumentLibraryDetailFileController : AuthorizeApiController<T_SC_DOCUMENT_LIBRARY_DETAIL_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_DOCUMENT_LIBRARY_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_SC_DOCUMENT_LIBRARY_DETAIL_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_DOCUMENT_LIBRARY_DETAIL_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_DOCUMENT_LIBRARY_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_SC_DOCUMENT_LIBRARY_DETAIL_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_DOCUMENT_LIBRARY_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_SC_DOCUMENT_LIBRARY_DETAIL_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  StandardCreate-标准化创建
	 /// <summary>
    ///  标准化创建
    /// </summary>
	 [Route("api/SC/StandardCreate")]
     public partial class StandardCreateController : AuthorizeApiController<T_SC_STANDARD_CREATE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SC_STANDARD_CREATE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_STANDARD_CREATE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_STANDARD_CREATE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_STANDARD_CREATE> 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_SC_STANDARD_CREATE entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SC_STANDARD_CREATE_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SC_STANDARD_CREATE_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SC_STANDARD_CREATE_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_SC_STANDARD_CREATE_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SC_STANDARD_CREATE_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_SC_STANDARD_CREATE_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  SafeSurvey-安全意识调查
	 /// <summary>
    ///  安全意识调查
    /// </summary>
	 [Route("api/SE/SafeSurvey")]
     public partial class SafeSurveyController : AuthorizeApiController<T_SE_SAFE_SURVEY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_SAFE_SURVEY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_SAFE_SURVEY> 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_SE_SAFE_SURVEY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_SAFE_SURVEY> 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_SE_SAFE_SURVEY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  SafeSurveyListDepartment-导航：参与部门
	 /// <summary>
    ///  导航：参与部门
    /// </summary>
	 [Route("api/SE/SafeSurveyListDepartment")]
     public partial class SafeSurveyListDepartmentController : AuthorizeApiController<T_SE_SAFE_SURVEY_LIST_DEPARTMENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY_LIST_DEPARTMENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY_LIST_DEPARTMENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_SAFE_SURVEY_LIST_DEPARTMENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_SAFE_SURVEY_LIST_DEPARTMENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_SE_SAFE_SURVEY_LIST_DEPARTMENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  SafeSurveyListFile-导航：附件
	 /// <summary>
    ///  导航：附件
    /// </summary>
	 [Route("api/SE/SafeSurveyListFile")]
     public partial class SafeSurveyListFileController : AuthorizeApiController<T_SE_SAFE_SURVEY_LIST_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY_LIST_FILE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY_LIST_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_SAFE_SURVEY_LIST_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_SAFE_SURVEY_LIST_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_SE_SAFE_SURVEY_LIST_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_SAFE_SURVEY_LIST_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_SE_SAFE_SURVEY_LIST_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  SafeSurveyListPaper-导航：试卷
	 /// <summary>
    ///  导航：试卷
    /// </summary>
	 [Route("api/SE/SafeSurveyListPaper")]
     public partial class SafeSurveyListPaperController : AuthorizeApiController<T_SE_SAFE_SURVEY_LIST_PAPER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY_LIST_PAPER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY_LIST_PAPER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_SAFE_SURVEY_LIST_PAPER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_SAFE_SURVEY_LIST_PAPER> 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_SE_SAFE_SURVEY_LIST_PAPER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_SAFE_SURVEY_LIST_PAPER> 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_SE_SAFE_SURVEY_LIST_PAPER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  SafeSurveyListPoint-导航：调查内容
	 /// <summary>
    ///  导航：调查内容
    /// </summary>
	 [Route("api/SE/SafeSurveyListPoint")]
     public partial class SafeSurveyListPointController : AuthorizeApiController<T_SE_SAFE_SURVEY_LIST_POINT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY_LIST_POINT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_SAFE_SURVEY_LIST_POINT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_SAFE_SURVEY_LIST_POINT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_SAFE_SURVEY_LIST_POINT> 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_SE_SAFE_SURVEY_LIST_POINT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_SAFE_SURVEY_LIST_POINT> 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_SE_SAFE_SURVEY_LIST_POINT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainSurvey-培训需求调查
	 /// <summary>
    ///  培训需求调查
    /// </summary>
	 [Route("api/SE/TrainSurvey")]
     public partial class TrainSurveyController : AuthorizeApiController<T_SE_TRAIN_SURVEY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY> 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_SE_TRAIN_SURVEY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_SURVEY> 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_SE_TRAIN_SURVEY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainSurveyListDemand-培训需求用户
	 /// <summary>
    ///  培训需求用户
    /// </summary>
	 [Route("api/SE/TrainSurveyListDemand")]
     public partial class TrainSurveyListDemandController : AuthorizeApiController<T_SE_TRAIN_SURVEY_LIST_DEMAND>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY_LIST_DEMAND>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY_LIST_DEMAND>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY_LIST_DEMAND> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY_LIST_DEMAND> 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_SE_TRAIN_SURVEY_LIST_DEMAND entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_SURVEY_LIST_DEMAND> 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_SE_TRAIN_SURVEY_LIST_DEMAND> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainSurveyListDemandItem-导航：培训需求
	 /// <summary>
    ///  导航：培训需求
    /// </summary>
	 [Route("api/SE/TrainSurveyListDemandItem")]
     public partial class TrainSurveyListDemandItemController : AuthorizeApiController<T_SE_TRAIN_SURVEY_LIST_DEMAND_ITEM>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY_LIST_DEMAND_ITEM>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY_LIST_DEMAND_ITEM>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY_LIST_DEMAND_ITEM> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY_LIST_DEMAND_ITEM> 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_SE_TRAIN_SURVEY_LIST_DEMAND_ITEM entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_SURVEY_LIST_DEMAND_ITEM> 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_SE_TRAIN_SURVEY_LIST_DEMAND_ITEM> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainSurveyListDepartment-导航：参与部门
	 /// <summary>
    ///  导航：参与部门
    /// </summary>
	 [Route("api/SE/TrainSurveyListDepartment")]
     public partial class TrainSurveyListDepartmentController : AuthorizeApiController<T_SE_TRAIN_SURVEY_LIST_DEPARTMENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY_LIST_DEPARTMENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY_LIST_DEPARTMENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY_LIST_DEPARTMENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY_LIST_DEPARTMENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_SE_TRAIN_SURVEY_LIST_DEPARTMENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainSurveyListPoint-导航：调查目的
	 /// <summary>
    ///  导航：调查目的
    /// </summary>
	 [Route("api/SE/TrainSurveyListPoint")]
     public partial class TrainSurveyListPointController : AuthorizeApiController<T_SE_TRAIN_SURVEY_LIST_POINT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY_LIST_POINT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_SURVEY_LIST_POINT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY_LIST_POINT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_SURVEY_LIST_POINT> 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_SE_TRAIN_SURVEY_LIST_POINT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_SURVEY_LIST_POINT> 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_SE_TRAIN_SURVEY_LIST_POINT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  YearTrainPlan-年度培训计划
	 /// <summary>
    ///  年度培训计划
    /// </summary>
	 [Route("api/SE/YearTrainPlan")]
     public partial class YearTrainPlanController : AuthorizeApiController<T_SE_YEAR_TRAIN_PLAN>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_YEAR_TRAIN_PLAN>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_YEAR_TRAIN_PLAN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_PLAN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_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_SE_YEAR_TRAIN_PLAN entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_YEAR_TRAIN_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_SE_YEAR_TRAIN_PLAN> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  YearTrainPlanDetail-年度培训计划详情
	 /// <summary>
    ///  年度培训计划详情
    /// </summary>
	 [Route("api/SE/YearTrainPlanDetail")]
     public partial class YearTrainPlanDetailController : AuthorizeApiController<T_SE_YEAR_TRAIN_PLAN_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_YEAR_TRAIN_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_SE_YEAR_TRAIN_PLAN_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_PLAN_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_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_SE_YEAR_TRAIN_PLAN_DETAIL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_YEAR_TRAIN_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_SE_YEAR_TRAIN_PLAN_DETAIL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  YearTrainPlanContent-年度培训内容关联表
	 /// <summary>
    ///  年度培训内容关联表
    /// </summary>
	 [Route("api/SE/YearTrainPlanContent")]
     public partial class YearTrainPlanContentController : AuthorizeApiController<T_SE_YEAR_TRAIN_PLAN_CONTENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_YEAR_TRAIN_PLAN_CONTENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_YEAR_TRAIN_PLAN_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_PLAN_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_PLAN_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_SE_YEAR_TRAIN_PLAN_CONTENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_YEAR_TRAIN_PLAN_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_SE_YEAR_TRAIN_PLAN_CONTENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  YearTrainPlanFile-年度培训计划附件
	 /// <summary>
    ///  年度培训计划附件
    /// </summary>
	 [Route("api/SE/YearTrainPlanFile")]
     public partial class YearTrainPlanFileController : AuthorizeApiController<T_SE_YEAR_TRAIN_PLAN_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_YEAR_TRAIN_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_SE_YEAR_TRAIN_PLAN_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_PLAN_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_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_SE_YEAR_TRAIN_PLAN_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_YEAR_TRAIN_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_SE_YEAR_TRAIN_PLAN_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  YearTrainPlanDepartment-年度培训发送部门
	 /// <summary>
    ///  年度培训发送部门
    /// </summary>
	 [Route("api/SE/YearTrainPlanDepartment")]
     public partial class YearTrainPlanDepartmentController : AuthorizeApiController<T_SE_YEAR_TRAIN_PLAN_DEPARTMENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_YEAR_TRAIN_PLAN_DEPARTMENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_YEAR_TRAIN_PLAN_DEPARTMENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_PLAN_DEPARTMENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_YEAR_TRAIN_PLAN_DEPARTMENT> OrderPaged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitOrderPaged(null, pageFilter);
        }
        /// <summary>
        /// 根据主键删除数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        [HttpGet, Route("Delete")]
        public JsonActionResult<bool> Delete(string id)
        {
            return WitRealDelete(id);
        }

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

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

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

        /// <summary>
        /// 获得单条实体数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Get")]
        public JsonActionResult<T_SE_YEAR_TRAIN_PLAN_DEPARTMENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DepTrainPlan-部门培训计划
	 /// <summary>
    ///  部门培训计划
    /// </summary>
	 [Route("api/SE/DepTrainPlan")]
     public partial class DepTrainPlanController : AuthorizeApiController<T_SE_DEP_TRAIN_PLAN>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_DEP_TRAIN_PLAN>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_DEP_TRAIN_PLAN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_DEP_TRAIN_PLAN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_DEP_TRAIN_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_SE_DEP_TRAIN_PLAN entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_DEP_TRAIN_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_SE_DEP_TRAIN_PLAN> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DepTrainPlanDetail-部门培训计划详情
	 /// <summary>
    ///  部门培训计划详情
    /// </summary>
	 [Route("api/SE/DepTrainPlanDetail")]
     public partial class DepTrainPlanDetailController : AuthorizeApiController<T_SE_DEP_TRAIN_PLAN_DETAIL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_DEP_TRAIN_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_SE_DEP_TRAIN_PLAN_DETAIL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_DEP_TRAIN_PLAN_DETAIL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_DEP_TRAIN_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_SE_DEP_TRAIN_PLAN_DETAIL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_DEP_TRAIN_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_SE_DEP_TRAIN_PLAN_DETAIL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  DepTrainPlanContent-部门培训内容关联表
	 /// <summary>
    ///  部门培训内容关联表
    /// </summary>
	 [Route("api/SE/DepTrainPlanContent")]
     public partial class DepTrainPlanContentController : AuthorizeApiController<T_SE_DEP_TRAIN_PLAN_CONTENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_DEP_TRAIN_PLAN_CONTENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_DEP_TRAIN_PLAN_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_DEP_TRAIN_PLAN_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_DEP_TRAIN_PLAN_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_SE_DEP_TRAIN_PLAN_CONTENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_DEP_TRAIN_PLAN_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_SE_DEP_TRAIN_PLAN_CONTENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainNotify-培训通知
	 /// <summary>
    ///  培训通知
    /// </summary>
	 [Route("api/SE/TrainNotify")]
     public partial class TrainNotifyController : AuthorizeApiController<T_SE_TRAIN_NOTIFY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_NOTIFY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_NOTIFY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_NOTIFY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_NOTIFY> 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_SE_TRAIN_NOTIFY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_NOTIFY> 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_SE_TRAIN_NOTIFY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainNotifyFile-培训通知附件
	 /// <summary>
    ///  培训通知附件
    /// </summary>
	 [Route("api/SE/TrainNotifyFile")]
     public partial class TrainNotifyFileController : AuthorizeApiController<T_SE_TRAIN_NOTIFY_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_NOTIFY_FILE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_NOTIFY_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_NOTIFY_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_NOTIFY_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_SE_TRAIN_NOTIFY_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_NOTIFY_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_SE_TRAIN_NOTIFY_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainNotifyContentRel-培训内容
	 /// <summary>
    ///  培训内容
    /// </summary>
	 [Route("api/SE/TrainNotifyContentRel")]
     public partial class TrainNotifyContentRelController : AuthorizeApiController<T_SE_TRAIN_NOTIFY_CONTENT_REL>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_NOTIFY_CONTENT_REL>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_NOTIFY_CONTENT_REL>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_NOTIFY_CONTENT_REL> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_NOTIFY_CONTENT_REL> 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_SE_TRAIN_NOTIFY_CONTENT_REL entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_NOTIFY_CONTENT_REL> 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_SE_TRAIN_NOTIFY_CONTENT_REL> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainNotifyPersons-培训通知人员
	 /// <summary>
    ///  培训通知人员
    /// </summary>
	 [Route("api/SE/TrainNotifyPersons")]
     public partial class TrainNotifyPersonsController : AuthorizeApiController<T_SE_TRAIN_NOTIFY_PERSONS>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_NOTIFY_PERSONS>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_NOTIFY_PERSONS>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_NOTIFY_PERSONS> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_NOTIFY_PERSONS> 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_SE_TRAIN_NOTIFY_PERSONS entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_NOTIFY_PERSONS> 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_SE_TRAIN_NOTIFY_PERSONS> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainRecord-培训记录
	 /// <summary>
    ///  培训记录
    /// </summary>
	 [Route("api/SE/TrainRecord")]
     public partial class TrainRecordController : AuthorizeApiController<T_SE_TRAIN_RECORD>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_RECORD>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_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_SE_TRAIN_RECORD entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_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_SE_TRAIN_RECORD> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainRecordFile-培训记录附件
	 /// <summary>
    ///  培训记录附件
    /// </summary>
	 [Route("api/SE/TrainRecordFile")]
     public partial class TrainRecordFileController : AuthorizeApiController<T_SE_TRAIN_RECORD_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_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_SE_TRAIN_RECORD_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_RECORD_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_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_SE_TRAIN_RECORD_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_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_SE_TRAIN_RECORD_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainRecordPaper-人员试题
	 /// <summary>
    ///  人员试题
    /// </summary>
	 [Route("api/SE/TrainRecordPaper")]
     public partial class TrainRecordPaperController : AuthorizeApiController<T_SE_TRAIN_RECORD_PAPER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_RECORD_PAPER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_RECORD_PAPER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_RECORD_PAPER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_RECORD_PAPER> 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_SE_TRAIN_RECORD_PAPER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_RECORD_PAPER> 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_SE_TRAIN_RECORD_PAPER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainRecordUser-培训记录参与人员
	 /// <summary>
    ///  培训记录参与人员
    /// </summary>
	 [Route("api/SE/TrainRecordUser")]
     public partial class TrainRecordUserController : AuthorizeApiController<T_SE_TRAIN_RECORD_USER>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_RECORD_USER>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_RECORD_USER>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_RECORD_USER> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_RECORD_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_SE_TRAIN_RECORD_USER entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_RECORD_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_SE_TRAIN_RECORD_USER> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainingEffectEvaluation-培训效果评估表
	 /// <summary>
    ///  培训效果评估表
    /// </summary>
	 [Route("api/SE/TrainingEffectEvaluation")]
     public partial class TrainingEffectEvaluationController : AuthorizeApiController<T_SE_TRAINING_EFFECT_EVALUATION>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_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_SE_TRAINING_EFFECT_EVALUATION entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAINING_EFFECT_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_SE_TRAINING_EFFECT_EVALUATION> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainingEffectEvaluationOpinion-培训效果评估表培训改进意见表
	 /// <summary>
    ///  培训效果评估表培训改进意见表
    /// </summary>
	 [Route("api/SE/TrainingEffectEvaluationOpinion")]
     public partial class TrainingEffectEvaluationOpinionController : AuthorizeApiController<T_SE_TRAINING_EFFECT_EVALUATION_OPINION>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION_OPINION>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION_OPINION>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION_OPINION> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION_OPINION> 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_SE_TRAINING_EFFECT_EVALUATION_OPINION entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAINING_EFFECT_EVALUATION_OPINION> 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_SE_TRAINING_EFFECT_EVALUATION_OPINION> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainingEffectEvaluationEnd-培训效果评估表结果表
	 /// <summary>
    ///  培训效果评估表结果表
    /// </summary>
	 [Route("api/SE/TrainingEffectEvaluationEnd")]
     public partial class TrainingEffectEvaluationEndController : AuthorizeApiController<T_SE_TRAINING_EFFECT_EVALUATION_END>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION_END>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION_END>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION_END> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION_END> 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_SE_TRAINING_EFFECT_EVALUATION_END entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAINING_EFFECT_EVALUATION_END> 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_SE_TRAINING_EFFECT_EVALUATION_END> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainingEffectEvaluationSurvey-培训效果评估调查表
	 /// <summary>
    ///  培训效果评估调查表
    /// </summary>
	 [Route("api/SE/TrainingEffectEvaluationSurvey")]
     public partial class TrainingEffectEvaluationSurveyController : AuthorizeApiController<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY> 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_SE_TRAINING_EFFECT_EVALUATION_SURVEY entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY> 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_SE_TRAINING_EFFECT_EVALUATION_SURVEY> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainingEffectEvaluationSurveyResults-培训效果评估调查表结果表
	 /// <summary>
    ///  培训效果评估调查表结果表
    /// </summary>
	 [Route("api/SE/TrainingEffectEvaluationSurveyResults")]
     public partial class TrainingEffectEvaluationSurveyResultsController : AuthorizeApiController<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY_RESULTS>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY_RESULTS>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY_RESULTS>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY_RESULTS> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY_RESULTS> 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_SE_TRAINING_EFFECT_EVALUATION_SURVEY_RESULTS entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAINING_EFFECT_EVALUATION_SURVEY_RESULTS> 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_SE_TRAINING_EFFECT_EVALUATION_SURVEY_RESULTS> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ThreeLevelSafeEduCard-三级安全教育卡
	 /// <summary>
    ///  三级安全教育卡
    /// </summary>
	 [Route("api/SE/ThreeLevelSafeEduCard")]
     public partial class ThreeLevelSafeEduCardController : AuthorizeApiController<T_SE_THREE_LEVEL_SAFE_EDU_CARD>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_EDU_CARD>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_EDU_CARD>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_EDU_CARD> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_EDU_CARD> 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_SE_THREE_LEVEL_SAFE_EDU_CARD entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_THREE_LEVEL_SAFE_EDU_CARD> 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_SE_THREE_LEVEL_SAFE_EDU_CARD> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ThreeLevelSafeTrainRecord-三级安全教育卡培训记录
	 /// <summary>
    ///  三级安全教育卡培训记录
    /// </summary>
	 [Route("api/SE/ThreeLevelSafeTrainRecord")]
     public partial class ThreeLevelSafeTrainRecordController : AuthorizeApiController<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_TRAIN_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_SE_THREE_LEVEL_SAFE_TRAIN_RECORD entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_THREE_LEVEL_SAFE_TRAIN_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_SE_THREE_LEVEL_SAFE_TRAIN_RECORD> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ThreeLevelSafeTrainRecordFile-三级安全教育卡培训记录附件
	 /// <summary>
    ///  三级安全教育卡培训记录附件
    /// </summary>
	 [Route("api/SE/ThreeLevelSafeTrainRecordFile")]
     public partial class ThreeLevelSafeTrainRecordFileController : AuthorizeApiController<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_TRAIN_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_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_TRAIN_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_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_THREE_LEVEL_SAFE_TRAIN_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_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ThreeLevelSafeTrainRecordSignatureFile-三级安全教育卡培训记录电子签名附件
	 /// <summary>
    ///  三级安全教育卡培训记录电子签名附件
    /// </summary>
	 [Route("api/SE/ThreeLevelSafeTrainRecordSignatureFile")]
     public partial class ThreeLevelSafeTrainRecordSignatureFileController : AuthorizeApiController<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_SIGNATURE_FILE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_SIGNATURE_FILE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_SIGNATURE_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_SIGNATURE_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_SIGNATURE_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_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_SIGNATURE_FILE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_SIGNATURE_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_SE_THREE_LEVEL_SAFE_TRAIN_RECORD_SIGNATURE_FILE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  CertificateType-证书类别
	 /// <summary>
    ///  证书类别
    /// </summary>
	 [Route("api/SE/CertificateType")]
     public partial class CertificateTypeController : AuthorizeApiController<T_SE_CERTIFICATE_TYPE>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_CERTIFICATE_TYPE>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_CERTIFICATE_TYPE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_CERTIFICATE_TYPE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_CERTIFICATE_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_SE_CERTIFICATE_TYPE entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_CERTIFICATE_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_SE_CERTIFICATE_TYPE> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  Seconfig-安全教育模块基础配置
	 /// <summary>
    ///  安全教育模块基础配置
    /// </summary>
	 [Route("api/SE/Seconfig")]
     public partial class SeconfigController : AuthorizeApiController<T_SE_SECONFIG>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_SECONFIG>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_SECONFIG>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_SECONFIG> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_SECONFIG> 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_SE_SECONFIG entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_SECONFIG> 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_SE_SECONFIG> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  RenewalTrain-换证培训触发
	 /// <summary>
    ///  换证培训触发
    /// </summary>
	 [Route("api/SE/RenewalTrain")]
     public partial class RenewalTrainController : AuthorizeApiController<T_SE_RENEWAL_TRAIN>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_RENEWAL_TRAIN>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_RENEWAL_TRAIN>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_RENEWAL_TRAIN> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_RENEWAL_TRAIN> 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_SE_RENEWAL_TRAIN entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_RENEWAL_TRAIN_FILE>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_RENEWAL_TRAIN_FILE> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_RENEWAL_TRAIN_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_SE_RENEWAL_TRAIN_FILE entity)
        {
            return WitUpdate(entity);
        }

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

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TEST>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TEST> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TEST> 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_SE_TEST entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TEST> 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_SE_TEST> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TestEnumPoint-试题知识点
	 /// <summary>
    ///  试题知识点
    /// </summary>
	 [Route("api/SE/TestEnumPoint")]
     public partial class TestEnumPointController : AuthorizeApiController<T_SE_TEST_ENUM_POINT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TEST_ENUM_POINT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TEST_ENUM_POINT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TEST_ENUM_POINT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TEST_ENUM_POINT> 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_SE_TEST_ENUM_POINT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TEST_ENUM_POINT> 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_SE_TEST_ENUM_POINT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TestListPoint-导航：试题知识点
	 /// <summary>
    ///  导航：试题知识点
    /// </summary>
	 [Route("api/SE/TestListPoint")]
     public partial class TestListPointController : AuthorizeApiController<T_SE_TEST_LIST_POINT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TEST_LIST_POINT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TEST_LIST_POINT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TEST_LIST_POINT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TEST_LIST_POINT> 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_SE_TEST_LIST_POINT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TEST_LIST_POINT> 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_SE_TEST_LIST_POINT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TestListPost-适用岗位
	 /// <summary>
    ///  适用岗位
    /// </summary>
	 [Route("api/SE/TestListPost")]
     public partial class TestListPostController : AuthorizeApiController<T_SE_TEST_LIST_POST>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TEST_LIST_POST>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TEST_LIST_POST>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TEST_LIST_POST> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TEST_LIST_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_SE_TEST_LIST_POST entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TEST_LIST_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_SE_TEST_LIST_POST> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  ThreeLevelSafeContent-三级安全教育卡培训内容
	 /// <summary>
    ///  三级安全教育卡培训内容
    /// </summary>
	 [Route("api/SE/ThreeLevelSafeContent")]
     public partial class ThreeLevelSafeContentController : AuthorizeApiController<T_SE_THREE_LEVEL_SAFE_CONTENT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_CONTENT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_THREE_LEVEL_SAFE_CONTENT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_CONTENT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_THREE_LEVEL_SAFE_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_SE_THREE_LEVEL_SAFE_CONTENT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_THREE_LEVEL_SAFE_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_SE_THREE_LEVEL_SAFE_CONTENT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainingSurveySubject-培训效果评估调查题目
	 /// <summary>
    ///  培训效果评估调查题目
    /// </summary>
	 [Route("api/SE/TrainingSurveySubject")]
     public partial class TrainingSurveySubjectController : AuthorizeApiController<T_SE_TRAINING_SURVEY_SUBJECT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_SURVEY_SUBJECT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAINING_SURVEY_SUBJECT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAINING_SURVEY_SUBJECT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAINING_SURVEY_SUBJECT> 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_SE_TRAINING_SURVEY_SUBJECT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAINING_SURVEY_SUBJECT> 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_SE_TRAINING_SURVEY_SUBJECT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainCheckTypeEnum-考核方式
	 /// <summary>
    ///  考核方式
    /// </summary>
	 [Route("api/SE/TrainCheckTypeEnum")]
     public partial class TrainCheckTypeEnumController : AuthorizeApiController<T_SE_TRAIN_CHECK_TYPE_ENUM>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_CHECK_TYPE_ENUM>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_CHECK_TYPE_ENUM>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_CHECK_TYPE_ENUM> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_CHECK_TYPE_ENUM> 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_SE_TRAIN_CHECK_TYPE_ENUM entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_CHECK_TYPE_ENUM> 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_SE_TRAIN_CHECK_TYPE_ENUM> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainDemandEnum-培训需求
	 /// <summary>
    ///  培训需求
    /// </summary>
	 [Route("api/SE/TrainDemandEnum")]
     public partial class TrainDemandEnumController : AuthorizeApiController<T_SE_TRAIN_DEMAND_ENUM>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_DEMAND_ENUM>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_DEMAND_ENUM>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_DEMAND_ENUM> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_DEMAND_ENUM> 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_SE_TRAIN_DEMAND_ENUM entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_DEMAND_ENUM> 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_SE_TRAIN_DEMAND_ENUM> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainRecordReport-培训教育统计报表
	 /// <summary>
    ///  培训教育统计报表
    /// </summary>
	 [Route("api/SE/TrainRecordReport")]
     public partial class TrainRecordReportController : AuthorizeApiController<T_SE_TRAIN_RECORD_REPORT>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_RECORD_REPORT>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_RECORD_REPORT>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_RECORD_REPORT> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_RECORD_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_SE_TRAIN_RECORD_REPORT entity)
        {
            return WitUpdate(entity);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="entity">对象实体</param>
        /// <returns></returns>
        [HttpPost, Route("BatchUpdate")]
        public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_SE_TRAIN_RECORD_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_SE_TRAIN_RECORD_REPORT> Get([FromBody] KeywordFilter filter)
        {
            return WitEntity(null, filter);
        }
        
     }
	 #endregion
					#region  TrainTypeEnum-培训类型
	 /// <summary>
    ///  培训类型
    /// </summary>
	 [Route("api/SE/TrainTypeEnum")]
     public partial class TrainTypeEnumController : AuthorizeApiController<T_SE_TRAIN_TYPE_ENUM>
     {   
         /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Entities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_TYPE_ENUM>> Entities([FromBody]KeywordFilter filter)
        {
            return WitEntities(null, filter);
        }
         /// <summary>
        /// 排序查询所有数据
        /// </summary>
        /// <param name="filter">过滤实体</param>
        /// <returns></returns>

        [HttpPost, Route("OrderEntities")]
        public JsonActionResult<IEnumerable<T_SE_TRAIN_TYPE_ENUM>> OrderEntities([FromBody]KeywordFilter filter)
        {
            return WitOrderEntities(null, filter);
        }
         /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("Paged")]
        public PagedActionResult<T_SE_TRAIN_TYPE_ENUM> Paged([FromBody]KeywordPageFilter pageFilter)
        {
            return WitPaged(null, pageFilter);
        }
        /// <summary>
        /// 排序分页查询数据
        /// </summary>
        /// <param name="pageFilter">分页过滤实体</param>
        /// <returns></returns>
        [HttpPost, Route("OrderPaged")]
        public PagedActionResult<T_SE_TRAIN_TYPE_ENUM> 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_SE_TRAIN_TYPE_ENUM entity)
        {
            return WitUpdate(entity);
        }

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