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

Merge remote-tracking branch 'origin/feature/REQ-3488' into feature/REQ-3488-zhh

Browse Source
This commit is contained in:
zhanghonghao 2025-01-09 16:28:02 +08:00
commit 16e9a6b749
49 changed files with 1479 additions and 424 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/invite/enums/WorkerInviteStatusEnum.java Normal file
View File

@ -0,0 +1,34 @@
package cn.axzo.orgmanax.api.invite.enums;
import com.google.common.collect.Lists;
import lombok.Getter;
import java.util.List;
@Getter
public enum WorkerInviteStatusEnum {
WAIT_LEADER_APPROVE(1, "待班组审批"),
WAIT_LABOUR_APPROVE(2, "待劳务审批"),
PASS(3, "通过"),
TEAM_OWNER_REFUSE(4, "班组长拒绝"),
MANAGER_REFUSE(5, "从业人员拒绝"),
SYSTEM_END(6, "系统终止"),
CANCEL(7, "撤销"),
;
private Integer value;
private String desc;
WorkerInviteStatusEnum(int value, String desc) {
this.value = value;
this.desc = desc;
}
public static List<Integer> active() {
return Lists.newArrayList(WAIT_LEADER_APPROVE.value, WAIT_LABOUR_APPROVE.value);
}
}

21
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/project/group/enums/ProjectGroupTypeEnum.java Normal file
View File

@ -0,0 +1,21 @@
package cn.axzo.orgmanax.api.project.group.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.checkerframework.checker.units.qual.A;
/**
* @author weXueFeng
* @date 2022/10/20 15:12
*/
@Getter
@AllArgsConstructor
public enum ProjectGroupTypeEnum {
DIRECTLY_UNDER(0, "直属小组"),
COOPERATION(1, "合作小组"),
;
Integer value;
String desc;
}

9
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/project/team/feign/OrgProjectTeamCategoryApi.java
View File

@ -2,6 +2,7 @@ package cn.axzo.orgmanax.api.project.team.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryAggregateDTO;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryDTO;
import cn.axzo.orgmanax.dto.project.team.req.GroupTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.OperateOrgTeamCategoryReq;
@ -11,6 +12,7 @@ import cn.axzo.orgmanax.dto.project.team.req.PreCheckRemoveTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.RemoveProjectTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.SaveProjectTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.SingletonOrgTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.TreeOrgTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.resp.RemoveTeamCategoryCheckResp;
import cn.axzo.orgmanax.dto.project.team.resp.SingletonOrgTeamCategoryResp;
import cn.axzo.orgmanax.dto.project.team.resp.TeamCategoryGroupResp;
@ -101,9 +103,16 @@ public interface OrgProjectTeamCategoryApi {
@PostMapping(value = "/api/project/team-category/list-by-node")
ApiResult<SingletonOrgTeamCategoryResp> listByNode(@RequestBody @Valid SingletonOrgTeamCategoryReq req);
// ---------------- 新版接口 ----------------
/**
* 列表分页查询
*/
@PostMapping(value = "/api/project/team-category/list")
ApiResult<PageResp<TeamCategoryDTO>> list(@RequestBody PageOrgTeamCategoryReq req);
/**
* 查询班组-树形结构
*/
@PostMapping(value = "/api/project/team-category/tree-list")
ApiResult<List<TeamCategoryAggregateDTO>> treeList(@RequestBody TreeOrgTeamCategoryReq req);
}

9
orgmanax-api/src/test/resources/http/project/teamcategory/team-category.http
View File

@ -4,6 +4,15 @@ POST {{host}}/api/project/team-category/list
Content-Type: application/json
Accept: application/json
{
"orgNodeIds": [14606,14585]
}
### 班组类别-树形结构
POST {{host}}/api/project/team-category/tree-list
Content-Type: application/json
Accept: application/json
{
"orgNodeIds": [14606,14585]
}

47
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/node/dto/NodeProfile.java
View File

@ -1,6 +1,7 @@
package cn.axzo.orgmanax.dto.node.dto;
import cn.axzo.orgmanax.dto.node.enums.NodeTypeEnum;
import cn.axzo.orgmanax.dto.nodeuser.req.ListNodeUserReq;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.ImmutableMap;
import lombok.AllArgsConstructor;
@ -10,6 +11,7 @@ import lombok.experimental.SuperBuilder;
import java.util.Date;
import java.util.Map;
import java.util.Optional;
/**
* 部门Profile定义
@ -204,4 +206,49 @@ public class NodeProfile {
public static Class<?> resolveProfileClass(Integer nodeType) {
return typeClassMapping.getOrDefault(nodeType, JSONObject.class);
}
/**
* 需指定{@link ListNodeUserReq.Needs#getNode()} ()} 为true才有用
* @return
*/
public static Long resolveProjectTeamId(OrgNodeBriefDTO node) {
if (node == null || node.getNodeType() == null) {
return null;
}
Integer nodeType = node.getNodeType();
if (nodeType.equals(NodeTypeEnum.PROJECT_TEAM.getValue())) {
//项目班组
NodeProfile.ProjectTeamProfile projectTeamProfile = node.resolveProfile();
return Optional.ofNullable(projectTeamProfile).orElse(new NodeProfile.ProjectTeamProfile()).getProjectTeamId();
}
if (nodeType.equals(NodeTypeEnum.PROJECT_GROUP.getValue())) {
//项目小组
NodeProfile.ProjectGroupProfile projectGroupProfile = node.resolveProfile();
return Optional.ofNullable(projectGroupProfile).orElse(new NodeProfile.ProjectGroupProfile()).getBelongProjectTeamId();
}
return null;
}
/**
* 需指定{@link ListNodeUserReq.Needs#getNode()} ()} 为true才有用
* @return
*/
public static Long resolvePlatTeamId(OrgNodeBriefDTO node) {
if (node == null || node.getNodeType() == null) {
return null;
}
Integer nodeType = node.getNodeType();
if (nodeType.equals(NodeTypeEnum.PROJECT_TEAM.getValue())) {
//项目班组
NodeProfile.ProjectTeamProfile projectTeamProfile = node.resolveProfile();
return Optional.ofNullable(projectTeamProfile).orElse(new NodeProfile.ProjectTeamProfile()).getPlatTeamId();
}
if (nodeType.equals(NodeTypeEnum.PROJECT_GROUP.getValue())) {
//项目小组
NodeProfile.ProjectGroupProfile projectGroupProfile = node.resolveProfile();
return Optional.ofNullable(projectGroupProfile).orElse(new NodeProfile.ProjectGroupProfile()).getBelongPlatTeamId();
}
//TODO 是否还有平台班组类型也有平台班组id？有需要自己下面继续实现
return null;
}
}

3
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/node/dto/OrgNodeBriefDTO.java
View File

@ -57,6 +57,9 @@ public class OrgNodeBriefDTO implements Serializable {
/**
* 节点信息，json，不同的节点类型，格式不一。如班组节点的解散状态等
* @see OrgNodeBriefDTO#resolveProfile()
* @see NodeProfile#resolveProjectTeamId
* @see NodeProfile#resolvePlatTeamId
*/
private JSONObject profile;

34
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/node/req/ListNodeReq.java
View File

@ -2,6 +2,7 @@ package cn.axzo.orgmanax.dto.node.req;
import cn.axzo.foundation.page.PageReqV2;
import cn.axzo.orgmanax.dto.common.WorkspaceOuPair;
import cn.axzo.orgmanax.dto.project.group.enums.ProjectGroupStatusEnum;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
@ -9,6 +10,7 @@ import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
@ -147,4 +149,36 @@ public class ListNodeReq extends PageReqV2 {
@Builder.Default
private Set<Long> platTeamIds = Collections.emptySet();
/**
* 项目内班组id列表
* todo 未实现
*/
@Builder.Default
private Set<Long> projectTeamIds = Collections.emptySet();
/**
* todo 未实现
* 小组类型
* @see cn.axzo.orgmanax.api.project.group.enums.ProjectGroupTypeEnum
*/
private Integer groupType;
/**
* todo 未实现
* 小组id列表
*/
private Collection<Long> groupIds;
/**
* todo 未实现
* 小组长工人身份id列表
*/
private Collection<Long> ownerWorkerIdentityIds;
/**
* todo 未实现
* 小组状态 0-未激活 1-已激活 2-已结束
* @see ProjectGroupStatusEnum
*/
private Integer groupStatus;
}

27
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/dto/NodeUserDTO.java
View File

@ -150,6 +150,8 @@ public class NodeUserDTO implements Serializable {
private Integer activeFlag;
/**
* @see NodeUserDTO#resolveProfile()
* @see NodeUserProfile#resolveProjectWorkerId
* 部门人员信息，json，不同部门类型的部门用户，格式不一。
*/
private JSONObject profile;
@ -219,29 +221,4 @@ public class NodeUserDTO implements Serializable {
}
return (T) Optional.ofNullable(profile).map(p -> JSONObject.parseObject(p.toString(), clazz)).orElse(null);
}
public Long getProjectWorkerId() {
if (ObjectUtil.isEmpty(profile)) {
return null;
}
return profile.getLong("projectWorkerId");
}
public Long getProjectTeamId() {
if (node == null || node.getNodeType() == null) {
return null;
}
Integer nodeType = node.getNodeType();
if (nodeType.equals(NodeTypeEnum.PROJECT_TEAM.getValue())) {
//项目班组
NodeProfile.ProjectTeamProfile projectTeamProfile = node.resolveProfile();
return Optional.ofNullable(projectTeamProfile).orElse(new NodeProfile.ProjectTeamProfile()).getProjectTeamId();
}
if (nodeType.equals(NodeTypeEnum.PROJECT_GROUP.getValue())) {
//项目小组
NodeProfile.ProjectGroupProfile projectGroupProfile = node.resolveProfile();
return Optional.ofNullable(projectGroupProfile).orElse(new NodeProfile.ProjectGroupProfile()).getBelongProjectTeamId();
}
return null;
}
}

9
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/dto/NodeUserProfile.java
View File

@ -1,6 +1,7 @@
package cn.axzo.orgmanax.dto.nodeuser.dto;
import cn.axzo.orgmanax.dto.node.enums.NodeTypeEnum;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.ImmutableMap;
import lombok.AllArgsConstructor;
@ -134,4 +135,12 @@ public class NodeUserProfile {
}
return typeClassMapping.getOrDefault(nodeType, JSONObject.class);
}
public static Long resolveProjectWorkerId(NodeUserDTO nodeUserDTO) {
if (ObjectUtil.isEmpty(nodeUserDTO) || ObjectUtil.isEmpty(nodeUserDTO.getProfile())) {
return null;
}
JSONObject profile = nodeUserDTO.getProfile();
return profile.getLong("projectWorkerId");
}
}

23
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/enums/ProjectGroupWorkerStatusEnum.java Normal file
View File

@ -0,0 +1,23 @@
package cn.axzo.orgmanax.dto.nodeuser.enums;
import lombok.Getter;
/**
* @author wenXueFeng
* @date 2022/10/20 13:53
*/
@Getter
public enum ProjectGroupWorkerStatusEnum {
VALID(0, "有效"),
NO_VALID(1, "无效"),
;
Integer value;
String desc;
ProjectGroupWorkerStatusEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
}

8
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/req/ListNodeUserReq.java
View File

@ -5,6 +5,7 @@ import cn.axzo.foundation.page.PageReqV2;
import cn.axzo.orgmanax.dto.common.DistinctRule;
import cn.axzo.orgmanax.dto.common.IdentityPair;
import cn.axzo.orgmanax.dto.common.WorkspaceOuPair;
import cn.axzo.orgmanax.dto.nodeuser.enums.ProjectGroupWorkerStatusEnum;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
@ -307,6 +308,13 @@ public class ListNodeUserReq extends PageReqV2 {
*/
private DistinctRule distinctRule;
/**
* todo 未实现
* 项目小组工人状态
* @see ProjectGroupWorkerStatusEnum
*/
private Integer projectGroupWorkerStatus;
//
// 指定聚合信息

23
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/group/enums/ProjectGroupStatusEnum.java Normal file
View File

@ -0,0 +1,23 @@
package cn.axzo.orgmanax.dto.project.group.enums;
import lombok.Getter;
/**
* @author wenXueFeng
* @date 2022/10/19 16:35
*/
@Getter
public enum ProjectGroupStatusEnum {
NOT_ACTIVE(0, "未激活"),
ACTIVE(1, "已激活"),
CLOSED(2, "已结束");
Integer value;
String desc;
ProjectGroupStatusEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
}

12
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/group/req/ProjectDirectGroupWorkerListReq.java
View File

@ -16,14 +16,6 @@ public class ProjectDirectGroupWorkerListReq {
* 小组id集合
*/
private List<Long> groupIdList;
/**
* 小组id
*/
private Long groupId;
/**
* 工人身份id
*/
private Long workerIdentityId;
/**
* 工人身份id集合
*/
@ -32,10 +24,6 @@ public class ProjectDirectGroupWorkerListReq {
* 项目id
*/
private Long workspaceId;
/**
* 小组长工人身份id
*/
private Long groupOwnerIdentityId;
/**
* 小组长工人身份id集合
*/

62
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/dto/TeamCategoryAggregateDTO.java
View File

@ -1,6 +1,11 @@
package cn.axzo.orgmanax.dto.project.team.dto;
import cn.axzo.orgmanax.dto.project.team.enums.DelimiterEnum;
import cn.axzo.orgmanax.dto.project.team.enums.TeamCategoryTypeEnum;
import cn.axzo.orgmanax.dto.project.team.enums.ValidationEnum;
import cn.hutool.core.collection.CollUtil;
import java.util.List;
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@ -14,50 +19,67 @@ import lombok.experimental.SuperBuilder;
@AllArgsConstructor
@NoArgsConstructor
public class TeamCategoryAggregateDTO {
/**
* 邀请id/申请id
*/
private Long inviteId;
/**
* 班组id
* 须知：返回的班组id可能没有，业务方如果只需要项目班组的班组类别，需要过滤掉为空的数据
*/
private Long projectTeamId;
/**
* 经营范围code
*/
private String categoryCode;
private String code;
/**
* 经营范围名称
*/
private String categoryName;
private String name;
/**
* 班组类别 - 分类
* @see TeamCategoryTypeEnum
*/
private Integer type;
/**
* 数据有效性标记
* @see ValidationEnum
*/
private Integer valid;
/**
* 父级经营范围code
*/
private String parentCategoryCode;
private String parentCode;
/**
* 父级经营范围name
*/
private String parentCategoryName;
private String parentName;
private Integer type;
private Integer valid;
/**
* 经营范围子级
*/
private List<TeamCategoryAggregateDTO> workScopes;
public TeamCategoryAggregateDTO(String categoryCode, String categoryName) {
this.categoryCode = categoryCode;
this.categoryName = categoryName;
/**
* 构建业务上需要 业务范围拼接
*/
public static String buildProjectBusinessScopeString(List<TeamCategoryAggregateDTO> value) {
String businessScope = "";
if (CollUtil.isNotEmpty(value)) {
businessScope = value.stream().map(e -> {
StringBuilder sb = new StringBuilder();
sb.append(e.getName());
if (CollUtil.isNotEmpty(e.getWorkScopes())) {
String workscope = e.getWorkScopes().stream().map(TeamCategoryAggregateDTO::getName).collect(
Collectors.joining(DelimiterEnum.PAUSE.getDelimiter()));
sb.append(DelimiterEnum.HYPHEN.getDelimiter()).append(workscope);
}
return sb.toString();
}).collect(Collectors.joining(DelimiterEnum.BUSINESS_SCOPE_VERTICAL_BAR.getDelimiter()));
}
return businessScope;
}
public TeamCategoryAggregateDTO(Long inviteId, Long projectTeamId, String categoryCode, String categoryName) {
this.inviteId = inviteId;
this.projectTeamId = projectTeamId;
this.categoryCode = categoryCode;
this.categoryName = categoryName;
}
}

19
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/enums/DelimiterEnum.java Normal file
View File

@ -0,0 +1,19 @@
package cn.axzo.orgmanax.dto.project.team.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor
public enum DelimiterEnum {
/**
* 分隔符
*/
PAUSE("、"),
CHINESE_COMMA("，"),
BUSINESS_SCOPE_VERTICAL_BAR("｜"),
HYPHEN("－"),
;
private final String delimiter;
}

3
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/enums/TeamCategoryTypeEnum.java
View File

@ -18,6 +18,9 @@ import lombok.Getter;
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public enum TeamCategoryTypeEnum{
/**
* 班组类别分类
*/
OTHERS(0, "其他"),
WORKER_GROUP_CATEGORY(1, "经营范围"),
WORKER_GROUP_PROFESSION(2, "经营范围子级"),

17
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/enums/ValidationEnum.java
View File

@ -1,12 +1,14 @@
package cn.axzo.orgmanax.dto.project.team.enums;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
import com.google.common.collect.Lists;
import java.util.Arrays;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @description
@ -40,4 +42,11 @@ public enum ValidationEnum {
.filter(e -> Objects.equals(e.code, code))
.findFirst();
}
public static Set<Integer> getAllCode() {
return Lists.newArrayList(EFFECTIVE, INVALID)
.stream()
.map(ValidationEnum::getCode)
.collect(Collectors.toSet());
}
}

10
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/req/ListProjectTeamReq.java
View File

@ -1,13 +1,12 @@
package cn.axzo.orgmanax.dto.project.team.req;
import java.util.List;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.List;
import java.util.Set;
/**
* @author : zhanghonghao@axzo.cn
* @since : 2024/12/30
@ -53,6 +52,11 @@ public class ListProjectTeamReq {
*/
private Set<Long> platTeamIds;
/**
* 项目内班组id列表
*/
private Set<Long> projectTeamIds;
/**
* 项目IDs workspaceId 和 workspaceIds只传一个
*/

29
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/req/PageOrgTeamCategoryReq.java
View File

@ -1,7 +1,9 @@
package cn.axzo.orgmanax.dto.project.team.req;
import cn.axzo.foundation.page.PageReqV2;
import java.util.List;
import cn.axzo.orgmanax.dto.project.team.enums.TeamCategoryTypeEnum;
import cn.axzo.orgmanax.dto.project.team.enums.ValidationEnum;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
@ -22,5 +24,28 @@ public class PageOrgTeamCategoryReq extends PageReqV2 {
/**
* nodeId 列表
*/
private List<Long> orgNodeIds;
private Set<Long> orgNodeIds;
/**
* 班组类别列表 categoryTypes
* @see TeamCategoryTypeEnum
*/
private Set<String> categoryTypes;
/**
* 经营范围/经营范围子级categoryCodes
*/
private Set<String> categoryCodes;
/**
* 数据有效性标记
* @see ValidationEnum
*/
private Integer valid;
/**
* 项目内班组id列表
*/
private Set<Long> projectTeamIds;
}

48
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/req/TreeOrgTeamCategoryReq.java Normal file
View File

@ -0,0 +1,48 @@
package cn.axzo.orgmanax.dto.project.team.req;
import cn.axzo.orgmanax.dto.project.team.enums.TeamCategoryTypeEnum;
import cn.axzo.orgmanax.dto.project.team.enums.ValidationEnum;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author syl
* @date 2024/12/18
*/
@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class TreeOrgTeamCategoryReq {
/**
* nodeId 列表
*/
private Set<Long> orgNodeIds;
/**
* 班组类别列表 categoryTypes
* @see TeamCategoryTypeEnum
*/
private Set<String> categoryTypes;
/**
* 经营范围/经营范围子级categoryCodes
*/
private Set<String> categoryCodes;
/**
* 数据有效性标记
* @see ValidationEnum
*/
private Integer valid;
/**
* 项目内班组id列表
*/
private Set<Long> projectTeamIds;
}

23
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/worker/enums/ProjectGroupWorkerStatusEnum.java Normal file
View File

@ -0,0 +1,23 @@
package cn.axzo.orgmanax.dto.project.worker.enums;
import lombok.Getter;
/**
* @author wenXueFeng
* @date 2022/10/20 13:53
*/
@Getter
public enum ProjectGroupWorkerStatusEnum {
VALID(0, "有效"),
NO_VALID(1, "无效"),
;
Integer value;
String desc;
ProjectGroupWorkerStatusEnum(Integer value, String desc) {
this.value = value;
this.desc = desc;
}
}

5
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/workerprofession/dto/SkillTagDTO.java
View File

@ -33,6 +33,11 @@ public class SkillTagDTO {
*/
private Long professionId;
/**
* 项目工人id
*/
private Long projectWorkerId;
private List<SkillTagDTO> childSkillTags;
private int level;

16
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/invite/dao/ProjectWorkerInviteDao.java Normal file
View File

@ -0,0 +1,16 @@
package cn.axzo.orgmanax.infra.dao.invite.dao;
import cn.axzo.orgmanax.infra.dao.invite.entity.ProjectWorkerInvite;
import cn.axzo.orgmanax.infra.dao.invite.mapper.ProjectWorkerInviteMapper;
import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionHistory;
import cn.axzo.orgmanax.infra.dao.workerprofession.mapper.WorkerProfessionHistoryMapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
@Service
public class ProjectWorkerInviteDao extends ServiceImpl<ProjectWorkerInviteMapper, ProjectWorkerInvite> {
}

163
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/invite/entity/ProjectWorkerInvite.java Normal file
View File

@ -0,0 +1,163 @@
package cn.axzo.orgmanax.infra.dao.invite.entity;
import cn.axzo.trade.datasecurity.core.annotation.CryptField;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.extension.activerecord.Model;
import com.baomidou.mybatisplus.extension.handlers.FastjsonTypeHandler;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
* 项目内工人邀请
* </p>
*
* @author zxp_auto
* @since 2022-07-12
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName(value = "org_project_worker_invite", autoResultMap = true)
public class ProjectWorkerInvite {
private static final long serialVersionUID = 1L;
@TableId(value = "id", type = IdType.AUTO)
private Long id;
/**
* 工作台ID
*/
@TableField("workspace_id")
private Long workspaceId;
/**
* 总包ID
*/
@TableField("ent_id")
private Long entId;
/**
* 项目内班组ID
*/
@TableField("project_team_id")
private Long projectTeamId;
/**
* 项目内工人id
*/
@TableField("project_worker_id")
private Long projectWorkerId;
/**
* 所属单位ID
*/
@TableField("organizational_unit_id")
private Long organizationalUnitId;
/**
* 所属单位类型: 1:总包 4:专业分包 5:劳务分包
*/
@TableField("organizational_unit_type")
private Integer organizationalUnitType;
/**
* 工人ID
*/
@TableField("worker_identity_id")
private Long workerIdentityId;
/**
* 状态：1、待班组审批  2、待劳务审批  3、通过 4、拒绝
*/
@TableField("status")
private Integer status;
/**
* 类型：1、班组长邀请 2、二维码邀请 3:派单
*/
@TableField("source")
private Integer source;
/**
* 邀请人id
*/
@TableField("inviter_id")
private Long inviterId;
/**
* 邀请人名称
*/
@TableField("inviter_name")
private String inviterName;
/**
* 是否删除 0:未删除 其他:已删除
*/
@TableField("is_delete")
private Long isDelete;
@TableField("create_at")
private Date createAt;
@TableField("update_at")
private Date updateAt;
/**
* 工种类别 技工 普工
*/
private String professionCategoryName;
/**
* 审批人的从业人员身份id
*/
@TableField("approver_identity_id")
private Long approverIdentityId;
/**
* 班组长审批时间,REQ-598
*/
@TableField("team_leader_audit_date")
private Date teamLeaderAuditDate;
/**
* source = 4合作小组派单，记录甲方的班组id
*/
@TableField("belong_project_team_id")
private Long belongProjectTeamId;
/**
* 工人名称
*/
@TableField("worker_name")
private String workerName;
/**
* 工人电话号码
*/
@TableField("worker_phone")
@CryptField
private String workerPhone;
/**
* 工作流流程实例id
*/
@TableField("process_instance_id")
private String processInstanceId;
/**
* 邀请的工种
*/
@TableField(value = "profession_ext", typeHandler = FastjsonTypeHandler.class)
private JSONObject professionExt;
/**
* 扩展字段
*/
@TableField(value = "extra", typeHandler = FastjsonTypeHandler.class)
private JSONObject extra;
}

19
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/invite/mapper/ProjectWorkerInviteMapper.java Normal file
View File

@ -0,0 +1,19 @@
package cn.axzo.orgmanax.infra.dao.invite.mapper;
import cn.axzo.orgmanax.infra.dao.invite.entity.ProjectWorkerInvite;
import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionHistory;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
@Mapper
public interface ProjectWorkerInviteMapper extends BaseMapper<ProjectWorkerInvite> {
List<ProjectWorkerInvite> workerInviteStatusInProjectTeam(@Param("projectTeamId") Long projectTeamId,
@Param("workerIdentityIdList") List<Long> workerIdentityIdList);
}

8
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/invite/repository/ProjectWorkerInviteRepository.java Normal file
View File

@ -0,0 +1,8 @@
package cn.axzo.orgmanax.infra.dao.invite.repository;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
public interface ProjectWorkerInviteRepository {
}

16
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/invite/repository/impl/ProjectWorkerInviteRepositoryImpl.java Normal file
View File

@ -0,0 +1,16 @@
package cn.axzo.orgmanax.infra.dao.invite.repository.impl;
import cn.axzo.orgmanax.infra.dao.invite.repository.ProjectWorkerInviteRepository;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Repository;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
@Repository
@Slf4j
@AllArgsConstructor
public class ProjectWorkerInviteRepositoryImpl implements ProjectWorkerInviteRepository {
}

17
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/project/team/repository/TeamCategoryRepository.java
View File

@ -4,11 +4,10 @@ import cn.axzo.foundation.dao.support.wrapper.CriteriaField;
import cn.axzo.foundation.dao.support.wrapper.Operator;
import cn.axzo.foundation.page.PageReqV2;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.orgmanax.dto.project.team.enums.TeamCategoryTypeEnum;
import cn.axzo.orgmanax.dto.project.team.enums.TeamSceneEnum;
import cn.axzo.orgmanax.dto.project.team.enums.ValidationEnum;
import cn.axzo.orgmanax.infra.dao.project.team.entity.TeamCategory;
import java.util.List;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
@ -46,7 +45,7 @@ public interface TeamCategoryRepository {
* 组织节点idList
*/
@CriteriaField(field = "orgNodeId", operator = Operator.IN)
private List<Long> orgNodeIds;
private Set<Long> orgNodeIds;
/**
* 班组类别code
*/
@ -56,7 +55,7 @@ public interface TeamCategoryRepository {
* 班组类别codes
*/
@CriteriaField(field = "code", operator = Operator.IN)
private List<String> codes;
private Set<String> codes;
/**
* 班组类别名称
*/
@ -67,16 +66,11 @@ public interface TeamCategoryRepository {
*/
@CriteriaField
private String parentCode;
/**
* 班组类别 - 分类
*/
@CriteriaField
private TeamCategoryTypeEnum type;
/**
* 班组类别 - 分类 List
*/
@CriteriaField(field = "type", operator = Operator.IN)
private List<TeamCategoryTypeEnum> types;
private Set<Integer> types;
/**
* 班组类别使用场景
*/
@ -84,9 +78,10 @@ public interface TeamCategoryRepository {
private TeamSceneEnum scene;
/**
* 数据有效性标记
* @see ValidationEnum
*/
@CriteriaField(field = "valid", operator = Operator.IN)
private List<ValidationEnum> valids;
private Set<Integer> validList;
/**
* 创建人的自然人id
*/

29
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/workerprofession/enums/SkillTypeEnum.java
View File

@ -1,29 +0,0 @@
package cn.axzo.orgmanax.infra.dao.workerprofession.enums;
import com.baomidou.mybatisplus.annotation.EnumValue;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 技术类型
* 无->0
* 普工->1
* 技工->2
*
* @author yangzhi
* @Date 2022/5/6 15:06
**/
@Getter
@AllArgsConstructor
public enum SkillTypeEnum {
/**
* 技术类型:1普工，2技工
*/
NONE(0, "无"),
COMMON(1, "普工"),
ENGINE_MAN(2, "技工"),
;
@EnumValue
private final Integer value;
private final String desc;
}

33
orgmanax-infra/src/main/resources/mapper/ProjectWorkerInviteMapper.xml Normal file
View File

@ -0,0 +1,33 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.axzo.orgmanax.infra.dao.invite.mapper.ProjectWorkerInviteMapper">
<select id="workerInviteStatusInProjectTeam" resultType="cn.axzo.orgmanax.infra.dao.invite.entity.ProjectWorkerInvite">
select
id,
project_team_id as projectTeamId,
worker_identity_id as workerIdentityId,
status
from
org_project_worker_invite
where
id in (
select
max(id)
from
org_project_worker_invite
where
project_team_id = #{projectTeamId}
and
worker_identity_id in (
<foreach collection="workerIdentityIdList" item="item" separator=",">
#{item}
</foreach>
)
and is_delete = 0
and status in (1, 2, 3)
group by
worker_identity_id
)
</select>
</mapper>

5
orgmanax-server/pom.xml
View File

@ -35,6 +35,11 @@
<artifactId>orgmanax-common</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>cn.axzo.framework</groupId>
<artifactId>axzo-logger-spring-boot-starter</artifactId>
<version>2.0.0-SNAPSHOT</version>
</dependency>
<!---->
<dependency>
<groupId>com.alibaba.cloud</groupId>

21
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/invite/service/ProjectWorkerInviteService.java Normal file
View File

@ -0,0 +1,21 @@
package cn.axzo.orgmanax.server.invite.service;
import java.util.List;
import java.util.Map;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
public interface ProjectWorkerInviteService {
/**
* 工人在项目内班组的邀请状态
*
* @param projectTeamId 项目内班组id
* @param workerIdentityIds 工人身份id
* @auther: wxf
* @date: 2022/12/4 22:51
* @return: {@link Integer}
*/
Map<Long, Integer> workerInviteStatusInProjectTeam(Long projectTeamId, List<Long> workerIdentityIds);
}

44
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/invite/service/impl/ProjectWorkerInviteServiceImpl.java Normal file
View File

@ -0,0 +1,44 @@
package cn.axzo.orgmanax.server.invite.service.impl;
import cn.axzo.orgmanax.infra.dao.invite.entity.ProjectWorkerInvite;
import cn.axzo.orgmanax.infra.dao.invite.mapper.ProjectWorkerInviteMapper;
import cn.axzo.orgmanax.server.invite.service.ProjectWorkerInviteService;
import cn.hutool.core.collection.CollectionUtil;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
@Service
@Slf4j
@AllArgsConstructor
public class ProjectWorkerInviteServiceImpl implements ProjectWorkerInviteService {
private ProjectWorkerInviteMapper projectWorkerInviteMapper;
/**
* 工人在项目内班组的邀请状态
*
* @param projectTeamId 项目内班组id
* @param workerIdentityIds 工人身份id
* @auther: wxf
* @date: 2022/12/4 22:51
* @return: {@link Integer}
*/
@Override
public Map<Long, Integer> workerInviteStatusInProjectTeam(Long projectTeamId, List<Long> workerIdentityIds) {
List<ProjectWorkerInvite> list = projectWorkerInviteMapper.workerInviteStatusInProjectTeam(projectTeamId, workerIdentityIds);
if (CollectionUtil.isEmpty(list)) {
return new HashMap<>();
}
return list.stream().collect(Collectors.toMap(ProjectWorkerInvite::getWorkerIdentityId, ProjectWorkerInvite::getStatus));
}
}

16
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/team/controller/OrgProjectTeamCategoryController.java
View File

@ -3,6 +3,7 @@ package cn.axzo.orgmanax.server.project.team.controller;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.api.project.team.feign.OrgProjectTeamCategoryApi;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryAggregateDTO;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryDTO;
import cn.axzo.orgmanax.dto.project.team.req.GroupTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.OperateOrgTeamCategoryReq;
@ -12,14 +13,16 @@ import cn.axzo.orgmanax.dto.project.team.req.PreCheckRemoveTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.RemoveProjectTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.SaveProjectTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.SingletonOrgTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.TreeOrgTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.resp.RemoveTeamCategoryCheckResp;
import cn.axzo.orgmanax.dto.project.team.resp.SingletonOrgTeamCategoryResp;
import cn.axzo.orgmanax.dto.project.team.resp.TeamCategoryGroupResp;
import cn.axzo.orgmanax.server.project.team.service.ProjectTeamCategoryService;
import cn.axzo.orgmanax.server.project.team.service.dto.ListTeamCategoryReq;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSONUtil;
import java.util.List;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@ -27,6 +30,7 @@ import org.springframework.web.bind.annotation.RestController;
* @author syl
* @date 2025/1/3
*/
@Slf4j
@RestController
@RequestMapping
@RequiredArgsConstructor
@ -71,7 +75,15 @@ public class OrgProjectTeamCategoryController implements OrgProjectTeamCategoryA
@Override
public ApiResult<PageResp<TeamCategoryDTO>> list(PageOrgTeamCategoryReq req) {
log.info("team_category page request param: [{}]", JSONUtil.toJsonStr(req));
return ApiResult.success(projectTeamCategoryService
.page(BeanUtil.copyProperties(req, ListTeamCategoryReq.class)));
.page(ListTeamCategoryReq.convertListReq(req)));
}
@Override
public ApiResult<List<TeamCategoryAggregateDTO>> treeList(TreeOrgTeamCategoryReq req) {
log.info("team_category tree request param: [{}]", JSONUtil.toJsonStr(req));
return ApiResult.success(projectTeamCategoryService
.treeList(ListTeamCategoryReq.convertTreeReq(req)));
}
}

12
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/team/foundation/impl/ProjectTeamCategoryFoundationServiceImpl.java
View File

@ -28,8 +28,7 @@ public class ProjectTeamCategoryFoundationServiceImpl implements ProjectTeamCate
private final TeamCategoryRepository teamCategoryRepository;
@Override
public PageResp<TeamCategoryDTO> page(ListTeamCategoryReq param) {
PageResp<TeamCategoryResp> page = teamCategoryRepository.page(
BeanUtil.copyProperties(param, TeamCategoryRepository.PageReq.class));
PageResp<TeamCategoryResp> page = teamCategoryRepository.page(convertFromList(param));
return PageResp.<TeamCategoryDTO>builder()
.size(page.getSize())
.current(page.getCurrent())
@ -53,4 +52,13 @@ public class ProjectTeamCategoryFoundationServiceImpl implements ProjectTeamCate
} while (pageResp.hasNext());
return categoryList;
}
public TeamCategoryRepository.PageReq convertFromList(ListTeamCategoryReq param) {
TeamCategoryRepository.PageReq pageReq = BeanUtil.copyProperties(param, TeamCategoryRepository.PageReq.class);
pageReq.setTypes(param.getCategoryTypes());
pageReq.setCodes(param.getCategoryCodes());
pageReq.setParentCode(param.getParentCode());
return pageReq;
}
}

10
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/team/service/ProjectTeamCategoryService.java
View File

@ -1,8 +1,10 @@
package cn.axzo.orgmanax.server.project.team.service;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryAggregateDTO;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryDTO;
import cn.axzo.orgmanax.server.project.team.service.dto.ListTeamCategoryReq;
import java.util.List;
/**
* @author syl
@ -10,5 +12,13 @@ import cn.axzo.orgmanax.server.project.team.service.dto.ListTeamCategoryReq;
*/
public interface ProjectTeamCategoryService {
/**
* 分页查询班组类别
*/
PageResp<TeamCategoryDTO> page(ListTeamCategoryReq req);
/**
* 班组类别聚合查询
*/
List<TeamCategoryAggregateDTO> treeList(ListTeamCategoryReq req);
}

80
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/team/service/dto/ListTeamCategoryReq.java
View File

@ -1,7 +1,15 @@
package cn.axzo.orgmanax.server.project.team.service.dto;
import cn.axzo.foundation.page.PageReqV2;
import java.util.List;
import cn.axzo.orgmanax.dto.project.team.enums.TeamCategoryTypeEnum;
import cn.axzo.orgmanax.dto.project.team.enums.TeamSceneEnum;
import cn.axzo.orgmanax.dto.project.team.enums.ValidationEnum;
import cn.axzo.orgmanax.dto.project.team.req.PageOrgTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.TreeOrgTeamCategoryReq;
import cn.hutool.core.bean.BeanUtil;
import com.google.common.collect.Sets;
import java.util.Objects;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
@ -22,5 +30,73 @@ public class ListTeamCategoryReq extends PageReqV2 {
/**
* nodeId 列表
*/
private List<Long> orgNodeIds;
private Set<Long> orgNodeIds;
/**
* 租户id
*/
private Long workspaceId;
/**
* 班组类别使用场景
* @see TeamSceneEnum
*/
private String scene;
/**
* 上级节点code
*/
private String parentCode;
/**
* 班组类别列表 categoryTypes
* @see TeamCategoryTypeEnum
*/
private Set<Integer> categoryTypes;
/**
* 经营范围/经营范围子级categoryCodes
*/
private Set<String> categoryCodes;
/**
* 数据有效性标记
* @see ValidationEnum
*/
private Set<Integer> validList;
/**
* 项目内班组idList
*/
private Set<Long> projectTeamIds;
/**
* 平台班组id
*/
private Set<Long> platTeamIds;
public static ListTeamCategoryReq convertListReq(PageOrgTeamCategoryReq req){
ListTeamCategoryReq param = BeanUtil.copyProperties(req, ListTeamCategoryReq.class);
if (Objects.isNull(req.getValid())) {
param.setValidList(Sets.newHashSet(ValidationEnum.EFFECTIVE.getCode()));
} else if (Objects.equals(ValidationEnum.ALL.getCode(), req.getValid())) {
param.setValidList(ValidationEnum.getAllCode());
} else {
param.setValidList(Sets.newHashSet(req.getValid()));
}
return param;
}
public static ListTeamCategoryReq convertTreeReq(TreeOrgTeamCategoryReq req){
ListTeamCategoryReq param = BeanUtil.copyProperties(req, ListTeamCategoryReq.class);
if (Objects.isNull(req.getValid())) {
param.setValidList(Sets.newHashSet(ValidationEnum.EFFECTIVE.getCode()));
} else if (Objects.equals(ValidationEnum.ALL.getCode(), req.getValid())) {
param.setValidList(ValidationEnum.getAllCode());
} else {
param.setValidList(Sets.newHashSet(req.getValid()));
}
return param;
}
}

168
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/team/service/impl/ProjectTeamCategoryServiceImpl.java
View File

@ -1,11 +1,36 @@
package cn.axzo.orgmanax.server.project.team.service.impl;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.orgmanax.dto.node.dto.NodeProfile;
import cn.axzo.orgmanax.dto.node.dto.OrgNodeDTO;
import cn.axzo.orgmanax.dto.node.enums.NodeTypeEnum;
import cn.axzo.orgmanax.dto.node.req.ListNodeReq;
import cn.axzo.orgmanax.dto.project.team.dto.OrgProjectTeamDTO;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryAggregateDTO;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryDTO;
import cn.axzo.orgmanax.dto.project.team.enums.TeamCategoryTypeEnum;
import cn.axzo.orgmanax.dto.project.team.req.ListProjectTeamReq;
import cn.axzo.orgmanax.dto.project.team.req.ListProjectTeamReq.ListProjectTeamReqBuilder;
import cn.axzo.orgmanax.server.node.service.NodeService;
import cn.axzo.orgmanax.server.project.team.foundation.ProjectTeamCategoryFoundationService;
import cn.axzo.orgmanax.server.project.team.service.ProjectTeamCategoryService;
import cn.axzo.orgmanax.server.project.team.service.ProjectTeamService;
import cn.axzo.orgmanax.server.project.team.service.dto.ListTeamCategoryReq;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.json.JSONUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@ -17,11 +42,150 @@ import org.springframework.stereotype.Service;
@Service
public class ProjectTeamCategoryServiceImpl implements ProjectTeamCategoryService {
private final static Long NO_PROJECT_TEAM_ID = 0L;
private final static String TOP_CATEGORY_PARENT_CODE = "0";
@Autowired
private ProjectTeamCategoryFoundationService teamCategoryFoundationService;
@Autowired
private ProjectTeamService projectTeamService;
@Autowired
private NodeService nodeService;
@Override
public PageResp<TeamCategoryDTO> page(ListTeamCategoryReq req) {
public PageResp<TeamCategoryDTO> page(ListTeamCategoryReq param) {
// todo 扩展
return teamCategoryFoundationService.page(req);
resolveNodeIds(param);
return teamCategoryFoundationService.page(param);
}
@Override
public List<TeamCategoryAggregateDTO> treeList(ListTeamCategoryReq param) {
Map<Long, Long> nodeTeamMap = resolveNodeIds(param);
List<TeamCategoryDTO> categoryList = teamCategoryFoundationService.pageAll(param);
if (CollUtil.isEmpty(categoryList)) {
return Lists.newArrayList();
}
return getCategoryTreeList(categoryList, nodeTeamMap);
}
private List<TeamCategoryAggregateDTO> getCategoryTreeList(List<TeamCategoryDTO> teamCategories,
Map<Long, Long> paramNodeTeamMap) {
if (CollUtil.isEmpty(paramNodeTeamMap)) {
log.info("getCategoryTreeList re-query project team");
ListNodeReq nodeReq = ListNodeReq.builder()
.ids(teamCategories.stream().map(TeamCategoryDTO::getOrgNodeId).collect(Collectors.toSet()))
.includeOrgNodeTypes(Sets.newHashSet(NodeTypeEnum.PROJECT_TEAM.getCode()))
.build();
List<OrgNodeDTO> orgNodeList = nodeService.list(nodeReq);
paramNodeTeamMap = orgNodeList.stream().collect(
Collectors.toMap(OrgNodeDTO::getId, this::getProjectTeamId, (v1, v2) -> v1));
}
final Map<Long, Long> nodeTeamMap = paramNodeTeamMap;
// 构建tree
Map<String, List<TeamCategoryDTO>> categoryMap = teamCategories.stream()
.collect(Collectors.groupingBy(TeamCategoryDTO::getParentCode));
return teamCategories.stream()
.filter(category ->
Objects.equals(category.getType(), TeamCategoryTypeEnum.WORKER_GROUP_CATEGORY.getCode()))
.map(c -> {
TeamCategoryAggregateDTO dto = convert(c, nodeTeamMap, c);
List<TeamCategoryDTO> childrens = categoryMap.get(c.getCode());
if (ObjectUtils.isNotEmpty(childrens)) {
List<TeamCategoryAggregateDTO> categoryRes = childrens.stream()
.map(s -> convert(s, nodeTeamMap, c))
.collect(Collectors.toList());
dto.setWorkScopes(categoryRes);
}
return dto;
}
).collect(Collectors.toList());
}
private Long getProjectTeamId(OrgNodeDTO node) {
NodeProfile.ProjectTeamProfile projectTeamProfile = node.resolveProfile();
if (Objects.isNull(projectTeamProfile)) {
return NO_PROJECT_TEAM_ID;
}
return projectTeamProfile.getProjectTeamId();
}
public TeamCategoryAggregateDTO convert(TeamCategoryDTO category, Map<Long, Long> nodeTeamMap,
TeamCategoryDTO parentCategory) {
TeamCategoryAggregateDTO dto = BeanUtil.copyProperties(category, TeamCategoryAggregateDTO.class);
Long projectTeamId = nodeTeamMap.get(category.getOrgNodeId());
if (Objects.nonNull(projectTeamId) && !Objects.equals(projectTeamId, NO_PROJECT_TEAM_ID)) {
dto.setProjectTeamId(projectTeamId);
}
dto.setParentCode(category.getParentCode());
if (!Objects.equals(category.getParentCode(), TOP_CATEGORY_PARENT_CODE)) {
dto.setParentName(parentCategory.getName());
}
return dto;
}
private Map<Long, Long> resolveNodeIds(ListTeamCategoryReq param) {
boolean hasProjectTeam = CollUtil.isNotEmpty(param.getProjectTeamIds());
boolean hasPlatTeam = CollUtil.isNotEmpty(param.getPlatTeamIds());
if (!hasProjectTeam && !hasPlatTeam) {
return Maps.newHashMap();
}
Set<Long> projectTeamNodeIds = new HashSet<>();
Set<Long> platTeamNodeIds = new HashSet<>();
List<OrgProjectTeamDTO> projectTeams = new ArrayList<>();
if (hasProjectTeam) {
// todo 通过项目班组id获取组织节点id
projectTeams = queryTeams(param.getProjectTeamIds(), NodeTypeEnum.PROJECT_TEAM);
projectTeamNodeIds = projectTeams.stream()
.map(OrgProjectTeamDTO::getOrganizationalNodeId)
.collect(Collectors.toSet());
}
if (hasPlatTeam) {
// todo 通过平台班组id获取组织节点id
List<OrgProjectTeamDTO> platTeams = queryTeams(param.getPlatTeamIds(), NodeTypeEnum.TEAM);
projectTeams.addAll(platTeams);
platTeamNodeIds = platTeams.stream()
.map(OrgProjectTeamDTO::getOrganizationalNodeId)
.collect(Collectors.toSet());
}
Set<Long> teamNodeIds;
// 拼接
if (!hasProjectTeam) {
teamNodeIds = intersectionNodeId(platTeamNodeIds, param.getOrgNodeIds());
} else if (!hasPlatTeam) {
teamNodeIds = intersectionNodeId(projectTeamNodeIds, param.getOrgNodeIds());
} else {
teamNodeIds = intersectionNodeId(Sets.intersection(projectTeamNodeIds, platTeamNodeIds)
, param.getOrgNodeIds());
}
log.info("resolveNodeIds teamNodeIds = [{}]", JSONUtil.toJsonStr(teamNodeIds));
param.setOrgNodeIds(teamNodeIds);
return projectTeams.stream()
.filter(t -> Objects.nonNull(t.getOrganizationalNodeId()))
.collect(Collectors.toMap(OrgProjectTeamDTO::getOrganizationalNodeId, OrgProjectTeamDTO::getProjectTeamId
, (p, n) -> p));
}
private Set<Long> intersectionNodeId(Set<Long> teamNodeIds, Set<Long> orgNodeIds) {
if (CollUtil.isEmpty(orgNodeIds)) {
return teamNodeIds;
}
return Sets.intersection(teamNodeIds, orgNodeIds);
}
private List<OrgProjectTeamDTO> queryTeams(Set<Long> teamIds, NodeTypeEnum nodeType) {
ListProjectTeamReqBuilder<?, ?> teamBuilder = ListProjectTeamReq.builder();
return CollUtil.defaultIfEmpty(projectTeamService
.list(teamBuilder.projectTeamIds(teamIds)
.nodeTypes(Sets.newHashSet(nodeType.getCode()))
.build()), CollUtil.newArrayList());
}
}

1
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/team/service/impl/ProjectTeamServiceImpl.java
View File

@ -43,6 +43,7 @@ public class ProjectTeamServiceImpl implements ProjectTeamService {
.ouIds(req.getOuIds())
.platTeamIds(platTeamIds)
.workspaceIds(req.getWorkspaceIds())
.projectTeamIds(req.getProjectTeamIds())
.build();
List<OrgNodeDTO> orgNodeDTOS = nodeService.list(nodeReq);
List<OrgProjectTeamDTO> orgProjectTeamDTOS = CollUtil.newArrayList();

9
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/projectworker/controller/OrgProjectWorkerController.java → orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/worker/controller/OrgProjectWorkerController.java
View File

@ -1,4 +1,4 @@
package cn.axzo.orgmanax.server.projectworker.controller;
package cn.axzo.orgmanax.server.project.worker.controller;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.api.project.worker.feign.OrgProjectWorkerApi;
@ -6,7 +6,7 @@ import cn.axzo.orgmanax.dto.project.group.req.ProjectDirectGroupUngroupedWorkerR
import cn.axzo.orgmanax.dto.project.group.req.ProjectDirectGroupWorkerListReq;
import cn.axzo.orgmanax.dto.project.group.resp.ProjectDirectGroupUngroupedWorkerResp;
import cn.axzo.orgmanax.dto.project.group.resp.ProjectDirectGroupWorkerListResp;
import cn.axzo.orgmanax.server.projectworker.service.OrgProjectWorkerService;
import cn.axzo.orgmanax.server.project.worker.service.OrgProjectWorkerService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RestController;
@ -27,12 +27,11 @@ public class OrgProjectWorkerController implements OrgProjectWorkerApi {
@Override
public ApiResult<List<ProjectDirectGroupUngroupedWorkerResp>> ungroupedWorker(@Valid ProjectDirectGroupUngroupedWorkerReq req) {
orgProjectWorkerService.ungroupedWorker(req);
return null;
return ApiResult.success(orgProjectWorkerService.ungroupedWorker(req));
}
@Override
public ApiResult<List<ProjectDirectGroupWorkerListResp>> workerList(@Valid ProjectDirectGroupWorkerListReq req) {
return null;
return ApiResult.success(orgProjectWorkerService.workerList(req));
}
}

28
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/worker/service/OrgProjectWorkerService.java Normal file
View File

@ -0,0 +1,28 @@
package cn.axzo.orgmanax.server.project.worker.service;
import cn.axzo.orgmanax.dto.project.group.req.ProjectDirectGroupUngroupedWorkerReq;
import cn.axzo.orgmanax.dto.project.group.req.ProjectDirectGroupWorkerListReq;
import cn.axzo.orgmanax.dto.project.group.resp.ProjectDirectGroupUngroupedWorkerResp;
import cn.axzo.orgmanax.dto.project.group.resp.ProjectDirectGroupWorkerListResp;
import java.util.List;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
public interface OrgProjectWorkerService {
/**
* 获取班组下未分组的工人
* @param req
* @return
*/
List<ProjectDirectGroupUngroupedWorkerResp> ungroupedWorker(ProjectDirectGroupUngroupedWorkerReq req);
/**
* 获取直属小组下工人
* @param req
* @return
*/
List<ProjectDirectGroupWorkerListResp> workerList(ProjectDirectGroupWorkerListReq req);
}

250
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/project/worker/service/impl/OrgProjectWorkerServiceImpl.java Normal file
View File

@ -0,0 +1,250 @@
package cn.axzo.orgmanax.server.project.worker.service.impl;
import cn.axzo.orgmanax.api.invite.enums.WorkerInviteStatusEnum;
import cn.axzo.orgmanax.api.project.group.enums.ProjectGroupTypeEnum;
import cn.axzo.orgmanax.api.project.worker.enums.ProjectWorkerStatusEnum;
import cn.axzo.orgmanax.dto.common.IdentityType;
import cn.axzo.orgmanax.dto.node.dto.NodeProfile;
import cn.axzo.orgmanax.dto.node.dto.OrgNodeDTO;
import cn.axzo.orgmanax.dto.node.enums.NodeTypeEnum;
import cn.axzo.orgmanax.dto.node.req.ListNodeReq;
import cn.axzo.orgmanax.dto.nodeuser.dto.NodeUserDTO;
import cn.axzo.orgmanax.dto.nodeuser.dto.NodeUserProfile;
import cn.axzo.orgmanax.dto.nodeuser.enums.ProjectGroupWorkerStatusEnum;
import cn.axzo.orgmanax.dto.nodeuser.req.ListNodeUserReq;
import cn.axzo.orgmanax.dto.project.group.enums.ProjectGroupStatusEnum;
import cn.axzo.orgmanax.dto.project.group.req.ProjectDirectGroupUngroupedWorkerReq;
import cn.axzo.orgmanax.dto.project.group.req.ProjectDirectGroupWorkerListReq;
import cn.axzo.orgmanax.dto.project.group.resp.*;
import cn.axzo.orgmanax.dto.workerprofession.dto.ProfessionDTO;
import cn.axzo.orgmanax.dto.workerprofession.dto.SkillTagDTO;
import cn.axzo.orgmanax.infra.client.datacollection.dto.DataCollectionSkillTypeEnum;
import cn.axzo.orgmanax.server.invite.service.ProjectWorkerInviteService;
import cn.axzo.orgmanax.server.node.service.NodeService;
import cn.axzo.orgmanax.server.nodeuser.service.NodeUserService;
import cn.axzo.orgmanax.server.project.worker.service.OrgProjectWorkerService;
import cn.axzo.orgmanax.server.workerprofession.service.OrgProjectWorkerProfessionService;
import cn.axzo.orgmanax.server.workerprofession.service.OrgProjectWorkerProfessionSkillService;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
@Service
@Slf4j
@AllArgsConstructor
public class OrgProjectWorkerServiceImpl implements OrgProjectWorkerService {
private NodeUserService nodeUserService;
private NodeService nodeService;
private ProjectWorkerInviteService projectWorkerInviteService;
private OrgProjectWorkerProfessionSkillService orgProjectWorkerProfessionSkillService;
private OrgProjectWorkerProfessionService orgProjectWorkerProfessionService;
/**
* 获取班组下未分组的工人
* @param req
* @return
*/
@Override
public List<ProjectDirectGroupUngroupedWorkerResp> ungroupedWorker(ProjectDirectGroupUngroupedWorkerReq req) {
//查询班组下工人
List<NodeUserDTO> allNodeUserDTOS = nodeUserService.list(ListNodeUserReq.builder()
.workspaceId(req.getWorkspaceId())
.platTeamId(req.getPlatTeamId())
.filterIncludeNodeTypes(Arrays.asList(NodeTypeEnum.PROJECT_TEAM.getValue()))
.identityType(IdentityType.WORKER.getCode())
.projectWorkerStatuses(Lists.newArrayList(ProjectWorkerStatusEnum.INACTIVE.getValue(), ProjectWorkerStatusEnum.ACTIVE.getValue()))
.needs(ListNodeUserReq.Needs.builder()
.personProfile(true) //后面需要用到头像
.node(true) //后面需要用到部门
.build())
.build());
if (ObjectUtil.isEmpty(allNodeUserDTOS)) {
return Collections.emptyList();
}
Long projectTeamId = NodeProfile.resolveProjectTeamId(allNodeUserDTOS.get(0).getNode());
List<NodeUserDTO> ungroupedWorkerList = allNodeUserDTOS;
//查询班组下的直属小组
List<OrgNodeDTO> orgNodeDTOS4Group = nodeService.list(ListNodeReq.builder()
.platTeamIds(Sets.newHashSet(req.getPlatTeamId()))
.workspaceIds(Sets.newHashSet(req.getWorkspaceId()))
.includeOrgNodeTypes(Sets.newHashSet(NodeTypeEnum.PROJECT_GROUP.getValue()))
.groupType(ProjectGroupTypeEnum.DIRECTLY_UNDER.getValue())
.build());
if (ObjectUtil.isNotEmpty(orgNodeDTOS4Group)) {
List<Long> nodeIds4Group = orgNodeDTOS4Group.stream().map(OrgNodeDTO::getId).collect(Collectors.toList());
//查询直属小组下的工人
List<NodeUserDTO> nodeUserDTOS4Group = nodeUserService.list(ListNodeUserReq.builder()
.workspaceId(req.getWorkspaceId())
.projectTeamId(projectTeamId)
.organizationalNodeIds(nodeIds4Group)
.filterIncludeNodeTypes(Arrays.asList(NodeTypeEnum.PROJECT_GROUP.getValue()))
.identityType(IdentityType.WORKER.getCode())
.projectGroupWorkerStatus(ProjectGroupWorkerStatusEnum.VALID.getValue())
.build());
//直属小组下的工人id列表
List<Long> groupProjectWorkerIds = nodeUserDTOS4Group.stream()
.map(nodeUserDTO -> NodeUserProfile.resolveProjectWorkerId(nodeUserDTO))
.collect(Collectors.toList());
//排除直属小组下的工人
ungroupedWorkerList = allNodeUserDTOS.stream()
.filter(nodeUserDTO -> !groupProjectWorkerIds.contains(NodeUserProfile.resolveProjectWorkerId(nodeUserDTO)))
.collect(Collectors.toList());
}
// todo 为保证部分工人被班组长、从业人员拒绝，labour_project_worker中未被is_delete掉，所以查一次邀请列表，去除这一部分工人
// 后面有时间把所有拒绝工人申请加入项目内班组的处理一下，同时is_delete项目内工人数据
if (CollUtil.isNotEmpty(ungroupedWorkerList)) {
List<Long> workerIdentityIds = ungroupedWorkerList.stream()
.filter(item -> ((NodeUserProfile.ProjectWorkerProfile)item.resolveProfile()).getProjectWorkerStatus().equals(ProjectWorkerStatusEnum.INACTIVE.getValue()))
.map(NodeUserDTO::getIdentityId).collect(Collectors.toList());
if (CollUtil.isNotEmpty(workerIdentityIds)) {
Map<Long, Integer> workerStatusMap = projectWorkerInviteService.workerInviteStatusInProjectTeam(projectTeamId, workerIdentityIds);
ungroupedWorkerList = ungroupedWorkerList.stream().filter(item -> checkWorkerEnterPass(workerStatusMap.get(item.getIdentityId()))).collect(Collectors.toList());
Map<Long, List<NodeUserDTO>> workerMap = ungroupedWorkerList.stream().collect(Collectors.groupingBy(NodeUserDTO::getIdentityId));
List<NodeUserDTO> lpw = new ArrayList<>();
workerMap.forEach((workerIdentityId, items) -> {
NodeUserDTO nodeUserDTO = items.stream().max(Comparator.comparing(NodeUserDTO::getId)).get();
lpw.add(nodeUserDTO);
});
ungroupedWorkerList = lpw;
}
}
if (ObjectUtil.isEmpty(ungroupedWorkerList)) {
return Collections.emptyList();
}
List<ProjectWorkerBaseInfo> projectWorkerBaseInfos = this.getProjectWorkerBaseInfos(ungroupedWorkerList);
List<ProjectDirectGroupUngroupedWorkerResp> resps = BeanUtil.copyToList(projectWorkerBaseInfos, ProjectDirectGroupUngroupedWorkerResp.class);
Map<Long, NodeUserDTO> nodeUserDTOMap = ungroupedWorkerList.stream().collect(Collectors.toMap(NodeUserDTO::getIdentityId, Function.identity(), (o, n) -> o));
for (ProjectDirectGroupUngroupedWorkerResp resp : resps) {
NodeUserDTO nodeUserDTO = nodeUserDTOMap.get(resp.getWorkerIdentityId());
if (nodeUserDTO != null) {
resp.setPlatTeamId(NodeProfile.resolvePlatTeamId(nodeUserDTO.getNode()));
resp.setProjectTeamId(NodeProfile.resolvePlatTeamId(nodeUserDTO.getNode()));
}
}
return resps;
}
/**
* 获取直属小组下工人
* @param req
* @return
*/
@Override
public List<ProjectDirectGroupWorkerListResp> workerList(ProjectDirectGroupWorkerListReq req) {
//查询小组信息
List<OrgNodeDTO> orgNodeDTOS = nodeService.list(ListNodeReq.builder()
.includeOrgNodeTypes(Sets.newHashSet(NodeTypeEnum.PROJECT_GROUP.getValue()))
.workspaceIds(Sets.newHashSet(req.getWorkspaceId()))
.groupIds(req.getGroupIdList())
.ownerWorkerIdentityIds(req.getGroupOwnerIdentityIdList())
.groupType(ProjectGroupTypeEnum.DIRECTLY_UNDER.getValue())
.groupStatus(ProjectGroupStatusEnum.ACTIVE.getValue())
.build());
if (ObjectUtil.isEmpty(orgNodeDTOS)) {
return Collections.emptyList();
}
List<Long> orgNodeIds = orgNodeDTOS.stream().map(OrgNodeDTO::getId).collect(Collectors.toList());
//查询小组下工人信息
List<NodeUserDTO> nodeUserDTOS = nodeUserService.list(ListNodeUserReq.builder()
.organizationalNodeIds(orgNodeIds)
.identityIds(req.getWorkerIdentityIdList())
.projectGroupWorkerStatus(ProjectGroupWorkerStatusEnum.VALID.getValue())
.identityType(IdentityType.WORKER.getCode())
.needs(ListNodeUserReq.Needs.builder().personProfile(true).build())
.build());
if (ObjectUtil.isEmpty(nodeUserDTOS)) {
return Collections.emptyList();
}
List<ProjectWorkerBaseInfo> projectWorkerBaseInfos = getProjectWorkerBaseInfos(nodeUserDTOS);
return BeanUtil.copyToList(projectWorkerBaseInfos, ProjectDirectGroupWorkerListResp.class);
}
private List<ProjectWorkerBaseInfo> getProjectWorkerBaseInfos(List<NodeUserDTO> nodeUserDTOS) {
if (CollUtil.isEmpty(nodeUserDTOS)) {
return Collections.emptyList();
}
List<Long> projectWorkerIdList = nodeUserDTOS.stream()
.map(nodeUser -> NodeUserProfile.resolveProjectWorkerId(nodeUser)).collect(Collectors.toList());
List<ProfessionDTO> professionDTOS = orgProjectWorkerProfessionService.listValidWorkerProfession(projectWorkerIdList);
Map<Long, List<ProfessionDTO>> professionMap = professionDTOS.stream().collect(Collectors.groupingBy(ProfessionDTO::getProjectWorkerId));
return nodeUserDTOS.stream().map(i -> {
ProjectWorkerBaseInfo workerBaseInfo = new ProjectDirectGroupUngroupedWorkerResp();
workerBaseInfo.setWorkerPersonId(i.getPersonId());
workerBaseInfo.setWorkerIdentityId(i.getIdentityId());
workerBaseInfo.setWorkerName(i.getRealName());
workerBaseInfo.setWorkerPhone(i.getPhone());
workerBaseInfo.setWorkerFaceUrl(i.getPersonProfile().getAvatarUrl());
// ungroupedWorker.setBlackType(i.getBlackType()); todo 网关从maokai 宽表中获取
// 工种
List<ProfessionDTO> professions = professionMap.get(NodeUserProfile.resolveProjectWorkerId(i));
if (CollUtil.isNotEmpty(professions)) {
List<ProjectWorkerProfessionRes> professionList = professions.stream().map(professionDTO -> {
ProjectWorkerProfessionRes res = new ProjectWorkerProfessionRes();
res.setId(professionDTO.getProfessionId());
res.setName(professionDTO.getProfessionName());
return res;
}).collect(Collectors.toList());
workerBaseInfo.setProfessionList(professionList);
// 技工 or 普工, 经讨论，取第一个即可
workerBaseInfo.setProfessionCategoryName(DataCollectionSkillTypeEnum.getType(professions.get(0).getSkillType()).getDesc());
}
// 技能标签
List<SkillTagDTO> skillTagDTOS = professionMap.get(NodeUserProfile.resolveProjectWorkerId(i)).stream().flatMap(professionDTO -> professionDTO.getSkillTags().stream()).collect(Collectors.toList());
if (CollUtil.isNotEmpty(skillTagDTOS)) {
List<ProjectWorkerSkillTagRes> workerSkillTagDtoList = skillTagDTOS.stream().map(
w -> {
ProjectWorkerSkillTagRes res = new ProjectWorkerSkillTagRes();
res.setId(0L); //历史代码skillTagId全是0L
res.setName(w.getName());
return res;
}
).collect(Collectors.toList());
workerBaseInfo.setSkillTagList(workerSkillTagDtoList);
}
NodeUserProfile.ProjectWorkerProfile projectWorkerProfile = i.resolveProfile();
workerBaseInfo.setStatus(projectWorkerProfile.getProjectWorkerStatus());
workerBaseInfo.setJoinAt(i.getJoinAt());
return workerBaseInfo;
}).collect(Collectors.toList());
}
// 工人审核标识
private boolean checkWorkerEnterPass(Integer status) {
if (Objects.isNull(status)) {
return true;
}
if (status.equals(WorkerInviteStatusEnum.TEAM_OWNER_REFUSE.getValue())
|| status.equals(WorkerInviteStatusEnum.MANAGER_REFUSE.getValue())) {
return false;
}
return true;
}
}

14
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/projectworker/service/OrgProjectWorkerService.java
View File

@ -1,14 +0,0 @@
package cn.axzo.orgmanax.server.projectworker.service;
import cn.axzo.orgmanax.dto.project.group.req.ProjectDirectGroupUngroupedWorkerReq;
import cn.axzo.orgmanax.dto.project.group.resp.ProjectDirectGroupUngroupedWorkerResp;
import java.util.List;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
public interface OrgProjectWorkerService {
List<ProjectDirectGroupUngroupedWorkerResp> ungroupedWorker(ProjectDirectGroupUngroupedWorkerReq req);
}

68
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/projectworker/service/impl/OrgProjectWorkerServiceImpl.java
View File

@ -1,68 +0,0 @@
package cn.axzo.orgmanax.server.projectworker.service.impl;
import cn.axzo.orgmanax.api.project.worker.enums.ProjectWorkerStatusEnum;
import cn.axzo.orgmanax.dto.common.IdentityType;
import cn.axzo.orgmanax.dto.node.req.ListNodeReq;
import cn.axzo.orgmanax.dto.nodeuser.dto.NodeUserDTO;
import cn.axzo.orgmanax.dto.nodeuser.req.ListNodeUserReq;
import cn.axzo.orgmanax.dto.project.group.req.ProjectDirectGroupUngroupedWorkerReq;
import cn.axzo.orgmanax.dto.project.group.resp.ProjectDirectGroupUngroupedWorkerResp;
import cn.axzo.orgmanax.server.node.service.NodeService;
import cn.axzo.orgmanax.server.nodeuser.service.NodeUserService;
import cn.axzo.orgmanax.server.projectworker.service.OrgProjectWorkerService;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
@Service
@Slf4j
@AllArgsConstructor
public class OrgProjectWorkerServiceImpl implements OrgProjectWorkerService {
private NodeUserService nodeUserService;
private NodeService nodeService;
@Override
public List<ProjectDirectGroupUngroupedWorkerResp> ungroupedWorker(ProjectDirectGroupUngroupedWorkerReq req) {
// //查询班组下工人
// List<NodeUserDTO> nodeUserDTOS4Team = nodeUserService.list(ListNodeUserReq.builder()
// .workspaceId(req.getWorkspaceId())
// .platTeamId(req.getPlatTeamId())
// .identityType(IdentityType.WORKER.getCode())
// .projectWorkerStatuses(Lists.newArrayList(ProjectWorkerStatusEnum.INACTIVE.getValue(), ProjectWorkerStatusEnum.ACTIVE.getValue()))
// .build());
// if (ObjectUtil.isEmpty(nodeUserDTOS4Team)) {
// return Collections.emptyList();
// }
//
// //查询班组下的直属小组工人
// nodeService.list(ListNodeReq.builder()
// .platTeamIds(Sets.newHashSet(req.getPlatTeamId()))
// .workspaceIds(Sets.newHashSet(req.getWorkspaceId()))
// .groupType(ProjectGroupTypeEnum.DIRECTLY_UNDER.getValue())
// .build());
//
//
// List<NodeUserDTO> nodeUserDTOS = nodeUserService.list(ListNodeUserReq.builder()
// .workspaceId(req.getWorkspaceId())
// .platTeamId(req.getPlatTeamId())
// .projectWorkerStatuses(Lists.newArrayList(ProjectWorkerStatusEnum.INACTIVE.getValue(), ProjectWorkerStatusEnum.ACTIVE.getValue()))
// .build());
return null;
}
}

8
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/workerprofession/service/OrgProjectWorkerProfessionService.java
View File

@ -6,6 +6,7 @@ import cn.axzo.orgmanax.dto.workerprofession.req.ProjectWorkerProfessionListVali
import cn.axzo.orgmanax.dto.workerprofession.req.ProjectWorkerProfessionSortOutProfessionCategoryReq;
import cn.axzo.orgmanax.dto.workerprofession.req.WorkerProfessionTagQueryPageReq;
import cn.axzo.orgmanax.dto.workerprofession.resp.ProjectWorkerProfessionResp;
import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionHistoryRepository;
import java.util.List;
import java.util.Map;
@ -42,4 +43,11 @@ public interface OrgProjectWorkerProfessionService {
* @return
*/
PageResp<ProjectWorkerProfessionResp> page(WorkerProfessionTagQueryPageReq req);
/**
* 获取历史工种
* @param req
* @return
*/
List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> listHistory(WorkerProfessionHistoryRepository.PageReq req);
}

8
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/workerprofession/service/OrgProjectWorkerProfessionSkillService.java
View File

@ -1,5 +1,6 @@
package cn.axzo.orgmanax.server.workerprofession.service;
import cn.axzo.orgmanax.dto.workerprofession.dto.SkillTagDTO;
import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionSkillTag;
import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionHistoryRepository;
import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionSkillTagRepository;
@ -12,4 +13,11 @@ import java.util.List;
*/
public interface OrgProjectWorkerProfessionSkillService {
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> list(WorkerProfessionSkillTagRepository.PageReq req);
/**
* 根据项目工人id列表获取技能标签， 包含历史工种表中的技能标签， 标签含有子标签关系
* @param projectWorkerIds
* @return
*/
List<SkillTagDTO> listSkillTagWithChild(List<Long> projectWorkerIds);
}

136
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/workerprofession/service/impl/OrgProjectWorkerProfessionServiceImpl.java
View File

@ -1,5 +1,4 @@
package cn.axzo.orgmanax.server.workerprofession.service.impl;
import cn.axzo.orgmanax.dto.workerprofession.dto.ProjectWorkerProfessionDTO;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.orgmanax.api.project.worker.enums.ProjectWorkerStatusEnum;
@ -17,6 +16,7 @@ import cn.axzo.orgmanax.dto.nodeuser.req.ListNodeUserReq;
import cn.axzo.orgmanax.dto.project.team.enums.TeamSceneEnum;
import cn.axzo.orgmanax.dto.project.team.enums.ValidationEnum;
import cn.axzo.orgmanax.dto.workerprofession.dto.ProfessionDTO;
import cn.axzo.orgmanax.dto.workerprofession.dto.ProjectWorkerProfessionDTO;
import cn.axzo.orgmanax.dto.workerprofession.dto.SkillTagDTO;
import cn.axzo.orgmanax.dto.workerprofession.model.ProfessionSkillTagTreeNode;
import cn.axzo.orgmanax.dto.workerprofession.req.ProjectWorkerProfessionListValidReq;
@ -26,9 +26,7 @@ import cn.axzo.orgmanax.dto.workerprofession.resp.ProjectWorkerProfessionResp;
import cn.axzo.orgmanax.infra.client.datacollection.DataCollectionDictInfoClient;
import cn.axzo.orgmanax.infra.client.datacollection.dto.DataCollectionListProfessionCategoriesResp;
import cn.axzo.orgmanax.infra.client.datacollection.dto.DataCollectionSkillTypeEnum;
import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionSkillTag;
import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionTag;
import cn.axzo.orgmanax.infra.dao.workerprofession.enums.SkillTypeEnum;
import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionHistoryRepository;
import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionSkillTagRepository;
import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionTagRepository;
@ -42,20 +40,17 @@ import cn.axzo.orgmanax.server.util.StreamUtil;
import cn.axzo.orgmanax.server.workerprofession.service.OrgProjectWorkerProfessionService;
import cn.axzo.orgmanax.server.workerprofession.service.OrgProjectWorkerProfessionSkillService;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSON;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.*;
import java.util.function.BinaryOperator;
@ -72,15 +67,21 @@ import static java.util.stream.Collectors.*;
*/
@Service
@Slf4j
@AllArgsConstructor
public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerProfessionService {
@Autowired
private NodeService nodeService;
@Autowired
private NodeUserService nodeUserService;
@Autowired
private WorkerProfessionTagRepository workerProfessionTagRepository;
@Autowired
private DataCollectionDictInfoClient dataCollectionDictInfoClient;
@Autowired
private OrgProjectWorkerProfessionSkillService orgProjectWorkerProfessionSkillService;
@Autowired
private WorkerProfessionHistoryRepository workerProfessionHistoryRepository;
@Autowired
private CooperateShipService cooperateShipService;
private static final ImmutableSet<Integer> TEAM_ORG_NODE_TYPES = ImmutableSet.of(
@ -122,17 +123,14 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
.organizationalNodeIds(nodeIds)
.identityIds(workerIdentityIds)
.identityType(IdentityType.WORKER.getCode())
.projectWorkerStatuses(Arrays.asList(ProjectWorkerStatusEnum.ACTIVE.getValue())) //TODO 待枚举定义
.projectWorkerStatuses(Arrays.asList(ProjectWorkerStatusEnum.ACTIVE.getValue()))
.build());
if (ObjectUtil.isEmpty(nodeUserDTOS)) {
return Collections.emptyMap();
}
List<Long> projectWorkerIds = nodeUserDTOS.stream().map(nodeUserDTO -> {
NodeUserProfile.ProjectWorkerProfile projectWorkerProfile = nodeUserDTO.resolveProfile();
return projectWorkerProfile.getProjectWorkerId();
}).collect(toList());
List<Long> projectWorkerIds = nodeUserDTOS.stream().map(nodeUserDTO -> NodeUserProfile.resolveProjectWorkerId(nodeUserDTO)).collect(toList());
Map<Long, NodeUserDTO> nodeUserDTOMap = nodeUserDTOS.stream().collect(toMap(NodeUserDTO::getIdentityId, identity()));
//获取工人工种
@ -146,8 +144,7 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
if (nodeUserDTO == null) {
result.put(identityId, Collections.emptyList());
} else {
NodeUserProfile.ProjectWorkerProfile projectWorkerProfile = nodeUserDTO.resolveProfile();
Long projectWorkerId = projectWorkerProfile.getProjectWorkerId();
Long projectWorkerId = nodeUserDTO.getProfile().getLong("projectWorkerId");
List<ProfessionDTO> professions = professionMap.get(projectWorkerId);
if (professions == null) {
professions = Collections.emptyList();
@ -192,7 +189,7 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
}
//获取技能标签包括历史技能标签(带子技能标签)
List<SkillTagDTO> skillTagDTOS = listSkillTagWithChild(projectWorkerIds);
List<SkillTagDTO> skillTagDTOS = orgProjectWorkerProfessionSkillService.listSkillTagWithChild(projectWorkerIds);
Map<Long, List<SkillTagDTO>> skillTagMap = skillTagDTOS.stream().collect(groupingBy(SkillTagDTO::getProfessionId));
//封装工人工种和技能标签
@ -211,6 +208,7 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
//查询工人
List<NodeUserDTO> nodeUserDTOS = nodeUserService.list(ListNodeUserReq.builder()
.projectWorkerIds(projectWorkerIdList)
.filterIncludeNodeTypes(Arrays.asList(NodeTypeEnum.PROJECT_TEAM.getValue()))
.identityType(IdentityType.WORKER.getCode())
.build());
if (ObjectUtil.isEmpty(nodeUserDTOS)) {
@ -338,6 +336,11 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
.build();
}
@Override
public List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> listHistory(WorkerProfessionHistoryRepository.PageReq req) {
return workerProfessionHistoryRepository.list(req);
}
private void assembleSkillTags(List<ProjectWorkerProfessionResp> workProcessionTags) {
if (ObjectUtils.isEmpty(workProcessionTags)) {
return;
@ -380,7 +383,7 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
private ProjectWorkerProfessionResp convertTagToResp(WorkerProfessionTag workerProfessionTag) {
ProjectWorkerProfessionResp workerProfessionTagResp = BeanUtil.copyProperties(workerProfessionTag, ProjectWorkerProfessionResp.class);
workerProfessionTagResp.setType(Optional.ofNullable(workerProfessionTag.getType()).orElse(SkillTypeEnum.COMMON.getValue()));
workerProfessionTagResp.setType(Optional.ofNullable(workerProfessionTag.getType()).orElse(DataCollectionSkillTypeEnum.COMMON.getValue()));
return workerProfessionTagResp;
}
@ -438,108 +441,9 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
return orgCooperateShipDTOS4Parent.get(0).getOrganizationalNodeId();
}
/**
* 获取技能标签包括历史技能标签(带子技能标签)
* @param projectWorkerIds
*/
private List<SkillTagDTO> listSkillTagWithChild(List<Long> projectWorkerIds) {
//获取技能标签
WorkerProfessionSkillTagRepository.PageReq pageReq4Skill = WorkerProfessionSkillTagRepository.PageReq.builder()
.projectWorkerIds(projectWorkerIds)
.scene(TeamSceneEnum.PROJECT_TEAM.name())
.build();
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> workerProfessionSkillTagResps = orgProjectWorkerProfessionSkillService.list(pageReq4Skill);
//获取历史技能标签
WorkerProfessionHistoryRepository.PageReq pageReq4HistoryProfession = WorkerProfessionHistoryRepository.PageReq.builder()
.scene(TeamSceneEnum.PROJECT_TEAM.name())
.projectWorkerIds(projectWorkerIds)
.build();
List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> workerProfessionHistoryResps = workerProfessionHistoryRepository.list(pageReq4HistoryProfession);
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> workerProfessionSkillTagResps4History = doHistoryWorkerSkilltag(workerProfessionHistoryResps);
//技能标签和历史技能标签合在一起
Stream<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> allStream = Stream.concat(workerProfessionSkillTagResps.stream(), workerProfessionSkillTagResps4History.stream());
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> allSkillTagResps = StreamUtil.distinct(allStream,
p -> String.format("%s_%s", p.getProjectWorkerId(), p.getSkillTagCode()), SKILL_TAG_MERGE_FUNC)
.collect(toList());
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> parentSkillTagLists = allSkillTagResps.stream()
.filter(item -> !StringUtils.hasLength(item.getParentSkillTagCode()) || item.getParentSkillTagCode().equals("0"))
.collect(toList());
Map<String, List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp>> chileMap = allSkillTagResps.stream()
.filter(item -> StringUtils.hasLength(item.getParentSkillTagCode()) || !item.getParentSkillTagCode().equals("0"))
.collect(Collectors.groupingBy(WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp::getParentSkillTagCode));
parentSkillTagLists.stream().map(i -> chileSkillTagConvert(i, chileMap)).collect(toList());
return parentSkillTagLists.stream().map(i -> chileSkillTagConvert(i, chileMap)).collect(toList());
}
private SkillTagDTO chileSkillTagConvert(WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp parentSkillTag, Map<String, List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp>> chileMap) {
SkillTagDTO tagDTO = new SkillTagDTO();
tagDTO.setCode(parentSkillTag.getSkillTagCode());
// tagDTO.setId(0L); //历史代码都为0L, 已经没用了
tagDTO.setName(parentSkillTag.getSkillTagName());
tagDTO.setProfessionId(parentSkillTag.getProfessionId());
tagDTO.setParentCode(parentSkillTag.getParentSkillTagCode());
tagDTO.setChildSkillTags(Lists.newArrayList());
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> childSkillTagResps = chileMap.get(parentSkillTag.getSkillTagCode());
if (CollUtil.isEmpty(childSkillTagResps)) {
return tagDTO;
}
for (WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp skillTagResp : childSkillTagResps) {
SkillTagDTO chileSkillTag = chileSkillTagConvert(skillTagResp, chileMap);
tagDTO.getChildSkillTags().add(chileSkillTag);
}
return tagDTO;
}
/**
* 转换历史技能标签
* @param workerProfessionHistoryResps
* @return
*/
private List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> doHistoryWorkerSkilltag(List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> workerProfessionHistoryResps) {
ArrayList<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> wss = Lists.newArrayList();
workerProfessionHistoryResps.forEach(item -> {
List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp.HistoryData> historyData = JSON.parseArray(item.getJsonContent(), WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp.HistoryData.class);
Long projectWorkerId;
if (Objects.nonNull(item.getBizData()) && item.getBizData().containsKey("projectWorkerId")) {
projectWorkerId = item.getBizData().getLong("projectWorkerId");
} else {
projectWorkerId = 0L;
}
for (WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp.HistoryData historyDatum : historyData) {
if (historyDatum.getDataFlag().equals(WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp.DATA_FLAG_SKILL)) {
List<WorkerProfessionSkillTag> skillTags = historyDatum.resolveWorkerProfessionSkillTags(ValidationEnum.EFFECTIVE);
// 需要使用有效工种
Stream<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> stream = skillTags.stream()
.filter(s -> !Strings.isNullOrEmpty(s.getSkillTagCode())).map(p -> {
WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp skillTag = new WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp();
skillTag.setId(p.getId());
skillTag.setSkillTagName(p.getSkillTagName());
skillTag.setSkillTagCode(p.getSkillTagCode());
skillTag.setParentSkillTagCode(p.getParentSkillTagCode());
skillTag.setProfessionId(p.getProfessionId());
skillTag.setWorkspaceId(p.getWorkspaceId());
skillTag.setProjectWorkerId(projectWorkerId);
skillTag.setCreateAt(p.getCreateAt());
skillTag.setUpdateAt(p.getUpdateAt());
skillTag.setIsDelete(p.getIsDelete());
return skillTag;
});
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> collect = StreamUtil.distinct(stream,
// 按照人+技能标签去重
p -> String.format("%s_%s", p.getProjectWorkerId(), p.getSkillTagCode()),
SKILL_TAG_MERGE_FUNC)
.collect(toList());
wss.addAll(collect);
}
}
});
return wss;
}
}

137
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/workerprofession/service/impl/OrgProjectWorkerProfessionSkillServiceImpl.java
View File

@ -1,13 +1,33 @@
package cn.axzo.orgmanax.server.workerprofession.service.impl;
import cn.axzo.orgmanax.dto.project.team.enums.TeamSceneEnum;
import cn.axzo.orgmanax.dto.project.team.enums.ValidationEnum;
import cn.axzo.orgmanax.dto.workerprofession.dto.SkillTagDTO;
import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionSkillTag;
import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionHistoryRepository;
import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionSkillTagRepository;
import cn.axzo.orgmanax.server.util.StreamUtil;
import cn.axzo.orgmanax.server.workerprofession.service.OrgProjectWorkerProfessionService;
import cn.axzo.orgmanax.server.workerprofession.service.OrgProjectWorkerProfessionSkillService;
import cn.hutool.core.collection.CollUtil;
import com.alibaba.fastjson.JSON;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.BinaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static java.util.stream.Collectors.toList;
/**
* @author zhanghongbo
@ -15,13 +35,128 @@ import java.util.List;
*/
@Service
@Slf4j
@AllArgsConstructor
public class OrgProjectWorkerProfessionSkillServiceImpl implements OrgProjectWorkerProfessionSkillService {
@Autowired
private WorkerProfessionSkillTagRepository workerProfessionSkillTagRepository;
@Autowired
private OrgProjectWorkerProfessionService orgProjectWorkerProfessionService;
private static final BinaryOperator<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> SKILL_TAG_MERGE_FUNC = (v1, v2) -> {
if (v1.getIsDelete() < v2.getIsDelete()) {
return v1;
}
return v2.getCreateAt().getTime() > v1.getCreateAt().getTime() ? v2 : v1;
};
@Override
public List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> list(WorkerProfessionSkillTagRepository.PageReq req) {
return workerProfessionSkillTagRepository.list(req);
}
/**
* 获取技能标签包括历史技能标签(带子技能标签)
* @param projectWorkerIds
*/
public List<SkillTagDTO> listSkillTagWithChild(List<Long> projectWorkerIds) {
//获取技能标签
WorkerProfessionSkillTagRepository.PageReq pageReq4Skill = WorkerProfessionSkillTagRepository.PageReq.builder()
.projectWorkerIds(projectWorkerIds)
.scene(TeamSceneEnum.PROJECT_TEAM.name())
.build();
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> workerProfessionSkillTagResps = workerProfessionSkillTagRepository.list(pageReq4Skill);
//获取历史技能标签
WorkerProfessionHistoryRepository.PageReq pageReq4HistoryProfession = WorkerProfessionHistoryRepository.PageReq.builder()
.scene(TeamSceneEnum.PROJECT_TEAM.name())
.projectWorkerIds(projectWorkerIds)
.build();
List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> workerProfessionHistoryResps = orgProjectWorkerProfessionService.listHistory(pageReq4HistoryProfession);
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> workerProfessionSkillTagResps4History = doHistoryWorkerSkilltag(workerProfessionHistoryResps);
//技能标签和历史技能标签合在一起
Stream<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> allStream = Stream.concat(workerProfessionSkillTagResps.stream(), workerProfessionSkillTagResps4History.stream());
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> allSkillTagResps = StreamUtil.distinct(allStream,
p -> String.format("%s_%s", p.getProjectWorkerId(), p.getSkillTagCode()), SKILL_TAG_MERGE_FUNC)
.collect(toList());
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> parentSkillTagLists = allSkillTagResps.stream()
.filter(item -> !StringUtils.hasLength(item.getParentSkillTagCode()) || item.getParentSkillTagCode().equals("0"))
.collect(toList());
Map<String, List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp>> chileMap = allSkillTagResps.stream()
.filter(item -> StringUtils.hasLength(item.getParentSkillTagCode()) || !item.getParentSkillTagCode().equals("0"))
.collect(Collectors.groupingBy(WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp::getParentSkillTagCode));
parentSkillTagLists.stream().map(i -> chileSkillTagConvert(i, chileMap)).collect(toList());
return parentSkillTagLists.stream().map(i -> chileSkillTagConvert(i, chileMap)).collect(toList());
}
/**
* 转换历史技能标签
* @param workerProfessionHistoryResps
* @return
*/
private List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> doHistoryWorkerSkilltag(List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> workerProfessionHistoryResps) {
ArrayList<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> wss = Lists.newArrayList();
workerProfessionHistoryResps.forEach(item -> {
List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp.HistoryData> historyData = JSON.parseArray(item.getJsonContent(), WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp.HistoryData.class);
Long projectWorkerId;
if (Objects.nonNull(item.getBizData()) && item.getBizData().containsKey("projectWorkerId")) {
projectWorkerId = item.getBizData().getLong("projectWorkerId");
} else {
projectWorkerId = 0L;
}
for (WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp.HistoryData historyDatum : historyData) {
if (historyDatum.getDataFlag().equals(WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp.DATA_FLAG_SKILL)) {
List<WorkerProfessionSkillTag> skillTags = historyDatum.resolveWorkerProfessionSkillTags(ValidationEnum.EFFECTIVE);
// 需要使用有效工种
Stream<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> stream = skillTags.stream()
.filter(s -> !Strings.isNullOrEmpty(s.getSkillTagCode())).map(p -> {
WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp skillTag = new WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp();
skillTag.setId(p.getId());
skillTag.setSkillTagName(p.getSkillTagName());
skillTag.setSkillTagCode(p.getSkillTagCode());
skillTag.setParentSkillTagCode(p.getParentSkillTagCode());
skillTag.setProfessionId(p.getProfessionId());
skillTag.setWorkspaceId(p.getWorkspaceId());
skillTag.setProjectWorkerId(projectWorkerId);
skillTag.setCreateAt(p.getCreateAt());
skillTag.setUpdateAt(p.getUpdateAt());
skillTag.setIsDelete(p.getIsDelete());
return skillTag;
});
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> collect = StreamUtil.distinct(stream,
// 按照人+技能标签去重
p -> String.format("%s_%s", p.getProjectWorkerId(), p.getSkillTagCode()),
SKILL_TAG_MERGE_FUNC)
.collect(toList());
wss.addAll(collect);
}
}
});
return wss;
}
private SkillTagDTO chileSkillTagConvert(WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp parentSkillTag, Map<String, List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp>> chileMap) {
SkillTagDTO tagDTO = new SkillTagDTO();
tagDTO.setCode(parentSkillTag.getSkillTagCode());
// tagDTO.setId(0L); //历史代码都为0L, 已经没用了
tagDTO.setName(parentSkillTag.getSkillTagName());
tagDTO.setProfessionId(parentSkillTag.getProfessionId());
tagDTO.setParentCode(parentSkillTag.getParentSkillTagCode());
tagDTO.setProjectWorkerId(parentSkillTag.getProjectWorkerId());
tagDTO.setChildSkillTags(Lists.newArrayList());
List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> childSkillTagResps = chileMap.get(parentSkillTag.getSkillTagCode());
if (CollUtil.isEmpty(childSkillTagResps)) {
return tagDTO;
}
for (WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp skillTagResp : childSkillTagResps) {
SkillTagDTO chileSkillTag = chileSkillTagConvert(skillTagResp, chileMap);
tagDTO.getChildSkillTags().add(chileSkillTag);
}
return tagDTO;
}
}

112
orgmanax-starter/src/main/resources/logback-spring.xml
View File

@ -1,109 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- 引用 Spring Boot 的 logback 基础配置 -->
<include resource="org/springframework/boot/logging/logback/defaults.xml"/>
<springProperty scope="context" name="appName" source="spring.application.name"/>
<springProperty scope="context" name="LOG_PREFIX" source="logback.path" defaultValue="/mnt/app-logdata"/>
<property name="POD_NAMESPACE" value="${MY_POD_NAMESPACE:-local}"/>
<property name="LOG_FILE" value="${appName}.log"/>
<!--日志路径-->
<property name="LOG_PATH" value="${LOG_PREFIX}/${POD_NAMESPACE}/${appName}"/>
<!-- 日志最大的历史 7天 -->
<property name="MAX_HISTORY" value="7"/>
<!--默认日志输出模式-->
<property name="PATTERN_CONSOLE"
value="%date{HH:mm:ss} %highlight(%-5level) [%X{ctxLogId}] [%15thread] %cyan([%class{36}#%M:%L]) %msg%n"/>
<property name="PATTERN_FILE"
value="%date{yyyy-MM-dd HH:mm:ss} %-5level --- [%15thread] [%X{ctxLogId}] %logger: %msg%n"/>
<contextName>${appName}</contextName>
<!-- 控制台 Appender -->
<appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>${PATTERN_CONSOLE}</pattern>
<charset>UTF-8</charset>
</encoder>
</appender>
<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
<encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern>${PATTERN_FILE}</pattern>
</layout>
</encoder>
<!-- 日志文件名 -->
<file>${LOG_PATH}/${LOG_FILE}</file>
<rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
<!-- 滚动后的日志文件名 -->
<fileNamePattern>${LOGBACK_ROLLINGPOLICY_FILE_NAME_PATTERN:-${LOG_PATH}/${LOG_FILE}.%d{yyyy-MM-dd}.%i.gz}</fileNamePattern>
<!-- 启动服务时，是否清理历史日志，一般不建议清理 -->
<cleanHistoryOnStart>${LOGBACK_ROLLINGPOLICY_CLEAN_HISTORY_ON_START:-false}</cleanHistoryOnStart>
<!-- 日志文件，到达多少容量，进行滚动 -->
<maxFileSize>${LOGBACK_ROLLINGPOLICY_MAX_FILE_SIZE:-10MB}</maxFileSize>
<!-- 日志文件的总大小，0 表示不限制 -->
<totalSizeCap>${LOGBACK_ROLLINGPOLICY_TOTAL_SIZE_CAP:-1GB}</totalSizeCap>
<!-- 日志文件的保留天数 -->
<maxHistory>${LOGBACK_ROLLINGPOLICY_MAX_HISTORY:-30}</maxHistory>
</rollingPolicy>
</appender>
<!-- 异步写入日志，提升性能 -->
<appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
<!-- 不丢失日志。默认的，如果队列的 80% 已满,则会丢弃 TRACT、DEBUG、INFO 级别的日志 -->
<discardingThreshold>0</discardingThreshold>
<!-- 更改默认的队列的深度，该值会影响性能。默认值为 256 -->
<queueSize>256</queueSize>
<appender-ref ref="FILE"/>
</appender>
<!-- 控制台输出LOGSTASH JSON日志 -->
<appender name="LOGSTASH" class="ch.qos.logback.core.ConsoleAppender" addtivity="false">
<encoder charset="UTF-8" class="net.logstash.logback.encoder.LoggingEventCompositeJsonEncoder">
<providers>
<timestamp>
<fieldName>@timestamp</fieldName>
<pattern>yyyy-MM-dd'T'HH:mm:ss.SSSx</pattern>
<timeZone>GMT+8</timeZone>
</timestamp>
<pattern>
<pattern>
{
"app":"${appName}",
"level":"%level",
"traceId":"%X{ctxLogId}",
"thread":"%thread",
"class":"%logger{40}",
"message":"%replace(%message){'^(.{3000}).*$', '$1'}",
"error_level":"%X{errorLevel}",
"error_type":"%X{errorType}",
"stack_trace":"%exception{20}"
}
</pattern>
</pattern>
</providers>
</encoder>
</appender>
<!-- 本地环境 -->
<springProfile name="local">
<root level="INFO">
<appender-ref ref="CONSOLE"/>
</root>
<!-- 导入安心筑全局日志配置 -->
<include resource="logback/logback-axzo.xml"/>
<!-- 覆盖开发环境日志配置 -->
<springProfile name="local,dev,test">
<logger name="cn.axzo" level="DEBUG"/>
</springProfile>
<springProfile name="dev,test,pre,live,default">
<root level="INFO">
<appender-ref ref="CONSOLE"/>
<appender-ref ref="ASYNC"/>
</root>
</springProfile>
<!-- 其它环境 -->
<springProfile name="master">
<root level="INFO">
<appender-ref ref="LOGSTASH"/>
</root>
</springProfile>
</configuration>
</configuration>