package com.landray.kmss.xp.org.organizational.util;
import com.alibaba.fastjson.JSONObject;
import com.landray.kmss.sys.organization.interfaces.ISysOrgCoreService;
import com.landray.kmss.sys.organization.model.*;
import com.landray.kmss.sys.organization.provider.function.OrgFunctionExtend;
import com.landray.kmss.util.SpringBeanUtil;
import com.landray.kmss.util.StringUtil;
import com.landray.kmss.util.UserUtil;
import com.landray.kmss.xp.modeling.app.it.service.spring.XpEkpSqlDefinitionServiceImp;
import com.landray.kmss.xp.modeling.app.it.service.spring.XpEkpSqlEkpServiceImp;
import com.landray.kmss.xp.org.organizational.constant.XpSysOrgElementConstant;
import com.landray.kmss.xp.org.organizational.service.spring.XpSysOrgMatrixServiceImp;
import com.landray.kmss.xp.util.XpHibernateUtil;
import com.landray.kmss.xp.util.XpStringUtil;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* 公式定义器自定义函数 - 组织架构相关
*@author Liquid
*/
public class XpOrgUtil {
public static final String DEPT_LEADER_FIRST = "1";
public static final String DEPT_LEADER_LAST = "2";
private static ISysOrgCoreService sysOrgCoreService;
private static XpSysOrgMatrixServiceImp xpSysOrgMatrixService;
private static ISysOrgCoreService getSysOrgCoreService() {
if (sysOrgCoreService == null) {
sysOrgCoreService = (ISysOrgCoreService) SpringBeanUtil.getBean("sysOrgCoreService");
}
return sysOrgCoreService;
}
public static XpSysOrgMatrixServiceImp getXpSysOrgMatrixService() {
if (xpSysOrgMatrixService == null) {
xpSysOrgMatrixService = (XpSysOrgMatrixServiceImp)SpringBeanUtil.getBean("xpSysOrgMatrixTarget");
}
return xpSysOrgMatrixService;
}
/**
* [已加公式定义器]
* @apiNote 测试
* @author Liquid
*/
public static String test(String param) {
System.out.println("TEST SUCCESSFULLY!");
return "TestReturn";
}
/**
* [已加公式定义器]
* @apiNote 获取组织对象所属的一级部门(真正使用的那一层部门)
* @author Liquid
* @date 2022年5月23日
* @param sysOrgElement 目标组织对象（人员、岗位、部门）
* @return SysOrgElement
*/
public static SysOrgElement getFirstDept(SysOrgElement sysOrgElement) {
/* 最新获取一级部门方式：向上找关键字为Y的部门作为一级部门 liquid 2023年4月21日18:17:03 */
// 非机构类型，向上找关键字为Y的部门
SysOrgElement parent = sysOrgElement;
while (!"Y".equals(parent.getFdKeyword())) {
if (Objects.equals(parent.getFdOrgType(), XpSysOrgElementConstant.ORG_TYPE_ORG)) {
break;
}
parent = parent.getFdParent();
}
return parent;
}
/**
* [已加公式定义器]
* @apiNote 获取组织对象所属的二级部门
* @author Liquid
* @date 2022年5月23日
* @param sysOrgElement 目标组织对象（人员、岗位、部门）
* @return SysOrgElement
*/
public static SysOrgElement getSecondDept(SysOrgElement sysOrgElement) {
return getDeptByLevel(sysOrgElement, 2);
}
/**
* [已加公式定义器]
* 获取组织架构的第N级部门
* @author Liquid
* @date 2022年5月23日
* @param sysOrgElement 目标组织对象（人员、岗位、部门）
* @param level 级数(1、2、3...)，例如黎令魁的1级部门为信息部，2级部门为信息系统组，3级部门为OA组
*/
private static SysOrgElement getDeptByLevel(SysOrgElement sysOrgElement, int level) {
List<SysOrgElement> orgList = getHierarchyList(sysOrgElement);
Integer lastOrgType = orgList.get(orgList.size() - 1).getFdOrgType();
if (lastOrgType.equals(XpSysOrgElementConstant.ORG_TYPE_PERSON) ||
lastOrgType.equals(XpSysOrgElementConstant.ORG_TYPE_POST)) {
// 最后一个对象是人员||岗位，则去掉
orgList.remove(orgList.size() - 1);
}
SysOrgElement rtnObj = null;
if (level < orgList.size()) {
rtnObj = orgList.get(level);
} else if (orgList.size() == 1) {// 当传入是人员或岗位，且该人员或岗位在某个机构里面时，该项成立
rtnObj = orgList.get(0);
}
return rtnObj;
}
/**
* @apiNote 判断俩组织架构对象是否属于同一个一级部门
* @author Liquid
* @date 2022年5月23日
* @param orgElm1 目标组织对象（人员、岗位、部门、机构）
* @param orgElm2 目标组织对象（人员、岗位、部门、机构）
* @return boolean
*/
public static boolean isSameFirstDept(SysOrgElement orgElm1, SysOrgElement orgElm2) {
String deptName1 = getFirstDept(orgElm1).getFdId();
String deptName2 = getFirstDept(orgElm2).getFdId();
return deptName1.equals(deptName2);
}
/**
* [已加公式定义器]
* @apiNote 递归获取组织对象的全部人员（SysOrgElement.getFdPersons()用不了!!!）
* @author Liquid
* @date 2022年5月23日
* @param sysOrgElement 目标组织对象（部门、机构）
* @return List<SysOrgElement>
*/
public static List<SysOrgElement> getAllUsers(SysOrgElement sysOrgElement) {
List<SysOrgElement> rtnList = new ArrayList<>();
List<?> children = sysOrgElement.getFdChildren();
for (Object o : children) {
SysOrgElement child = (SysOrgElement) o;
int childType = child.getFdOrgType();
// 人员对象
if (childType == XpSysOrgElementConstant.ORG_TYPE_PERSON) {
rtnList.add(child);
}
// 机构或部门
else if (childType == XpSysOrgElementConstant.ORG_TYPE_ORG
|| childType == XpSysOrgElementConstant.ORG_TYPE_DEPT) {
rtnList.addAll(getAllUsers(child));
}
}
return rtnList;
}
/**[已加公式定义器]
* 获取组织对象全部子组织对象
* @author Liquid
* @date 2022年6月26日13
* @param sysOrgElement 目标组织对象
* @param orgType 子组织对象类型
* @return List<SysOrgElement>
*/
public static List<SysOrgElement> getAllChildren(SysOrgElement sysOrgElement, int orgType) {
ISysOrgCoreService sysOrgCoreService = getSysOrgCoreService();
try {
return (List<SysOrgElement>) sysOrgCoreService.findAllChildren(sysOrgElement, orgType);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* [已加公式定义器]
* @apiNote 获取组织对象的层级列表 （从所属最低级的架构开始直到第一个机构，子公司在不返回信邦实业）
* @author Liquid
* @date 2022年5月23日
* @param sysOrgElement 目标组织对象（人员、岗位、部门、机构）
* 传入 "黎令魁" 返回 信邦实业,信息部,OA组,黎令魁
* 传入 "OA组" 返回 信邦实业,信息部,OA组
* 传入 "OA工程师" 信邦实业,信息部,OA组,OA工程师
* @return List<SysOrgElement>
*/
public static List<SysOrgElement> getHierarchyList(SysOrgElement sysOrgElement) {
List<SysOrgElement> hierarchyList = new ArrayList<>();
hierarchyList.add(sysOrgElement);
SysOrgElement lastOrg = sysOrgElement.getFdParent();
// while上一级架构存在且不是机构类型（公司）
while (lastOrg != null && lastOrg.getFdOrgType() != XpSysOrgElementConstant.ORG_TYPE_ORG) {
hierarchyList.add(0, lastOrg);
lastOrg = lastOrg.getFdParent();
}
if(lastOrg != null) {
hierarchyList.add(0, lastOrg);
}
return hierarchyList;
}
/**
* 判断person的岗位是否含有post
* @author liquid
* @date 2023年4月2日
* @param post 岗位
* @param person 人员
* @return person的岗位是否含有post
*/
public static boolean isPersonInPost(SysOrgElement post, SysOrgElement person) {
List<SysOrgElement> postList = person.getFdPosts();
postList = postList == null ? new ArrayList<>() : postList;
List<String> postIdList = postList.stream().map(SysOrgElement::getFdId).collect(Collectors.toList());
return postIdList.contains(post.getFdId());
}
/**
* [已加公式定义器]
* @apiNote 获取组织对象所属机构编号
* @author Liquid
* @date 2022年5月23日
* @param sysOrgElement 目标组织对象(个人、岗位、部门、机构)
* @return String
*/
public static String getFdParentOrgNo(SysOrgElement sysOrgElement) {
return sysOrgElement.getFdParentOrg().getFdNo();
}
/**
* [已加公式定义器]
* @apiNote 获取汇报关系(若传入部门或机构则返回对应领导的汇报关系)
* @author Liquid
* @date 2022年5月23日
* @param sysOrgElement 组织架构对象(机构、部门、岗位、人员)
* @param flag 标识，true：存在[行政总裁]则去掉[总裁]
* @return List<SysOrgElement>
*/
public static List<SysOrgElement> getReportRelation (SysOrgElement sysOrgElement, boolean flag) throws Exception {
/* 获取完整的汇报关系 */
int sysOrgElementOrgType = sysOrgElement.getFdOrgType();
SysOrgElement targetOrg = sysOrgElement;// 目标对象(拿谁的汇报关系)
List<SysOrgElement> reportList = new ArrayList<>();
boolean is_org_dept = sysOrgElementOrgType == XpSysOrgElementConstant.ORG_TYPE_DEPT
|| sysOrgElementOrgType == XpSysOrgElementConstant.ORG_TYPE_ORG;// 传入的架构对象是机构或部门
if (is_org_dept) {// 如果传入的sysOrgElement是机构/部门，则拿机构/部门领导的汇报关系(包括机构/部门领导)，此时targetOrg为对应领导
targetOrg = sysOrgElement.getHbmThisLeader();
reportList.add(targetOrg);// 传入的是机构或部门时，对应的机构/部门领导都要加到审批线(这样才符合业务逻辑)
}
if (XpHibernateUtil.isHbmObjNull(targetOrg)) {
return reportList;
}
List<SysOrgElement> leaderPostList = OrgFunctionExtend.getElementDescLeader(targetOrg, 1, null);
int level = 1;
int j = 0;
while (leaderPostList.size() != 0) {
// 最大层级数（避免死循环）
if (j == 15) {
break;
}
SysOrgElement leaderPost = leaderPostList.get(0);
reportList.add(leaderPost);
leaderPostList = OrgFunctionExtend.getElementDescLeader(targetOrg, ++level, targetOrg);
j++;
}
/* (传入非部门和机构)如果汇报关系中第一个元素是自己或自己岗位 → 去掉 */
if (!is_org_dept && reportList.size() != 0) {
SysOrgElement firstOrg = reportList.get(0);
boolean isSameType = Objects.equals(firstOrg.getFdOrgType(), targetOrg.getFdOrgType());// 同一类型
boolean isSameOrgObject = Objects.equals(firstOrg.getFdId(), targetOrg.getFdId());// 同一个对象
if (isSameType && isSameOrgObject) {
reportList.remove(0);
} else if (Objects.equals(firstOrg.getFdOrgType(), XpSysOrgElementConstant.ORG_TYPE_POST)){
// firstOrg是岗位，则targetOrg一定是人员
if (isPersonInPost(firstOrg, targetOrg)) {
reportList.remove(0);
}
} else if (Objects.equals(targetOrg.getFdOrgType(), XpSysOrgElementConstant.ORG_TYPE_POST)) {
if (isPersonInPost(targetOrg, firstOrg)) {
reportList.remove(0);
}
}
}
/* 处理完整汇报关系中存在行政总裁和董事长的情况 - 当flag为true && 同时存在行政总裁和董事长 && 目标对象不是行政总裁，则去掉董事长 */
List<SysOrgElement> rtnList = new ArrayList<>();
boolean targetOrg_900 = false;// 目标对象的岗位等级是否大于等于900
// 目标对象是岗位，直接拿其等级进行判断
if (targetOrg.getFdOrgType() == XpSysOrgElementConstant.ORG_TYPE_POST) {
Map<String, Object> proMap = targetOrg.getCustomPropMap();// 注意本地启动时，proMap拿到的是空map对象
Integer postLevel = (Integer) proMap.get("fd_post_level");
postLevel = postLevel == null ? 0 : postLevel;
targetOrg_900 = postLevel >= 900;
}
// 目标对象是人员，拿其全部岗位进行判断(其一符合即可)
if (targetOrg.getFdOrgType() == XpSysOrgElementConstant.ORG_TYPE_PERSON) {
List<SysOrgElement> postList = targetOrg.getFdPosts();
for (SysOrgElement post : postList) {
Map<String, Object> proMap = post.getCustomPropMap();
Integer postLevel = (Integer) proMap.get("fd_post_level");
postLevel = postLevel == null ? 0 : postLevel;
targetOrg_900 = postLevel >= 900;
if (targetOrg_900) break;
}
}
for (SysOrgElement org : reportList) {
rtnList.add(org);
if (flag) {// 需处理[完整汇报关系中同时含有行政总裁和董事长]的问题
Map<String, Object> proMap = org.getCustomPropMap();
Integer postLevel = (Integer) proMap.get("fd_post_level");
postLevel = postLevel == null ? 0 : postLevel;
if (postLevel >= 900 && !targetOrg_900) {// 当目标对象岗位等级,非大于等于900，岗位等级截止于900(含900)
break;
}
}
}
return rtnList;
}
/**
* [已加公式定义器]
* @apiNote 获取汇报关系(若传入部门则返回部门领导的汇报关系), 返回某级的领导，不存在返回null
* @author Liquid
* @date 2022年5月23日
* @param sysOrgElement 组织架构对象(机构、部门、岗位、人员)
* @param flag 标识，true：存在[行政总裁]则去掉[总裁]
* @param leaderLevel 1: 1级直线领导(汇报关系上的第1个元素) 2: 2级直线领导(汇报关系上的第2个元素)
* @return List<SysOrgElement>
*/
public static SysOrgElement getReportRelationByLevel(SysOrgElement sysOrgElement, boolean flag, int leaderLevel) throws Exception {
List<SysOrgElement> reportList = getReportRelation(sysOrgElement, flag);
int index = leaderLevel - 1;
if (index < reportList.size()) {
return reportList.get(index);
}
return null;
}
/**
* [已加公式定义器]
* @apiNote 参数只做简单校验，如调用异常，请开发人员查看日志排查
* @author zengwf
* @date 2022年5月23日
* @param sysOrgElement 组织架构对象(机构、部门、岗位、人员)
* @param businessId = 业务授权ID
* @param num 额度/数量
* @return List<SysOrgElement>
*/
public static List<SysOrgElement> getRelationsByBusinessAuth
(SysOrgElement sysOrgElement,String businessId,String num) throws Exception {
//获取完整的审批线
List<SysOrgElement> signList = getReportRelation(sysOrgElement,false);
//经过业务授权过滤后的审批线
List<SysOrgElement> rtnList = new ArrayList<>();
if(signList.size() <= 0) {
return null;
}
BigDecimal quota = null;
if(StringUtil.isNotNull(num)){
quota =new BigDecimal(num);
}
//是否根据业务授权过滤
if(StringUtil.isNotNull(businessId) && null != quota){
System.out.println("getRelationsByBusinessAuth----------------------"+businessId);
XpEkpSqlEkpServiceImp xpEkpSqlService = (XpEkpSqlEkpServiceImp) SpringBeanUtil.getBean("xpEkpSqlEkpTarget");
XpEkpSqlDefinitionServiceImp xpEkpSqlDefinitionService = (XpEkpSqlDefinitionServiceImp) SpringBeanUtil.getBean("xpEkpSqlDefinitionTarget");
Map definitionData = xpEkpSqlDefinitionService.getSelectedColumnsByKey("ekpsql_hr_president_sign");
//根据关键字获取sql
String sql = (String) definitionData.get("fd_sql");
JSONObject params = new JSONObject();
params.put("userid", sysOrgElement.getFdId());
List<?> queryData = xpEkpSqlService.executeQuery(sql, params);
//当申请人是马总直管时，且事件为请假或出差时，需要判断免审批天数
//当申请人是马总直管时，且事件为财务、金钱相关时，无论申请多少，皆需要马总审批
//当申请人非马总直管时，正常获取人员审批线，遍历人员，查找业务授权表，找到符合数据则停止，返回审批线。
if (queryData.size() > 0) {//马总直管人员
Object [] obj = (Object [])queryData.get(0);
String[] typeArr = {"askforleave","businesstrip_in","businesstrip_out"};
rtnList = signList;
for (int i = 0; i < typeArr.length; i++) {
if(businessId.contains(typeArr[i])) {
BigDecimal bg = new BigDecimal(obj[i].toString());
if (quota.compareTo(bg) == 1) {
rtnList = new ArrayList();
rtnList.add(signList.get(0));
break;
} else {
rtnList = new ArrayList();
break;
}
}
}
}else {//非马总直管人员
definitionData = xpEkpSqlDefinitionService.getSelectedColumnsByKey("ekpsql_hr_approval_power");
sql = (String) definitionData.get("fd_sql");
for (SysOrgElement orgElement : signList) {
params.clear();
params.put("userId", orgElement.getFdId());
params.put("typeId", businessId);
params.put("quota", quota);
queryData = xpEkpSqlService.executeQuery(sql, params);
rtnList.add(orgElement);
if (queryData.size() > 0) {
break;
}
}
}
}
return rtnList;
}
/**
* [已加公式定义器]
* @apiNote 参数只做简单校验，如调用异常，请开发人员查看日志排查
* @author zengwf
* @date 2022年5月23日
* @param list 审批线
* @param minLevel 最小值
* @param maxLevel 最大值
* @return List<SysOrgElement>
*/
public static List<SysOrgElement> getRelationsByPostLevel (List<SysOrgElement> list, Integer minLevel, Integer maxLevel)
throws Exception {
if(list.size() <= 0){
System.out.println("获取当前岗位审批线出错！请查看该岗位的组织架构关系");
return null;
}
System.out.println("根据岗位等级区间进行切割，起始级别："+minLevel+"，最高级别："+maxLevel);
Integer level = 0;
List<SysOrgElement> rtnList = new ArrayList<>();
for (SysOrgElement sysOrgElement : list) {
if (sysOrgElement == null) continue;
Map map = sysOrgElement.getCustomPropMap();
// 无岗位等级 或 是人员时默认加入
if (map.get("fd_post_level") == null || map.get("fd_post_level").toString().equals("null")) {
if (sysOrgElement.getFdOrgType() == XpSysOrgElementConstant.ORG_TYPE_PERSON) {
rtnList.add(sysOrgElement);
}
continue;
}
level = (Integer) map.get("fd_post_level");
if (Math.max(minLevel, level) == Math.min(level, maxLevel)) {
rtnList.add(sysOrgElement);
System.out.println("当前岗位：" + sysOrgElement.getFdName() + "，级别：" + level + "，符合");
}
}
return rtnList;
}
public static Class getClassByOrgType(int orgType) {
Class classType = null;
switch (orgType) {
case XpSysOrgElementConstant.ORG_TYPE_ORG: classType = SysOrgOrg.class;break;
case XpSysOrgElementConstant.ORG_TYPE_DEPT: classType = SysOrgDept.class;break;
case XpSysOrgElementConstant.ORG_TYPE_POST: classType = SysOrgPost.class;break;
case XpSysOrgElementConstant.ORG_TYPE_PERSON: classType = SysOrgPerson.class;break;
case XpSysOrgElementConstant.ORG_TYPE_GROUP: classType = SysOrgGroup.class;break;
default : {};
}
return classType;
}
/**
* @apiNote 通过id获取组织对象
* @author liquid
* @date 2022年5月23日
* @param fdId 组织对象fd_id
* @param classType 需获取的实际对象(SysOrgElement.class 或 SysOrgElement的子类)
* @return SysOrgElement
*/
public static SysOrgElement getSysOrgElementById(String fdId, Class classType) {
SysOrgElement orgObj = null;
ISysOrgCoreService sysOrgCoreService = getSysOrgCoreService();
try {
orgObj = sysOrgCoreService.findByPrimaryKey(fdId, classType);
} catch (Exception e) {
e.printStackTrace();
}
return orgObj;
}
/**
* @apiNote 通过id列表获取组织对象
* @author liquid
* @date 2022年7月31日
* @param idList 组织对象fd_id列表
* @param classType 需获取的实际对象(SysOrgElement.class 或 SysOrgElement的子类)
* @return List<SysOrgElement>
*/
public static List<SysOrgElement> getSysOrgElementByIdList(List<String> idList, Class classType) {
List<SysOrgElement> orgList = new ArrayList<>();
for (String id : idList) {
SysOrgElement org = getSysOrgElementById(id, classType);
if (org != null) {
orgList.add(org);
}
}
return orgList;
}
/**
* @apiNote 通过id获取组织对象
* @author liquid
* @date 2022年5月23日
* @param fdId 组织对象fd_id
* @return SysOrgPerson
*/
public static SysOrgPerson getSysOrgPersonById(String fdId) {
SysOrgPerson orgPerson = null;
ISysOrgCoreService sysOrgCoreService = getSysOrgCoreService();
try {
orgPerson = (SysOrgPerson) sysOrgCoreService.findByPrimaryKey(fdId, SysOrgPerson.class);
} catch (Exception e) {
e.printStackTrace();
}
return orgPerson;
}
/**
* @apiNote 通过id列表获取人员组织对象
* @author liquid
* @date 2022年7月31日
* @param idList 组织对象fd_id列表
* @return List<SysOrgPerson>
*/
public static List<SysOrgPerson> getSysOrgPersonByIdList(List<String> idList) {
List<SysOrgPerson> personList = new ArrayList<>();
for (String id : idList) {
SysOrgPerson person = getSysOrgPersonById(id);
if (person != null) {
personList.add(person);
}
}
return personList;
}
/**[已加公式定义器]
* @apiNote 通过登录名获取人员组织对象
* @author liquid
* @date 2022年5月24日
* @param fdLoginName 人员登录名
* @return SysOrgPerson
*/
public static SysOrgPerson getSysOrgPersonByLoginName(String fdLoginName) {
SysOrgPerson orgPerson = null;
ISysOrgCoreService sysOrgCoreService = getSysOrgCoreService();
try {
orgPerson = sysOrgCoreService.findByLoginName(fdLoginName);
} catch (Exception e) {
e.printStackTrace();
}
return orgPerson;
}
/**
* @apiNote 通过登录名字列表获取人员组织对象
* @author liquid
* @date 2022年7月31日
* @param loginNameList 组织对象fd_id列表
* @return List<SysOrgPerson>
*/
public static List<SysOrgPerson> getSysOrgPersonByLoginNameList(List<String> loginNameList) {
List<SysOrgPerson> personList = new ArrayList<>();
for (String loginName : loginNameList) {
SysOrgPerson person = getSysOrgPersonByLoginName(loginName);
if (person != null) {
personList.add(person);
}
}
return personList;
}
/**
* @apiNote 根据参数获取组织架构对象
* @author liquid
* @date 2022年5月24日
* @param fdId 架构对象id(无则传入null)
* @param fdLoginName 人员登录名(无则传入null)
* @param request HttpServletRequest(无则传入null)
* 提示：以上参数优先级逐次降低，若均无则选用[当前调用人员对象,传入request以获取页面中的调用人员]
* @return SysOrgPerson
*/
public static SysOrgElement getSysOrgPersonByOptions(String fdId, String fdLoginName, HttpServletRequest request) {
SysOrgElement orgElm;
if (StringUtil.isNotNull(fdId)) {
orgElm = XpOrgUtil.getSysOrgPersonById(fdId);
}
else if (StringUtil.isNotNull(fdLoginName)) {
orgElm = XpOrgUtil.getSysOrgPersonByLoginName(fdLoginName);
}
else {
// 当前调用人员对象
orgElm = request == null ? UserUtil.getUser() : UserUtil.getUser(request);
}
return orgElm;
}
/**
* [已加公式定义器]
* 通过群组id获取群组全部人员对象
* @author liquid
* @date 2022年9月2日
* @param groupId 群组id
* @return 群组内全部人员对象
*/
public static List<SysOrgPerson> getPersonByGroupId(String groupId) throws Exception {
ISysOrgCoreService sysOrgCoreService = getSysOrgCoreService();
SysOrgElement orgElement = getSysOrgElementById(groupId, SysOrgGroup.class);
if (XpHibernateUtil.isHbmObjNull(orgElement)) {
return new ArrayList<>();
}
SysOrgGroup group = (SysOrgGroup)sysOrgCoreService.format(orgElement);
return getSysOrgCoreService().expandToPerson(group.getFdMembers());
}
/**
* 创建架构对象(非hibernate对象)
* @author liquid
* @date 2022年11月9日
* @param id 架构对象fd_id
* @param type 实际对象类型（传入非XpSysOrgElementConstant，则返回SysOrgElement）
* @return new出来的架构对象
*/
public static SysOrgElement createOrg(String id, int type) {
SysOrgElement sysOrgElement;
switch (type) {
case XpSysOrgElementConstant.ORG_TYPE_PERSON: sysOrgElement = new SysOrgPerson(); break;
case XpSysOrgElementConstant.ORG_TYPE_ORG: sysOrgElement = new SysOrgOrg(); break;
case XpSysOrgElementConstant.ORG_TYPE_DEPT: sysOrgElement = new SysOrgDept(); break;
case XpSysOrgElementConstant.ORG_TYPE_POST: sysOrgElement = new SysOrgPost(); break;
case XpSysOrgElementConstant.ORG_TYPE_GROUP: sysOrgElement = new SysOrgGroup(); break;
default : sysOrgElement = new SysOrgElement();
}
sysOrgElement.setFdId(id);
return sysOrgElement;
}
/**
* 创建架构对象(非hibernate对象)
* @author liquid
* @date 2022年11月9日
* @param id 架构对象fd_id
* @param name 架构对象fd_name
* @return new出来的架构对象
*/
public static SysOrgElement createOrg(String id, String name, int type) {
SysOrgElement sysOrgElement = createOrg(id, type);
sysOrgElement.setFdName(name);
return sysOrgElement;
}
/**
* 创建人员架构对象(非hibernate对象)
* @author liquid
* @date 2022年11月9日
* @param id 架构对象fd_id
* @return new出来的架构对象
*/
public static SysOrgPerson createPerson(String id) {
return (SysOrgPerson) createOrg(id, XpSysOrgElementConstant.ORG_TYPE_PERSON);
}
/**
* 创建人员架构对象(非hibernate对象)
* @author liquid
* @date 2022年11月9日
* @param id 架构对象fd_id
* @param name 架构对象fd_name
* @return new出来的架构对象
*/
public static SysOrgPerson createPerson(String id, String name) {
return (SysOrgPerson) createOrg(id, name, XpSysOrgElementConstant.ORG_TYPE_PERSON);
}
/**
* 创建人员架构对象(非hibernate对象)
* @author liquid
* @date 2022年11月9日
* @param map {id:人员id, name:人员名称}
* @return new出来的架构对象
*/
public static SysOrgPerson createPersonByMap(Map<String, String> map) {
String id = map.get("id");
String name = map.get("name");
return createPerson(id, name);
}
/**
* 创建架构对象列表(非hibernate对象)
* @author liquid
* @date 2022年11月9日
* @param idList 架构对象fd_id列表
* @return new出来的架构对象
*/
public static List<SysOrgElement> createOrgByIds(List<String> idList) {
List<SysOrgElement> rtnList = new ArrayList<>();
idList.forEach(id -> {
rtnList.add(createOrg(id, -1));
});
return rtnList;
}
/**
* 通过人员对象列表获取人员邮箱列表
* @author liquid
* @date 2022年9月2日
* @param orgList 人员对象列表
* @return 人员邮箱列表
*/
public static List<String> getEmailsByOrgList(List<SysOrgPerson> orgList) {
List<String> emails = new ArrayList<>();
if (orgList == null) {
return emails;
}
orgList.forEach(org ->{
if (org != null) {
emails.add(org.getFdEmail());
}
});
return emails;
}
/**
* 通过人员id列表，拿到邮箱列表
* @author liquid
* @date 2022年9月2日
* @param ids 人员id列表
* @return 人员邮箱列表
*/
public static List<String> getEmailsByIdList(List<String> ids) {
List<String> emails = new ArrayList<>();
if (ids == null) {
return emails;
}
List<SysOrgPerson> persons = getSysOrgPersonByIdList(ids);
persons.forEach(person ->{
emails.add(person.getFdEmail());
});
return emails;
}
/**
* 通过人员登录名列表，拿到邮箱列表
* @author liquid
* @date 2022年9月2日
* @param loginNameList 人员登录名列表
* @return 人员邮箱列表
*/
public static List<String> getEmailsByLoginNameList(List<String> loginNameList) {
List<String> emails = new ArrayList<>();
if (loginNameList == null) {
return emails;
}
List<SysOrgPerson> persons = getSysOrgPersonByLoginNameList(loginNameList);
persons.forEach(person ->{
emails.add(person.getFdEmail());
});
return emails;
}
/**
* 通过[群组id]，拿到群组人员邮箱列表
* @author liquid
* @date 2022年9月2日
* @param groupId 群组id
* @return 人员邮箱列表
*/
public static List<String> getEmailsByGroupId(String groupId) throws Exception {
List<SysOrgPerson> persons = getPersonByGroupId(groupId);
List<String> emails = new ArrayList<>();
persons.forEach(person -> {
if (person != null) {
emails.add(person.getFdEmail());
}
});
return emails;
}
/**
* [已加公式定义器]
* 根据中文列名获取矩阵中的组织架构对象列表
* @author liquid
* @date 2022年9月16日
* @param matrixId 矩阵id(矩阵编辑页面url参数fdId，或数据库表sys_org_matrix.fd_id)
* @param name 矩阵列名(中文)
* @param version 版本号(不区分大小写，例如V1、v2)，传入null或空字符串则获取最新版本
* @return 架构对象列表
*/
public static List<SysOrgElement> getMatrixOrgFieldValues(String matrixId, String name, String version) throws Exception {
List matrixValues = getXpSysOrgMatrixService().findMatrixFieldValueByName(matrixId, name, version);
return getSysOrgElementByIdList(matrixValues, SysOrgElement.class);
}
/**
* [已加公式定义器]
* 获取部门领导
* @author liquid
* @date 2022年9月15日
* @param sysOrgElement 目标组织对象（人员、岗位、部门）
* @param which XpOrgUtil.DEPT_LEADER_FIRST：一级部门领导 XpOrgUtil.DEPT_LEADER_LAST：最后一级部门领导
* @return 部门领导
*/
public static SysOrgElement getDeptLeader(SysOrgElement sysOrgElement, String which) {
SysOrgElement dept;
switch (which) {
case DEPT_LEADER_FIRST: dept = getFirstDept(sysOrgElement);break;
case DEPT_LEADER_LAST: dept = sysOrgElement.getFdParent();;break;
default : dept = null;
}
return Objects.requireNonNull(dept).getHbmThisLeader();
}
/**
* 获取部门领导(人员，若领导是岗位则取第一人)
* @author liquid
* @date 2023年3月13日
* @param sysOrgElement 目标组织对象（人员、岗位、部门）
* @param which XpOrgUtil.DEPT_LEADER_FIRST：一级部门领导 XpOrgUtil.DEPT_LEADER_LAST：最后一级部门领导
* @return 部门领导(若是岗位,则取第一人,不存在则返回null)
*/
public static SysOrgElement getDeptLeaderFirstPerson(SysOrgElement sysOrgElement, String which) {
SysOrgElement deptLeader = getDeptLeader(sysOrgElement, which);
if (deptLeader.getFdOrgType().equals(XpSysOrgElementConstant.ORG_TYPE_POST)) {
try {
List personList = OrgFunctionExtend.getPersonByPostName(deptLeader);
if (personList.size() > 0) {
deptLeader = (SysOrgElement) personList.get(0);
} else {
deptLeader = null;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
return deptLeader;
}
/**
* [已加公式定义器]
* 根据明细表人员ID列，返回一个sysOrgPerson的list
* @author zengwf
* @date 2022年11月14日
* @param list 明细表的列
* @return rtnList
*/
public static List getSysOrgPersonByGridColumn(List list) {
List rtnList = new ArrayList();
for (int i = 0; i < list.size(); i++) {
String[] strArr = list.get(i).toString().split(",");
for (int j = 0; j < strArr.length; j++) {
if(StringUtil.isNotNull(strArr[j])) {
SysOrgElement org = getSysOrgPersonById(strArr[j]);
if (!XpHibernateUtil.isHbmObjNull(org)) {
rtnList.add(org);
}
}
}
}
return rtnList;
}
/**
* [已加公式定义器]
* 获取人员的第一个岗位
* @author liquid
* @date 2023年3月1日
* @param person 人员对象
* @return 岗位对象(若目标人员无岗位信息，则元素为null，若传入的是岗位则返回其本身)
*/
public static SysOrgElement getPersonFirstPost(SysOrgElement person) {
if (Objects.equals(person.getFdOrgType(), XpSysOrgElementConstant.ORG_TYPE_POST)) {
return person;
} else if (Objects.equals(person.getFdOrgType(), XpSysOrgElementConstant.ORG_TYPE_PERSON)) {
List posts = person.getFdPosts();
if (posts != null && posts.size() > 0) {
return (SysOrgElement) posts.get(0);
}
}
return new SysOrgElement();
}
/**
* [已加公式定义器]
* 获取人员列表的第一个岗位(返回列表)
* @author liquid
* @date 2023年4月7日
* @param personList 人员对象列表
* @return 岗位对象列表(若目标人员无岗位信息，则元素为null，若传入的是岗位则返回其本身)
*/
public static List<SysOrgElement> getPeopleFirstPost(List<SysOrgElement> personList) {
List<SysOrgElement> postList = new ArrayList<>();
for (SysOrgElement person : personList) {
if (XpHibernateUtil.isHbmObjNull(person)) {
postList.add(null);
continue;
}
SysOrgElement post = getPersonFirstPost(person);
if (XpHibernateUtil.isHbmObjNull(post)) {
postList.add(null);
continue;
}
postList.add(post);
}
return postList;
}
/**
* 获取某岗位下第一个人员对象
* @author liquid
* @date 2023年4月16日
* @param post 岗位对象
* @return 第一个人员对象
*/
public static SysOrgElement getPostFirstPerson(SysOrgElement post) {
if (post.getFdOrgType().equals(XpSysOrgElementConstant.ORG_TYPE_POST)) {
List personList;
try {
personList = OrgFunctionExtend.getPersonByPostName(post);
} catch (Exception e) {
throw new RuntimeException(e);
}
if (personList.size() > 0) {
return (SysOrgElement) personList.get(0);
}
}
return null;
}
}
扫一扫
08-06
10-21
982
982
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
