wangli/orgmanax
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add(feature/REQ-3714) 工人退出班组消息、去掉权限、设置岗位

Browse Source
This commit is contained in:
zhangran 2025-03-11 15:56:44 +08:00
parent 9b4dfab87f
commit e5a9252ce7
14 changed files with 576 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
orgmanax-infra/pom.xml
View File

@ -120,5 +120,10 @@
<artifactId>tyr-client</artifactId>
<version>${revision}</version>
</dependency>
<dependency>
<groupId>cn.axzo.msgcenter</groupId>
<artifactId>msg-center-api-v2</artifactId>
<version>1.0.1-SNAPSHOT</version>
</dependency>
</dependencies>
</project>

20
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/msg/MsgCenterGateway.java Normal file
View File

@ -0,0 +1,20 @@
package cn.axzo.orgmanax.infra.client.msg;
import cn.axzo.msg.center.api.v2.message.feign.MessageApiV2;
import cn.axzo.msg.center.api.v2.message.req.MessageSendV2Req;
import cn.axzo.orgmanax.infra.client.RpcWrapper;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Component
@Slf4j
@RequiredArgsConstructor
public class MsgCenterGateway {
private final MessageApiV2 messageApiV2;
public void sendMsg(MessageSendV2Req req) {
RpcWrapper.wrapApiResult(() ->messageApiV2.send(req),"发送消息、待办", req);
}
}

14
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/msg/vo/JoinLeaveEnum.java Normal file
View File

@ -0,0 +1,14 @@
package cn.axzo.orgmanax.infra.client.msg.vo;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum JoinLeaveEnum {
JOIN("加入"),
LEAVE("退出"),
;
private final String value;
}

48
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/msg/vo/MessageCodeEnum.java Normal file
View File

@ -0,0 +1,48 @@
package cn.axzo.orgmanax.infra.client.msg.vo;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 新版消息
*/
@Getter
@AllArgsConstructor
public enum MessageCodeEnum {
// // bizCodeTemplate: worker:apply:leave:unit:workerIdentityId:platTeamNodeId
// WORKER_APPLY_LEAVE_UNIT("worker_leaving_unit_team", "worker:apply:leave:unit:%d:%d"),
// 加入单位班组申请提交/结果通知 您申请加入${teamLeaderName}的班组,${action}。 -> 工人 bizCodeTemplate: worker:apply:unit:team:platInviteId
WORKER_APPLY_UNIT_TEAM("worker_apply_for_companyclass_station", "worker:apply:unit:team:%d"),
// bizCodeTemplate: change:team:leader:new:platTeamNodeId:newTeamLeaderPersonId
CHANGE_TEAM_LEADER_TO_NEW_LEADER_MSG("companyclass_trade_for_classowner", "change:team:leader:new:%d:%d"),
// 移除单位班组通知 您已被移除${teamLeaderName}的班组,请知悉！ -> 工人 bizCodeTemplate: unit:team:remove:worker:workerIdentityId:platTeamNodeId
UNIT_TEAM_REMOVE_WORKER("delete_worker_companyclass", "unit:team:remove:worker:%d:%d"),
// bizCodeTemplate: unit:profession:add/delete:platTeamNodeId:workerIdentityId
UNIT_WORKER_PROFESSION_CHANGE("companyworker_change_professionName", "unit:profession:%s:%d:%d"),
// bizCodeTemplate: unit:team:dissolve:platTeamNodeId
UNIT_TEAM_DISSOLVE("dissolution_companyclass", "unit:team:dissolve:%d"),
// ${workerName}，已${action}您的班组，请知悉。 -> 班组长 bizCodeTemplate: worker:join/leave:unit:team:platTeamNodeId:workerPersonId
WORKER_JOIN_LEAVE_UNIT_TEAM("worker_station_companytclass_to_classowner", "worker:%s:unit:team:%d:%d"),
// 工人加入项目失败 -> 班组长 bizCodeTemplate: worker:join:workspace:failed:processInstanceId
WORKER_JOIN_WORKSPACE_FAILED("worker_fail_add_project_toclassowner", "worker:join:workspace:failed:%d"),
// 成功加入单位班组通知(手动添加、班组长扫工人码、加项目加入单位班组) -> 工人 bizCodeTemplate: passive:join:unit:team:platTeamNodeId:workerIdentityId
PASSIVE_JOIN_UNIT_TEAM_MSG("worker_add_to_companyclass", "passive:join:unit:team:%d:%d"),
// 带班长${action} ${realName}${action}您担任}${workspaceName}${teamLeaderName}的带班长。 -> 工人 bizCodeTemplate: project:agent:leader:grant/ungrant:projectTeamId
PROJECT_AGENT_LEADER_GRANT_MSG("projectclassmanger_station_to_self", "project:agent:leader:%s:%d"),
// 班组长管理员${action} ${realName}${action}您担任${teamLeaderName}的班组管理员。 -> 工人 bizCodeTemplate: project:agent:leader:grant/ungrant:teamId
UNIT_AGENT_LEADER_GRANT_MSG("classmanger_station_to_self", "unit:agent:leader:%s:%d"),
// 工人申请 ${workerName}申请加入您的班组，请及时处理，点击查看详情。 -> 班组长 bizCodeTemplate: apply:unit:team:2leader:platInviteId
APPLY_UNIT_TEAM_MSG_2LEADER("worker_apply_company_class", "apply:unit:team:2leader:%d"),
// 班组解散 ${teamName}已解散，请知悉。 -> 班组长/单位负责人 bizCodeTemplate: dismiss:unit:team:2leader:nodeId
DISMISS_TEAM_2_LEADER("dismiss_team_to_leader", "dismiss:unit:team:2leader:%d"),
// 班组解散 ${teamName}已解散，请知悉。 -> 班组长/单位负责人 bizCodeTemplate: dismiss:unit:team:2leader:nodeId
FAIL_DISMISS_TEAM_2_INITIATOR("fail_dismiss_team", "dismiss:unit:team:fail:%d"),
;
private final String code;
private final String bizCodeTemplate;
public String buildBizCode(Object... objects) {
return String.format(bizCodeTemplate, objects);
}
}

52
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/msg/vo/MessageVariableNameEnum.java Normal file
View File

@ -0,0 +1,52 @@
package cn.axzo.orgmanax.infra.client.msg.vo;
import cn.hutool.core.text.CharSequenceUtil;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum MessageVariableNameEnum {
// 工作台名
WORKSPACE_NAME("workspaceName"),
ORGANIZATIONAL_UNIT_NAME("organizationalUnitName"),
ORGANIZATIONAL_UNIT_TYPE("organizationalUnitType"),
PRIMARY_CONTRACTOR_OU_NAME("primaryContractorOuName"),
SUB_CONTRACTOR_OU_NAME("subContractorOuName"),
WORKER_NAME("workerName"),
TEAM_LEADER_NAME("teamLeaderName"),
PRACTITIONER_NAME("practitionerName"),
REAL_NAME("realName"),
TEAM_NAME("teamName"),
TEAM_CATEGORY_NAME("teamCategoryName"),
PROFESSION_NAME("professionName"),
ACTION("action"),
SKILL_TAG_NAME("skillTagName"),
DATE("date"),
INVITE_ID("inviteId"),
WORKER_REAL_NAME("workerRealName"),
NODE_ID("nodeId"),
TEAM_ID("teamId"),
WORKFLOW_PROCESS_TYPE("workflowProcessType"),
// 待办id
IDENTITY_CODE("identityCode"),
;
private final String name;
public static String prefix(String prefix, MessageVariableNameEnum nameEnum) {
return prefix + CharSequenceUtil.upperFirst(nameEnum.getName());
}
public static String postFix(String postFix, MessageVariableNameEnum nameEnum) {
return nameEnum.getName() + postFix;
}
@Getter
@AllArgsConstructor
public enum CommonPrefix {
NEW("new"),
OLD("old"),
;
private final String value;
}
}

13
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/tyr/SaasRoleUserClient.java Normal file
View File

@ -0,0 +1,13 @@
package cn.axzo.orgmanax.infra.client.tyr;
import cn.axzo.orgmanax.infra.client.tyr.dto.OrgManaxWorkerManagerRoleUserReq;
/**
* @Author zr
* @Date 2025/3/11 14:26
* @Description
**/
public interface SaasRoleUserClient {
void grantOrUngrantWorkerManager(OrgManaxWorkerManagerRoleUserReq req);
}

94
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/tyr/dto/OrgManaxWorkerManagerRoleUserReq.java Normal file
View File

@ -0,0 +1,94 @@
package cn.axzo.orgmanax.infra.client.tyr.dto;
import cn.axzo.orgmanax.dto.common.IdentityType;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* @Author zr
* @Date 2025/3/11 14:27
* @Description
**/
@Data
@Builder
public class OrgManaxWorkerManagerRoleUserReq {
private List<ManagerInfo> managerInfos;
/**
* 这个字段在设置后续产品重构了班组管理员、代班长相关功能的时候，要替换成ROLE ID。
* 现在保留权限集ID是因为只是做统一权限角色，查询链路先暂时不变（REQ-2046)
*/
private List<Long> permissionGroupId;
/**
* 角色ID 会与权限集ID取并集
*/
private Collection<Long> roleId;
private IdentityType identityType;
@NotNull
private Integer resourceType;
// -------------
/**
* 是否取消授权
*/
@Builder.Default
private boolean ungrant = false;
/**
* 是否取消所有权限，是的话则不消费permissionGroupId
*/
@Builder.Default
private boolean isUngrantAll = false;
/**
* 取消所有授权的角色分组 saas role group 上的categoryCode;
* 只有在isUngrantAll时生效
* #{@link cn.axzo.tyr.client.common.enums.SaasPositionEnum}
*/
private String roleGroupCategoryCode;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public static class ManagerInfo {
@NotNull
private Long ouId;
@NotNull
private Long workspaceId;
/**
* #{@link cn.axzo.tyr.client.common.enums.RoleResourceTypeEnum }
*/
@NotNull
private Long resourceId;
@Builder.Default
private List<IdentityInfo> identityInfos = new ArrayList<>();
}
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Data
public class IdentityInfo {
private Long personId;
private Long identityId;
private IdentityType identityType;
}
}

45
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/tyr/dto/PlatWorkTeamGrantPositionReq.java Normal file
View File

@ -0,0 +1,45 @@
package cn.axzo.orgmanax.infra.client.tyr.dto;
import cn.axzo.tyr.client.common.enums.SaasPositionEnum;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.Set;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PlatWorkTeamGrantPositionReq implements Serializable {
/**
* 平台班组-单位id
*/
@NotNull
private Long platWorkTeamOuId;
/**
* 工人身份ID
*/
@NotNull
private Set<Long> workerIdentityId;
/**
* Flag 是取消授权、还是授权。
*/
@NotNull
private Boolean ungrant = false;
/**
* 职位Code {@link SaasPositionEnum}
*/
@NotNull
private String positionCode;
}

3
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/nodeuser/repository/NodeUserUpsertRepository.java
View File

@ -10,6 +10,7 @@ import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public interface NodeUserUpsertRepository {
@ -18,6 +19,8 @@ public interface NodeUserUpsertRepository {
OrganizationalNodeUser update(UpdateReq node);
List<OrganizationalNodeUser> updateBatchById(List<UpdateReq> req) ;
void batchDelete(Set<Long> ids);
@EqualsAndHashCode(callSuper = true)

16
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/nodeuser/repository/impl/NodeUserUpsertRepositoryImpl.java
View File

@ -1,9 +1,11 @@
package cn.axzo.orgmanax.infra.dao.nodeuser.repository.impl;
import cn.axzo.foundation.exception.Axssert;
import cn.axzo.foundation.result.ResultCode;
import cn.axzo.orgmanax.infra.dao.nodeuser.dao.NodeUserDao;
import cn.axzo.orgmanax.infra.dao.nodeuser.entity.OrganizationalNodeUser;
import cn.axzo.orgmanax.infra.dao.nodeuser.repository.NodeUserUpsertRepository;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
@ -12,7 +14,11 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
@Service
@RequiredArgsConstructor
@ -37,6 +43,16 @@ public class NodeUserUpsertRepositoryImpl implements NodeUserUpsertRepository {
return nodeUserDao.getById(req.getId());
}
@Override
public List<OrganizationalNodeUser> updateBatchById(List<UpdateReq> req) {
Optional<UpdateReq> first = req.stream().filter(item -> Objects.isNull(item.getId())).findFirst();
Axssert.check(!first.isPresent(), ResultCode.INVALID_PARAMS, "更新部门人员，部门人员不能为空");
List<OrganizationalNodeUser> updateNodeUsers = BeanUtil.copyToList(req, OrganizationalNodeUser.class);
List<Long> ids = req.stream().map(OrganizationalNodeUser::getId).collect(Collectors.toList());
nodeUserDao.updateBatchById(updateNodeUsers);
return nodeUserDao.listByIds(ids);
}
@Override
public void batchDelete(Set<Long> ids) {
Date date = new Date();

31
orgmanax-integration/src/main/java/cn/axzo/orgmanax/integration/sdk/tyr/SaasRoleUserClientImpl.java Normal file
View File

@ -0,0 +1,31 @@
package cn.axzo.orgmanax.integration.sdk.tyr;
import cn.axzo.orgmanax.infra.client.tyr.SaasRoleUserClient;
import cn.axzo.orgmanax.infra.client.tyr.dto.OrgManaxWorkerManagerRoleUserReq;
import cn.axzo.orgmanax.integration.core.RpcWrapper;
import cn.axzo.tyr.client.feign.TyrSaasRoleUserApi;
import cn.axzo.tyr.client.model.roleuser.req.WorkerManagerRoleUserReq;
import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* @Author zr
* @Date 2025/3/11 14:33
* @Description
**/
@AllArgsConstructor
@Component
@Slf4j
public class SaasRoleUserClientImpl implements SaasRoleUserClient {
private final TyrSaasRoleUserApi tyrSaasRoleUserApi;
@Override
public void grantOrUngrantWorkerManager(OrgManaxWorkerManagerRoleUserReq req) {
log.info("授权或者取消授权班组管理员或者项目代班长、小组长", JSON.toJSONString(req));
WorkerManagerRoleUserReq managerRoleUserReq = BeanUtil.copyProperties(req, WorkerManagerRoleUserReq.class);
RpcWrapper.wrapApiResult(() -> tyrSaasRoleUserApi.grantOrUngrantWorkerManager(managerRoleUserReq));
}
}

3
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/nodeuser/foundation/NodeUserFoundationService.java
View File

@ -30,6 +30,9 @@ public interface NodeUserFoundationService {
@Transactional(rollbackFor = Throwable.class)
OrganizationalNodeUser update(NodeUserUpdate req);
@Transactional(rollbackFor = Throwable.class)
List<OrganizationalNodeUser> updateBatchById(List<NodeUserUpdate> req);
/**
* 该接口为删除的收口接口，业务使用的时候，需要自行做业务判断
*

11
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/nodeuser/foundation/impl/NodeUserFoundationServiceImpl.java
View File

@ -158,6 +158,17 @@ public class NodeUserFoundationServiceImpl implements NodeUserFoundationService
return nodeUserUpsertRepository.update(updateReq);
}
@Override
public List<OrganizationalNodeUser> updateBatchById(List<NodeUserUpdate> req) {
List<Long> nodeUserIds = req.stream().map(NodeUserUpdate::getId).collect(Collectors.toList());
List<NodeUserQueryRepository.NodeUserResp> dbNodeUsers = nodeUserQueryRepository.list(NodeUserQueryRepository.ListReq.builder()
.ids(nodeUserIds).build());
Axssert.checkNotEmpty(dbNodeUsers,"部门人员不存在 {}",nodeUserIds);
List<NodeUserUpsertRepository.UpdateReq> updateReqs = BeanUtil.copyToList(req, NodeUserUpsertRepository.UpdateReq.class);
return nodeUserUpsertRepository.updateBatchById(updateReqs);
}
@Override
public List<OrganizationalNodeUser> delete(NodeUserDelete req) {
checkDeleteReq(req);

223
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/nodeuser/service/processor/impl/DeletePlatTeamWorkerProcessor.java
View File

@ -1,31 +1,58 @@
package cn.axzo.orgmanax.server.nodeuser.service.processor.impl;
import cn.axzo.foundation.exception.Axssert;
import cn.axzo.framework.rocketmq.EventProduceTemplate;
import cn.axzo.framework.rocketmq.RocketConfigProperties;
import cn.axzo.karma.client.model.request.PlatWorkTeamGrantPositionReq;
import cn.axzo.msg.center.api.v2.message.req.MessageSendV2Req;
import cn.axzo.msg.center.api.v2.message.req.PersonV2DTO;
import cn.axzo.orgmanax.dto.common.IdentityType;
import cn.axzo.orgmanax.dto.nodeuser.dto.NodeUserDTO;
import cn.axzo.orgmanax.dto.nodeuser.req.DeleteNodeUserReq;
import cn.axzo.orgmanax.dto.nodeuser.req.ListNodeUserReq;
import cn.axzo.orgmanax.dto.project.team.enums.TeamSceneEnum;
import cn.axzo.orgmanax.infra.client.eventhub.dto.OrganizationTypeEnum;
import cn.axzo.orgmanax.infra.client.msg.MsgCenterGateway;
import cn.axzo.orgmanax.infra.client.tyr.SaasRoleUserClient;
import cn.axzo.orgmanax.infra.client.tyr.dto.OrgManaxWorkerManagerRoleUserReq;
import cn.axzo.orgmanax.infra.dao.cooperateship.entity.SaasCooperateShip;
import cn.axzo.orgmanax.infra.dao.cooperateship.repository.CooperateShipQueryRepository;
import cn.axzo.orgmanax.infra.dao.node.entity.OrganizationalTeamOuRelation;
import cn.axzo.orgmanax.infra.dao.node.repository.TeamOuRelationRepository;
import cn.axzo.orgmanax.infra.dao.nodeuser.entity.OrganizationalNodeUser;
import cn.axzo.orgmanax.infra.dao.orgjob.repository.OrgJobQueryRepository;
import cn.axzo.orgmanax.infra.dao.unit.repository.UnitQueryRepository;
import cn.axzo.orgmanax.server.nodeuser.foundation.NodeUserFoundationService;
import cn.axzo.orgmanax.server.nodeuser.foundation.req.NodeUserDelete;
import cn.axzo.orgmanax.server.nodeuser.foundation.req.NodeUserUpdate;
import cn.axzo.orgmanax.server.nodeuser.service.NodeUserService;
import cn.axzo.orgmanax.server.nodeuser.service.processor.NodeUserProcessor;
import cn.axzo.orgmanax.infra.client.msg.vo.JoinLeaveEnum;
import cn.axzo.orgmanax.infra.client.msg.vo.MessageCodeEnum;
import cn.axzo.orgmanax.infra.client.msg.vo.MessageVariableNameEnum;
import cn.axzo.orgmanax.server.util.AssertUtil;
import cn.axzo.orgmanax.server.workerprofession.foundation.OrgProjectWorkerProfessionFoundationService;
import cn.axzo.orgmanax.server.workerprofession.foundation.dto.DeleteWorkerProfession;
import cn.axzo.tyr.client.common.enums.RoleResourceTypeEnum;
import cn.axzo.tyr.client.common.enums.SaasPositionEnum;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.function.Function;
import java.util.stream.Collectors;
@ -44,6 +71,28 @@ public class DeletePlatTeamWorkerProcessor implements NodeUserProcessor {
private final NodeUserService nodeUserService;
private final NodeUserFoundationService nodeUserFoundationService;
private final OrgProjectWorkerProfessionFoundationService workerProfessionFoundationService;
private final UnitQueryRepository unitQueryRepository;
private final MsgCenterGateway msgCenterGateway;
private final CooperateShipQueryRepository cooperateShipQueryRepository;
private final OrgJobQueryRepository orgJobQueryRepository;
private final SaasRoleUserClient saasRoleUserClient;
private final EventProduceTemplate eventProduceTemplate;
private final RocketConfigProperties rocketConfigProperties;
private static final String PROMISE_GROUP_EVENT_MODULE = "promise-group";
private static final String PROMISE_GROUP_EVENT_NAME = "promise-group-remove";
/**
* 班组管理员的默认CODE
*/
@Value("${job.code.team.entTeamManager:entTeamManager}")
public String entManagerCode;
/**
* 工人默认CODE
*/
@Value("${job.code.team.entWorker:entWorker}")
public String entWorkerCode;
@Override
public ProcessResult process(ProcessContext context) {
@ -73,6 +122,8 @@ public class DeletePlatTeamWorkerProcessor implements NodeUserProcessor {
nodeUserMap.forEach((nodeId, vs) -> {
OrganizationalTeamOuRelation ouRelation = teamOuRelationMap.get(nodeId);
if (Objects.nonNull(ouRelation)) {
// 移除代班长权限
removePlatTeamManager(ouRelation, vs);
// 删除平台工人
List<Long> deleteTeamWorkerPersonIds = vs.stream().map(NodeUserDTO::getPersonId).collect(Collectors.toList());
NodeUserDelete nodeUserDelete = NodeUserDelete.builder()
@ -89,13 +140,181 @@ public class DeletePlatTeamWorkerProcessor implements NodeUserProcessor {
.orgNodeId(nodeId)
.build();
workerProfessionFoundationService.delete(workerProfession);
return ;
// 发送消息
sendWorkerMessage(ouRelation, vs);
return;
}
log.error("获取企业下班组与平台班组关系失败, nodeId:{}", nodeId);
});
}
return ProcessResult.success();
}
private void removePlatTeamManager(OrganizationalTeamOuRelation ouRelation, List<NodeUserDTO> nodeUserDTOS) {
//若该工人是班组管理员，则一并移除平台管理员、项目级权限等。
SaasCooperateShip saasCooperateShip = getSaasCooperateShip(ouRelation.getNodeId());
// 获取岗位
List<OrgJobQueryRepository.JobResp> jobs = getJob(Sets.newHashSet(entManagerCode, entWorkerCode));
Optional<OrgJobQueryRepository.JobResp> entWorkerJob = jobs.stream().filter(item -> Objects.equals(item.getCode(), entWorkerCode)).findFirst();
AssertUtil.isTrue(entWorkerJob.isPresent(), "获取工人岗位失败");
// 修改平台班组下工人岗位
updateWorkerNodeJob(entWorkerJob.get(), nodeUserDTOS);
// 去掉权限
grantOrUngrantWorkerManager(saasCooperateShip, ouRelation, nodeUserDTOS);
// 目前已知需要发送消息的场景：
// 1.平台代班长若被移出时，需要将招工发布的信息同步清理掉
sendMQ(ouRelation, nodeUserDTOS);
}
private void sendMQ(OrganizationalTeamOuRelation ouRelation, List<NodeUserDTO> nodeUserDTOS){
PlatWorkTeamGrantPositionReq build = PlatWorkTeamGrantPositionReq.builder()
.platWorkTeamOuId(ouRelation.getTeamOuId())
.workerIdentityId(nodeUserDTOS.stream().map(NodeUserDTO::getIdentityId).collect(Collectors.toSet()))
.ungrant(Boolean.TRUE)
.positionCode(SaasPositionEnum.PLAT_ACTING_MONITOR.getCode())
.build();
eventProduceTemplate.send(
rocketConfigProperties.getProduces().get("tyr"),
PROMISE_GROUP_EVENT_MODULE,
PROMISE_GROUP_EVENT_NAME,
JSON.toJSONString(build),
String.valueOf(ouRelation.getTeamOuId()),
String.valueOf(ouRelation.getTeamOuId()),
"platWorkTeamOuId"
);
}
private SaasCooperateShip getSaasCooperateShip(Long nodeId) {
CooperateShipQueryRepository.OneReq build = CooperateShipQueryRepository.OneReq.builder()
.organizationalNodeId(nodeId)
.build();
return cooperateShipQueryRepository.one(build);
}
private void updateWorkerNodeJob(OrgJobQueryRepository.JobResp jobResp, List<NodeUserDTO> nodeUserDTOS) {
List<NodeUserUpdate> nodeUserUpdates = nodeUserDTOS.stream().map(item -> {
return NodeUserUpdate.builder()
.id(item.getId())
.organizationalJobId(jobResp.getId())
.build();
}).collect(Collectors.toList());
nodeUserFoundationService.updateBatchById(nodeUserUpdates);
}
private void grantOrUngrantWorkerManager(SaasCooperateShip saasCooperateShip, OrganizationalTeamOuRelation ouRelation, List<NodeUserDTO> nodeUserDTOS) {
List<OrgManaxWorkerManagerRoleUserReq.IdentityInfo> identityInfos = nodeUserDTOS.stream().map(item -> {
return OrgManaxWorkerManagerRoleUserReq.IdentityInfo.builder()
.identityId(item.getIdentityId())
.personId(item.getPersonId())
.build();
}).collect(Collectors.toList());
OrgManaxWorkerManagerRoleUserReq.ManagerInfo managerInfo = OrgManaxWorkerManagerRoleUserReq.ManagerInfo.builder()
.identityInfos(identityInfos)
.ouId(saasCooperateShip.getOrganizationalUnitId())
.workspaceId(saasCooperateShip.getWorkspaceId())
.resourceId(ouRelation.getTeamOuId())
.build();
OrgManaxWorkerManagerRoleUserReq orgManaxWorkerManagerRoleUserReq = OrgManaxWorkerManagerRoleUserReq.builder()
.managerInfos(Lists.newArrayList(managerInfo))
.identityType(IdentityType.WORKER)
.resourceType(RoleResourceTypeEnum.UNIT.getCode())
.ungrant(true)
.isUngrantAll(true)
.roleGroupCategoryCode(SaasPositionEnum.PLAT_ACTING_MONITOR.getCode())
.build();
saasRoleUserClient.grantOrUngrantWorkerManager(orgManaxWorkerManagerRoleUserReq);
}
private List<OrgJobQueryRepository.JobResp> getJob(Set<String> jobCode) {
OrgJobQueryRepository.ListReq build = OrgJobQueryRepository.ListReq.builder()
.codes(jobCode)
.build();
List<OrgJobQueryRepository.JobResp> jobResps = orgJobQueryRepository.list(build);
if (CollUtil.isNotEmpty(jobResps))
return jobResps;
return Collections.emptyList();
}
private void sendWorkerMessage(OrganizationalTeamOuRelation ouRelation, List<NodeUserDTO> nodeUserDTOS) {
ListNodeUserReq listNodeUserReq = ListNodeUserReq.builder()
.identityType(IdentityType.WORKER_LEADER.getCode())
.organizationalNodeId(nodeUserDTOS.get(0).getOrganizationalNodeId())
.build();
List<NodeUserDTO> nodeUserDTOList = nodeUserService.list(listNodeUserReq);
if (CollUtil.isEmpty(nodeUserDTOList)) {
log.error("获取班组负责人失败, listNodeUserReq:{}", JSON.toJSONString(listNodeUserReq));
return;
}
NodeUserDTO teamLeader = nodeUserDTOList.get(0);
// 发消息
CompletableFuture.runAsync(() -> {
UnitQueryRepository.UnitResp unitResp = unitQueryRepository.getById(ouRelation.getOuId());
if (Objects.isNull(unitResp)) {
log.error("获取企业失败, ouRelation:{}", JSON.toJSONString(ouRelation));
return;
}
nodeUserDTOS.forEach(item -> {
// 班组长消息
sendLeaderWorkerJoinLeaveMsg(JoinLeaveEnum.LEAVE, ouRelation, item, teamLeader, unitResp.getName());
// 工人消息
sendWorkerMsg(ouRelation.getOuId(), teamLeader.getRealName(), unitResp.getName(), item);
});
});
}
private void sendWorkerMsg(Long ouId, String teamLeaderName, String unitName, NodeUserDTO item) {
// 发给工人消息通知 发送通知消息
MessageSendV2Req msgReq = new MessageSendV2Req();
PersonV2DTO receiver = new PersonV2DTO(item.getPersonId(), item.getRealName());
msgReq.setReceivers(Collections.singletonList(receiver));
msgReq.setReceiversOuId(ouId);
msgReq.setReceiversOrgType(OrganizationTypeEnum.ENT.getCode());
JSONObject jsonObject = new JSONObject();
jsonObject.put(MessageVariableNameEnum.TEAM_LEADER_NAME.getName(), teamLeaderName);
jsonObject.put(MessageVariableNameEnum.ORGANIZATIONAL_UNIT_NAME.getName(), unitName);
jsonObject.put(MessageVariableNameEnum.DATE.getName(), DateUtil.now());
msgReq.setBizExtParams(jsonObject);
msgReq.setBizEventMappingCode(MessageCodeEnum.UNIT_TEAM_REMOVE_WORKER.getCode());
String bizCode = String.format(MessageCodeEnum.UNIT_TEAM_REMOVE_WORKER.getBizCodeTemplate(), item.getPersonId(), item.getOrganizationalNodeId());
msgReq.setBizCode(bizCode);
msgCenterGateway.sendMsg(msgReq);
}
private void sendLeaderWorkerJoinLeaveMsg(JoinLeaveEnum joinLeaveEnum,
OrganizationalTeamOuRelation resp,
NodeUserDTO profile,
NodeUserDTO teamLeader,
String unitName) {
MessageSendV2Req message = new MessageSendV2Req();
JSONObject jsonObject = new JSONObject();
message.setBizEventMappingCode(MessageCodeEnum.WORKER_JOIN_LEAVE_UNIT_TEAM.getCode());
message.setReceiversOuId(resp.getOuId());
message.setReceiversOrgType(OrganizationTypeEnum.ENT.getCode());
String bizCode = String.format(MessageCodeEnum.WORKER_JOIN_LEAVE_UNIT_TEAM.getBizCodeTemplate(), joinLeaveEnum.name().toLowerCase(),
resp.getNodeId(), profile.getPersonId());
message.setBizCode(bizCode);
jsonObject.put(MessageVariableNameEnum.ACTION.getName(), joinLeaveEnum.getValue());
jsonObject.put(MessageVariableNameEnum.TEAM_LEADER_NAME.getName(), teamLeader.getRealName());
jsonObject.put(MessageVariableNameEnum.ORGANIZATIONAL_UNIT_NAME.getName(), unitName);
jsonObject.put(MessageVariableNameEnum.DATE.getName(), DateUtil.now());
jsonObject.put(MessageVariableNameEnum.WORKER_NAME.getName(), profile.getRealName());
message.setBizExtParams(jsonObject);
PersonV2DTO receiver = new PersonV2DTO(teamLeader.getPersonId(), teamLeader.getRealName());
message.setReceivers(Collections.singletonList(receiver));
msgCenterGateway.sendMsg(message);
}
}