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-04-22 17:08:29 +08:00
parent 23ad0c6b7b
commit 2537e129af
24 changed files with 285661 additions and 143410 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
APT.BaseData.Services/Services/FM/FMFlowPermitService.cs
View File

@ -418,6 +418,9 @@ namespace APT.BaseData.Services.Services.FM
var hm = this.GetEntity<T_HM_EVALUATION_PLAN>(t => t.STATUS == FOPreMeetingStatusEnum.归档);
var users = this.GetEntities<T_FM_USER>(t => t.ENABLE_STATUS == 0, new BaseFilter(approveTemp.ORG_ID), "Nav_Department", "Nav_ApproveRole").ToList();//((t.APPROVE_ROLE_ID != null && approveRoles.Contains((Guid)t.APPROVE_ROLE_ID)) || listUserID.Contains(t.ID))
var userVacations = this.GetEntities<T_FM_USER_VACATION_SET>(t => t.START_DATE <= DateTime.Now && t.END_DATE >= DateTime.Now, new BaseFilter(approveTemp.ORG_ID), "Nav_Agent");
var loginUser = users.FirstOrDefault(t => t.ID == loginUserId);
List<Guid> departmentIds = new List<Guid>();
GetDepartmentId((Guid)loginUser.DEPARTMENT_ID, ref departmentIds);
approveTemp.Nav_ApproveTempDetails.ForEach(t =>
{
//var user = users.FirstOrDefault(x => x.APPROVE_ROLE_ID == t.APPROVE_ROLE_ID);
@ -460,8 +463,18 @@ namespace APT.BaseData.Services.Services.FM
detail.Nav_ApproveUser = null;
}
detail.Nav_ApproveRole = t.Nav_ApproveRole;
if (detail.APPROVE_USER_ID == null)
throw new Exception("审批流未找到" + detail.NAME + "，请到用户列表配置对应审批角色");
if (detail.APPROVE_USER_ID == null)
{
var approveRole = this.GetEntity<T_PF_APPROVAL_ROLE>(t => t.ID == detail.APPROVE_ROLE_ID);
if (approveRole != null)
{
var depart = this.GetEntity<T_FM_DEPARTMENT>(t => departmentIds.Contains(t.ID) && t.DEPARTMENT_TYPE == approveRole.DEPARTMENT_TYPE && t.CATEGORY == FMCATEGORY.ACTURE);
if (depart != null)
{
throw new Exception("审批流未找到" + detail.NAME + "，请到用户列表配置对应审批角色");
}
}
}
if (detail.APPROVE_USER_ID != null)
appdetails.Add(detail);
});

79
APT.BaseData.Services/Services/PF/PFApproveCallBackService.cs
View File

@ -2490,22 +2490,73 @@ namespace APT.BaseData.Services.DomainServices
entity.STATUS = PFStandardStatus.Archived;
entity.FIRE_STATUS = FOFireStatus.ApprovingFinish;
T_FM_NOTIFICATION_TASK notice = null;
T_FO_TECH_DISCLOSURE_FROM_SAFE formSafe = null;
var tech = new T_FO_TECH_DISCLOSURE_FROM();
var techUsers = new List<T_FO_TECH_DISCLOSURE_PERSON>();
//触发技术交底表给施工单位负责人
if (entity.FIRE_USER_ID != null)
{
var sendUser = this.GetEntity<T_FM_USER>(t => t.ID == entity.FIRE_USER_ID);
if (sendUser != null)
{
formSafe = new T_FO_TECH_DISCLOSURE_FROM_SAFE();
formSafe.ORG_ID = entity.ORG_ID;
formSafe.FIRE_JOB_ID = entity.ID;
formSafe.USER_ID = sendUser.ID;
formSafe.DISCLOSURE_DATE = DateTime.Now;
formSafe.DEPARTMENT_ID = sendUser.DEPARTMENT_ID;
formSafe.CODE = "AQJD" + DateTime.Now.ToShortDateString().Replace("/", "") + new Random().Next(1, 999);
notice = NotificationTaskService.InsertUserNoticeTaskModel("安全技术交底表", formSafe.ID, entity.ORG_ID, sendUser.ID, sendUser.NAME, DateTime.Now,
DateTime.Now.AddHours(24), (int)FMNoticeTypeEnum.消息, "FO037");
{ //触发技术交底表
var techForm = this.GetEntity<T_FO_TECH_DISCLOSURE_FROM>(t => t.FIRE_JOB_ID == entity.ID);
if (techForm == null)
{
//取审批流水码
var sysFilter = new SystemCodeFilter();
sysFilter.CodeType = (int)PFCodeRuleType.技术交底表编号;
sysFilter.Count = 1;
sysFilter.OrgId = entity.ORG_ID;
var codes = CodeRuleService.NewGenSerial(sysFilter);
var codeList = codes.Split(new char[] { ',' });
//主表
tech.CODE = codeList[0];
tech.ORG_ID = entity.ORG_ID;
tech.OPERATION_STEP_ID = entity.OPERATION_STEP_ID;
tech.FIRE_JOB_ID = entity.ID;
tech.JOB_LOCATION = entity.JOB_LOCATION;
tech.DISCLOSURE_PERSON_ID = sendUser.ID;
tech.IS_AUTO = (int)ISImportantEnum.是;
tech.IS_OUTSOURCE = false;
tech.RELATED_ID = null;
if (entity.SAFE_USER_ID != null)
{
T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
person.ORG_ID = entity.ORG_ID;
person.USER_ID = entity.SAFE_USER_ID;
person.TECH_DISCLOSURE_FROM_ID = tech.ID;
person.CREATER_ID = entity.CREATER_ID;
techUsers.Add(person);
}
if (entity.Nav_Users != null && entity.Nav_Users.Any())
{
entity.Nav_Users.ForEach(t =>
{
T_FO_TECH_DISCLOSURE_PERSON person = new T_FO_TECH_DISCLOSURE_PERSON();
person.ORG_ID = t.ORG_ID;
person.USER_ID = t.USER_ID;
person.TECH_DISCLOSURE_FROM_ID = tech.ID;
person.CREATER_ID = t.CREATER_ID;
techUsers.Add(person);
});
}
techUsers = techUsers.Where(m => m.USER_ID != null).Distinct(t => t.USER_ID).ToList();
notice = NotificationTaskService.InsertUserNoticeTaskModel("安全技术交底表", tech.ID, entity.ORG_ID, sendUser.ID, sendUser.NAME, DateTime.Now,
DateTime.Now.AddHours(24), (int)FMNoticeTypeEnum.消息, "FO019");
}
else
{
entity.STATUS = PFStandardStatus.Archived;
tech = null; techUsers = null;
}
//formSafe = new T_FO_TECH_DISCLOSURE_FROM_SAFE();
//formSafe.ORG_ID = entity.ORG_ID;
//formSafe.FIRE_JOB_ID = entity.ID;
//formSafe.USER_ID = sendUser.ID;
//formSafe.DISCLOSURE_DATE = DateTime.Now;
//formSafe.DEPARTMENT_ID = sendUser.DEPARTMENT_ID;
//formSafe.CODE = "AQJD" + DateTime.Now.ToShortDateString().Replace("/", "") + new Random().Next(1, 999);
}
}
//if (entity.JOB_DATE.Value.AddMinutes(-30) <= DateTime.Now && entity.IS_RUN == false && entity.Nav_Users != null && entity.Nav_Users.Any())
@ -2535,8 +2586,10 @@ namespace APT.BaseData.Services.DomainServices
BantchSaveEntityNoCommit(listTaskNext);
if (entity != null)
this.UpdateEntityNoCommit(entity);
if (formSafe != null)
this.UpdateEntityNoCommit(formSafe);
if (tech != null)
this.UpdateEntityNoCommit(tech);
if (techUsers != null && techUsers.Count > 0)
BantchSaveEntityNoCommit(techUsers);
if (notice != null)
this.UpdateEntityNoCommit(notice);
});

139300
APT.Data.Migrations/Migrations/20260422090706_hmr2026042201.Designer.cs generated Normal file
View File

File diff suppressed because it is too large Load Diff

45
APT.Data.Migrations/Migrations/20260422090706_hmr2026042201.cs Normal file
View File

@ -0,0 +1,45 @@
using System;
using Microsoft.EntityFrameworkCore.Migrations;
namespace APT.Data.Migrations.Migrations
{
public partial class hmr2026042201 : Migration
{
protected override void Up(MigrationBuilder migrationBuilder)
{
migrationBuilder.AddColumn<Guid>(
name: "FIRE_JOB_ID",
table: "T_FO_TECH_DISCLOSURE_FROM",
type: "uniqueidentifier",
nullable: true);
migrationBuilder.CreateIndex(
name: "IX_T_FO_TECH_DISCLOSURE_FROM_FIRE_JOB_ID",
table: "T_FO_TECH_DISCLOSURE_FROM",
column: "FIRE_JOB_ID");
migrationBuilder.AddForeignKey(
name: "FK_T_FO_TECH_DISCLOSURE_FROM_T_FO_FIRE_JOB_FIRE_JOB_ID",
table: "T_FO_TECH_DISCLOSURE_FROM",
column: "FIRE_JOB_ID",
principalTable: "T_FO_FIRE_JOB",
principalColumn: "ID",
onDelete: ReferentialAction.Restrict);
}
protected override void Down(MigrationBuilder migrationBuilder)
{
migrationBuilder.DropForeignKey(
name: "FK_T_FO_TECH_DISCLOSURE_FROM_T_FO_FIRE_JOB_FIRE_JOB_ID",
table: "T_FO_TECH_DISCLOSURE_FROM");
migrationBuilder.DropIndex(
name: "IX_T_FO_TECH_DISCLOSURE_FROM_FIRE_JOB_ID",
table: "T_FO_TECH_DISCLOSURE_FROM");
migrationBuilder.DropColumn(
name: "FIRE_JOB_ID",
table: "T_FO_TECH_DISCLOSURE_FROM");
}
}
}

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

@ -38856,6 +38856,9 @@ namespace APT.Data.Migrations.Migrations
b.Property<int>("ENTITY_ORG_TPYE")
.HasColumnType("int");
b.Property<Guid?>("FIRE_JOB_ID")
.HasColumnType("uniqueidentifier");
b.Property<Guid?>("FLOW_ID")
.HasColumnType("uniqueidentifier");
@ -38912,6 +38915,8 @@ namespace APT.Data.Migrations.Migrations
b.HasIndex("DISCLOSURE_PERSON_ID");
b.HasIndex("FIRE_JOB_ID");
b.HasIndex("JOB_NAME_ID");
b.HasIndex("JOB_NAME_OUTSOURCE_ID");
@ -112717,6 +112722,11 @@ namespace APT.Data.Migrations.Migrations
.HasForeignKey("DISCLOSURE_PERSON_ID")
.OnDelete(DeleteBehavior.Restrict);
b.HasOne("APT.MS.Domain.Entities.FO.T_FO_FIRE_JOB", "Nav_FireJob")
.WithMany()
.HasForeignKey("FIRE_JOB_ID")
.OnDelete(DeleteBehavior.Restrict);
b.HasOne("APT.MS.Domain.Entities.FO.T_FO_CRUCIAL_LICENSE_JOB", "Nav_JobName")
.WithMany()
.HasForeignKey("JOB_NAME_ID")
@ -112742,6 +112752,8 @@ namespace APT.Data.Migrations.Migrations
b.Navigation("Nav_DisclosurePerson");
b.Navigation("Nav_FireJob");
b.Navigation("Nav_JobName");
b.Navigation("Nav_JobNameOut");

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

@ -1805,6 +1805,7 @@ builder.Ignore(t => t.PUBLISH);
builder.Ignore(t => t.IS_OVERTIME);
builder.Ignore(t => t.CONTEXT);
builder.Property(t => t.PARENT_NAME).HasMaxLength(500);
builder.Ignore(t => t.USER_NAME);
}
}
#endregion
@ -2296,6 +2297,7 @@ builder.HasOne(t => t.Nav_ImgFile).WithMany().HasForeignKey(t => t.IMG_FILE_ID).
builder.Property(t => t.CODE).HasMaxLength(100);
builder.HasOne(t => t.Nav_OperationStep).WithMany().HasForeignKey(t => t.OPERATION_STEP_ID).OnDelete(DeleteBehavior.Restrict);
builder.HasOne(t => t.Nav_JobName).WithMany().HasForeignKey(t => t.JOB_NAME_ID).OnDelete(DeleteBehavior.Restrict);
builder.HasOne(t => t.Nav_FireJob).WithMany().HasForeignKey(t => t.FIRE_JOB_ID).OnDelete(DeleteBehavior.Restrict);
builder.HasOne(t => t.Nav_JobNameOut).WithMany().HasForeignKey(t => t.JOB_NAME_OUTSOURCE_ID).OnDelete(DeleteBehavior.Restrict);
builder.Property(t => t.JOB_LOCATION).HasMaxLength(500);
builder.HasOne(t => t.Nav_DisclosurePerson).WithMany().HasForeignKey(t => t.DISCLOSURE_PERSON_ID).OnDelete(DeleteBehavior.Restrict);

6
APT.MS.Domain/Entities/FO/T_FO_JOB_EVENT_RECORD.cs
View File

@ -92,6 +92,10 @@ namespace APT.MS.Domain.Entities.FO
public string CONTEXT { get; set; }
[Description("部门名称")]
public string PARENT_NAME { get; set; }
public string PARENT_NAME { get; set; }
[Description("作业人员")]
[DataFieldIngore]
public string USER_NAME { get; set; }
}
}

12
APT.MS.Domain/Entities/FO/T_FO_TECH_DISCLOSURE_FROM.cs
View File

@ -49,7 +49,19 @@ namespace APT.MS.Domain.Entities.FO
[Description("导航属性：关键许可工作票")]
public T_FO_CRUCIAL_LICENSE_JOB Nav_JobName { get; set; }
/// <summary>
/// 动火工作票
/// </summary>
[Description("动火工作票")]
[DataFieldForeignKey("Nav_FireJob")]
[FormFieldEdit]
public Guid? FIRE_JOB_ID { get; set; }
/// <summary>
/// 导航属性：动火工作票
/// </summary>
[Description("导航属性：动火工作票")]
public T_FO_FIRE_JOB Nav_FireJob { get; set; }
/// <summary>
/// 关键许可工作票

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

9
APT.MicroApi/APT.FO.WebApi/Controllers/JobEventRecordController.cs
View File

@ -757,7 +757,7 @@ namespace APT.FO.WebApi.Controllers
var manageDepartId = this.GetEntity<T_FM_USER>(t => t.Nav_ApproveRole != null && t.Nav_ApproveRole.NAME == "安环部负责人" && t.ENABLE_STATUS == 0)?.DEPARTMENT_ID;
if (loginUserCode == "admin" || loginDepartmentId == manageDepartId)
{
result = this.GetOrderPageEntities<T_FO_JOB_EVENT_RECORD>(null, pageFilter, "Nav_CreateUser");
result = this.GetOrderPageEntities<T_FO_JOB_EVENT_RECORD>(null, pageFilter, "Nav_CreateUser", "Nav_JobEventPerson.Nav_User");
}
else
{
@ -766,7 +766,7 @@ namespace APT.FO.WebApi.Controllers
DepartmentService.GetDepartmentIds(pageFilter.OrgId.Value, departmentId, ref departmentIds);
if (departmentIds != null && departmentIds.Any())
{
result = this.GetOrderPageEntities<T_FO_JOB_EVENT_RECORD>(t => t.Nav_CreateUser.DEPARTMENT_ID != null && departmentIds.Contains(t.Nav_CreateUser.DEPARTMENT_ID.Value), pageFilter, "Nav_CreateUser");//|| dataIds.Contains(t.ID)
result = this.GetOrderPageEntities<T_FO_JOB_EVENT_RECORD>(t => t.Nav_CreateUser.DEPARTMENT_ID != null && departmentIds.Contains(t.Nav_CreateUser.DEPARTMENT_ID.Value), pageFilter, "Nav_CreateUser", "Nav_JobEventPerson.Nav_User");//|| dataIds.Contains(t.ID)
}
else
result.Data = null;
@ -781,6 +781,11 @@ namespace APT.FO.WebApi.Controllers
var depart = GetDEPARTMENTLevel(departments, (Guid)t.Nav_CreateUser.DEPARTMENT_ID);
t.PARENT_NAME = depart?.NAME;
}
if (t.Nav_JobEventPerson != null && t.Nav_JobEventPerson.Any())
{
var names = t.Nav_JobEventPerson.Select(m => m.Nav_User?.NAME).ToList();
t.USER_NAME = string.Join(", ", names);
}
});
if (filter != null && !string.IsNullOrEmpty(filter.Value.ToString()))
result.Data = result.Data.Where(t => t.PARENT_NAME != null && t.PARENT_NAME.Contains(filter.Value.ToString()));

6
APT.MicroApi/APT.FO.WebApi/Controllers/PreShiftMeetingRecordController.cs
View File

@ -144,8 +144,10 @@ namespace APT.FO.WebApi.Controllers.Api.FO
if (entity.DEPARTMENT_ID == null)
{
var user = GetEntity<T_FM_USER>(t => t.ID == userID);
if (user != null)
entity.DEPARTMENT_ID = user.DEPARTMENT_ID;
if (user != null)
{
entity.DEPARTMENT_ID = GetEntity<T_FM_DEPARTMENT>(t => t.ID == user.DEPARTMENT_ID)?.PARENT_ID;
}
}
if (entity.USER_ID == null)
{

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

File diff suppressed because it is too large Load Diff

87
APT.MicroApi/APT.FO.WebApi/Controllers/TechDisclosureFromController.cs
View File

@ -134,11 +134,62 @@ namespace APT.FO.WebApi.Controllers
t.Nav_RelatedUser = null; t.Nav_User = null;
});
}
T_FO_FIRE_JOB job = null;
if (entity.PUBLISH != null && entity.PUBLISH.Equals("SaveAndNotify"))
{
if (entity.DISCLOSURE_DATE == null || entity.DISCLOSURE_DATE == DateTime.Parse("0001-01-01 00:00:00"))
throw new Exception("交底时间必需填写");
if (entity.IS_OUTSOURCE == true && entity.RELATED_ID != null)
if (entity.FIRE_JOB_ID != null)
{
persons.ForEach(t =>
{
t.RELATED_USER_ID = null;
if (t.USER_ID == loginUserId)
t.DEAL_STATUS = FOUserShiftStatusEnum.已处理;
});
//新增的消息通知
var userIds = persons.Where(m => m.USER_ID != null && m.USER_ID != loginUserId).Select(t => (Guid)t.USER_ID).Distinct().ToList();
if (userIds != null && userIds.Any())
{
entity.FORM_STATUS = (int)FOTeamActivityState.签到中;
var UserNames = new List<string>();
var user = this.GetEntities<T_FM_USER>(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && userIds.Contains(t.ID), new BaseFilter(entity.ORG_ID));
foreach (var u in userIds)
{
var current = user.FirstOrDefault(t => t.ID == u);
UserNames.Add(current?.NAME);
}
//发消息
DateTime dtEnd = NotificationTaskService.GetTaskEndTime(FMTASKTYPE.JobSite, entity.ORG_ID.Value, DateTime.Now, null, null);
notices = NotificationTaskService.InsertUserNoticeTaskModels("安全技术交底表确认", entity.ID, entity.ORG_ID, userIds, UserNames, DateTime.Now,
dtEnd, (int)FMNoticeTypeEnum.消息, "FO019_SHOWPRINT");
}
else
{
job = this.GetEntity<T_FO_FIRE_JOB>(t => t.ID == entity.FIRE_JOB_ID);
if (job != null)
{
entity.FORM_STATUS = (int)FOTeamActivityState.已归档;
job.IS_RUN = true;
job.FIRE_STATUS = FOFireStatus.Sign;
var jobUsers = this.GetEntities<T_FO_FIRE_JOB_USER>(t => t.FIRE_JOB_ID == job.ID, new BaseFilter(job.ORG_ID));
var userType = this.GetEntity<T_OG_RELATED_USER_TYPE>(t => t.NAME == "动火操作人员");
var sendUser = jobUsers.FirstOrDefault(t => t.USER_TYPE_ID == userType.ID);
if (sendUser != null)
{
var userName = this.GetEntity<T_FM_USER>(t => t.ID == sendUser.USER_ID)?.NAME;
var notice = NotificationTaskService.InsertUserNoticeTaskModel("动火作业现场条件验收", job.ID, job.ORG_ID, (Guid)sendUser.USER_ID, userName, DateTime.Now,
DateTime.Now.AddHours(24), (int)FMNoticeTypeEnum.消息, "FO043_1");
notices.Add(notice);
}
}
else
{
throw new Exception("未找到动火作业工作票，请联系管理员排查");
}
}
}
else if (entity.IS_OUTSOURCE == true && entity.RELATED_ID != null)
{
var userIds = new List<Guid>();
persons.ForEach(t =>
@ -414,7 +465,9 @@ namespace APT.FO.WebApi.Controllers
if (flowList != null && flowList.Any())
this.BantchSaveEntityNoCommit(flowList);
if (measureList != null && measureList.Any())
this.BantchSaveEntityNoCommit(measureList);
this.BantchSaveEntityNoCommit(measureList);
if (job != null)
this.UpdateEntityNoCommit(job);
});
return true;
});
@ -489,13 +542,33 @@ namespace APT.FO.WebApi.Controllers
List<T_FO_JOB_ACTIVITY_PERSON> persons = new List<T_FO_JOB_ACTIVITY_PERSON>();
List<T_FO_JOB_ACTIVITY_DETAIL> detailList = new List<T_FO_JOB_ACTIVITY_DETAIL>();
List<T_FO_JOB_ACTIVITY_FLOW> flowList = new List<T_FO_JOB_ACTIVITY_FLOW>();
List<T_FO_JOB_ACTIVITY_MEASURE> measureList = new List<T_FO_JOB_ACTIVITY_MEASURE>();
List<T_FO_JOB_ACTIVITY_MEASURE> measureList = new List<T_FO_JOB_ACTIVITY_MEASURE>();
T_FO_FIRE_JOB job = null;
var todoCount = this.GetCount<T_FO_TECH_DISCLOSURE_PERSON>(t => t.TECH_DISCLOSURE_FROM_ID == tech.ID && t.DEAL_STATUS == 0 && t.USER_ID != null, new BaseFilter(orgId));
var isExist = this.GetEntity<T_FO_JOB_ACTIVITY_RECORD>(t => t.TECH_DISCLOSURE_ID == tech.ID);
if (todoCount == 0 || todoCount == 1)
{
tech.FORM_STATUS = (int)FOTeamActivityState.已归档;
if (isExist == null)
tech.FORM_STATUS = (int)FOTeamActivityState.已归档;
if (tech.FIRE_JOB_ID != null)
{
job = this.GetEntity<T_FO_FIRE_JOB>(t => t.ID == tech.FIRE_JOB_ID);
if (job != null)
{
job.IS_RUN = true;
job.FIRE_STATUS = FOFireStatus.Sign;
var jobUsers = this.GetEntities<T_FO_FIRE_JOB_USER>(t => t.FIRE_JOB_ID == job.ID, new BaseFilter(job.ORG_ID));
var userType = this.GetEntity<T_OG_RELATED_USER_TYPE>(t => t.NAME == "动火操作人员");
var sendUser = jobUsers.FirstOrDefault(t => t.USER_TYPE_ID == userType.ID);
if (sendUser != null)
{
var userName = this.GetEntity<T_FM_USER>(t => t.ID == sendUser.USER_ID)?.NAME;
var notice = NotificationTaskService.InsertUserNoticeTaskModel("动火作业现场条件验收", job.ID, job.ORG_ID, (Guid)sendUser.USER_ID, userName, DateTime.Now,
DateTime.Now.AddHours(24), (int)FMNoticeTypeEnum.消息, "FO043_1");
notices.Add(notice);
}
}
}
else if (isExist == null)
{
//自动生成作业活动记录表
record = new T_FO_JOB_ACTIVITY_RECORD();
@ -694,7 +767,9 @@ namespace APT.FO.WebApi.Controllers
if (flowList != null && flowList.Any())
this.BantchSaveEntityNoCommit(flowList);
if (measureList != null && measureList.Any())
this.BantchSaveEntityNoCommit(measureList);
this.BantchSaveEntityNoCommit(measureList);
if (job != null)
UpdateEntityNoCommit(job);
});
return true;
});

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

File diff suppressed because it is too large Load Diff

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

@ -1,136 +1,145 @@

//------------------------------------------------------------------------------
// 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.LG.WebApi.Controllers.Api
{

//------------------------------------------------------------------------------
// 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.LG.WebApi.Controllers.Api
{
using APT.BaseData.Domain.Entities.LG;
#region Oprate-表单操作日志表
/// <summary>
/// 表单操作日志表
/// </summary>
[Route("api/LG/Oprate")]
public partial class OprateController : AuthorizeApiController<T_LG_OPRATE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_LG_OPRATE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_LG_OPRATE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_LG_OPRATE entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_LG_OPRATE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_LG_OPRATE> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
}
#region Oprate-表单操作日志表
/// <summary>
/// 表单操作日志表
/// </summary>
[Route("api/LG/Oprate")]
public partial class OprateController : AuthorizeApiController<T_LG_OPRATE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_LG_OPRATE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_LG_OPRATE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_LG_OPRATE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_LG_OPRATE entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_LG_OPRATE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_LG_OPRATE> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
}

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

@ -1,368 +1,382 @@

//------------------------------------------------------------------------------
// 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.NW.WebApi.Controllers.Api
{

//------------------------------------------------------------------------------
// 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.NW.WebApi.Controllers.Api
{
using APT.BaseData.Domain.Entities.NW;
#region Enterprise-子企业表
/// <summary>
/// 子企业表
/// </summary>
[Route("api/NW/Enterprise")]
public partial class EnterpriseController : AuthorizeTreeApiController<T_NW_ENTERPRISE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ENTERPRISE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ENTERPRISE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ENTERPRISE entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ENTERPRISE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ENTERPRISE> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<T_NW_ENTERPRISE>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
}
#endregion
#region RoleDataPerm-子企业数据权限表
/// <summary>
/// 子企业数据权限表
/// </summary>
[Route("api/NW/RoleDataPerm")]
public partial class RoleDataPermController : AuthorizeApiController<T_NW_ROLE_DATA_PERM>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_DATA_PERM entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_DATA_PERM> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_DATA_PERM> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
#region RoleMenu-子企业权限表
/// <summary>
/// 子企业权限表
/// </summary>
[Route("api/NW/RoleMenu")]
public partial class RoleMenuController : AuthorizeApiController<T_NW_ROLE_MENU>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ROLE_MENU> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ROLE_MENU> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_MENU entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_MENU> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_MENU> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
}
#region Enterprise-子企业表
/// <summary>
/// 子企业表
/// </summary>
[Route("api/NW/Enterprise")]
public partial class EnterpriseController : AuthorizeTreeApiController<T_NW_ENTERPRISE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ENTERPRISE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ENTERPRISE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ENTERPRISE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ENTERPRISE entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ENTERPRISE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ENTERPRISE> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
/// <summary>
/// 获得树形实体数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("TreeData")]
public JsonActionResult<IEnumerable<TreeNode<T_NW_ENTERPRISE>>> TreeData([FromBody] KeywordFilter filter)
{
return WitTreeOrderEntities(null, filter);
}
}
#endregion
#region RoleDataPerm-子企业数据权限表
/// <summary>
/// 子企业数据权限表
/// </summary>
[Route("api/NW/RoleDataPerm")]
public partial class RoleDataPermController : AuthorizeApiController<T_NW_ROLE_DATA_PERM>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_DATA_PERM>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ROLE_DATA_PERM> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_DATA_PERM entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_DATA_PERM> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_DATA_PERM> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
#region RoleMenu-子企业权限表
/// <summary>
/// 子企业权限表
/// </summary>
[Route("api/NW/RoleMenu")]
public partial class RoleMenuController : AuthorizeApiController<T_NW_ROLE_MENU>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_NW_ROLE_MENU>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_NW_ROLE_MENU> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_NW_ROLE_MENU> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_NW_ROLE_MENU entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_NW_ROLE_MENU> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_NW_ROLE_MENU> Get([FromBody] KeywordFilter filter)
{
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

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

File diff suppressed because it is too large Load Diff

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

@ -1,4 +1,9 @@


@ -8,6 +13,7 @@
//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
@ -21,4 +27,5 @@ using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF;
namespace APT.PP.WebApi.Controllers.Api
{
}
}

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

File diff suppressed because it is too large Load Diff

151
APT.MicroApi/APT.SK.WebApi/Controllers/Api/EnterpriseLibraryController.cs
View File

@ -310,6 +310,11 @@ namespace APT.SK.WebApi.Controllers.Api
}
}
var checkTypeId = departList.FirstOrDefault(t => t.CHECK_TYPE_ID == null);
if (checkTypeId != null)
{
throw new Exception("管控措施->检查内容下面存在检查类型为空的数据，请逐一检查维护");
}
//辨识层级
var postdepartIds = libraryPost.Select(t => t.DEPARTMENT_ID).Distinct().ToList();
var identitylLevel = departments.Where(m => postdepartIds.Contains(m.ID)).Select(t => t.DEPARTMENT_TYPE).Distinct().ToList();
@ -320,83 +325,87 @@ namespace APT.SK.WebApi.Controllers.Api
else
{
throw new Exception("辨识岗位不能为空");
}
}
//是否有虚拟组织
var departVir = departments.FirstOrDefault(m => postdepartIds.Contains(m.ID)&& m.CATEGORY == FMCATEGORY.VIRTUAL);
//管控层级
var controlLevel = libraryDepart.Select(t => t.DEPARTMENT_TYPE).Distinct().ToList();
var count = controlLevel.Count();
//检查层级
var checkLevel = departList.Select(t => t.CHECK_TYPE).Distinct().ToList();
if (entity.EVALUATE_LEVEL == SKEvaluateLevelEnum.重大风险)
{
if (count >= 4 && controlLevel.Contains(SKDepartmentTypeEnum.公司级))
{
//重大风险管控层级必须有四个层级，并且要有公司级
}
else
{
foreach (var level in identitylLevel)
{
if (!controlLevel.Contains((SKDepartmentTypeEnum)level))
{
throw new Exception("缺少管控层级，请添加管控层级:" + ((SKDepartmentTypeEnum)level).GetDescription());
}
}
}
}
if (entity.EVALUATE_LEVEL == SKEvaluateLevelEnum.较大风险)
if (departVir == null)
{
if (entity.EVALUATE_LEVEL == SKEvaluateLevelEnum.重大风险)
{
if (count >= 4 && controlLevel.Contains(SKDepartmentTypeEnum.公司级))
{
//重大风险管控层级必须有四个层级，并且要有公司级
}
else
{
foreach (var level in identitylLevel)
{
if (!controlLevel.Contains((SKDepartmentTypeEnum)level))
{
throw new Exception("缺少管控层级，请添加管控层级:" + ((SKDepartmentTypeEnum)level).GetDescription());
}
}
}
}
if (entity.EVALUATE_LEVEL == SKEvaluateLevelEnum.较大风险)
{
if (count >= 3 && controlLevel.Contains(SKDepartmentTypeEnum.部门级))
{
//较大风险管控层级必须有三个层级，并且要有部门级
}
else
{
foreach (var level in identitylLevel)
{
if (!controlLevel.Contains((SKDepartmentTypeEnum)level))
{
throw new Exception("缺少管控层级，请添加管控层级:" + ((SKDepartmentTypeEnum)level).GetDescription());
}
}
}
}
if (entity.EVALUATE_LEVEL == SKEvaluateLevelEnum.一般风险)
{
if (count >= 2 && controlLevel.Contains(SKDepartmentTypeEnum.车间级))
{
//一般风险管控层级必须有两个层级，并且要有车间级
}
else
{
foreach (var level in identitylLevel)
{
if (!controlLevel.Contains((SKDepartmentTypeEnum)level))
{
throw new Exception("缺少管控层级，请添加管控层级:" + ((SKDepartmentTypeEnum)level).GetDescription());
}
}
}
}
if (entity.EVALUATE_LEVEL == SKEvaluateLevelEnum.低风险)
{
if (count >= 1 && controlLevel.Contains(SKDepartmentTypeEnum.班组级))
{
//低风险管控层级必须有一个层级，并且要有班组级
}
else
{
foreach (var level in identitylLevel)
{
if (!controlLevel.Contains((SKDepartmentTypeEnum)level))
{
throw new Exception("缺少管控层级，请添加管控层级:" + ((SKDepartmentTypeEnum)level).GetDescription());
}
}
if (count >= 3 && controlLevel.Contains(SKDepartmentTypeEnum.部门级))
{
//较大风险管控层级必须有三个层级，并且要有部门级
}
else
{
foreach (var level in identitylLevel)
{
if (!controlLevel.Contains((SKDepartmentTypeEnum)level))
{
throw new Exception("缺少管控层级，请添加管控层级:" + ((SKDepartmentTypeEnum)level).GetDescription());
}
}
}
}
if (entity.EVALUATE_LEVEL == SKEvaluateLevelEnum.一般风险)
{
if (count >= 2 && controlLevel.Contains(SKDepartmentTypeEnum.车间级))
{
//一般风险管控层级必须有两个层级，并且要有车间级
}
else
{
foreach (var level in identitylLevel)
{
if (!controlLevel.Contains((SKDepartmentTypeEnum)level))
{
throw new Exception("缺少管控层级，请添加管控层级:" + ((SKDepartmentTypeEnum)level).GetDescription());
}
}
}
}
if (entity.EVALUATE_LEVEL == SKEvaluateLevelEnum.低风险)
{
if (count >= 1 && controlLevel.Contains(SKDepartmentTypeEnum.班组级))
{
//低风险管控层级必须有一个层级，并且要有班组级
}
else
{
foreach (var level in identitylLevel)
{
if (!controlLevel.Contains((SKDepartmentTypeEnum)level))
{
throw new Exception("缺少管控层级，请添加管控层级:" + ((SKDepartmentTypeEnum)level).GetDescription());
}
}
}
}
}
if (controlLevel != null && controlLevel.Any())
{
foreach (var level in controlLevel)
@ -1350,7 +1359,7 @@ namespace APT.SK.WebApi.Controllers.Api
}
else
{
result = this.GetOrderPageEntities<T_FM_USER_POST>(null, pageFilter);
result = null;//this.GetOrderPageEntities<T_FM_USER_POST>(null, pageFilter);
}
}
else if (!string.IsNullOrEmpty(pageFilter.Keyword))
@ -1363,12 +1372,12 @@ namespace APT.SK.WebApi.Controllers.Api
}
else
{
result = this.GetOrderPageEntities<T_FM_USER_POST>(null, pageFilter);
result = null;//this.GetOrderPageEntities<T_FM_USER_POST>(null, pageFilter);
}
}
else
{
result = this.GetOrderPageEntities<T_FM_USER_POST>(null, pageFilter);
result = null;//this.GetOrderPageEntities<T_FM_USER_POST>(null, pageFilter);
}
return result;
}

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

File diff suppressed because it is too large Load Diff