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

安全检查从检查清单触发

Browse Source
This commit is contained in:
何美荣 2026-05-06 11:09:04 +08:00
parent d4d0a03474
commit ec8698ed3b
21 changed files with 289417 additions and 146460 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139645
APT.Data.Migrations/Migrations/20260506030816_hmr2026050601.Designer.cs generated Normal file
View File

File diff suppressed because it is too large Load Diff

34
APT.Data.Migrations/Migrations/20260506030816_hmr2026050601.cs Normal file
View File

@ -0,0 +1,34 @@
using Microsoft.EntityFrameworkCore.Migrations;
namespace APT.Data.Migrations.Migrations
{
public partial class hmr2026050601 : Migration
{
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.AddColumn<int>(
name: "ADD_TYPE",
table: "T_SK_CHECK_SET",
type: "int",
nullable: true);
migrationBuilder.AddColumn<bool>(
name: "IS_SEND",
table: "T_SK_CHECK_SET",
type: "bit",
nullable: false,
defaultValue: false);
}
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropColumn(
name: "ADD_TYPE",
table: "T_SK_CHECK_SET");
migrationBuilder.DropColumn(
name: "IS_SEND",
table: "T_SK_CHECK_SET");
}
}
}

6
APT.Data.Migrations/Migrations/MigrationContextModelSnapshot.cs
View File

@ -78641,6 +78641,9 @@ namespace APT.Data.Migrations.Migrations
.ValueGeneratedOnAdd() .ValueGeneratedOnAdd()
.HasColumnType("uniqueidentifier"); .HasColumnType("uniqueidentifier");
b.Property<int?>("ADD_TYPE")
.HasColumnType("int");
b.Property<int>("CHECK_CYCLE") b.Property<int>("CHECK_CYCLE")
.HasColumnType("int"); .HasColumnType("int");
@ -78680,6 +78683,9 @@ namespace APT.Data.Migrations.Migrations
b.Property<bool>("IS_DELETED") b.Property<bool>("IS_DELETED")
.HasColumnType("bit"); .HasColumnType("bit");
b.Property<bool>("IS_SEND")
.HasColumnType("bit");
b.Property<Guid?>("MODIFIER_ID") b.Property<Guid?>("MODIFIER_ID")
.HasColumnType("uniqueidentifier"); .HasColumnType("uniqueidentifier");

1
APT.MS.Data/Mapping/T4/T4Map.cs
View File

@ -13736,6 +13736,7 @@ builder.Ignore(t => t.TYPE_NAME);
builder.Ignore(t => t.DEPART_NAME); builder.Ignore(t => t.DEPART_NAME);
builder.Ignore(t => t.MINE_NAME); builder.Ignore(t => t.MINE_NAME);
builder.Ignore(t => t.PRODUCTION_UNIT_ID); builder.Ignore(t => t.PRODUCTION_UNIT_ID);
builder.Ignore(t => t.USER_ID);
} }
} }
#endregion #endregion

9
APT.MS.Domain/Entities/SK/T_SK_CHECK_SET.cs
View File

@ -81,7 +81,12 @@ namespace APT.MS.Domain.Entities.SK
[FormFieldEdit] [FormFieldEdit]
public ICollection<T_SK_CHECK_SET_USER> Nav_CheckUsers { get; set; } public ICollection<T_SK_CHECK_SET_USER> Nav_CheckUsers { get; set; }
[Description("是否自动触发")] [Description("是否自动触发")]
public bool IS_AUTO { get; set; } = false; public bool IS_AUTO { get; set; } = false;
[Description("来源")]
[EnumName("SKAddTypeEnum")]
public SKAddTypeEnum? ADD_TYPE { get; set; }
[Description("是否触发")]
public bool IS_SEND { get; set; } = false;
} }
} }

6
APT.MS.Domain/Entities/SK/T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART.cs
View File

@ -111,6 +111,10 @@ namespace APT.MS.Domain.Entities.SK
[DataFieldIngore] [DataFieldIngore]
public Guid? PRODUCTION_UNIT_ID { get; set; } public Guid? PRODUCTION_UNIT_ID { get; set; }
[DataFieldIngore]
public string USER_ID { get; set; }
} }
} }

7
APT.MS.Domain/Enums/SK/SKEnums.cs
View File

@ -485,5 +485,12 @@ namespace APT.MS.Domain.Enums.SK
OK = 0, OK = 0,
[Description("不同意销号")] [Description("不同意销号")]
NO = 10, NO = 10,
}
public enum SKAddTypeEnum
{
[Description("企业库同步")]
企业库同步 = 0,
[Description("手动新增")]
手动新增 = 1,
} }
} }

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

File diff suppressed because it is too large Load Diff

13998
APT.MicroApi/APT.BS.WebApi/Controllers/Api/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

@ -1,142 +1,151 @@
 
//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//------------------------------------------------------------------------------
using APT.Infrastructure.Core;
using Microsoft.AspNetCore.Mvc; //------------------------------------------------------------------------------
using System.Collections.Generic; // T4模板文件：基础接口类
using APT.Utility; // 此代码由T4模板自动生成
using APT.Infrastructure.Api; // 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
using APT.BaseData.Domain.ApiModel.PF; //------------------------------------------------------------------------------
namespace APT.LG.WebApi.Controllers.Api 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.LG.WebApi.Controllers.Api
{
using APT.BaseData.Domain.Entities.LG; using APT.BaseData.Domain.Entities.LG;
#region Oprate-表单操作日志表
/// <summary> #region Oprate-表单操作日志表
/// 表单操作日志表 /// <summary>
/// </summary> /// 表单操作日志表
[Route("api/LG/Oprate")] /// </summary>
public partial class OprateController : AuthorizeApiController<T_LG_OPRATE> [Route("api/LG/Oprate")]
{ public partial class OprateController : AuthorizeApiController<T_LG_OPRATE>
/// <summary> {
/// 查询所有数据 /// <summary>
/// </summary> /// 查询所有数据
/// <param name="filter">过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="filter">过滤实体</param>
[HttpPost, Route("Entities")] /// <returns></returns>
public JsonActionResult<IEnumerable<T_LG_OPRATE>> Entities([FromBody]KeywordFilter filter) [HttpPost, Route("Entities")]
{ public JsonActionResult<IEnumerable<T_LG_OPRATE>> Entities([FromBody]KeywordFilter filter)
return WitEntities(null, filter); {
} return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据 /// <summary>
/// </summary> /// 排序查询所有数据
/// <param name="filter">过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> OrderEntities([FromBody]KeywordFilter filter) [HttpPost, Route("OrderEntities")]
{ public JsonActionResult<IEnumerable<T_LG_OPRATE>> OrderEntities([FromBody]KeywordFilter filter)
return WitOrderEntities(null, filter); {
} return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据 /// <summary>
/// </summary> /// 分页查询数据
/// <param name="pageFilter">分页过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="pageFilter">分页过滤实体</param>
[HttpPost, Route("Paged")] /// <returns></returns>
public PagedActionResult<T_LG_OPRATE> Paged([FromBody]KeywordPageFilter pageFilter) [HttpPost, Route("Paged")]
{ public PagedActionResult<T_LG_OPRATE> Paged([FromBody]KeywordPageFilter pageFilter)
return WitPaged(null, pageFilter); {
} return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据 /// <summary>
/// </summary> /// 排序分页查询数据
/// <param name="pageFilter">分页过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="pageFilter">分页过滤实体</param>
[HttpPost, Route("OrderPaged")] /// <returns></returns>
public PagedActionResult<T_LG_OPRATE> OrderPaged([FromBody]KeywordPageFilter pageFilter) [HttpPost, Route("OrderPaged")]
{ public PagedActionResult<T_LG_OPRATE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
return WitOrderPaged(null, pageFilter); {
} return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据 /// <summary>
/// </summary> /// 根据主键删除数据
/// <param name="id">主键ID</param> /// </summary>
/// <returns></returns> /// <param name="id">主键ID</param>
[HttpGet, Route("Delete")] /// <returns></returns>
public JsonActionResult<bool> Delete(string id) [HttpGet, Route("Delete")]
{ public JsonActionResult<bool> Delete(string id)
return WitRealDelete(id); {
} return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据 /// <summary>
/// </summary> /// 更新或新增数据
/// <param name="entity">对象实体</param> /// </summary>
/// <returns></returns> /// <param name="entity">对象实体</param>
[HttpPost, Route("Update")] /// <returns></returns>
public JsonActionResult<bool> Update([FromBody]T_LG_OPRATE entity) [HttpPost, Route("Update")]
{ public JsonActionResult<bool> Update([FromBody]T_LG_OPRATE entity)
return WitUpdate(entity); {
} return WitUpdate(entity);
}
/// <summary>
/// 批量更新 /// <summary>
/// </summary> /// 批量更新
/// <param name="entity">对象实体</param> /// </summary>
/// <returns></returns> /// <param name="entity">对象实体</param>
[HttpPost, Route("BatchUpdate")] /// <returns></returns>
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_LG_OPRATE> entity) [HttpPost, Route("BatchUpdate")]
{ public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_LG_OPRATE> entity)
return WitBantchUpdate(entity?.Data); {
} return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据 /// <summary>
/// </summary> /// 批量删除数据
/// <param name="ids">id字符串（id用逗号分隔）</param> /// </summary>
/// <returns></returns> /// <param name="ids">id字符串（id用逗号分隔）</param>
[HttpGet, Route("BatchDelete")] /// <returns></returns>
public JsonActionResult<bool> BatchDelete(string ids) [HttpGet, Route("BatchDelete")]
{ public JsonActionResult<bool> BatchDelete(string ids)
return WitRealBatchDelete(ids); {
} return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据 /// <summary>
/// </summary> /// 获得单条实体数据
/// <param name="filter">过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="filter">过滤实体</param>
[HttpPost, Route("Get")] /// <returns></returns>
public JsonActionResult<T_LG_OPRATE> Get([FromBody] KeywordFilter filter) [HttpPost, Route("Get")]
{ public JsonActionResult<T_LG_OPRATE> Get([FromBody] KeywordFilter filter)
return WitEntity(null, filter); {
} return WitEntity(null, filter);
}
}
#endregion
} }
#endregion
}

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

@ -1,381 +1,395 @@
 
//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
// 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
//------------------------------------------------------------------------------
using APT.Infrastructure.Core;
using Microsoft.AspNetCore.Mvc; //------------------------------------------------------------------------------
using System.Collections.Generic; // T4模板文件：基础接口类
using APT.Utility; // 此代码由T4模板自动生成
using APT.Infrastructure.Api; // 对此文件的更改可能会导致不正确的行为，并且如果重新生成代码，这些更改将会丢失。
using APT.BaseData.Domain.ApiModel.PF; //------------------------------------------------------------------------------
namespace APT.NW.WebApi.Controllers.Api 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.NW.WebApi.Controllers.Api
{
using APT.BaseData.Domain.Entities.NW; using APT.BaseData.Domain.Entities.NW;
#region Enterprise-子企业表
/// <summary> #region Enterprise-子企业表
/// 子企业表 /// <summary>
/// </summary> /// 子企业表
[Route("api/NW/Enterprise")] /// </summary>
public partial class EnterpriseController : AuthorizeTreeApiController<T_NW_ENTERPRISE> [Route("api/NW/Enterprise")]
{ public partial class EnterpriseController : AuthorizeTreeApiController<T_NW_ENTERPRISE>
/// <summary> {
/// 查询所有数据 /// <summary>
/// </summary> /// 查询所有数据
/// <param name="filter">过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="filter">过滤实体</param>
[HttpPost, Route("Entities")] /// <returns></returns>
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> Entities([FromBody]KeywordFilter filter) [HttpPost, Route("Entities")]
{ public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> Entities([FromBody]KeywordFilter filter)
return WitEntities(null, filter); {
} return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据 /// <summary>
/// </summary> /// 排序查询所有数据
/// <param name="filter">过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> OrderEntities([FromBody]KeywordFilter filter) [HttpPost, Route("OrderEntities")]
{ public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> OrderEntities([FromBody]KeywordFilter filter)
return WitOrderEntities(null, filter); {
} return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据 /// <summary>
/// </summary> /// 分页查询数据
/// <param name="pageFilter">分页过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="pageFilter">分页过滤实体</param>
[HttpPost, Route("Paged")] /// <returns></returns>
public PagedActionResult<T_NW_ENTERPRISE> Paged([FromBody]KeywordPageFilter pageFilter) [HttpPost, Route("Paged")]
{ public PagedActionResult<T_NW_ENTERPRISE> Paged([FromBody]KeywordPageFilter pageFilter)
return WitPaged(null, pageFilter); {
} return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据 /// <summary>
/// </summary> /// 排序分页查询数据
/// <param name="pageFilter">分页过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="pageFilter">分页过滤实体</param>
[HttpPost, Route("OrderPaged")] /// <returns></returns>
public PagedActionResult<T_NW_ENTERPRISE> OrderPaged([FromBody]KeywordPageFilter pageFilter) [HttpPost, Route("OrderPaged")]
{ public PagedActionResult<T_NW_ENTERPRISE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
return WitOrderPaged(null, pageFilter); {
} return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据 /// <summary>
/// </summary> /// 根据主键删除数据
/// <param name="id">主键ID</param> /// </summary>
/// <returns></returns> /// <param name="id">主键ID</param>
[HttpGet, Route("Delete")] /// <returns></returns>
public JsonActionResult<bool> Delete(string id) [HttpGet, Route("Delete")]
{ public JsonActionResult<bool> Delete(string id)
return WitRealDelete(id); {
} return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据 /// <summary>
/// </summary> /// 更新或新增数据
/// <param name="entity">对象实体</param> /// </summary>
/// <returns></returns> /// <param name="entity">对象实体</param>
[HttpPost, Route("Update")] /// <returns></returns>
public JsonActionResult<bool> Update([FromBody]T_NW_ENTERPRISE entity) [HttpPost, Route("Update")]
{ public JsonActionResult<bool> Update([FromBody]T_NW_ENTERPRISE entity)
return WitUpdate(entity); {
} return WitUpdate(entity);
}
/// <summary>
/// 批量更新 /// <summary>
/// </summary> /// 批量更新
/// <param name="entity">对象实体</param> /// </summary>
/// <returns></returns> /// <param name="entity">对象实体</param>
[HttpPost, Route("BatchUpdate")] /// <returns></returns>
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ENTERPRISE> entity) [HttpPost, Route("BatchUpdate")]
{ public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ENTERPRISE> entity)
return WitBantchUpdate(entity?.Data); {
} return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据 /// <summary>
/// </summary> /// 批量删除数据
/// <param name="ids">id字符串（id用逗号分隔）</param> /// </summary>
/// <returns></returns> /// <param name="ids">id字符串（id用逗号分隔）</param>
[HttpGet, Route("BatchDelete")] /// <returns></returns>
public JsonActionResult<bool> BatchDelete(string ids) [HttpGet, Route("BatchDelete")]
{ public JsonActionResult<bool> BatchDelete(string ids)
return WitRealBatchDelete(ids); {
} return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据 /// <summary>
/// </summary> /// 获得单条实体数据
/// <param name="filter">过滤实体</param> /// </summary>
/// <returns></returns> /// <param name="filter">过滤实体</param>
[HttpPost, Route("Get")] /// <returns></returns>
public JsonActionResult<T_NW_ENTERPRISE> Get([FromBody] KeywordFilter filter) [HttpPost, Route("Get")]
{ public JsonActionResult<T_NW_ENTERPRISE> Get([FromBody] KeywordFilter filter)
return WitEntity(null, filter); {
} return WitEntity(null, filter);
}
/// <summary>
/// 获得树形实体数据
/// </summary> /// <summary>
/// <param name="filter"></param> /// 获得树形实体数据
/// <returns></returns> /// </summary>
[HttpPost, Route("TreeData")] /// <param name="filter"></param>
public JsonActionResult<IEnumerable<TreeNode<T_NW_ENTERPRISE>>> TreeData([FromBody] KeywordFilter filter) /// <returns></returns>
{ [HttpPost, Route("TreeData")]
return WitTreeOrderEntities(null, filter); public JsonActionResult<IEnumerable<TreeNode<T_NW_ENTERPRISE>>> TreeData([FromBody] KeywordFilter filter)
} {
return WitTreeOrderEntities(null, filter);
}
}
#endregion
}
#region RoleDataPerm-子企业数据权限表 #endregion
/// <summary>
/// 子企业数据权限表
/// </summary>
[Route("api/NW/RoleDataPerm")] #region RoleDataPerm-子企业数据权限表
public partial class RoleDataPermController : AuthorizeApiController<T_NW_ROLE_DATA_PERM> /// <summary>
{ /// 子企业数据权限表
/// <summary> /// </summary>
/// 查询所有数据 [Route("api/NW/RoleDataPerm")]
/// </summary> public partial class RoleDataPermController : AuthorizeApiController<T_NW_ROLE_DATA_PERM>
/// <param name="filter">过滤实体</param> {
/// <returns></returns> /// <summary>
[HttpPost, Route("Entities")] /// 查询所有数据
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> Entities([FromBody]KeywordFilter filter) /// </summary>
{ /// <param name="filter">过滤实体</param>
return WitEntities(null, filter); /// <returns></returns>
} [HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> Entities([FromBody]KeywordFilter filter)
/// <summary> {
/// 排序查询所有数据 return WitEntities(null, filter);
/// </summary> }
/// <param name="filter">过滤实体</param>
/// <returns></returns> /// <summary>
/// 排序查询所有数据
[HttpPost, Route("OrderEntities")] /// </summary>
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> OrderEntities([FromBody]KeywordFilter filter) /// <param name="filter">过滤实体</param>
{ /// <returns></returns>
return WitOrderEntities(null, filter);
} [HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> OrderEntities([FromBody]KeywordFilter filter)
/// <summary> {
/// 分页查询数据 return WitOrderEntities(null, filter);
/// </summary> }
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <summary>
[HttpPost, Route("Paged")] /// 分页查询数据
public PagedActionResult<T_NW_ROLE_DATA_PERM> Paged([FromBody]KeywordPageFilter pageFilter) /// </summary>
{ /// <param name="pageFilter">分页过滤实体</param>
return WitPaged(null, pageFilter); /// <returns></returns>
} [HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> Paged([FromBody]KeywordPageFilter pageFilter)
/// <summary> {
/// 排序分页查询数据 return WitPaged(null, pageFilter);
/// </summary> }
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns> /// <summary>
[HttpPost, Route("OrderPaged")] /// 排序分页查询数据
public PagedActionResult<T_NW_ROLE_DATA_PERM> OrderPaged([FromBody]KeywordPageFilter pageFilter) /// </summary>
{ /// <param name="pageFilter">分页过滤实体</param>
return WitOrderPaged(null, pageFilter); /// <returns></returns>
} [HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> OrderPaged([FromBody]KeywordPageFilter pageFilter)
/// <summary> {
/// 根据主键删除数据 return WitOrderPaged(null, pageFilter);
/// </summary> }
/// <param name="id">主键ID</param>
/// <returns></returns> /// <summary>
[HttpGet, Route("Delete")] /// 根据主键删除数据
public JsonActionResult<bool> Delete(string id) /// </summary>
{ /// <param name="id">主键ID</param>
return WitRealDelete(id); /// <returns></returns>
} [HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
/// <summary> {
/// 更新或新增数据 return WitRealDelete(id);
/// </summary> }
/// <param name="entity">对象实体</param>
/// <returns></returns> /// <summary>
[HttpPost, Route("Update")] /// 更新或新增数据
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_DATA_PERM entity) /// </summary>
{ /// <param name="entity">对象实体</param>
return WitUpdate(entity); /// <returns></returns>
} [HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_DATA_PERM entity)
/// <summary> {
/// 批量更新 return WitUpdate(entity);
/// </summary> }
/// <param name="entity">对象实体</param>
/// <returns></returns> /// <summary>
[HttpPost, Route("BatchUpdate")] /// 批量更新
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_DATA_PERM> entity) /// </summary>
{ /// <param name="entity">对象实体</param>
return WitBantchUpdate(entity?.Data); /// <returns></returns>
} [HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_DATA_PERM> entity)
/// <summary> {
/// 批量删除数据 return WitBantchUpdate(entity?.Data);
/// </summary> }
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns> /// <summary>
[HttpGet, Route("BatchDelete")] /// 批量删除数据
public JsonActionResult<bool> BatchDelete(string ids) /// </summary>
{ /// <param name="ids">id字符串（id用逗号分隔）</param>
return WitRealBatchDelete(ids); /// <returns></returns>
} [HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
/// <summary> {
/// 获得单条实体数据 return WitRealBatchDelete(ids);
/// </summary> }
/// <param name="filter">过滤实体</param>
/// <returns></returns> /// <summary>
[HttpPost, Route("Get")] /// 获得单条实体数据
public JsonActionResult<T_NW_ROLE_DATA_PERM> Get([FromBody] KeywordFilter filter) /// </summary>
{ /// <param name="filter">过滤实体</param>
return WitEntity(null, filter); /// <returns></returns>
} [HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_DATA_PERM> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
} }
#endregion
#region RoleMenu-子企业权限表
/// <summary> }
/// 子企业权限表 #endregion
/// </summary>
[Route("api/NW/RoleMenu")]
public partial class RoleMenuController : AuthorizeApiController<T_NW_ROLE_MENU>
{ #region RoleMenu-子企业权限表
/// <summary> /// <summary>
/// 查询所有数据 /// 子企业权限表
/// </summary> /// </summary>
/// <param name="filter">过滤实体</param> [Route("api/NW/RoleMenu")]
/// <returns></returns> public partial class RoleMenuController : AuthorizeApiController<T_NW_ROLE_MENU>
[HttpPost, Route("Entities")] {
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> Entities([FromBody]KeywordFilter filter) /// <summary>
{ /// 查询所有数据
return WitEntities(null, filter); /// </summary>
} /// <param name="filter">过滤实体</param>
/// <returns></returns>
/// <summary> [HttpPost, Route("Entities")]
/// 排序查询所有数据 public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> Entities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="filter">过滤实体</param> return WitEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("OrderEntities")] /// <summary>
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> OrderEntities([FromBody]KeywordFilter filter) /// 排序查询所有数据
{ /// </summary>
return WitOrderEntities(null, filter); /// <param name="filter">过滤实体</param>
} /// <returns></returns>
/// <summary> [HttpPost, Route("OrderEntities")]
/// 分页查询数据 public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> OrderEntities([FromBody]KeywordFilter filter)
/// </summary> {
/// <param name="pageFilter">分页过滤实体</param> return WitOrderEntities(null, filter);
/// <returns></returns> }
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ROLE_MENU> Paged([FromBody]KeywordPageFilter pageFilter) /// <summary>
{ /// 分页查询数据
return WitPaged(null, pageFilter); /// </summary>
} /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
/// <summary> [HttpPost, Route("Paged")]
/// 排序分页查询数据 public PagedActionResult<T_NW_ROLE_MENU> Paged([FromBody]KeywordPageFilter pageFilter)
/// </summary> {
/// <param name="pageFilter">分页过滤实体</param> return WitPaged(null, pageFilter);
/// <returns></returns> }
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ROLE_MENU> OrderPaged([FromBody]KeywordPageFilter pageFilter) /// <summary>
{ /// 排序分页查询数据
return WitOrderPaged(null, pageFilter); /// </summary>
} /// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
/// <summary> [HttpPost, Route("OrderPaged")]
/// 根据主键删除数据 public PagedActionResult<T_NW_ROLE_MENU> OrderPaged([FromBody]KeywordPageFilter pageFilter)
/// </summary> {
/// <param name="id">主键ID</param> return WitOrderPaged(null, pageFilter);
/// <returns></returns> }
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id) /// <summary>
{ /// 根据主键删除数据
return WitRealDelete(id); /// </summary>
} /// <param name="id">主键ID</param>
/// <returns></returns>
/// <summary> [HttpGet, Route("Delete")]
/// 更新或新增数据 public JsonActionResult<bool> Delete(string id)
/// </summary> {
/// <param name="entity">对象实体</param> return WitRealDelete(id);
/// <returns></returns> }
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_MENU entity) /// <summary>
{ /// 更新或新增数据
return WitUpdate(entity); /// </summary>
} /// <param name="entity">对象实体</param>
/// <returns></returns>
/// <summary> [HttpPost, Route("Update")]
/// 批量更新 public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_MENU entity)
/// </summary> {
/// <param name="entity">对象实体</param> return WitUpdate(entity);
/// <returns></returns> }
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_MENU> entity) /// <summary>
{ /// 批量更新
return WitBantchUpdate(entity?.Data); /// </summary>
} /// <param name="entity">对象实体</param>
/// <returns></returns>
/// <summary> [HttpPost, Route("BatchUpdate")]
/// 批量删除数据 public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_MENU> entity)
/// </summary> {
/// <param name="ids">id字符串（id用逗号分隔）</param> return WitBantchUpdate(entity?.Data);
/// <returns></returns> }
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids) /// <summary>
{ /// 批量删除数据
return WitRealBatchDelete(ids); /// </summary>
} /// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
/// <summary> [HttpGet, Route("BatchDelete")]
/// 获得单条实体数据 public JsonActionResult<bool> BatchDelete(string ids)
/// </summary> {
/// <param name="filter">过滤实体</param> return WitRealBatchDelete(ids);
/// <returns></returns> }
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_MENU> Get([FromBody] KeywordFilter filter) /// <summary>
{ /// 获得单条实体数据
return WitEntity(null, filter); /// </summary>
} /// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_MENU> Get([FromBody] KeywordFilter filter)
} {
#endregion return WitEntity(null, filter);
}
}
}
#endregion
}

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

492
APT.MicroApi/APT.PP.WebApi/Controllers/Api/SKController.cs
View File

@ -71,7 +71,12 @@ namespace APT.PP.WebApi.Controllers.Api
public string CheckPost { get; set; } public string CheckPost { get; set; }
public Guid? CheckPostId { get; set; } public Guid? CheckPostId { get; set; }
public List<CheckListDetail> details { get; set; } public List<CheckListDetail> details { get; set; }
public List<CheckListUser> users { get; set; }
}
public class CheckListUser
{
public Guid? USER_ID { get; set; }
} }
public class CheckListDetail public class CheckListDetail
{ {
@ -6029,12 +6034,14 @@ namespace APT.PP.WebApi.Controllers.Api
{ {
try try
{ {
var deleteHidIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS_HIDDEN>(t => true, new BaseFilter(filter.OrgId)).Select(m => m.ID).ToList(); //var deleteHidIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS_HIDDEN>(t => true, new BaseFilter(filter.OrgId)).Select(m => m.ID).ToList();
var deleteConIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS>(t => true, new BaseFilter(filter.OrgId)).Select(m => m.ID).ToList(); var deleteSetIds = this.GetEntities<T_SK_CHECK_SET>(t => t.ADD_TYPE == SKAddTypeEnum.企业库同步, new BaseFilter(filter.OrgId)).Select(m => m.ID).ToList();
var deleteSetIds = this.GetEntities<T_SK_CHECK_SET>(t => true, new BaseFilter(filter.OrgId)).Select(m => m.ID).ToList(); var deleteConIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS>(t => deleteSetIds.Contains(t.CHECK_SET_ID), new BaseFilter(filter.OrgId)).Select(m => m.ID).ToList();
var deleteUserIds = this.GetEntities<T_SK_CHECK_SET_USER>(t => deleteSetIds.Contains(t.CHECK_SET_ID), new BaseFilter(filter.OrgId)).Select(m => m.ID).ToList();
List<T_SK_CHECK_SET> sets = new List<T_SK_CHECK_SET>(); List<T_SK_CHECK_SET> sets = new List<T_SK_CHECK_SET>();
List<T_SK_CHECK_SET_CONTENTS> setContents = new List<T_SK_CHECK_SET_CONTENTS>(); List<T_SK_CHECK_SET_CONTENTS> setContents = new List<T_SK_CHECK_SET_CONTENTS>();
List<T_SK_CHECK_SET_CONTENTS_HIDDEN> setConHiddens = new List<T_SK_CHECK_SET_CONTENTS_HIDDEN>(); List<T_SK_CHECK_SET_USER> setUsers = new List<T_SK_CHECK_SET_USER>();
//List<T_SK_CHECK_SET_CONTENTS_HIDDEN> setConHiddens = new List<T_SK_CHECK_SET_CONTENTS_HIDDEN>();
List<CheckListNew> list = new List<CheckListNew>(); List<CheckListNew> list = new List<CheckListNew>();
List<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART> conDepartlist = new List<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>(); List<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART> conDepartlist = new List<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>();
var departs = this.GetEntities<T_FM_DEPARTMENT>(t => t.ENABLE_STATUS == 0, new BaseFilter(filter.OrgId), "Nav_User"); var departs = this.GetEntities<T_FM_DEPARTMENT>(t => t.ENABLE_STATUS == 0, new BaseFilter(filter.OrgId), "Nav_User");
@ -6053,6 +6060,8 @@ namespace APT.PP.WebApi.Controllers.Api
var libContentIds = libraryDetails.Select(t => t.ID).ToList(); var libContentIds = libraryDetails.Select(t => t.ID).ToList();
//检查层级 //检查层级
var contentDeparts = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>(t => !t.IS_DELETED && libContentIds.Contains(t.ENTERPRISE_LIBRARY_DETAIL_CONTENT_ID), new BaseFilter(filter.OrgId), "Nav_CheckType", "Nav_Department").ToList(); var contentDeparts = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>(t => !t.IS_DELETED && libContentIds.Contains(t.ENTERPRISE_LIBRARY_DETAIL_CONTENT_ID), new BaseFilter(filter.OrgId), "Nav_CheckType", "Nav_Department").ToList();
var conDepartIds = contentDeparts.Select(t => t.ID).ToList();
var contentDepartUsers = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_USER>(t => !t.IS_DELETED && conDepartIds.Contains(t.ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART_ID), new BaseFilter(filter.OrgId)).ToList();
//隐患描述 //隐患描述
//var contentHiddens = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN>(t => !t.IS_DELETED, new BaseFilter(filter.OrgId)).ToList(); //var contentHiddens = this.GetEntities<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_HIDDEN>(t => !t.IS_DELETED, new BaseFilter(filter.OrgId)).ToList();
//辨识岗位 //辨识岗位
@ -6064,6 +6073,8 @@ namespace APT.PP.WebApi.Controllers.Api
{ {
foreach (var item in contentDeparts) foreach (var item in contentDeparts)
{ {
var departUsers = contentDepartUsers.Where(t => t.ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART_ID == item.ID).Select(m => m.USER_ID).ToList();
var departUserIds = string.Join(",", departUsers);
var conFirst = contents.FirstOrDefault(t => t.ID == item.ENTERPRISE_LIBRARY_DETAIL_CONTENT_ID); var conFirst = contents.FirstOrDefault(t => t.ID == item.ENTERPRISE_LIBRARY_DETAIL_CONTENT_ID);
var detailFirst = libraryDetails.FirstOrDefault(t => t.ID == conFirst?.ENTERPRISE_LIBRARY_DETAIL_ID); var detailFirst = libraryDetails.FirstOrDefault(t => t.ID == conFirst?.ENTERPRISE_LIBRARY_DETAIL_ID);
var libFirst = librarys.FirstOrDefault(t => t.ID == detailFirst?.ENTERPRISE_LIBRARY_ID); var libFirst = librarys.FirstOrDefault(t => t.ID == detailFirst?.ENTERPRISE_LIBRARY_ID);
@ -6090,6 +6101,7 @@ namespace APT.PP.WebApi.Controllers.Api
de.DEPART_NAME = item.Nav_Department?.NAME; de.DEPART_NAME = item.Nav_Department?.NAME;
de.POST_ID = item2.POST_ID; de.POST_ID = item2.POST_ID;
de.POST_NAME = item2.Nav_Post?.NAME; de.POST_NAME = item2.Nav_Post?.NAME;
de.USER_ID = departUserIds;
conDepartlist.Add(de); conDepartlist.Add(de);
} }
} }
@ -6134,6 +6146,7 @@ namespace APT.PP.WebApi.Controllers.Api
de.DEPART_NAME = item.Nav_Department?.NAME; de.DEPART_NAME = item.Nav_Department?.NAME;
de.POST_ID = userInfo?.Nav_Person?.POST_ID; de.POST_ID = userInfo?.Nav_Person?.POST_ID;
de.POST_NAME = item.POST_NAME; de.POST_NAME = item.POST_NAME;
de.USER_ID = departUserIds;
conDepartlist.Add(de); conDepartlist.Add(de);
} }
} }
@ -6182,6 +6195,34 @@ namespace APT.PP.WebApi.Controllers.Api
} }
listNew.details = listDetail.GroupBy(n => new { n.RISK_AREA_ID, n.RISK_NAME, n.CHECK_CONTENTS_ID }).Select(g => g.FirstOrDefault()).OrderBy(t => t.RISK_AREA_NAME).ThenBy(m => m.RISK_NAME).ToList(); listNew.details = listDetail.GroupBy(n => new { n.RISK_AREA_ID, n.RISK_NAME, n.CHECK_CONTENTS_ID }).Select(g => g.FirstOrDefault()).OrderBy(t => t.RISK_AREA_NAME).ThenBy(m => m.RISK_NAME).ToList();
} }
var depatUserIds = conDepartlist.Where(t => t.DEPARTMENT_ID == item.Key.DEPARTMENT_ID && t.CHECK_TYPE_ID == item.Key.CHECK_TYPE_ID && t.CHECK_TYPE == item.Key.CHECK_TYPE && t.CHECK_CYCLE == item.Key.CHECK_CYCLE && t.PRODUCTION_UNIT_ID == item.Key.PRODUCTION_UNIT_ID && t.POST_NAME == item.Key.POST_NAME && t.POST_ID == item.Key.POST_ID).Select(m => m.USER_ID).ToList();
var depatUserIdList = new List<string>();
if (depatUserIds != null && depatUserIds.Any())
{
foreach (var tem in depatUserIds)
{
var tempUsers = tem.Split(",").ToList();
foreach (var tem2 in depatUserIds)
{
if (!string.IsNullOrEmpty(tem2))
{
depatUserIdList.Add(tem2);
}
}
}
depatUserIdList = depatUserIdList.Distinct().ToList();
}
if (depatUserIdList != null && depatUserIdList.Any())
{
List<CheckListUser> listUser = new List<CheckListUser>();
foreach (var tem in depatUserIdList)
{
CheckListUser user = new CheckListUser();
user.USER_ID = Guid.Parse(tem);
listUser.Add(user);
}
listNew.users = listUser.Distinct(m => m.USER_ID).ToList();
}
list.Add(listNew); list.Add(listNew);
} }
list = list.OrderBy(y => y.PRODUCTION_UNIT_ID).ThenBy(x => x.Num).ThenBy(n => n.CheckDepart).ToList(); list = list.OrderBy(y => y.PRODUCTION_UNIT_ID).ThenBy(x => x.Num).ThenBy(n => n.CheckDepart).ToList();
@ -6199,7 +6240,20 @@ namespace APT.PP.WebApi.Controllers.Api
set.CHECK_CYCLE = item.Cycle; set.CHECK_CYCLE = item.Cycle;
set.CHECK_TYPE = item.DepartType; set.CHECK_TYPE = item.DepartType;
set.POST_NAME = item.CheckPost; set.POST_NAME = item.CheckPost;
set.ADD_TYPE = SKAddTypeEnum.企业库同步;
set.IS_SEND = true;
sets.Add(set); sets.Add(set);
if (item.users != null && item.users.Any())
{
foreach (var item2 in item.users)
{
T_SK_CHECK_SET_USER user = new T_SK_CHECK_SET_USER();
user.ORG_ID = filter.OrgId;
user.CHECK_SET_ID = set.ID;
user.USER_ID = item2.USER_ID;
setUsers.Add(user);
}
}
if (item.details != null && item.details.Any()) if (item.details != null && item.details.Any())
{ {
var i = 1; var i = 1;
@ -6247,8 +6301,10 @@ namespace APT.PP.WebApi.Controllers.Api
} }
UnifiedCommit(() => UnifiedCommit(() =>
{ {
if (deleteHidIds != null && deleteHidIds.Any()) //if (deleteHidIds != null && deleteHidIds.Any())
BantchDeleteEntityNoCommit<T_SK_CHECK_SET_CONTENTS_HIDDEN>(deleteHidIds); // BantchDeleteEntityNoCommit<T_SK_CHECK_SET_CONTENTS_HIDDEN>(deleteHidIds);
if (deleteUserIds != null && deleteUserIds.Any())
BantchDeleteEntityNoCommit<T_SK_CHECK_SET_USER>(deleteUserIds);
if (deleteConIds != null && deleteConIds.Any()) if (deleteConIds != null && deleteConIds.Any())
BantchDeleteEntityNoCommit<T_SK_CHECK_SET_CONTENTS>(deleteConIds); BantchDeleteEntityNoCommit<T_SK_CHECK_SET_CONTENTS>(deleteConIds);
if (deleteSetIds != null && deleteSetIds.Any()) if (deleteSetIds != null && deleteSetIds.Any())
@ -6257,6 +6313,8 @@ namespace APT.PP.WebApi.Controllers.Api
BantchSaveEntityNoCommit(sets); BantchSaveEntityNoCommit(sets);
if (setContents != null && setContents.Any()) if (setContents != null && setContents.Any())
BantchSaveEntityNoCommit(setContents); BantchSaveEntityNoCommit(setContents);
if (setUsers != null && setUsers.Any())
BantchSaveEntityNoCommit(setUsers);
//if (setConHiddens != null && setConHiddens.Any()) //if (setConHiddens != null && setConHiddens.Any())
// BantchSaveEntityNoCommit(setConHiddens); // BantchSaveEntityNoCommit(setConHiddens);
}); });
@ -6270,6 +6328,426 @@ namespace APT.PP.WebApi.Controllers.Api
} }
return true; return true;
}); });
}
/// <summary>
/// 从检查清单触发安全检查通知
/// </summary>
/// <param name="pageFilter"></param>
/// <returns></returns>
[HttpPost, Route("CheckContentSet")]
public JsonActionResult<bool> CheckContentSet([FromBody] KeywordFilter filter)
{
return SafeExecute<bool>(() =>
{
try
{
var dtNow = DateTime.Now;
var year = dtNow.Year;
var month = dtNow.Month;
var day = dtNow.Day;
var week = dtNow.DayOfWeek;
List<T_SK_PLAN_SET> setList = new List<T_SK_PLAN_SET>();
//查配置表，有配才执行
var timeSets = GetEntities<T_SK_PLAN_SET>(i => i.ENABLE_STATUS == 0, new BaseFilter(filter.OrgId)).ToList();
if (timeSets != null && timeSets.Any())
{
foreach (var set in timeSets)
{
switch (set.CHECK_CYCLE)
{
case SKPLANCHECKFREQUENCYEnum.Year:
if (set.MONTH == month && set.DATA == day)
{
setList.Add(set);
}
break;
case SKPLANCHECKFREQUENCYEnum.HalfYear:
if ((set.MONTH == month && set.DATA == day) || ((set.MONTH + 6) == month && (set.DATA + 183) == day))
{
setList.Add(set);
}
break;
case SKPLANCHECKFREQUENCYEnum.Date:
setList.Add(set);
break;
//case SKPLANCHECKFREQUENCYEnum.Class:
// setList.Add(set);
break;
case SKPLANCHECKFREQUENCYEnum.Week:
if (set.WEEKDATA != null && (int)set.WEEKDATA.Value == (int)week)
{
setList.Add(set);
}
break;
case SKPLANCHECKFREQUENCYEnum.Month:
if (set.DATA == day)
{
setList.Add(set);
}
break;
case SKPLANCHECKFREQUENCYEnum.Quarter:
if (set.MONTH == 1)
{
if ((month == 1 || month == 4 || month == 7 || month == 10) && set.DATA == day)
{
setList.Add(set);
}
}
if (set.MONTH == 2)
{
if ((month == 2 || month == 5 || month == 8 || month == 11) && set.DATA == day)
{
setList.Add(set);
}
}
if (set.MONTH == 3)
{
if ((month == 3 || month == 6 || month == 9 || month == 12) && set.DATA == day)
{
setList.Add(set);
}
}
break;
default:
break;
}
}
}
List<T_FM_NOTIFICATION_TASK> notices = new List<T_FM_NOTIFICATION_TASK>();
List<T_SK_SECURITY_INSPECTION_NOTICE> safeNotices = new List<T_SK_SECURITY_INSPECTION_NOTICE>();
List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL> safeDetialNotices = new List<T_SK_SECURITY_INSPECTION_NOTICE_DETAIL>();
List<T_SK_SECURITY_INSPECTION_RECORD> records = new List<T_SK_SECURITY_INSPECTION_RECORD>();
List<T_SK_SECURITY_INSPECTION_RECORD_DETAIL> recordDetails = new List<T_SK_SECURITY_INSPECTION_RECORD_DETAIL>();
List<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER> recordDetailUsers = new List<T_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER>();
List<CheckListNew> list = new List<CheckListNew>();
List<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART> conDepartlist = new List<T_SK_ENTERPRISE_LIBRARY_DETAIL_CONTENT_DEPART>();
if (setList != null && setList.Any())
{
var departs = this.GetEntities<T_FM_DEPARTMENT>(t => t.ENABLE_STATUS == 0, new BaseFilter(filter.OrgId), "Nav_User");
var users = this.GetEntities<T_FM_USER>(t => t.ENABLE_STATUS == 0 && t.DEPARTMENT_ID != null && !t.CODE.Contains("admin") && t.Nav_Person != null, new BaseFilter(filter.OrgId), "Nav_Person.Nav_Post", "Nav_ApproveRole");
var checkCycles = setList.Select(t => t.CHECK_CYCLE).Distinct().ToList();
//检查清单
var sets = this.GetEntities<T_SK_CHECK_SET>(t => !t.IS_DELETED && t.IS_SEND == true, new BaseFilter(filter.OrgId), "Nav_Department").ToList();
var setIds = sets.Select(t => t.ID).ToList();
//子表
var setDetails = this.GetEntities<T_SK_CHECK_SET_CONTENTS>(t => !t.IS_DELETED && setIds.Contains(t.CHECK_SET_ID), new BaseFilter(filter.OrgId)).ToList();
var setDetailIds = setDetails.Select(t => t.CHECK_CONTENTS_ID).ToList();
//取检查人
var setUsers = this.GetEntities<T_SK_CHECK_SET_USER>(t => !t.IS_DELETED && setIds.Contains(t.CHECK_SET_ID), new BaseFilter(filter.OrgId)).ToList();
//检查内容
var contents = this.GetEntities<T_SK_CHECK_CONTENTS>(t => !t.IS_DELETED && setDetailIds.Contains(t.ID), new BaseFilter(filter.OrgId)).ToList();
var libContentIds = contents.Select(t => t.ID).ToList();
//检查依据
var contentBasics = this.GetEntities<T_SK_CHECK_CONTENTS_BASIC>(t => !t.IS_DELETED && libContentIds.Contains((Guid)t.CHECK_CONTENTS_ID), new BaseFilter(filter.OrgId)).ToList();
//隐患描述
var contentHiddens = this.GetEntities<T_SK_CHECK_QUESTION>(t => !t.IS_DELETED && libContentIds.Contains((Guid)t.CHECK_CONTENTS_ID), new BaseFilter(filter.OrgId)).ToList();
//岗位排查
var checkTypes = this.GetEntities<T_SK_CHECK_TYPE>(t => true, new BaseFilter(filter.OrgId)).ToList();
var checkTypeIds = checkTypes.Where(t => t.NAME == "岗位排查").Select(x => x.ID).ToList();
var productions = this.GetEntities<T_FM_USER_PRODUCTION_UNIT_SET>(t => !t.IS_DELETED, new BaseFilter(filter.OrgId)).ToList();
if (filter.Parameter1 != null)
{
dtNow = DateTime.Parse(filter.Parameter1);
}
//提前一个小时触发
DateTime minTime = dtNow.AddMinutes(0);
DateTime maxTime = dtNow.AddMinutes(60);
var shiftClassList = this.GetEntities<T_FM_DEPARTMENT_SCHEDULING>(s => s.START_TIME >= minTime && s.START_TIME <= maxTime && s.START_TIME != s.END_TIME && s.Nav_Team.ENABLE_STATUS == 0 && s.TEAM_ID != null, new BaseFilter(filter.OrgId), "Nav_DepartmentSchedulingDetail.Nav_Person").ToList();
var teamIds = shiftClassList.Select(t => t.TEAM_ID).Distinct().ToList();
var teamInfos = this.GetEntities<T_FM_TEAM>(t => teamIds.Contains(t.ID), new BaseFilter(filter.OrgId));
var teamDepartIds = teamInfos.Select(m => m.DEPARTMENT_ID).Distinct().ToList();
//所有有排班的人员
var personIds = new List<Guid>();
if (shiftClassList != null && shiftClassList.Any())
{
foreach (var item in shiftClassList)
{
if (item.Nav_DepartmentSchedulingDetail != null && item.Nav_DepartmentSchedulingDetail.Any())
{
var ids = item.Nav_DepartmentSchedulingDetail.Select(t => t.PERSON_ID).Distinct().ToList();
personIds.AddRange(ids);
}
}
}
var baseFilter = new BaseFilter(filter.GetOrgId());
baseFilter.IgnoreDataRule = true;
baseFilter.SelectField = new string[] { "PRODUCTION_UNIT_ID", "CHECK_TYPE_ID", "APPLY_DEPARTMENT_ID", "APPLY_USER_ID", "PLANCHECKFREQUENCY", "DEPARTMENT_TYPE", "CREATE_TIME" }; //指定字段，包括导航属性
Expression<Func<T_SK_SECURITY_INSPECTION_NOTICE, bool>> expression = i => i.IS_DELETED == false && (i.CREATE_TIME.Value.Date == dtNow.Date || i.CREATE_TIME.Value.Date == dtNow.AddDays(-1).Date);
List<T_SK_SECURITY_INSPECTION_NOTICE> noticeExsiss = this.GetOrderEntities(expression, baseFilter).ToList();
baseFilter.SelectField = new string[] { "PRODUCTION_UNIT_ID", "CHECK_TYPE_ID", "APPLY_DEPARTMENT_ID", "APPLY_USER_ID", "PLANCHECKFREQUENCY", "DEPARTMENT_TYPE", "CREATE_TIME" };
Expression<Func<T_SK_SECURITY_INSPECTION_RECORD, bool>> expressionR = i => i.IS_DELETED == false && (i.CREATE_TIME.Value.Date == dtNow.Date || i.CREATE_TIME.Value.Date == dtNow.AddDays(-1).Date);
List<T_SK_SECURITY_INSPECTION_RECORD> recordExsiss = this.GetOrderEntities(expressionR, baseFilter).ToList();
//查有没有休假代理人
var userVacations = this.GetEntities<T_FM_USER_VACATION_SET>(t => t.START_DATE <= dtNow && t.END_DATE >= dtNow, new BaseFilter(filter.GetOrgId()), "Nav_Agent");
//检查清单
if (sets != null && sets.Any())
{
foreach (var item in sets)
{
var departInfo = departs.FirstOrDefault(t => t.ID == item.DEPARTMENT_ID);
var userIds = setUsers.Where(t => t.CHECK_SET_ID == item.ID && t.USER_ID != null).Select(m => (Guid)m.USER_ID).Distinct().ToList();
//触发岗位排查
if (item.CHECK_TYPE_ID != null && checkTypeIds.Contains((Guid)item.CHECK_TYPE_ID))
{
//找检查人
if (userIds == null || !userIds.Any())
{
//没有检查人，根据岗位触发给对应的人，班组级要判断排班
if (item.POST_ID != null)
{
userIds = users.Where(t => t.DEPARTMENT_ID == item.DEPARTMENT_ID && t.Nav_Person != null && t.Nav_Person.POST_ID == item.POST_ID).Select(m => m.ID).ToList();
}
}
//班组级要判断排班
if (departInfo.DEPARTMENT_TYPE == 2)
{
userIds = users.Where(t => userIds.Contains(t.ID) && t.PERSON_ID != null && personIds.Contains((Guid)t.PERSON_ID)).Select(m => m.ID).ToList();
}
userIds = userIds.Distinct().ToList();
if (userIds != null && userIds.Any())
{
foreach (var userId in userIds)
{
//取排班
var teamFirst = teamInfos.FirstOrDefault(t => t.DEPARTMENT_ID == item.DEPARTMENT_ID);
var sche = shiftClassList.FirstOrDefault(t => t.TEAM_ID == teamFirst?.ID);
//触发安全检查记录给对应的岗位工(有排班才触发)
var userInfo = users.FirstOrDefault(t => t.ID == userId);
if (userInfo != null && sche != null)
{
var startTime = sche.START_TIME.AddHours(-1.5);
var startDate = sche.START_TIME.Date.AddDays(-1);
//判断是否重复触发
var exist = recordExsiss.FirstOrDefault(t => t.APPLY_DEPARTMENT_ID == item.DEPARTMENT_ID && t.APPLY_USER_ID == userInfo.ID && t.DEPARTMENT_TYPE == (SKDepartmentTypeEnum)departInfo?.DEPARTMENT_TYPE && t.CHECK_TYPE_ID == item.CHECK_TYPE_ID && t.PLANCHECKFREQUENCY == item.CHECK_CYCLE && t.CREATE_TIME.Value.Date == sche.START_TIME.Date);
if (sche.START_TIME.Date != sche.END_TIME.Date)//跨天
{
recordExsiss.FirstOrDefault(t => t.APPLY_DEPARTMENT_ID == item.DEPARTMENT_ID && t.APPLY_USER_ID == userInfo.ID && t.DEPARTMENT_TYPE == (SKDepartmentTypeEnum)departInfo?.DEPARTMENT_TYPE && t.CHECK_TYPE_ID == item.CHECK_TYPE_ID && t.PLANCHECKFREQUENCY == item.CHECK_CYCLE && t.CREATE_TIME >= startTime && (t.CREATE_TIME.Value.Date == sche.START_TIME.Date || t.CREATE_TIME.Value.Date == startDate));
}
//触发岗位排查表
if (exist == null)
{
T_SK_SECURITY_INSPECTION_RECORD record = new T_SK_SECURITY_INSPECTION_RECORD();
record.ORG_ID = filter.OrgId;
record.APPLY_DEPARTMENT_ID = item.DEPARTMENT_ID;
record.APPLY_USER_ID = userInfo.ID;
record.RECORD_USER_ID = userInfo.ID;
record.CHECK_PERSON = userInfo.NAME;
record.PRODUCTION_UNIT_ID = item.PRODUCTION_UNIT_ID;
record.CHECK_TYPE_ID = item.CHECK_TYPE_ID;
record.PLANCHECKFREQUENCY = item.CHECK_CYCLE;
record.DEPARTMENT_TYPE = (SKDepartmentTypeEnum)departInfo?.DEPARTMENT_TYPE;
record.STATUS = PFStandardStatus.Draft;
record.ISAUTO = true;
record.NOTICE_CODE = "GWPC" + DateTime.Now.ToString("yyyyMMddHH") + new Random().Next(1, 9999);
records.Add(record);
var details = setDetails.Where(t => t.CHECK_CONTENTS_ID == item.ID).ToList();
if (details != null && details.Any())
{
foreach (var item2 in details)
{
var i = 1;
//var repeat = safeDetialNotices.FirstOrDefault(t => t.SECURITY_INSPECTION_NOTICE_ID == safeNotice.ID && t.RISK_AREA_ID == item2.AREA_ID && t.CHECK_CONTENTS_ID == item2.CHECK_CONTENTS_ID);
//if (repeat == null)
{
T_SK_SECURITY_INSPECTION_RECORD_DETAIL detail = new T_SK_SECURITY_INSPECTION_RECORD_DETAIL();
detail.ORG_ID = filter.OrgId;
detail.SECURITY_INSPECTION_RECORD_ID = record.ID;
detail.RISK_AREA_ID = item2.AREA_ID;
detail.CHECK_CONTENTS_ID = item2.CHECK_CONTENTS_ID;
detail.CHECKCONTENT = item2.CHECK_CONTENT;
detail.CHECKSTANDARD = item2.CHECK_STANDARD;
detail.NUM = i;
recordDetails.Add(detail);
i++;
T_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER deUser = new T_SK_SECURITY_INSPECTION_RECORD_DETAIL_USER();
deUser.ORG_ID = filter.OrgId;
deUser.SECURITY_INSPECTION_RECORD_DETAIL_ID = detail.ID;
deUser.USER_ID = userInfo.ID;
deUser.ISMAINCHECK = true;
recordDetailUsers.Add(deUser);
}
}
}
var date = DateTime.Now.Month.PadLeft(2, '0') + DateTime.Now.AddHours(4).Day.PadLeft(2, '0');
var endtime = DateTime.Now.AddHours(24);
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.Week)
{
endtime = DateTime.Now.AddDays(7);
}
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.Month)
{
endtime = DateTime.Now.AddMonths(1);
}
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.HalfYear)
{
endtime = DateTime.Now.AddMonths(6);
}
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.Year)
{
endtime = DateTime.Now.AddMonths(12);
}
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.Quarter)
{
endtime = DateTime.Now.AddMonths(3);
}
var notice = NotificationTaskService.InsertUserNoticeTaskModel(userInfo.Nav_Person?.Nav_Post?.NAME + "岗位排查记录" + date, record.ID, filter.OrgId, userInfo.ID, userInfo.NAME, DateTime.Now, endtime, (int)FMNoticeTypeEnum.消息, "SK010");
notices.Add(notice);
}
}
}
}
}
else
{
//找检查人
if (userIds == null || !userIds.Any())
{
//没有检查人，根据审批角色触发给对应的人，班组级要判断排班
if (!string.IsNullOrEmpty(item.POST_NAME))
{
userIds = users.Where(t => t.DEPARTMENT_ID == item.DEPARTMENT_ID && t.Nav_ApproveRole != null && t.Nav_ApproveRole.NAME == item.POST_NAME).Select(m => m.ID).ToList();
if (userIds == null || !userIds.Any())
{
//没有安全员，找部门表负责人字段
var depart = departs.FirstOrDefault(t => t.ID == item.DEPARTMENT_ID && t.USER_ID != null);
if (depart != null)
{
userIds = new List<Guid>();
userIds.Add((Guid)depart.USER_ID);
}
}
}
}
//班组级要判断排班
if (departInfo?.DEPARTMENT_TYPE == 2)
{
var userTempIds = users.Where(t => userIds.Contains(t.ID) && t.PERSON_ID != null && personIds.Contains((Guid)t.PERSON_ID)).Select(m => m.ID).ToList();
if (userTempIds == null || !userTempIds.Any())
{
//查代理人
userIds = userVacations.Where(t => t.USER_ID != null && t.AGENT_ID != null && userIds.Contains((Guid)t.USER_ID)).Select(m => (Guid)m.AGENT_ID).ToList();
}
}
userIds = userIds.Distinct().ToList();
if (userIds != null && userIds.Any())
{
foreach (var userId in userIds)
{
var setTime = setList.FirstOrDefault(t => t.PRODUCTION_UNIT_ID == item.PRODUCTION_UNIT_ID && t.CHECK_CYCLE == item.CHECK_CYCLE);
//判断是否重复触发
var exist = noticeExsiss.FirstOrDefault(t => t.APPLY_DEPARTMENT_ID == item.DEPARTMENT_ID && t.DEPARTMENT_TYPE == (SKDepartmentTypeEnum)departInfo?.DEPARTMENT_TYPE && t.CHECK_TYPE_ID == item.CHECK_TYPE_ID && t.PLANCHECKFREQUENCY == item.CHECK_CYCLE && t.CREATE_TIME.Value.Date == dtNow.Date);
//如果是大夜班，跨天的情况下再判断一次，如果存在，就表示今天已触发，只是创建日期是昨天
if (item.POST_NAME == "班组负责人")
{
//取排班
var teamFirst = teamInfos.FirstOrDefault(t => t.DEPARTMENT_ID == item.DEPARTMENT_ID);
var sche = shiftClassList.FirstOrDefault(t => t.TEAM_ID == teamFirst?.ID);
if (sche != null)
{
var startTime = sche.START_TIME.AddHours(-1.5);
var startDate = sche.START_TIME.Date.AddDays(-1);
if (sche.START_TIME.Date != sche.END_TIME.Date || (sche.START_TIME.Date == sche.END_TIME.Date && sche.START_TIME == sche.START_TIME.Date))//跨天
{
exist = noticeExsiss.FirstOrDefault(t => t.APPLY_DEPARTMENT_ID == item.DEPARTMENT_ID && t.DEPARTMENT_TYPE == (SKDepartmentTypeEnum)departInfo?.DEPARTMENT_TYPE && t.CHECK_TYPE_ID == item.CHECK_TYPE_ID && t.PLANCHECKFREQUENCY == item.CHECK_CYCLE && t.CREATE_TIME >= startTime && (t.CREATE_TIME.Value.Date == sche.START_TIME.Date || t.CREATE_TIME.Value.Date == startDate));
}
}
}
if ((exist == null && item.POST_NAME == "班组负责人") || (exist == null && item.POST_NAME != "班组负责人" && setTime != null && dtNow.Hour == setTime.CHECKTIME.Value.Hour))
{
T_SK_SECURITY_INSPECTION_NOTICE safeNotice = new T_SK_SECURITY_INSPECTION_NOTICE();
safeNotice.ORG_ID = filter.OrgId;
safeNotice.APPLY_DEPARTMENT_ID = item.DEPARTMENT_ID;
safeNotice.APPLY_USER_ID = userId;
safeNotice.PRODUCTION_UNIT_ID = item.PRODUCTION_UNIT_ID;
safeNotice.CHECK_TYPE_ID = item.CHECK_TYPE_ID;
safeNotice.PLANCHECKFREQUENCY = item.CHECK_CYCLE;
safeNotice.DEPARTMENT_TYPE = (SKDepartmentTypeEnum)departInfo?.DEPARTMENT_TYPE;
safeNotice.STATUS = PFStandardStatus.Draft;
safeNotice.ISAUTO = true;
safeNotice.NOTICE_CODE = "JCZD" + DateTime.Now.ToString("yyyyMMddHH") + new Random().Next(1, 9999);
safeNotices.Add(safeNotice);
var details = setDetails.Where(t => t.CHECK_CONTENTS_ID == item.ID).ToList();
if (details != null && details.Any())
{
foreach (var item2 in details)
{
var i = 1;
//var repeat = safeDetialNotices.FirstOrDefault(t => t.SECURITY_INSPECTION_NOTICE_ID == safeNotice.ID && t.RISK_AREA_ID == item2.AREA_ID && t.CHECK_CONTENTS_ID == item2.CHECK_CONTENTS_ID);
//if (repeat == null)
{
T_SK_SECURITY_INSPECTION_NOTICE_DETAIL detail = new T_SK_SECURITY_INSPECTION_NOTICE_DETAIL();
detail.ORG_ID = filter.OrgId;
detail.SECURITY_INSPECTION_NOTICE_ID = safeNotice.ID;
detail.RISK_AREA_ID = item2.AREA_ID;
detail.CHECK_CONTENTS_ID = item2.CHECK_CONTENTS_ID;
detail.CHECKCONTENT = item2.CHECK_CONTENT;
detail.CHECKSTANDARD = item2.CHECK_STANDARD;
detail.NUM = i;
safeDetialNotices.Add(detail);
}
}
}
var date = DateTime.Now.Month.PadLeft(2, '0') + DateTime.Now.AddHours(4).Day.PadLeft(2, '0');
var endtime = DateTime.Now.AddHours(24);
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.Week)
{
endtime = DateTime.Now.AddDays(7);
}
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.Month)
{
endtime = DateTime.Now.AddMonths(1);
}
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.HalfYear)
{
endtime = DateTime.Now.AddMonths(6);
}
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.Year)
{
endtime = DateTime.Now.AddMonths(12);
}
if (item.CHECK_CYCLE == SKPLANCHECKFREQUENCYEnum.Quarter)
{
endtime = DateTime.Now.AddMonths(3);
}
var userName = users.FirstOrDefault(t => t.ID == userId)?.NAME;
var typeName = checkTypes.FirstOrDefault(t => t.ID == item.CHECK_TYPE_ID)?.NAME;
var mineName = productions.FirstOrDefault(t => t.ID == item.PRODUCTION_UNIT_ID)?.NAME;
var notice = NotificationTaskService.InsertUserNoticeTaskModel(mineName + typeName + date, safeNotice.ID, filter.OrgId, userId, userName, DateTime.Now, endtime, (int)FMNoticeTypeEnum.消息, "SK006");
notices.Add(notice);
}
}
}
}
}
}
}
UnifiedCommit(() =>
{
if (notices != null && notices.Any())
BantchSaveEntityNoCommit(notices);
if (safeNotices != null && safeNotices.Any())
BantchSaveEntityNoCommit(safeNotices);
if (safeDetialNotices != null && safeDetialNotices.Any())
BantchSaveEntityNoCommit(safeDetialNotices);
if (records != null && records.Any())
BantchSaveEntityNoCommit(records);
if (recordDetails != null && recordDetails.Any())
BantchSaveEntityNoCommit(recordDetails);
if (recordDetailUsers != null && recordDetailUsers.Any())
BantchSaveEntityNoCommit(recordDetailUsers);
});
}
catch (Exception ex)
{
if (!string.IsNullOrEmpty(ex.StackTrace))
throw new Exception("错误日志：[StackTrace]" + ex.StackTrace);
else
throw new Exception("【" + HttpContext.Request.Path + "】错误日志：[Message]" + ex.Message);
}
return true;
});
} }
} }
} }

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

@ -1,4 +1,9 @@
 
@ -13,6 +18,7 @@
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// T4模板文件：基础接口类 // T4模板文件：基础接口类
@ -28,4 +34,5 @@ using APT.BaseData.Domain.ApiModel.PF;
namespace APT.PP.WebApi.Controllers.Api namespace APT.PP.WebApi.Controllers.Api
{ {
} }

153476
APT.MicroApi/APT.SC.WebApi/Controllers/Api/T4/T4Control.cs
View File

File diff suppressed because it is too large Load Diff

140
APT.MicroApi/APT.SK.WebApi/Controllers/Api/CheckSetController.cs
View File

@ -55,9 +55,9 @@ namespace APT.SK.WebApi.Controllers.Api
{ {
return SafeExecute<bool>(() => return SafeExecute<bool>(() =>
{ {
List<T_SK_CHECK_SET_CONTENTS_HIDDEN> hiddens = new List<T_SK_CHECK_SET_CONTENTS_HIDDEN>(); //List<T_SK_CHECK_SET_CONTENTS_HIDDEN> hiddens = new List<T_SK_CHECK_SET_CONTENTS_HIDDEN>();
List<T_SK_CHECK_SET_CONTENTS_BASIC> basics = new List<T_SK_CHECK_SET_CONTENTS_BASIC>(); //List<T_SK_CHECK_SET_CONTENTS_BASIC> basics = new List<T_SK_CHECK_SET_CONTENTS_BASIC>();
List<T_SK_CHECK_SET_USER> users = new List<T_SK_CHECK_SET_USER>(); List<T_SK_CHECK_SET_USER> checkUserList = new List<T_SK_CHECK_SET_USER>();
//List<T_SK_CHECK_SET_CONTENTS_AREA> areas = new List<T_SK_CHECK_SET_CONTENTS_AREA>(); //List<T_SK_CHECK_SET_CONTENTS_AREA> areas = new List<T_SK_CHECK_SET_CONTENTS_AREA>();
//List<T_SK_CHECK_SET_CONTENTS_AREA_RISK> risks = new List<T_SK_CHECK_SET_CONTENTS_AREA_RISK>(); //List<T_SK_CHECK_SET_CONTENTS_AREA_RISK> risks = new List<T_SK_CHECK_SET_CONTENTS_AREA_RISK>();
var details = entity.Nav_CheckSetContents; var details = entity.Nav_CheckSetContents;
@ -66,48 +66,98 @@ namespace APT.SK.WebApi.Controllers.Api
entity.Nav_CheckUsers = null; entity.Nav_CheckUsers = null;
List<Guid> detailIds = new List<Guid>(); List<Guid> detailIds = new List<Guid>();
List<Guid> deleteCheckUserIds = new List<Guid>(); List<Guid> deleteCheckUserIds = new List<Guid>();
List<Guid> basicIds = new List<Guid>(); //List<Guid> basicIds = new List<Guid>();
deleteCheckUserIds = this.GetEntities<T_SK_CHECK_SET_USER>(t => t.CHECK_SET_ID == entity.ID, new BaseFilter(entity.ORG_ID)).Select(t => t.ID).ToList(); deleteCheckUserIds = this.GetEntities<T_SK_CHECK_SET_USER>(t => t.CHECK_SET_ID == entity.ID, new BaseFilter(entity.ORG_ID)).Select(t => t.ID).ToList();
detailIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS>(t => t.CHECK_SET_ID == entity.ID, new BaseFilter(entity.ORG_ID)).Select(t => t.ID).ToList(); detailIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS>(t => t.CHECK_SET_ID == entity.ID, new BaseFilter(entity.ORG_ID)).Select(t => t.ID).ToList();
basicIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS_BASIC>(t => detailIds.Contains(t.CHECK_CONTENTS_SET_ID), new BaseFilter(entity.ORG_ID)).Select(t => t.ID).ToList(); //basicIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS_BASIC>(t => detailIds.Contains(t.CHECK_CONTENTS_SET_ID), new BaseFilter(entity.ORG_ID)).Select(t => t.ID).ToList();
//hiddenIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS_HIDDEN>(t => detailIds.Contains(t.CHECK_CONTENTS_SET_ID), new BaseFilter(entity.ORG_ID)).Select(t => t.ID).ToList(); //hiddenIds = this.GetEntities<T_SK_CHECK_SET_CONTENTS_HIDDEN>(t => detailIds.Contains(t.CHECK_CONTENTS_SET_ID), new BaseFilter(entity.ORG_ID)).Select(t => t.ID).ToList();
var record = this.GetEntity<T_SK_CHECK_SET>(t => t.ID != entity.ID && t.PRODUCTION_UNIT_ID == entity.PRODUCTION_UNIT_ID && t.CHECK_TYPE == entity.CHECK_TYPE && t.CHECK_TYPE_ID == entity.CHECK_TYPE_ID && t.CHECK_CYCLE == entity.CHECK_CYCLE && t.DEPARTMENT_ID == entity.DEPARTMENT_ID); var users = this.GetEntities<T_FM_USER>(t => t.ENABLE_STATUS == 0, new BaseFilter(entity.ORG_ID), "Nav_Person", "Nav_ApproveRole");
if (record != null) if (entity.DEPARTMENT_ID == null)
{ {
throw new Exception("相同检查已存在，请修改检查信息或回到列表页检索"); throw new Exception("检查部门不能为空");
}
if (entity.ADD_TYPE == null)
{
entity.ADD_TYPE = SKAddTypeEnum.手动新增;
}
if (checkUsers != null)
{
checkUsers = checkUsers.Where(t => !t.IS_DELETED).ToList();
} }
if (checkUsers != null && checkUsers.Any()) if (checkUsers != null && checkUsers.Any())
{ {
checkUsers = checkUsers.Where(t => !t.IS_DELETED).ToList(); foreach (var item in checkUsers)
checkUsers.ForEach(t => t.Nav_User = null); {
T_SK_CHECK_SET_USER u = new T_SK_CHECK_SET_USER();
u.ORG_ID = entity.ORG_ID;
u.CHECK_SET_ID = entity.ID;
u.USER_ID = item.USER_ID;
checkUserList.Add(u);
}
if (checkUserList != null && checkUserList.Any())
{
var userIds = checkUserList.Select(t => t.USER_ID).Distinct().ToList();
var departIds = users.Where(t => userIds.Contains(t.ID) && t.DEPARTMENT_ID != null).Select(m => m.DEPARTMENT_ID).Distinct().ToList();
if (departIds.Count > 1)
{
throw new Exception("检查人员只能是相同组织架构，请删除不同部门人员");
}
var userPostIds = users.Where(t => userIds.Contains(t.ID) && t.Nav_Person != null && t.Nav_Person.POST_ID != null).Select(m => m.Nav_Person.POST_ID).Distinct().ToList();
if (userPostIds.Count > 1)
{
throw new Exception("检查人员只能是相同岗位，请删除不同岗位人员");
}
var userPost = users.FirstOrDefault(t => userIds.Contains(t.ID) && t.Nav_Person != null);
entity.POST_ID = userPost?.Nav_Person?.POST_ID;
var userNames = users.Where(t => userIds.Contains(t.ID)).Select(m => m.NAME).Distinct().ToList();
entity.POST_NAME = string.Join(",", userNames);
}
} }
else else
{ {
//默认当前层级安全员，没有就找负责人 //默认当前层级安全员，没有就找负责人
var userId = APT.Infrastructure.Api.AppContext.CurrentSession.UserID; var userPost = users.FirstOrDefault(t => t.DEPARTMENT_ID == entity.DEPARTMENT_ID && t.Nav_ApproveRole != null && t.Nav_ApproveRole.NAME.Contains("安全员") && t.Nav_Person != null);
var departId = APT.Infrastructure.Api.AppContext.CurrentSession.DepartmentID; if (userPost != null)
var userInfo = this.GetEntity<T_FM_USER>(t => t.ENABLE_STATUS == 0 && t.DEPARTMENT_ID == departId && t.Nav_Person!=null && t.Nav_ApproveRole!=null && t.Nav_ApproveRole.NAME.Contains("安全员"));
if (userInfo == null)
{ {
userInfo = this.GetEntity<T_FM_USER>(t => t.ENABLE_STATUS == 0 && t.DEPARTMENT_ID == departId && t.Nav_Person != null && t.Nav_ApproveRole != null && t.Nav_ApproveRole.NAME.Contains("负责人")); entity.POST_ID = userPost?.Nav_Person?.POST_ID;
entity.POST_NAME = userPost?.Nav_ApproveRole?.NAME;
} }
if (userInfo == null) else
{ {
var departUser = this.GetEntity<T_FM_DEPARTMENT>(t => t.ENABLE_STATUS == 0 && t.ID == departId)?.USER_ID; var departPost = this.GetEntity<T_FM_DEPARTMENT>(t => t.ID == entity.DEPARTMENT_ID && t.Nav_User != null && t.Nav_User.Nav_Person != null);
if(departUser!=null) if (departPost != null)
userInfo = this.GetEntity<T_FM_USER>(t => t.ENABLE_STATUS == 0 && t.ID == departUser && t.Nav_Person != null); {
entity.POST_ID = departPost?.Nav_User?.Nav_Person?.POST_ID;
if (departPost?.Nav_User?.Nav_ApproveRole != null)
{
entity.POST_NAME = departPost?.Nav_User?.Nav_ApproveRole?.NAME;
}
else
{
if (departPost.DEPARTMENT_TYPE == 0)
{
entity.POST_NAME = "部门安全员";
}
if (departPost.DEPARTMENT_TYPE == 1)
{
entity.POST_NAME = "车间安全员";
}
if (departPost.DEPARTMENT_TYPE == 2)
{
entity.POST_NAME = "班组负责人";
}
if (departPost.DEPARTMENT_TYPE == 3)
{
entity.POST_NAME = "安环部安全员";
}
}
}
} }
if (userInfo != null) }
{ var record = this.GetEntity<T_SK_CHECK_SET>(t => t.ID != entity.ID && t.MineType == entity.MineType && t.CHECK_TYPE == entity.CHECK_TYPE && t.CHECK_TYPE_ID == entity.CHECK_TYPE_ID && t.CHECK_CYCLE == entity.CHECK_CYCLE && t.DEPARTMENT_ID == entity.DEPARTMENT_ID && t.POST_ID == entity.POST_ID);
T_SK_CHECK_SET_USER newUser = new T_SK_CHECK_SET_USER(); if (record != null)
newUser.ORG_ID = entity.ORG_ID; {
newUser.USER_ID = userInfo.ID; throw new Exception("相同检查表已存在，请修改检查信息或回到列表页检索");
newUser.CHECK_SET_ID = entity.ID;
checkUsers = new List<T_SK_CHECK_SET_USER>();
checkUsers.Add(newUser);
entity.POST_ID = userInfo.Nav_Person?.POST_ID;
}
//throw new Exception("检查人员必须填写");
} }
if (details != null && details.Any()) if (details != null && details.Any())
{ {
@ -125,15 +175,15 @@ namespace APT.SK.WebApi.Controllers.Api
// //conHiddenIds.Add(item2.CHECK_QUESTION_ID); // //conHiddenIds.Add(item2.CHECK_QUESTION_ID);
// } // }
//} //}
if (item.Nav_ContentsBasics != null && item.Nav_ContentsBasics.Any()) //if (item.Nav_ContentsBasics != null && item.Nav_ContentsBasics.Any())
{ //{
foreach (var item2 in item.Nav_ContentsBasics) // foreach (var item2 in item.Nav_ContentsBasics)
{ // {
item2.ORG_ID = entity.ORG_ID; // item2.ORG_ID = entity.ORG_ID;
item2.CHECK_CONTENTS_SET_ID = item.ID; // item2.CHECK_CONTENTS_SET_ID = item.ID;
basics.Add(item2); // basics.Add(item2);
} // }
} //}
//if (item.Nav_ContentsAreas != null && item.Nav_ContentsAreas.Any()) //if (item.Nav_ContentsAreas != null && item.Nav_ContentsAreas.Any())
//{ //{
@ -423,8 +473,8 @@ namespace APT.SK.WebApi.Controllers.Api
details.ForEach(t => { t.Nav_ContentsHiddens = null; t.Nav_ContentsBasics = null; }); details.ForEach(t => { t.Nav_ContentsHiddens = null; t.Nav_ContentsBasics = null; });
this.UnifiedCommit(() => this.UnifiedCommit(() =>
{ {
if (basicIds != null && basicIds.Any()) //if (basicIds != null && basicIds.Any())
this.BantchDeleteEntityNoCommit<T_SK_CHECK_SET_CONTENTS_BASIC>(basicIds); // this.BantchDeleteEntityNoCommit<T_SK_CHECK_SET_CONTENTS_BASIC>(basicIds);
if (deleteCheckUserIds != null && deleteCheckUserIds.Any()) if (deleteCheckUserIds != null && deleteCheckUserIds.Any())
this.BantchDeleteEntityNoCommit<T_SK_CHECK_SET_USER>(deleteCheckUserIds); this.BantchDeleteEntityNoCommit<T_SK_CHECK_SET_USER>(deleteCheckUserIds);
if (detailIds != null && detailIds.Any()) if (detailIds != null && detailIds.Any())
@ -435,10 +485,10 @@ namespace APT.SK.WebApi.Controllers.Api
BantchSaveEntityNoCommit(checkUsers); BantchSaveEntityNoCommit(checkUsers);
if (details != null && details.Any()) if (details != null && details.Any())
BantchSaveEntityNoCommit(details); BantchSaveEntityNoCommit(details);
if (hiddens != null && hiddens.Any()) //if (hiddens != null && hiddens.Any())
BantchSaveEntityNoCommit(hiddens); // BantchSaveEntityNoCommit(hiddens);
if (basics != null && basics.Any()) //if (basics != null && basics.Any())
BantchSaveEntityNoCommit(basics); // BantchSaveEntityNoCommit(basics);
//if (areas != null && areas.Any()) //if (areas != null && areas.Any())
// BantchSaveEntityNoCommit(areas); // BantchSaveEntityNoCommit(areas);
//if (risks != null && risks.Any()) //if (risks != null && risks.Any())

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

File diff suppressed because it is too large Load Diff