//------------------------------------------------------------------------------
//     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.FO.WebApi.Controllers.Api
{
	using APT.MS.Domain.Entities.FO;

	#region  ChangeShiftRecord-岗位交接班记录表
	/// <summary>
    ///  岗位交接班记录表
    /// </summary>
	[Route("api/FO/ChangeShiftRecord")]
    public partial class ChangeShiftRecordController : AuthorizeApiController<T_FO_CHANGE_SHIFT_RECORD>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CHANGE_SHIFT_RECORD>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  ChangeShiftRecordAfterUser-接班人员表
	/// <summary>
    ///  接班人员表
    /// </summary>
	[Route("api/FO/ChangeShiftRecordAfterUser")]
    public partial class ChangeShiftRecordAfterUserController : AuthorizeApiController<T_FO_CHANGE_SHIFT_RECORD_AFTER_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CHANGE_SHIFT_RECORD_AFTER_USER>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  ChangeShiftRecordFile-附件表
	/// <summary>
    ///  附件表
    /// </summary>
	[Route("api/FO/ChangeShiftRecordFile")]
    public partial class ChangeShiftRecordFileController : AuthorizeApiController<T_FO_CHANGE_SHIFT_RECORD_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CHANGE_SHIFT_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_FO_CHANGE_SHIFT_RECORD_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

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

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

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

    }
	#endregion

	#region  ChangeShiftRecordPreUser-交班人员表
	/// <summary>
    ///  交班人员表
    /// </summary>
	[Route("api/FO/ChangeShiftRecordPreUser")]
    public partial class ChangeShiftRecordPreUserController : AuthorizeApiController<T_FO_CHANGE_SHIFT_RECORD_PRE_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CHANGE_SHIFT_RECORD_PRE_USER>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  CrucialLicenseDealMeasure-作业后处理措施
	/// <summary>
    ///  作业后处理措施
    /// </summary>
	[Route("api/FO/CrucialLicenseDealMeasure")]
    public partial class CrucialLicenseDealMeasureController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_DEAL_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_DEAL_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_DEAL_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicenseJob-关键许可工作表
	/// <summary>
    ///  关键许可工作表
    /// </summary>
	[Route("api/FO/CrucialLicenseJob")]
    public partial class CrucialLicenseJobController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_JOB>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_JOB>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_JOB> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicenseJobFile-附件上传
	/// <summary>
    ///  附件上传
    /// </summary>
	[Route("api/FO/CrucialLicenseJobFile")]
    public partial class CrucialLicenseJobFileController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_JOB_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_JOB_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  CrucialLicenseJobOutsource-关键许可工作表
	/// <summary>
    ///  关键许可工作表
    /// </summary>
	[Route("api/FO/CrucialLicenseJobOutsource")]
    public partial class CrucialLicenseJobOutsourceController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_JOB_OUTSOURCE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_JOB_OUTSOURCE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_JOB_OUTSOURCE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicenseOutsourceDealMeasure-作业后处理措施
	/// <summary>
    ///  作业后处理措施
    /// </summary>
	[Route("api/FO/CrucialLicenseOutsourceDealMeasure")]
    public partial class CrucialLicenseOutsourceDealMeasureController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_OUTSOURCE_DEAL_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_OUTSOURCE_DEAL_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_OUTSOURCE_DEAL_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicenseOutsourcePerson-关键许可人员表
	/// <summary>
    ///  关键许可人员表
    /// </summary>
	[Route("api/FO/CrucialLicenseOutsourcePerson")]
    public partial class CrucialLicenseOutsourcePersonController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_OUTSOURCE_PERSON>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_OUTSOURCE_PERSON>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_OUTSOURCE_PERSON> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicenseOutsourceSafeConfirm-作业前安全确认
	/// <summary>
    ///  作业前安全确认
    /// </summary>
	[Route("api/FO/CrucialLicenseOutsourceSafeConfirm")]
    public partial class CrucialLicenseOutsourceSafeConfirmController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_OUTSOURCE_SAFE_CONFIRM>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_OUTSOURCE_SAFE_CONFIRM>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_OUTSOURCE_SAFE_CONFIRM> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicenseOutsourceSafeMeasure-作业流程及安全措施
	/// <summary>
    ///  作业流程及安全措施
    /// </summary>
	[Route("api/FO/CrucialLicenseOutsourceSafeMeasure")]
    public partial class CrucialLicenseOutsourceSafeMeasureController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_OUTSOURCE_SAFE_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_OUTSOURCE_SAFE_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_OUTSOURCE_SAFE_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicensePerson-关键许可人员表
	/// <summary>
    ///  关键许可人员表
    /// </summary>
	[Route("api/FO/CrucialLicensePerson")]
    public partial class CrucialLicensePersonController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_PERSON>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_PERSON>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_PERSON> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicenseSafeConfirm-作业前安全确认
	/// <summary>
    ///  作业前安全确认
    /// </summary>
	[Route("api/FO/CrucialLicenseSafeConfirm")]
    public partial class CrucialLicenseSafeConfirmController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_SAFE_CONFIRM>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_SAFE_CONFIRM>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_SAFE_CONFIRM> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CrucialLicenseSafeMeasure-作业流程及安全措施
	/// <summary>
    ///  作业流程及安全措施
    /// </summary>
	[Route("api/FO/CrucialLicenseSafeMeasure")]
    public partial class CrucialLicenseSafeMeasureController : AuthorizeApiController<T_FO_CRUCIAL_LICENSE_SAFE_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CRUCIAL_LICENSE_SAFE_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CRUCIAL_LICENSE_SAFE_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CurrentClassRecord-岗位当班工作记录表
	/// <summary>
    ///  岗位当班工作记录表
    /// </summary>
	[Route("api/FO/CurrentClassRecord")]
    public partial class CurrentClassRecordController : AuthorizeApiController<T_FO_CURRENT_CLASS_RECORD>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CURRENT_CLASS_RECORD>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  CurrentClassRecordFile-附件表
	/// <summary>
    ///  附件表
    /// </summary>
	[Route("api/FO/CurrentClassRecordFile")]
    public partial class CurrentClassRecordFileController : AuthorizeApiController<T_FO_CURRENT_CLASS_RECORD_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CURRENT_CLASS_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_FO_CURRENT_CLASS_RECORD_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

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

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

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

    }
	#endregion

	#region  CurrentClassRecordLabourSupply-岗位当班劳保用品清单
	/// <summary>
    ///  岗位当班劳保用品清单
    /// </summary>
	[Route("api/FO/CurrentClassRecordLabourSupply")]
    public partial class CurrentClassRecordLabourSupplyController : AuthorizeApiController<T_FO_CURRENT_CLASS_RECORD_LABOUR_SUPPLY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CURRENT_CLASS_RECORD_LABOUR_SUPPLY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_CURRENT_CLASS_RECORD_LABOUR_SUPPLY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  CurrentClassRecordUser-岗位当班工作人员表
	/// <summary>
    ///  岗位当班工作人员表
    /// </summary>
	[Route("api/FO/CurrentClassRecordUser")]
    public partial class CurrentClassRecordUserController : AuthorizeApiController<T_FO_CURRENT_CLASS_RECORD_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_CURRENT_CLASS_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_FO_CURRENT_CLASS_RECORD_USER>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

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

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

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

    }
	#endregion

	#region  Holidays-国家法定假期维护
	/// <summary>
    ///  国家法定假期维护
    /// </summary>
	[Route("api/FO/Holidays")]
    public partial class HolidaysController : AuthorizeApiController<T_FO_HOLIDAYS>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_HOLIDAYS>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_HOLIDAYS> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  HolidaysDetail-
	/// <summary>
    ///  
    /// </summary>
	[Route("api/FO/HolidaysDetail")]
    public partial class HolidaysDetailController : AuthorizeApiController<T_FO_HOLIDAYS_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_HOLIDAYS_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobActivityDetail-作业活动记录(关键/许可)明细表
	/// <summary>
    ///  作业活动记录(关键/许可)明细表
    /// </summary>
	[Route("api/FO/JobActivityDetail")]
    public partial class JobActivityDetailController : AuthorizeApiController<T_FO_JOB_ACTIVITY_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_ACTIVITY_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobActivityFile-作业活动记录附件表
	/// <summary>
    ///  作业活动记录附件表
    /// </summary>
	[Route("api/FO/JobActivityFile")]
    public partial class JobActivityFileController : AuthorizeApiController<T_FO_JOB_ACTIVITY_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_ACTIVITY_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobActivityFlow-作业流程及安全措施确认
	/// <summary>
    ///  作业流程及安全措施确认
    /// </summary>
	[Route("api/FO/JobActivityFlow")]
    public partial class JobActivityFlowController : AuthorizeApiController<T_FO_JOB_ACTIVITY_FLOW>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_ACTIVITY_FLOW>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_JOB_ACTIVITY_FLOW> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  JobActivityFlowFile-作业流程及安全措施附件表
	/// <summary>
    ///  作业流程及安全措施附件表
    /// </summary>
	[Route("api/FO/JobActivityFlowFile")]
    public partial class JobActivityFlowFileController : AuthorizeApiController<T_FO_JOB_ACTIVITY_FLOW_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_ACTIVITY_FLOW_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobActivityMeasure-作业后处理措施确认
	/// <summary>
    ///  作业后处理措施确认
    /// </summary>
	[Route("api/FO/JobActivityMeasure")]
    public partial class JobActivityMeasureController : AuthorizeApiController<T_FO_JOB_ACTIVITY_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_ACTIVITY_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_JOB_ACTIVITY_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  JobActivityMeasureFile-作业活动记录附件表
	/// <summary>
    ///  作业活动记录附件表
    /// </summary>
	[Route("api/FO/JobActivityMeasureFile")]
    public partial class JobActivityMeasureFileController : AuthorizeApiController<T_FO_JOB_ACTIVITY_MEASURE_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_ACTIVITY_MEASURE_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobActivityPerson-作业活动记录(关键/许可)人员表
	/// <summary>
    ///  作业活动记录(关键/许可)人员表
    /// </summary>
	[Route("api/FO/JobActivityPerson")]
    public partial class JobActivityPersonController : AuthorizeApiController<T_FO_JOB_ACTIVITY_PERSON>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_ACTIVITY_PERSON>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_JOB_ACTIVITY_PERSON> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  JobActivityRecord-作业活动记录表(关键/许可)
	/// <summary>
    ///  作业活动记录表(关键/许可)
    /// </summary>
	[Route("api/FO/JobActivityRecord")]
    public partial class JobActivityRecordController : AuthorizeApiController<T_FO_JOB_ACTIVITY_RECORD>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_ACTIVITY_RECORD>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobEventDetail-作业活动记录明细表
	/// <summary>
    ///  作业活动记录明细表
    /// </summary>
	[Route("api/FO/JobEventDetail")]
    public partial class JobEventDetailController : AuthorizeApiController<T_FO_JOB_EVENT_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_EVENT_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobEventFile-作业活动记录附件表
	/// <summary>
    ///  作业活动记录附件表
    /// </summary>
	[Route("api/FO/JobEventFile")]
    public partial class JobEventFileController : AuthorizeApiController<T_FO_JOB_EVENT_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_EVENT_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobEventFlow-作业流程及安全措施确认
	/// <summary>
    ///  作业流程及安全措施确认
    /// </summary>
	[Route("api/FO/JobEventFlow")]
    public partial class JobEventFlowController : AuthorizeApiController<T_FO_JOB_EVENT_FLOW>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_EVENT_FLOW>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_JOB_EVENT_FLOW> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  JobEventFlowFile-作业流程及安全措施附件表
	/// <summary>
    ///  作业流程及安全措施附件表
    /// </summary>
	[Route("api/FO/JobEventFlowFile")]
    public partial class JobEventFlowFileController : AuthorizeApiController<T_FO_JOB_EVENT_FLOW_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_EVENT_FLOW_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobEventMeasure-作业后处理措施确认
	/// <summary>
    ///  作业后处理措施确认
    /// </summary>
	[Route("api/FO/JobEventMeasure")]
    public partial class JobEventMeasureController : AuthorizeApiController<T_FO_JOB_EVENT_MEASURE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_EVENT_MEASURE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_JOB_EVENT_MEASURE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  JobEventMeasureFile-作业活动记录附件表
	/// <summary>
    ///  作业活动记录附件表
    /// </summary>
	[Route("api/FO/JobEventMeasureFile")]
    public partial class JobEventMeasureFileController : AuthorizeApiController<T_FO_JOB_EVENT_MEASURE_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_EVENT_MEASURE_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  JobEventPerson-作业活动记录人员表
	/// <summary>
    ///  作业活动记录人员表
    /// </summary>
	[Route("api/FO/JobEventPerson")]
    public partial class JobEventPersonController : AuthorizeApiController<T_FO_JOB_EVENT_PERSON>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_EVENT_PERSON>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_JOB_EVENT_PERSON> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  JobEventRecord-作业活动记录表
	/// <summary>
    ///  作业活动记录表
    /// </summary>
	[Route("api/FO/JobEventRecord")]
    public partial class JobEventRecordController : AuthorizeApiController<T_FO_JOB_EVENT_RECORD>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_JOB_EVENT_RECORD>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  LabourSupply-劳保用品
	/// <summary>
    ///  劳保用品
    /// </summary>
	[Route("api/FO/LabourSupply")]
    public partial class LabourSupplyController : AuthorizeApiController<T_FO_LABOUR_SUPPLY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_LABOUR_SUPPLY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_LABOUR_SUPPLY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  PreOperSch-作业方案讨论记录
	/// <summary>
    ///  作业方案讨论记录
    /// </summary>
	[Route("api/FO/PreOperSch")]
    public partial class PreOperSchController : AuthorizeApiController<T_FO_PRE_OPER_SCH>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_PRE_OPER_SCH>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_PRE_OPER_SCH> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  PreOperSchFile-作业方案讨论记录附件
	/// <summary>
    ///  作业方案讨论记录附件
    /// </summary>
	[Route("api/FO/PreOperSchFile")]
    public partial class PreOperSchFileController : AuthorizeApiController<T_FO_PRE_OPER_SCH_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_PRE_OPER_SCH_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  PreOperSchUser-作业方案讨论记录参会人员表
	/// <summary>
    ///  作业方案讨论记录参会人员表
    /// </summary>
	[Route("api/FO/PreOperSchUser")]
    public partial class PreOperSchUserController : AuthorizeApiController<T_FO_PRE_OPER_SCH_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_PRE_OPER_SCH_USER>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  PreShiftMeetingRecord-班前会议记录表
	/// <summary>
    ///  班前会议记录表
    /// </summary>
	[Route("api/FO/PreShiftMeetingRecord")]
    public partial class PreShiftMeetingRecordController : AuthorizeApiController<T_FO_PRE_SHIFT_MEETING_RECORD>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_PRE_SHIFT_MEETING_RECORD>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  PreShiftMeetingRecordDetail-导航：上班生产情况
	/// <summary>
    ///  导航：上班生产情况
    /// </summary>
	[Route("api/FO/PreShiftMeetingRecordDetail")]
    public partial class PreShiftMeetingRecordDetailController : AuthorizeApiController<T_FO_PRE_SHIFT_MEETING_RECORD_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_PRE_SHIFT_MEETING_RECORD_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_PRE_SHIFT_MEETING_RECORD_DETAIL> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  PreShiftMeetingRecordDetailPost-涉及岗位
	/// <summary>
    ///  涉及岗位
    /// </summary>
	[Route("api/FO/PreShiftMeetingRecordDetailPost")]
    public partial class PreShiftMeetingRecordDetailPostController : AuthorizeApiController<T_FO_PRE_SHIFT_MEETING_RECORD_DETAIL_POST>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_PRE_SHIFT_MEETING_RECORD_DETAIL_POST>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_PRE_SHIFT_MEETING_RECORD_DETAIL_POST> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  PreShiftMeetingRecordFile-班前会议附件
	/// <summary>
    ///  班前会议附件
    /// </summary>
	[Route("api/FO/PreShiftMeetingRecordFile")]
    public partial class PreShiftMeetingRecordFileController : AuthorizeApiController<T_FO_PRE_SHIFT_MEETING_RECORD_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_PRE_SHIFT_MEETING_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_FO_PRE_SHIFT_MEETING_RECORD_FILE>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

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

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

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

    }
	#endregion

	#region  PreShiftMeetingRecordUser-班前会议记录与会人员表
	/// <summary>
    ///  班前会议记录与会人员表
    /// </summary>
	[Route("api/FO/PreShiftMeetingRecordUser")]
    public partial class PreShiftMeetingRecordUserController : AuthorizeApiController<T_FO_PRE_SHIFT_MEETING_RECORD_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_PRE_SHIFT_MEETING_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_FO_PRE_SHIFT_MEETING_RECORD_USER>> OrderEntities([FromBody]KeywordFilter filter)
       {
           return WitOrderEntities(null, filter);
       }

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

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

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

    }
	#endregion

	#region  Scheduling-工作票排班明细
	/// <summary>
    ///  工作票排班明细
    /// </summary>
	[Route("api/FO/Scheduling")]
    public partial class SchedulingController : AuthorizeApiController<T_FO_SCHEDULING>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_SCHEDULING>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_SCHEDULING> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  SchedulingTemplate-工作票排班模板
	/// <summary>
    ///  工作票排班模板
    /// </summary>
	[Route("api/FO/SchedulingTemplate")]
    public partial class SchedulingTemplateController : AuthorizeApiController<T_FO_SCHEDULING_TEMPLATE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_SCHEDULING_TEMPLATE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_SCHEDULING_TEMPLATE> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  SchedulingTemplateDetail-明细表
	/// <summary>
    ///  明细表
    /// </summary>
	[Route("api/FO/SchedulingTemplateDetail")]
    public partial class SchedulingTemplateDetailController : AuthorizeApiController<T_FO_SCHEDULING_TEMPLATE_DETAIL>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_SCHEDULING_TEMPLATE_DETAIL>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  TeamActivity-班组安全活动记录表
	/// <summary>
    ///  班组安全活动记录表
    /// </summary>
	[Route("api/FO/TeamActivity")]
    public partial class TeamActivityController : AuthorizeApiController<T_FO_TEAM_ACTIVITY>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_TEAM_ACTIVITY>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_TEAM_ACTIVITY> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  TeamActivityFile-班组安全活动附件
	/// <summary>
    ///  班组安全活动附件
    /// </summary>
	[Route("api/FO/TeamActivityFile")]
    public partial class TeamActivityFileController : AuthorizeApiController<T_FO_TEAM_ACTIVITY_FILE>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_TEAM_ACTIVITY_FILE>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  TeamActivityUser-班组安全活动人员表
	/// <summary>
    ///  班组安全活动人员表
    /// </summary>
	[Route("api/FO/TeamActivityUser")]
    public partial class TeamActivityUserController : AuthorizeApiController<T_FO_TEAM_ACTIVITY_USER>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_TEAM_ACTIVITY_USER>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

    }
	#endregion

	#region  TeamSlogan-班组口号配置
	/// <summary>
    ///  班组口号配置
    /// </summary>
	[Route("api/FO/TeamSlogan")]
    public partial class TeamSloganController : AuthorizeApiController<T_FO_TEAM_SLOGAN>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_TEAM_SLOGAN>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_TEAM_SLOGAN> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  TechDisclosureFrom-技术交底表
	/// <summary>
    ///  技术交底表
    /// </summary>
	[Route("api/FO/TechDisclosureFrom")]
    public partial class TechDisclosureFromController : AuthorizeApiController<T_FO_TECH_DISCLOSURE_FROM>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_TECH_DISCLOSURE_FROM>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_TECH_DISCLOSURE_FROM> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

	#region  TechDisclosurePerson-被交底人员表
	/// <summary>
    ///  被交底人员表
    /// </summary>
	[Route("api/FO/TechDisclosurePerson")]
    public partial class TechDisclosurePersonController : AuthorizeApiController<T_FO_TECH_DISCLOSURE_PERSON>
    {   
       /// <summary>
       /// 查询所有数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Entities")]
       public JsonActionResult<IEnumerable<T_FO_TECH_DISCLOSURE_PERSON>> Entities([FromBody]KeywordFilter filter)
       {
           return WitEntities(null, filter);
       }

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

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

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

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

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

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

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

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

       /// <summary>
       /// 获得单条实体数据
       /// </summary>
       /// <param name="filter">过滤实体</param>
       /// <returns></returns>
       [HttpPost, Route("Get")]
       public JsonActionResult<T_FO_TECH_DISCLOSURE_PERSON> Get([FromBody] KeywordFilter filter)
       {
           return WitEntity(null, filter);
       }
       

    }
	#endregion

 }