wyw/mh_jy_safe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
66986befb9
mh_jy_safe/APT.MicroApi/APT.PF.WebApi/Controllers/Api/ApproveController.cs

1100 lines
55 KiB
C#
Raw Normal View History

仓库复制
2025-08-25 09:56:57 +08:00
namespace APT.PF.WebApi.Controllers.Api
{
using APT.Infrastructure.Core;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using APT.Utility;
using APT.Infrastructure.Api;
using APT.BaseData.Domain.ApiModel.PF;
using APT.BaseData.Domain.Entities;
using APT.BaseData.Domain.Enums.PF;
using System.Linq;
using System;
using APT.BaseData.Domain.IServices.FM;
using APT.MS.Domain.Enums;
using System.Dynamic;
using System.Reflection;
using APT.BaseData.Domain.Entities.PF;
using APT.BaseData.Domain.Entities.FM;
using System.Linq.Expressions;
using APT.MS.Domain.Entities.BS;
using APT.BaseData.Domain.Enums;
using APT.BaseData.Domain.IServices;
using APT.MS.Domain.Entities.HM;
using Newtonsoft.Json;
using NPOI.Util;
using System.Data;
using NPOI.SS.Formula.Functions;
using APT.MS.Domain.Entities.SC;
using APT.Infrastructure.EF;
using APT.BaseData.Services.DomainServices;
using APT.BaseData.Services.Services.FM;
using APT.BaseData.Services.Sys;
using APT.MS.Domain.Entities.FO;
获取某用户的conn FullGet 测试
2025-10-23 11:03:02 +08:00
using APT.BaseData.Domain.IServices.OP;
仓库复制
2025-08-25 09:56:57 +08:00
[Route("api/PF/PFApprove")]
public partial class ApproveController : AuthorizeApiController<T_PF_APPROVE>
{
IFMNotificationTaskService NotificationTaskService { get; set; }
IPFSysLogService SysLogService { get; set; }
IRepository Repository { get; set; }
IPFCodeRuleService CodeRuleService { get; set; }
IFMDepartmentService DepartmentService { get; set; }
IFMUserService UserService { get; set; }
获取某用户的conn FullGet 测试
2025-10-23 11:03:02 +08:00
IOPTenantDBConnService OPTenantDBConnService { get; set; }
仓库复制
2025-08-25 09:56:57 +08:00
获取某用户的conn FullGet 测试
2025-10-23 11:03:02 +08:00
public ApproveController(IFMNotificationTaskService notificationTaskService, IPFSysLogService sysLogService, IRepository repository, IPFCodeRuleService codeRuleService, IFMDepartmentService departmentService, IFMUserService userService, IOPTenantDBConnService oPTenantDBConnService)
仓库复制
2025-08-25 09:56:57 +08:00
{
NotificationTaskService = notificationTaskService;
SysLogService = sysLogService;
Repository = repository;
CodeRuleService = codeRuleService;
DepartmentService = departmentService;
UserService = userService;
获取某用户的conn FullGet 测试
2025-10-23 11:03:02 +08:00
OPTenantDBConnService = oPTenantDBConnService;
仓库复制
2025-08-25 09:56:57 +08:00
}
/// <summary>
/// 更新或新增数据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("FullUpdate")]
public JsonActionResult<bool> FullUpdate([FromBody] T_PF_APPROVE entity)
{
return SafeExecute<bool>(() =>
{
var detail = entity.Nav_ApproveDetails;
entity.Nav_ApproveDetails = null;
UnifiedCommit(() =>
{
this.UpdateEntityNoCommit(entity);
if (detail != null)
this.BantchSaveEntityNoCommit(detail);
});
return true;
});
}
/// <summary>
/// 审批单据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Submit")]
public JsonActionResult<string> Submit([FromBody] T_PF_APPROVE entity)
{
return base.SafeExecute(() =>
{
var ret = string.Empty;
var dbApprove = this.GetEntity<T_PF_APPROVE>(entity.ID.ToString(), false, "Nav_ApproveDetails");
if (dbApprove == null)
this.ThrowError("020027");
if (dbApprove.APPROVE_STATUS != (int)ApproveStatus.Doing)
this.ThrowError("020028");
var node = dbApprove.Nav_ApproveDetails.FirstOrDefault(i => i.ID == entity.CurrentNode.ID);
if (!node.IS_CURRENT)
this.ThrowError("020030");
//查询消息表
var task = this.GetEntity<T_FM_NOTIFICATION_TASK>(i => i.SOURCE_DATA_ID == entity.ID && i.USER_ID == node.APPROVE_USER_ID
&& i.NOTICE_STATUS == FMNoticeStatusEnum.未处理.GetInt(), false);
if (task != null)
{
task.NOTICE_STATUS = FMNoticeStatusEnum.正常已办.GetInt();
task.TASK_DT = DateTime.Now;
if (DateTime.Now > task.TASK_ENDDT)
task.NOTICE_STATUS = FMNoticeStatusEnum.超期办理.GetInt();
}
//修改节点状态
node.NODE_APPROVE_TIME = DateTime.Now;
node.NODE_APPROVE_STATUS = entity.CurrentNode.NODE_APPROVE_STATUS;
node.IS_CURRENT = false;
node.CONTEXT = entity.CurrentNode.CONTEXT;
//Type dbTypeEnd = null;//反射类
//MethodInfo methodInfoEnd = null;//反射方法
//更新审批单据状态
if (node.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Reject)//驳回
{
//驳回时状态改为驳回，并通知申请人重新提交
dbApprove.APPROVE_STATUS = ApproveStatus.Reject.GetInt();
var details = dbApprove.Nav_ApproveDetails;
dbApprove.Nav_ApproveDetails = null;
details.ForEach(i => i.Nav_Approve = null);
List<Guid> userIds = new List<Guid>();
userIds.Add((Guid)dbApprove.CREATER_ID);
//消息通知并修改状态
NotificationTaskService.SendNotificationTask(entity.NAME + "已被驳回,请重新新建表单提交审核",
entity.ID, APT.Infrastructure.Api.AppContext.CurrentSession.OrgId, userIds,
DateTime.Now, DateTime.Now.AddHours(24), (int)FMNoticeTypeEnum.消息, "PF119", () =>
{
if (task != null)
this.UpdateEntityNoCommit(task);
this.UpdateEntityNoCommit(dbApprove);
this.BantchUpdateEntityNoCommit(details);
});
return ret;
}
else if (node.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Done)
{
//判断下一个节点是否包含 本节点的人
//如果是 并且 只有这个人
// 继续判断下一个人节点
#region wyw 默认审批判断
bool isLast = false;
List<T_PF_APPROVE_DETAIL> Nav_ApproveDetails = dbApprove.Nav_ApproveDetails.ToList();
DoneLaterApproverDeal(node, node.APPROVE_USER_ID.Value, node.CONTEXT, node.NODE_APPROVE_STATUS, ref Nav_ApproveDetails, ref isLast);
dbApprove.Nav_ApproveDetails = Nav_ApproveDetails;//可能会有修改赋值过去
#endregion
//var lastNode = dbApprove.Nav_ApproveDetails.Where(i => i.NUM >= entity.CurrentNode.NUM && i.ID != entity.CurrentNode.ID && i.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Doing);
//if (!lastNode.Any())
if (isLast)
{
dbApprove.APPROVE_STATUS = ApproveStatus.Done.GetInt();//完成
ret = dbApprove.CALLBACK_INTERFACE;
//if (ret == "SC/SCMtMeetingMinutes/MeetingMinutesBack")
//{
// //不存在无参的构造函数所以实例化失败 ccy
// var callBackInterface = APT.Infrastructure.Core.Refctor.ReflectHelper.FindTypeInCurrentDomain("PFApproveCallBackMTService");
// MethodInfo callbackMethd = callBackInterface.GetMethod("MeetingMinutesBack", BindingFlags.Public | BindingFlags.Instance);
// var instance = Activator.CreateInstance(callBackInterface, Repository, CodeRuleService, NotificationTaskService, SysLogService, DepartmentService, UserService);
// callbackMethd.Invoke(instance, new object[] { dbApprove.DATA_ID.ToString() });
// //将方法写在此类也可以调用 wyw
// //var callBackInterface1 = this.GetType();
// //MethodInfo callbackMethd1 = callBackInterface1.GetMethod("MeetingMinutesBack", BindingFlags.Public | BindingFlags.Instance); // Error lies
// //callbackMethd1.Invoke(this, new object[] { dbApprove.DATA_ID.ToString() });
//}
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
仓库复制
2025-08-25 09:56:57 +08:00
//查询审批的表单数据
var form = this.GetEntity<T_PF_FORM>(i => i.CODE == dbApprove.APPROVE_CODE, new BaseFilter(dbApprove.ORG_ID));
var tableName = form?.TABLE_NAME;
if (string.IsNullOrEmpty(tableName))
{
var formEdit = this.GetEntity<T_PF_PAGE_EDIT>(i => i.PAGE_FORM_ID == form.ID && i.PARENT_ID == null);
if (formEdit != null)
{
tableName = formEdit.EDIT_NAME;
}
}
if (!string.IsNullOrEmpty(tableName))
{
var dbType = APT.Infrastructure.Core.Refctor.ReflectHelper.FindTypeInCurrentDomain(tableName);
if (dbType != null)
{
MethodInfo methodInfo = this.GetType().GetMethod("GetMyEntity",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
var entity = methodInfo.MakeGenericMethod(new Type[] { dbType }).
Invoke(this, new object[] { dbApprove.DATA_ID });
if (entity != null)
{
var prop = dbType.GetProperty("FLOW_STATUS");
if (prop != null)
{
prop.SetValue(entity, 2);
MethodInfo methodInfoUpdate = this.GetType().GetMethod("UpdateMyEntityNoCommit",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
var details = dbApprove.Nav_ApproveDetails;
dbApprove.Nav_ApproveDetails = null;
details.ForEach(i => i.Nav_Approve = null);
UnifiedCommit(() =>
{
if (task != null)
this.UpdateEntityNoCommit(task);
this.UpdateEntityNoCommit(dbApprove);
this.BantchUpdateEntityNoCommit(details);
methodInfoUpdate.MakeGenericMethod(new Type[] { dbType }).
Invoke(this, new object[] { entity });
});
return ret;
}
}
}
}
if (ret == "FO/FOCrucialLicenseJob/BackUpdate")
{
BackUpdate_FOJobCrucialLicense(dbApprove.DATA_ID.ToString(), () => JobChangeApproveStatus(dbApprove, task));
return "";
}
if (ret == "FO/FOJobEventRecord/BackUpdate")
{
BackUpdate_FOJobEventRecord(dbApprove.DATA_ID.ToString(), () => JobChangeApproveStatus(dbApprove, task));
return "";
}
}
else
{
var next = dbApprove.Nav_ApproveDetails.Where(i => i.NUM == entity.CurrentNode.NUM && i.ID != entity.CurrentNode.ID && i.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Doing);
if (next.Any())
{
}
else
{
//var nextNodes = dbApprove.Nav_ApproveDetails.Where(i => i.NUM > entity.CurrentNode.NUM);//wyw
var nextNodes = dbApprove.Nav_ApproveDetails.Where(i => i.NUM > entity.CurrentNode.NUM && i.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Doing);
if (nextNodes.Any())
{
T_PF_APPROVE_DETAIL curentApprove = null;
GetApproveNodes(nextNodes.ToList(), ref curentApprove);
//所有节点均无审核人,直接归档
if (curentApprove == null)
{
dbApprove.APPROVE_STATUS = ApproveStatus.Done.GetInt();//完成
ret = dbApprove.CALLBACK_INTERFACE;
//查询审批的表单数据
var form = this.GetEntity<T_PF_FORM>(i => i.CODE == dbApprove.APPROVE_CODE, new BaseFilter(dbApprove.ORG_ID));
var tableName = form?.TABLE_NAME;
if (string.IsNullOrEmpty(tableName))
{
var formEdit = this.GetEntity<T_PF_PAGE_EDIT>(i => i.PAGE_FORM_ID == form.ID && i.PARENT_ID == null);
if (formEdit != null)
{
tableName = formEdit.EDIT_NAME;
}
}
if (!string.IsNullOrEmpty(tableName))
{
var dbType = APT.Infrastructure.Core.Refctor.ReflectHelper.FindTypeInCurrentDomain(tableName);
if (dbType != null)
{
MethodInfo methodInfo = this.GetType().GetMethod("GetMyEntity",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
var entity = methodInfo.MakeGenericMethod(new Type[] { dbType }).
Invoke(this, new object[] { dbApprove.DATA_ID });
if (entity != null)
{
var prop = dbType.GetProperty("FLOW_STATUS");
if (prop != null)
{
prop.SetValue(entity, 2);
MethodInfo methodInfoUpdate = this.GetType().GetMethod("UpdateMyEntityNoCommit",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
var details = dbApprove.Nav_ApproveDetails;
dbApprove.Nav_ApproveDetails = null;
details.ForEach(i => i.Nav_Approve = null);
UnifiedCommit(() =>
{
if (task != null)
this.UpdateEntityNoCommit(task);
this.UpdateEntityNoCommit(dbApprove);
this.BantchUpdateEntityNoCommit(details);
methodInfoUpdate.MakeGenericMethod(new Type[] { dbType }).
Invoke(this, new object[] { entity });
});
return ret;
}
}
}
}
}
else
{
var nextNode = nextNodes.Where(i => i.NUM == curentApprove.NUM && i.APPROVE_USER_ID != entity.CurrentNode.APPROVE_USER_ID);// && i.APPROVE_USER_ID != entity.CurrentNode.APPROVE_USER_ID
nextNode.ForEach(i => i.IS_CURRENT = true);
List<Guid> userIds = new List<Guid>();
userIds.AddRange(nextNode.Select(i => (Guid)i.APPROVE_USER_ID).ToArray());
var details = dbApprove.Nav_ApproveDetails;
details.ForEach(i => i.Nav_Approve = null);
dbApprove.Nav_ApproveDetails = null;
//var nextNodeName=nextNode.Select(i => i.NAME).FirstOrDefault();
//消息通知并修改状态
string NoticeTitle = entity.NAME;
if (!entity.NAME.EndsWith("审批"))
{
NoticeTitle = NoticeTitle + "待审批";
}
var startTime = DateTime.Now;
var endTime = DateTime.Now.AddHours(24);
switch (entity.NAME)
{
case "作业任务识别表":
case "作业任务识别分析表":
case "一般任务分析表":
case "关键任务分析表":
case "作业许可分析表":
endTime = Convert.ToDateTime(DateTime.Now.AddDays(2).ToString("D").ToString()).AddSeconds(-1);
break;
case "作业活动记录(一般作业)":
case "关键许可工作票":
case "关键许可工作票（无审批层级）":
case "关键许可工作票（一级审批）":
case "关键许可工作票（二级审批）":
case "关键许可工作票（三级审批）":
case "关键许可工作票（四级审批）":
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
var job = this.GetEntity<T_FO_CRUCIAL_LICENSE_JOB>(t => t.ID == entity.DATA_ID, "Nav_OperationStep");
NoticeTitle = job != null && job.Nav_OperationStep != null ? entity.NAME + "-" + job.Nav_OperationStep?.NAME + "待审批" : NoticeTitle;
仓库复制
2025-08-25 09:56:57 +08:00
endTime = Convert.ToDateTime(DateTime.Now.AddDays(1).ToString("D").ToString()).AddSeconds(-1);
break;
default: break;
}
NotificationTaskService.SendNotificationTask(NoticeTitle,
entity.ID, APT.Infrastructure.Api.AppContext.CurrentSession.OrgId, userIds,
startTime, endTime, (int)FMNoticeTypeEnum.审批, "PF119", () =>
{
if (task != null)
this.UpdateEntityNoCommit(task);
this.UpdateEntityNoCommit(dbApprove);
this.BantchUpdateEntityNoCommit(details);
});
return ret;
}
}
else
{
}
}
}
}
ChangeApproveStatus(dbApprove, task);//, dbTypeEnd, methodInfoEnd
return ret;
});
}
/// <summary>
/// 审批通过 判断是否下一节点未本人 wyw
/// </summary>
/// <param name="currentNode"></param>
/// <param name="OperateID"></param>
/// <param name="CONTEXT"></param>
/// <param name="NODE_APPROVE_STATUS"></param>
/// <param name="Nav_ApproveDetails"></param>
/// <param name="isLast"></param>
private void DoneLaterApproverDeal(T_PF_APPROVE_DETAIL currentNode, Guid OperateID, string CONTEXT, int NODE_APPROVE_STATUS, ref List<T_PF_APPROVE_DETAIL> Nav_ApproveDetails, ref bool isLast)
{
if (NODE_APPROVE_STATUS != 10)
{
//审批不通过
return;
}
var detailDoing = Nav_ApproveDetails.FirstOrDefault(e => e.APPROVE_USER_ID.HasValue && e.NUM >= currentNode.NUM && e.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Doing && e.ID != currentNode.ID);
if (detailDoing == null)
{
//最后一个审批人了
isLast = true;
return;
}
else
{
isLast = false;
}
if (!isLast)
{
//如果不是最后一个审批人 判断处理 下级审批人信息
//同级 审批完了 下一级有他 默认审批
var currentNumNode = Nav_ApproveDetails.FirstOrDefault(e => e.NUM == currentNode.NUM && e.ID != currentNode.ID && e.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Doing);
if (currentNumNode != null)
{
//同级 还有未审批的
return;
}
//同级没有未审批的人员信息
List<T_PF_APPROVE_DETAIL> listDoing = Nav_ApproveDetails.FindAll(e => e.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Doing).OrderBy(e => e.NUM).ToList();
if (listDoing != null && listDoing.Count > 0)
{
//还有未审批的
List<T_PF_APPROVE_DETAIL> listDoingMin = listDoing.FindAll(e => e.NUM == listDoing[0].NUM);//最小未审批节点
T_PF_APPROVE_DETAIL detailLogin = listDoingMin.FirstOrDefault(e => e.APPROVE_USER_ID == OperateID);
if (detailLogin == null)
{
//下一个节点不是当前审批人
return;
}
//默认 审批
//detailLogin
detailLogin.NODE_APPROVE_TIME = DateTime.Now;
detailLogin.NODE_APPROVE_STATUS = (int)NodeApproveStatus.Done;
detailLogin.IS_CURRENT = false;
detailLogin.CONTEXT = CONTEXT;
if (listDoingMin.Count == 1)
{
DoneLaterApproverDeal(detailLogin, OperateID, CONTEXT, NODE_APPROVE_STATUS, ref Nav_ApproveDetails, ref isLast);
}
}
}
}
private void JobChangeApproveStatus(T_PF_APPROVE dbApprove, T_FM_NOTIFICATION_TASK task)//, Type dbTypeEnd = null, MethodInfo methodInfoEnd = null
{
var details = dbApprove.Nav_ApproveDetails;
dbApprove.Nav_ApproveDetails = null;
details.ForEach(i => i.Nav_Approve = null);
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
if (task != null)
this.UpdateEntityNoCommit(task);
this.UpdateEntityNoCommit(dbApprove);
this.BantchUpdateEntityNoCommit(details);
//if (methodInfoEnd != null)
// methodInfoEnd.MakeGenericMethod(new Type[] { dbTypeEnd }).Invoke(this, new object[] { dbApprove.DATA_ID.ToString() });
仓库复制
2025-08-25 09:56:57 +08:00
}
private void ChangeApproveStatus(T_PF_APPROVE dbApprove, T_FM_NOTIFICATION_TASK task)//, Type dbTypeEnd = null, MethodInfo methodInfoEnd = null
{
var details = dbApprove.Nav_ApproveDetails;
dbApprove.Nav_ApproveDetails = null;
details.ForEach(i => i.Nav_Approve = null);
UnifiedCommit(() =>
{
if (task != null)
this.UpdateEntityNoCommit(task);
this.UpdateEntityNoCommit(dbApprove);
this.BantchUpdateEntityNoCommit(details);
//if (methodInfoEnd != null)
// methodInfoEnd.MakeGenericMethod(new Type[] { dbTypeEnd }).Invoke(this, new object[] { dbApprove.DATA_ID.ToString() });
});
}
public T GetMyEntity<T>(Guid id) where T : MesEntityBase, new()
{
return this.GetEntity<T>(id.ToString());
}
public T GetMyEntity2<T>(Expression<Func<T, bool>> expression) where T : MesEntityBase, new()
{
return GetEntity<T>(expression);
}
public void UpdateMyEntityNoCommit<T>(T entity) where T : MesEntityBase, new()
{
this.UpdateEntityNoCommit<T>(entity);
}
/// <summary>
/// 转办
/// </summary>
/// <param name="keywordFilter">参数</param>
/// <returns></returns>
[HttpPost, Route("Complaint")]
public JsonActionResult<bool> Complaint([FromBody] KeywordFilter keywordFilter)
{
return base.SafeExecute(() =>
{
if (string.IsNullOrEmpty(keywordFilter.Keyword))
this.ThrowError("020005");
if (string.IsNullOrEmpty(keywordFilter.Parameter1))
this.ThrowError("020024");
var dbApproveDetail = this.GetEntity<T_PF_APPROVE_DETAIL>(keywordFilter.Keyword, false, "Nav_Approve");
if (dbApproveDetail == null)
this.ThrowError("020007");
//查询消息表
var task = this.GetEntity<T_FM_NOTIFICATION_TASK>(i => i.SOURCE_DATA_ID == dbApproveDetail.APPROVE_ID && i.USER_ID == dbApproveDetail.APPROVE_USER_ID
&& i.NOTICE_STATUS == FMNoticeStatusEnum.未处理.GetInt(), false);
if (task != null)
{
task.USER_ID = Guid.Parse(keywordFilter.Parameter1);
task.USER_NAME = this.GetEntity<T_FM_USER>(t => t.ID == task.USER_ID && t.ENABLE_STATUS == 0)?.NAME;
}
//修改当前审核人为转办人
dbApproveDetail.APPROVE_USER_ID = Guid.Parse(keywordFilter.Parameter1);
//添加转办记录
T_PF_COMPLAINT_LOG complant = new T_PF_COMPLAINT_LOG();
complant.ORG_ID = keywordFilter.OrgId;
complant.APPROVE_DETAIL_ID = Guid.Parse(keywordFilter.Keyword);
complant.COMPLAINT_USER_ID = Guid.Parse(keywordFilter.Parameter1);
UnifiedCommit(() =>
{
if (task != null)
this.UpdateEntityNoCommit(task);
if (dbApproveDetail != null)
this.UpdateEntityNoCommit(dbApproveDetail);
this.AddEntityNoCommit(complant);
});
return true;
});
}
/// <summary>
/// 根据数据id获取审核id
/// </summary>
/// <param name="keywordFilter">参数</param>
/// <returns></returns>
[HttpPost, Route("GetDataId")]
public JsonActionResult<string> GetDataId([FromBody] KeywordFilter keywordFilter)
{
return SafeExecute<string>(() =>
{
Guid dataId = new Guid(keywordFilter.Keyword);
bool isAPPROVEID = false;
if (string.IsNullOrEmpty(keywordFilter.Keyword))
this.ThrowError("020005");
if (!string.IsNullOrEmpty(keywordFilter.Parameter2))
{
//以这种形式传参查看反射实现 一劳永逸
if (keywordFilter.Parameter2 == "T_BS_RISK_SUBMIT_NOTICE,RISK_SUBMIT_ID")
{
T_BS_RISK_SUBMIT_NOTICE modelNo = GetEntity<T_BS_RISK_SUBMIT_NOTICE>(e => e.RISK_SUBMIT_ID == dataId);
if (modelNo != null)
dataId = modelNo.ID;
else
return "";
//throw new Exception("未获取到审批流信息！");
}
else if (keywordFilter.Parameter2 == "T_BS_SAFE_CHECK,APPROVE_CHECKAUDIT_ID")
{
var T_BS_SAFE_CHECK = GetEntity<T_BS_SAFE_CHECK>(e => e.ID == dataId);
if (T_BS_SAFE_CHECK != null && T_BS_SAFE_CHECK.APPROVE_CHECKAUDIT_ID.HasValue)
{
dataId = T_BS_SAFE_CHECK.APPROVE_CHECKAUDIT_ID.Value;
isAPPROVEID = true;
}
else
{
dataId = Guid.Empty;
}
}
}
Expression<Func<T_PF_APPROVE, bool>> expression = e => e.DATA_ID == dataId;
if (isAPPROVEID)
{
expression = e => e.ID == dataId;
}
if (!string.IsNullOrEmpty(keywordFilter.Parameter1))
{
expression = expression.And(e => e.PARAM == keywordFilter.Parameter1);
}
var orgId = APT.Infrastructure.Api.AppContext.CurrentSession.OrgId;
var dbApprove = this.GetEntities<T_PF_APPROVE>(expression, new BaseFilter(keywordFilter.OrgId)).OrderByDescending(t => t.CREATE_TIME).FirstOrDefault();
if (dbApprove == null)
return "";
return dbApprove.ID.ToString();
});
}
/// <summary>
/// 更新状态为已阅
/// </summary>
/// <param name="dbApprove"></param>
[HttpPost, Route("ChangeStatus")]
public JsonActionResult<bool> ChangeStatus([FromBody] T_PF_APPROVE dbApprove)
{
return SafeExecute<bool>(() =>
{
//更新状态为已阅
dbApprove.Nav_ApproveDetails = null;
dbApprove.APPROVE_STATUS = (int)ApproveStatus.View;
//查询消息表
var task = this.GetEntity<T_FM_NOTIFICATION_TASK>(i => i.SOURCE_DATA_ID == dbApprove.ID && i.USER_ID == dbApprove.CREATER_ID
&& (i.NOTICE_STATUS == FMNoticeStatusEnum.未处理.GetInt() || i.NOTICE_STATUS == FMNoticeStatusEnum.超期办理.GetInt()), false);
if (task != null)
{
if (DateTime.Now > task.TASK_ENDDT)
task.NOTICE_STATUS = (int)FMNoticeStatusEnum.超期办理;
else
task.NOTICE_STATUS = (int)FMNoticeStatusEnum.正常已办;
//task.NOTICE_STATUS = FMNoticeStatusEnum.已阅.GetInt();
task.TASK_DT = DateTime.Now;
}
UnifiedCommit(() =>
{
if (task != null)
this.UpdateEntityNoCommit(task);
this.UpdateEntityNoCommit(dbApprove);
});
return true;
});
}
/// <summary>
/// 获取下个审核节点、审核人
/// </summary>
/// <param name="approveDetails"></param>
/// <param name="approveNode"></param>
/// <returns></returns>
static void GetApproveNodes(List<T_PF_APPROVE_DETAIL> approveDetails, ref T_PF_APPROVE_DETAIL approveNode)
{
if (approveDetails == null)
return;
var curentNode = approveDetails.FirstOrDefault(i => i.NUM == approveDetails.Min(x => x.NUM) && i.NODE_APPROVE_STATUS == (int)NodeApproveStatus.Doing);
if (curentNode == null || curentNode.APPROVE_USER_ID == null)
{
approveDetails.Remove(curentNode);
approveNode = null;
if (!approveDetails.Any())
return;
GetApproveNodes(approveDetails, ref approveNode);
}
else
{
approveNode = curentNode;
return;
}
}
/// <summary>
/// 获得单条实体数据
/// </summary>
/// <param name="filter">过滤实体</param>
/// <returns></returns>
[HttpPost, Route("FullGet")]
public JsonActionResult<T_PF_APPROVE> FullGet([FromBody] KeywordFilter filter)
{
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
return SafeExecute(() =>
仓库复制
2025-08-25 09:56:57 +08:00
{
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
T_PF_APPROVE result = null;
if (!string.IsNullOrEmpty(filter.Parameter1) && filter.OrgId.HasValue && filter.Parameter1 != filter.OrgId.Value.ToString())
{
//集团人员 通过 首页点击 获取对应的数据库链接 返回结果
//这边怎么调用 原生的 GetEntity 方法
获取某用户的conn FullGet 测试
2025-10-23 11:03:02 +08:00
string conn = OPTenantDBConnService.GetConnByORGID(new Guid(filter.Parameter1));
//var service = APT.Infrastructure.Api.ServiceLocator.Instance.GetService<IFMNotificatoinService>();
filter.IgnoreOrgRule = true;
//filter.OrgId = null;
filter.SpecifyDbConn = conn;
filter.SpecifyTenant = "0005";
//var ccc = service.GetEntities<T_PF_APPROVE>(e => !e.IS_DELETED, filter, null);
var aaa = GetEntities<T_PF_APPROVE>(e => !e.IS_DELETED, filter, null);
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
}
else
仓库复制
2025-08-25 09:56:57 +08:00
{
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
result = GetEntity<T_PF_APPROVE>(null, filter, null);
if (result != null)
{
if (result.APPROVE_TEMP_ID != null)
{
var approveTemp = this.GetEntity<T_PF_APPROVE_TEMP>(t => t.ID == result.APPROVE_TEMP_ID);
if (approveTemp != null)
result.REJECT_INTERFACE = approveTemp.REJECT_INTERFACE;
}
result.Nav_ApproveDetails = result.Nav_ApproveDetails.OrderBy(t => t.NUM).ThenBy(m => m.MODIFY_TIME).ToList();
}
仓库复制
2025-08-25 09:56:57 +08:00
}
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
return result;
});
仓库复制
2025-08-25 09:56:57 +08:00
}
/// <summary>
/// 驳回单据
/// </summary>
/// <param name="entity">对象实体</param>
/// <returns></returns>
[HttpPost, Route("Reject")]
public JsonActionResult<string> Reject([FromBody] T_PF_APPROVE entity)
{
return base.SafeExecute(() =>
{
var ret = string.Empty;
var dbApprove = this.GetEntity<T_PF_APPROVE>(entity.ID.ToString(), false, "Nav_ApproveDetails");
if (dbApprove == null)
this.ThrowError("020027");
if (dbApprove.APPROVE_STATUS != (int)ApproveStatus.Doing)
this.ThrowError("020028");
var node = dbApprove.Nav_ApproveDetails.FirstOrDefault(i => i.ID == entity.CurrentNode.ID);
if (!node.IS_CURRENT)
this.ThrowError("020030");
//查询消息表
var task = this.GetEntity<T_FM_NOTIFICATION_TASK>(i => i.SOURCE_DATA_ID == entity.ID && i.USER_ID == node.APPROVE_USER_ID
&& i.NOTICE_STATUS == FMNoticeStatusEnum.未处理.GetInt(), false);
if (task != null)
{
task.NOTICE_STATUS = FMNoticeStatusEnum.正常已办.GetInt();
task.TASK_DT = DateTime.Now;
if (DateTime.Now > task.TASK_ENDDT)
task.NOTICE_STATUS = FMNoticeStatusEnum.超期办理.GetInt();
}
//修改节点状态
node.NODE_APPROVE_TIME = DateTime.Now;
node.NODE_APPROVE_STATUS = entity.CurrentNode.NODE_APPROVE_STATUS;
node.IS_CURRENT = false;
node.CONTEXT = entity.CurrentNode.CONTEXT;
//驳回时状态改为驳回，并通知申请人重新提交
dbApprove.APPROVE_STATUS = ApproveStatus.Reject.GetInt();
var details = dbApprove.Nav_ApproveDetails;
dbApprove.Nav_ApproveDetails = null;
details.ForEach(i => i.Nav_Approve = null);
var rejectInfo = this.GetEntity<T_PF_APPROVE_TEMP>(t => t.ID == dbApprove.APPROVE_TEMP_ID);
if (rejectInfo != null && !string.IsNullOrEmpty(rejectInfo.REJECT_INTERFACE))
ret = rejectInfo.REJECT_INTERFACE;
else
this.ThrowError("020030");
UnifiedCommit(() =>
{
if (task != null)
this.UpdateEntityNoCommit(task);
this.UpdateEntityNoCommit(dbApprove);
this.BantchUpdateEntityNoCommit(details);
});
return ret;
});
}
/// <summary>
/// 获取驳回意见
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpPost, Route("GetRejectContent")]
public JsonActionResult<string> GetRejectContent(string id)
{
return base.SafeExecute(() =>
{
var result = string.Empty;
var orgId = APT.Infrastructure.Api.AppContext.CurrentSession.OrgId;
var newFilter = new BaseFilter(orgId);
newFilter.SelectField = new List<string> { "Nav_ApproveDetails" };
var approveInfo = this.GetEntities<T_PF_APPROVE>(t => t.DATA_ID == Guid.Parse(id), newFilter).OrderByDescending(m => m.CREATE_TIME).FirstOrDefault();
if (approveInfo != null && approveInfo.Nav_ApproveDetails.Any())
{
var detail = approveInfo.Nav_ApproveDetails.FirstOrDefault(t => t.NODE_APPROVE_STATUS == 20);
if (detail != null)
{
var userInfo = this.GetEntity<T_FM_USER>(t => t.ID == detail.APPROVE_USER_ID && t.ENABLE_STATUS == 0);
result = userInfo?.NAME + "驳回，内容：" + detail.CONTEXT;
}
}
return result;
});
}
/// <summary>
/// 获取驳回原因
/// </summary>
/// <param name="ApproveID"></param>
/// <returns></returns>
[HttpGet, Route("GetRejectContentByAPPID")]
public JsonActionResult<string> GetRejectContentByAPPID(string ApproveID)
{
return SafeExecute<string>(() =>
{
if (string.IsNullOrEmpty(ApproveID))
{
throw new Exception("传参有误");
}
var appID = Guid.Empty;
try
{
appID = new Guid(ApproveID);
}
catch
{
throw new Exception("传参有误");
}
var approveDetail = GetEntity<T_PF_APPROVE_DETAIL>(e => e.APPROVE_ID == appID && !e.ISCANCEL && e.NODE_APPROVE_STATUS == 20);
if (approveDetail != null)
{
var userInfo = this.GetEntity<T_FM_USER>(t => t.ID == approveDetail.APPROVE_USER_ID);
if (DataHelper.GetRequestType(Request.Headers) == 2)
{
return approveDetail.CONTEXT + "\r\n" + (userInfo != null ? userInfo.NAME + "（" + approveDetail.MODIFY_TIME.Value.ToString("yyyy-MM-dd HH:mm") + "）" : approveDetail.MODIFY_TIME.Value.ToString("yyyy-MM-dd HH:mm"));
}
else
{
return userInfo?.NAME + " 驳回内容：" + approveDetail.CONTEXT;
}
}
else
{
throw new Exception("未获取到驳回信息！");
}
});
}
/// <summary>
/// 记录回调失败LOG
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
[HttpPost, Route("AddLog")]
public JsonActionResult<bool> AddLog([FromBody] T_PF_APPROVE entity)
{
return base.SafeExecute(() =>
{
var loginUserId = APT.Infrastructure.Api.AppContext.CurrentSession.UserID;
string data = "APPROVE:" + JsonConvert.SerializeObject(entity);
SysLogService.AddLog(entity.ORG_ID.Value, loginUserId.Value, PFSysLogTypeEnum.FaildApproveCallBack, "PF119", "审批流回调失败-hmr记录", string.IsNullOrEmpty(entity.CALLBACK_INTERFACE) ? "" : "未执行回调：" + (entity.CALLBACK_INTERFACE + "ID=(" + entity.ID + ")&" + "DATA_ID=(" + entity.DATA_ID + ")"), data);
return true;
});
}
/// <summary>
/// 根据数据id获取审核id
/// </summary>
/// <param name="keywordFilter">参数</param>
/// <returns></returns>
[HttpPost, Route("GetApproveInfo")]
public JsonActionResult<List<T_PF_APPROVE>> GetApproveInfo([FromBody] KeywordFilter keywordFilter)
{
return SafeExecute<List<T_PF_APPROVE>>(() =>
{
Guid dataId = new Guid(keywordFilter.Keyword);
bool isAPPROVEID = false;
if (string.IsNullOrEmpty(keywordFilter.Keyword))
this.ThrowError("020005");
if (!string.IsNullOrEmpty(keywordFilter.Parameter2))
{
#region 反射demo 行255
var parms = keywordFilter.Parameter2.Split(',');
string tableName = parms[0];
string attribute = parms[1];
var dbType = APT.Infrastructure.Core.Refctor.ReflectHelper.FindTypeInCurrentDomain(tableName);
if (dbType != null)
{
//var mt = this.GetType().GetMethods().OrderBy(e => e.Name).ToList();
if (keywordFilter.Parameter2 == "T_BS_RISK_SUBMIT_NOTICE,RISK_SUBMIT_ID")
{
//标准化执行 > 安全检查管理 > 手动隐患上报
MethodInfo methodInfo = this.GetType().GetMethod("GetMyEntity2", BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
Expression<Func<T_BS_RISK_SUBMIT_NOTICE, bool>> expression2 = e => e.RISK_SUBMIT_ID == dataId;
var modelNo = methodInfo.MakeGenericMethod(new Type[] { dbType }).
Invoke(this, new object[] { expression2 });
//T_BS_RISK_SUBMIT_NOTICE modelNo = GetEntity<T_BS_RISK_SUBMIT_NOTICE>(e => e.RISK_SUBMIT_ID == dataId);
if (modelNo != null)
dataId = new Guid(dbType.GetProperty("ID").GetValue(modelNo).ToString());
else
return null;
//throw new Exception("未获取到审批流信息！");
}
else if (keywordFilter.Parameter2 == "T_BS_SAFE_CHECK,APPROVE_CHECKAUDIT_ID")
{
MethodInfo methodInfo = this.GetType().GetMethod("GetMyEntity", BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
var entity = methodInfo.MakeGenericMethod(new Type[] { dbType }).
Invoke(this, new object[] { dataId });
if (entity != null)
{
var prop = dbType.GetProperty(attribute).GetValue(entity);
if (prop != null)
{
dataId = new Guid(prop.ToString());
isAPPROVEID = true;
}
else
{
dataId = Guid.Empty;
}
}
}
else if (keywordFilter.Parameter2 == "T_BS_SAFE_CHECK,APPROVE_ID")
{
MethodInfo methodInfo = this.GetType().GetMethod("GetMyEntity", BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
var entity = methodInfo.MakeGenericMethod(new Type[] { dbType }).
Invoke(this, new object[] { dataId });
if (entity != null)
{
var prop = dbType.GetProperty(attribute).GetValue(entity);
if (prop != null)
{
dataId = new Guid(prop.ToString());
isAPPROVEID = true;
}
else
{
dataId = Guid.Empty;
}
}
}
}
#endregion
////以这种形式传参查看反射实现 一劳永逸
//if (keywordFilter.Parameter2 == "T_BS_RISK_SUBMIT_NOTICE,RISK_SUBMIT_ID")
//{
// T_BS_RISK_SUBMIT_NOTICE modelNo = GetEntity<T_BS_RISK_SUBMIT_NOTICE>(e => e.RISK_SUBMIT_ID == dataId);
// if (modelNo != null)
// dataId = modelNo.ID;
// else
// return null;
// //throw new Exception("未获取到审批流信息！");
//}
//else if (keywordFilter.Parameter2 == "T_BS_SAFE_CHECK,APPROVE_CHECKAUDIT_ID")
//{
// var T_BS_SAFE_CHECK = GetEntity<T_BS_SAFE_CHECK>(e => e.ID == dataId);
// if (T_BS_SAFE_CHECK != null && T_BS_SAFE_CHECK.APPROVE_CHECKAUDIT_ID.HasValue)
// {
// dataId = T_BS_SAFE_CHECK.APPROVE_CHECKAUDIT_ID.Value;
// isAPPROVEID = true;
// }
// else
// {
// dataId = Guid.Empty;
// }
//}
}
Expression<Func<T_PF_APPROVE, bool>> expression = e => e.DATA_ID == dataId;
if (isAPPROVEID)
{
expression = e => e.ID == dataId;
}
if (!string.IsNullOrEmpty(keywordFilter.Parameter1))
{
expression = expression.And(e => e.PARAM == keywordFilter.Parameter1);
}
var orgId = APT.Infrastructure.Api.AppContext.CurrentSession.OrgId;
var dbApprove = this.GetEntities<T_PF_APPROVE>(expression, new BaseFilter(keywordFilter.OrgId), new string[] { "Nav_ApproveDetails.Nav_ApproveUser" }).OrderByDescending(t => t.CREATE_TIME).ToList();
if (!dbApprove.Any())
return null;
return dbApprove;
});
}
public bool MeetingMinutesBack(string id)
{
//状态修改
Guid MeetingMinutesId = new Guid(id);
T_SC_MT_MEETING_MINUTES entity = GetEntity<T_SC_MT_MEETING_MINUTES>(MeetingMinutesId);
entity.STATUS = PFStandardStatus.Archived;//变成已归档
this.UnifiedCommit(() =>
{
if (entity != null)
UpdateEntityNoCommit(entity);
});
return true;
}
/// <summary>
/// 工作票回调函数
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
private bool BackUpdate_FOJobCrucialLicense(string id, Action action)
仓库复制
2025-08-25 09:56:57 +08:00
{
//var entity = this.GetEntity<T_FO_CRUCIAL_LICENSE_JOB>(id, false, "Nav_OperationStep", "Nav_ApplyUser", "Nav_CrucialLicensePerson");
var entity = this.GetEntity<T_FO_CRUCIAL_LICENSE_JOB>(id, new string[] { "Nav_OperationStep", "Nav_ApplyUser", "Nav_CrucialLicensePerson" });// wyw
entity.IS_PUBLISH = (int)FOPreMeetingStatusEnum.签到中;
//触发技术交底表
var tech = new T_FO_TECH_DISCLOSURE_FROM();
var techUsers = new List<T_FO_TECH_DISCLOSURE_PERSON>();
var notices = new List<T_FM_NOTIFICATION_TASK>();
var techForm = this.GetEntity<T_FO_TECH_DISCLOSURE_FROM>(t => t.JOB_NAME_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.JOB_NAME_ID = entity.ID;
tech.JOB_LOCATION = entity.JOB_LOCATION;
tech.DISCLOSURE_PERSON_ID = entity.APPLY_USER_ID;
tech.IS_AUTO = (int)ISImportantEnum.是;
tech.IS_OUTSOURCE = false;
tech.RELATED_ID = null;
if (entity.MONITOR_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.MONITOR_USER_ID;
person.TECH_DISCLOSURE_FROM_ID = tech.ID;
person.CREATER_ID = entity.CREATER_ID;
techUsers.Add(person);
}
if (entity.Nav_CrucialLicensePerson != null && entity.Nav_CrucialLicensePerson.Any())
{
entity.Nav_CrucialLicensePerson.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();
var userIds = entity.Nav_CrucialLicensePerson.Select(t => (Guid)t.USER_ID).Distinct().ToList();
//if (!userIds.Contains((Guid)entity.MONITOR_USER_ID))
//{
// techUsers.Where(t => t.USER_ID == entity.MONITOR_USER_ID).ForEach(m => m.DEAL_STATUS = FOUserShiftStatusEnum.已处理);
//}
var UserNames = new List<string>();
var user = this.GetEntities<T_FM_USER>(t => t.ENABLE_STATUS == (int)FMEnableStatusEnum.启用 && (userIds.Contains(t.ID) || t.ID == entity.APPLY_USER_ID), new BaseFilter(entity.ORG_ID));
var userFirst = user.FirstOrDefault(t => t.ID == entity.APPLY_USER_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);
if (userFirst != null)
{
notices.Add(NotificationTaskService.InsertUserNoticeTaskModel("安全技术交底表(" + entity.JOB_DATE.Value.ToShortDateString().Replace("/", "") + ")", tech.ID, entity.ORG_ID, entity.APPLY_USER_ID.Value, userFirst?.NAME, DateTime.Now,
entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO019"));
}
if (userIds != null && userIds.Any())
{
notices.AddRange(NotificationTaskService.InsertUserNoticeTaskModels("关键作业/许可作业工作票确认(" + entity.JOB_DATE.Value.ToShortDateString().Replace("/", "") + ")", entity.ID, entity.ORG_ID, userIds, UserNames, DateTime.Now,
entity.JOB_DATE.Value, (int)FMNoticeTypeEnum.消息, "FO017_SHOWPRINT"));
}
}
else
{
entity.IS_PUBLISH = (int)FOPreMeetingStatusEnum.归档;
tech = null; techUsers = null; notices = null;
}
UnifiedCommit(() =>
{
if (entity != null)
this.UpdateEntityNoCommit(entity);
if (notices != null && notices.Any())
this.BantchSaveEntityNoCommit(notices);
if (tech != null)
this.UpdateEntityNoCommit(tech);
if (techUsers != null && techUsers.Any())
this.BantchSaveEntityNoCommit(techUsers);
if (action != null)
action();
});
return true;
}
1、所有总、子公司数据库链接存入Redis，提供基础方法获取链接 2、审批角色 添加 是否总部【ISHEAD】属性 ，总部会同步到子公司，子公司不能修改总部传入的数据 3、审批明细 添加【ISHEAD】属性 ，功能暂未处理 4、首页获取待办修改 使不过滤ORGID 5、用户添加时，如果是总公司 同步到子公司，同步修改了一些bug 6、审批页面数据获取方法【FullGet】提供修改前提 后续功能待完善 7、HeadHelper.GetIsHead 判断是否总部 ["Tenant"]"0003"
2025-10-23 09:54:36 +08:00
private bool BackUpdate_FOJobEventRecord(string id, Action action)
仓库复制
2025-08-25 09:56:57 +08:00
{
var entity = this.GetEntity<T_FO_JOB_EVENT_RECORD>(id, "Nav_Details");
entity.FORM_STATUS = (int)FOTeamActivityState.已归档;
UnifiedCommit(() =>
{
if (entity != null)
this.UpdateEntityNoCommit(entity);
if (action != null)
action();
});
return true;
}
}
}
Reference in New Issue Copy Permalink