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

2134

Browse Source
This commit is contained in:
wyw 2026-04-23 09:26:18 +08:00
commit c8769e0b27
26 changed files with 281403 additions and 139179 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

@ -38921,6 +38921,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");
@ -38977,6 +38980,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");
@ -112801,6 +112806,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")
@ -112826,6 +112836,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

51
APT.MicroApi/APT.FM.WebApi/Controllers/Api/OrganizationController.cs
View File

@ -1,18 +1,27 @@
using APT.BaseData.Domain.IServices;
using APT.BaseData.Domain.Enums.PF;
using APT.BaseData.Domain.IServices;
using APT.BaseData.Domain.IServices.OP;
using APT.BaseData.Services.Services.OP;
using APT.Infrastructure.Core;
using APT.Migrations;
using APT.MS.Domain.Entities.SK;
using APT.Utility;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using APT.Utility;
using System.Linq.Expressions;
using System;
namespace APT.FM.WebApi.Controllers.Api.FM
{
[Route("api/FM/Organization")]
public class OrganizationController : AuthorizeTreeApiController<T_FM_ORGANIZATION>
{
{
IOPTenantDBConnService OPTenantDBConnService { get; set; }
public OrganizationController(IOPTenantDBConnService opTenantDBConnService)
{
OPTenantDBConnService = opTenantDBConnService;
}
/// <summary>
/// 查询
/// </summary>
@ -188,6 +197,38 @@ namespace APT.FM.WebApi.Controllers.Api.FM
filter.OrgId = null;
filter.IgnoreOrgRule = true;
return WitEntity(null, filter);
}
/// <summary>
/// 从集团取数据
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("JTOrderEntities")]
public JsonActionResult<IEnumerable<T_FM_ORGANIZATION>> JTOrderEntities([FromBody] KeywordFilter filter)
{
var orgId = filter.OrgId;
filter.OrgId = null;
filter.IgnoreOrgRule = true;
var result = new JsonActionResult<IEnumerable<T_FM_ORGANIZATION>>();
string strConn = OPTenantDBConnService.GetConnByORGID(new Guid(FilePathHead.JY.GetDescription()));
Dictionary<string, DbOrder> orders = new Dictionary<string, DbOrder>();
orders.Add("CREATE_TIME", DbOrder.DESC);
using (var context = new MigrationContext(strConn))
{
Expression<Func<T_FM_ORGANIZATION, bool>> expression = t => true;
var parentRule = filter.FilterGroup.Rules.FirstOrDefault(i => i.Field == "PARENT_ID");
if (parentRule != null && string.IsNullOrEmpty(parentRule.Value.ToString()))
{
expression = expression.And(i => i.ID == orgId);
}
var temps = context.GetOrderEntities(expression, orders, null);
if (temps != null && temps.Any())
{
result.Data = temps.ToList();
result.TotalCount = result.Data.Count();
}
}
return result;
}
}
}

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

File diff suppressed because it is too large Load Diff

44
APT.MicroApi/APT.FM.WebApi/Controllers/Api/UserController.cs
View File

@ -1557,6 +1557,50 @@ namespace APT.FM.WebApi.Controllers.Api.FM
throw new Exception("组织架构错误,请联系管理员");
return user;
});
}
/// <summary>
/// 更新用户公司
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
[HttpPost, Route("ChangeCompany")]
public JsonActionResult<bool> ChangeCompany([FromBody] KeywordFilter filter)
{
return SafeExecute<bool>(() =>
{
var userID = filter.Keyword;
var userIDGUID = new Guid(userID);
var OrgId = APT.Infrastructure.Api.AppContext.CurrentSession.OrgId;
BaseFilter BaseFilter = new BaseFilter(OrgId);
var user = this.GetEntity<T_FM_USER>(userID);
if (!string.IsNullOrEmpty(filter.Parameter1))
{
var orgIDGUID = new Guid(filter.Parameter1);
using (var context = new MigrationContext(ConfigurationManager.ConnectionStrings["default"]))
{
var allUser = context.GetEntity<T_OP_ALLUSER>(t => t.CODE == user.CODE, new string[] { "ID,CODE,ORG_ID,TENANT" });
if (allUser != null)
{
allUser.TENANT = filter.Parameter1.Substring(0,3);
allUser.ORG_ID = orgIDGUID;
context.UpdateEntity(allUser);
context.SaveChanges();
}
}
user.ENABLE_STATUS = 1;
}
else
{
throw new Exception("请先选择公司");
}
this.UnifiedCommit(() =>
{
this.UpdateEntityNoCommit(user);
});
return true;
});
}
}
}

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

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

@ -1,13 +1,19 @@


//------------------------------------------------------------------------------
// T4模板文件：基础接口类
// 此代码由T4模板自动生成
@ -26,6 +32,7 @@ using APT.MS.Domain.Entities.PF;
using APT.BaseData.Domain.Entities.PF;
using APT.BaseData.Domain.Entities.T4;
#region Annourcement-公告
/// <summary>
/// 公告
@ -134,9 +141,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region AnnourcementFile-公告附件
/// <summary>
/// 公告附件
@ -245,9 +254,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region AnnourcementOrg-公告下属公司
/// <summary>
/// 公告下属公司
@ -356,9 +367,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region ApprovalRole-审批角色
/// <summary>
/// 审批角色
@ -467,9 +480,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region Approve-审批流主表
/// <summary>
/// 审批流主表
@ -578,9 +593,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region ApproveDetail-审批流子表
/// <summary>
/// 审批流子表
@ -689,9 +706,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region ApproveOperationRole-操作角色
/// <summary>
/// 操作角色
@ -800,9 +819,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region ApproveRejectConfig-审批驳回配置表
/// <summary>
/// 审批驳回配置表
@ -911,9 +932,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region ApproveRoleDepartment-分管部门
/// <summary>
/// 分管部门
@ -1022,9 +1045,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region ApproveTemp-审批流模板主表
/// <summary>
/// 审批流模板主表
@ -1133,9 +1158,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region ApproveTempDetail-审批流模板子表
/// <summary>
/// 审批流模板子表
@ -1244,9 +1271,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region AppVersion-App版本发布
/// <summary>
/// App版本发布
@ -1355,9 +1384,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region AppVersionFile-App包文件
/// <summary>
/// App包文件
@ -1466,117 +1497,7 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region Bititle-标语
/// <summary>
/// 标语
/// </summary>
[Route("api/PF/Bititle")]
public partial class BititleController : AuthorizeApiController<T_PF_BITITLE>
{
/// <summary>
/// 查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Entities")]
public JsonActionResult<IEnumerable<T_PF_BITITLE>> Entities([FromBody]KeywordFilter filter)
{
return WitEntities(null, filter);
}
/// <summary>
/// 排序查询所有数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderEntities")]
public JsonActionResult<IEnumerable<T_PF_BITITLE>> OrderEntities([FromBody]KeywordFilter filter)
{
return WitOrderEntities(null, filter);
}
/// <summary>
/// 分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Paged")]
public PagedActionResult<T_PF_BITITLE> Paged([FromBody]KeywordPageFilter pageFilter)
{
return WitPaged(null, pageFilter);
}
/// <summary>
/// 排序分页查询数据
/// </summary>
/// <param name="pageFilter">分页过滤实体</param>
/// <returns></returns>
[HttpPost, Route("OrderPaged")]
public PagedActionResult<T_PF_BITITLE> OrderPaged([FromBody]KeywordPageFilter pageFilter)
{
return WitOrderPaged(null, pageFilter);
}
/// <summary>
/// 根据主键删除数据
/// </summary>
/// <param name="id">主键ID</param>
/// <returns></returns>
[HttpGet, Route("Delete")]
public JsonActionResult<bool> Delete(string id)
{
return WitRealDelete(id);
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Update")]
public JsonActionResult<bool> Update([FromBody]T_PF_BITITLE entity)
{
return WitUpdate(entity);
}
/// <summary>
/// 批量更新
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("BatchUpdate")]
public JsonActionResult<bool> BatchUpdate([FromBody] BatchUpdateModel<T_PF_BITITLE> entity)
{
return WitBantchUpdate(entity?.Data);
}
/// <summary>
/// 批量删除数据
/// </summary>
/// <param name="ids">id字符串（id用逗号分隔）</param>
/// <returns></returns>
[HttpGet, Route("BatchDelete")]
public JsonActionResult<bool> BatchDelete(string ids)
{
return WitRealBatchDelete(ids);
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("Get")]
public JsonActionResult<T_PF_BITITLE> Get([FromBody] KeywordFilter filter)
{
return WitEntity(null, filter);
}
}
#endregion
@ -1688,9 +1609,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region CodeRuleRunLog-编码规则跑批表
/// <summary>
/// 编码规则跑批表
@ -1799,9 +1722,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region ComplaintLog-转办记录表
/// <summary>
/// 转办记录表
@ -1910,9 +1835,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region DataChannel-数据通道
/// <summary>
/// 数据通道
@ -2021,9 +1948,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region DataFrequency-采集频率
/// <summary>
/// 采集频率
@ -2132,9 +2061,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region Fddeback-意见反馈
/// <summary>
/// 意见反馈
@ -2243,9 +2174,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FddebackFile-意见反馈附件
/// <summary>
/// 意见反馈附件
@ -2354,9 +2287,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FileDb-
/// <summary>
///
@ -2465,9 +2400,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FileDbFile-
/// <summary>
///
@ -2576,9 +2513,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FileType-
/// <summary>
///
@ -2687,9 +2626,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FormHomeChart-首页：图标区域
/// <summary>
/// 首页：图标区域
@ -2798,9 +2739,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FormHomeHmi-首页：HMI区域
/// <summary>
/// 首页：HMI区域
@ -2909,9 +2852,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FormHomeRanking-首页：排名区域
/// <summary>
/// 首页：排名区域
@ -3020,9 +2965,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FormHomeStatistic-首页：统计区域
/// <summary>
/// 首页：统计区域
@ -3131,9 +3078,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region FormRelation-关联表单配置
/// <summary>
/// 关联表单配置
@ -3242,9 +3191,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region HomeTitle-首页方针
/// <summary>
/// 首页方针
@ -3353,9 +3304,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region MqttConfig-MQTT配置表
/// <summary>
/// MQTT配置表
@ -3464,9 +3417,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region MqttConfigTheme-
/// <summary>
///
@ -3575,9 +3530,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region Notice-通知
/// <summary>
/// 通知
@ -3686,9 +3643,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region NoticeFile-
/// <summary>
///
@ -3797,9 +3756,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region PicFilter-图片条件主表
/// <summary>
/// 图片条件主表
@ -3908,9 +3869,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region PicFilterDetail-图片条件子表
/// <summary>
/// 图片条件子表
@ -4019,9 +3982,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region QuestionFeedback-问题反馈表
/// <summary>
/// 问题反馈表
@ -4130,9 +4095,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region QuestionFeedbackFile-问题反馈附件表
/// <summary>
/// 问题反馈附件表
@ -4241,9 +4208,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region Scopes-资源表
/// <summary>
/// 资源表
@ -4352,9 +4321,11 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
#region VersionManage-版本管理表
/// <summary>
/// 版本管理表
@ -4463,6 +4434,8 @@ using APT.BaseData.Domain.Entities.T4;
}
}
#endregion
}

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