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

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

@@ -13,7 +13,7 @@ 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.resp.RemoveTeamCategoryCheckResp;
 import cn.axzo.orgmanax.dto.project.team.resp.SingletonOrgTeamCategoryResp;
-import cn.axzo.orgmanax.dto.project.team.resp.TeamCategoryResp;
+import cn.axzo.orgmanax.dto.project.team.resp.TeamCategoryGroupResp;
 import java.util.List;
 import javax.validation.Valid;
 import javax.validation.constraints.NotEmpty;
@@ -39,7 +39,7 @@ public interface OrgProjectTeamCategoryApi {
      * 用到 org_project_team_category 表数据
      */
     @PostMapping("/api/project/team-category/group-list")
-    ApiResult<List<TeamCategoryResp>> groupList(@RequestBody GroupTeamCategoryReq req);
+    ApiResult<List<TeamCategoryGroupResp>> groupList(@RequestBody GroupTeamCategoryReq req);
 
     /**
      * todo 三期实现

orgmanax-api/src/test/resources/http/nodeuser/node-user.http

@@ -75,7 +75,7 @@ Accept: application/json
   "activeFlag": 1,
   "searchCount": true,
   "needs": {
-    "childNodeUser": true
+    "job": true
   },
   "distinctRule": {
     "distinctByFields": [

orgmanax-common/src/main/java/cn/axzo/orgmanax/common/config/BizResultCode.java

@@ -16,6 +16,8 @@ public enum BizResultCode implements IResultCode {
     INVALID_PARAM("400", "参数异常"),
     ENTITY_NOT_FOUND("404", "实体不存在"),
 
+    BIZ_ERROR("500", "业务异常"),
+
     // 900 ~ 998 二方SDK相关错误码
     RPC_ERROR("900", "rpc error"),
 

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

@@ -349,11 +349,6 @@ public class ListNodeUserReq extends PageReqV2 {
          */
         private Boolean jobGroup; // TODO : 待实现
 
-        /**
-         * 是否返回下级组织人员。所在节点的下级节点的
-         */
-        private Boolean childNodeUser; // TODO: 待实现
-
         /**
          * 是否查询下属。（同单位，directManagerPersonId等于自己的）
          */

orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/req/TeamCategoryTreeNode.java

@@ -1,6 +1,6 @@
 package cn.axzo.orgmanax.dto.project.team.req;
 
-import cn.axzo.orgmanax.dto.workerprofession.model.IBaseTree;
+import cn.axzo.orgmanax.dto.common.IBaseTree;
 import com.alibaba.fastjson.JSON;
 import java.io.Serializable;
 import java.util.ArrayList;

orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/project/team/resp/TeamCategoryGroupResp.java

@@ -15,7 +15,7 @@ import lombok.experimental.SuperBuilder;
 @SuperBuilder
 @AllArgsConstructor
 @NoArgsConstructor
-public class TeamCategoryResp {
+public class TeamCategoryGroupResp {
 
     /**
      * 班组id

orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/workerprofession/dto/ProjectWorkerProfessionDTO.java

@@ -0,0 +1,76 @@
+package cn.axzo.orgmanax.dto.workerprofession.dto;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+import java.util.Date;
+
+/**
+ * 项目内工人工种表实体类
+ *
+ * @author chenliang@axzo.cn
+ * @since 2022-07-18 18:18:18
+ */
+@Data
+@Accessors(chain = true)
+public class ProjectWorkerProfessionDTO {
+
+  private Long id;
+
+  /**
+   * 项目内工人id
+   */
+  private Long projectWorkerId;
+
+//  /**
+//   * 项目内班组id
+//   */
+//  private Long projectTeamId;
+
+//  /**
+//   * 邀请id
+//   */
+//  private Long inviteId;
+
+  /**
+   * 工作台ID
+   */
+  private Long workspaceId;
+
+  /**
+   * 工种id
+   */
+  private Long professionId;
+
+  /**
+   * 工种名称
+   */
+  private String professionName;
+
+  /**
+   * 1有效 0无效
+   */
+  private Integer valid;
+
+  /**
+   * 是否删除 0:未删除 其他:已删除
+   */
+  private Long isDelete;
+
+  /**
+   * 创建时间
+   */
+  private Date createAt;
+
+
+  private Date updateAt;
+
+  private Integer type;
+
+
+  private Integer createFlag;
+
+  private Integer updateFlag;
+
+}
+

orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/workerprofession/model/IBaseTree.java

@@ -1,42 +0,0 @@
-package cn.axzo.orgmanax.dto.workerprofession.model;
-
-import java.util.List;
-
-/**
- * @author cn
- * @version 1.0
- * @description
- * @date 2022/4/6 13:56
- */
-
-public interface IBaseTree<T extends IBaseTree<T, O>, O> {
-
-  /**
-   * 节点编码
-   *
-   * @return 节点编码
-   */
-  O getNodeCode();
-
-  /**
-   * 父节点编码
-   *
-   * @return 父节点编码
-   */
-  O getParentNodeCode();
-
-  /**
-   * 子节点
-   *
-   * @return 子节点
-   */
-  List<T> getNodeChildren();
-
-  /**
-   * 设置子节点
-   *
-   * @param nodeChildren
-   */
-  void setNodeChildren(List<T> nodeChildren);
-
-}

orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/workerprofession/model/ProfessionSkillTagTreeNode.java

@@ -1,6 +1,6 @@
 package cn.axzo.orgmanax.dto.workerprofession.model;
 
-import cn.axzo.trade.datasecurity.core.util.ObjectUtil;
+import cn.axzo.orgmanax.dto.common.IBaseTree;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 import lombok.AllArgsConstructor;

orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/workerprofession/req/WorkerProfessionTagQueryPageReq.java

@@ -2,11 +2,17 @@ package cn.axzo.orgmanax.dto.workerprofession.req;
 
 import cn.axzo.foundation.page.PageReqV2;
 import cn.axzo.orgmanax.dto.project.team.enums.TeamSceneEnum;
+import cn.hutool.core.util.ObjectUtil;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.util.Set;
 
 /**
@@ -17,11 +23,21 @@ import java.util.Set;
 @AllArgsConstructor
 @Data
 @SuperBuilder
+@Slf4j
 public class WorkerProfessionTagQueryPageReq extends PageReqV2 {
-    private Long orgNodeId;
+    /**
+     * 平台班组|项目内班组|项目内小组组织节点id, 传递该值后，对于小组会转换对应父节点的班组部门id
+     */
+    private Long orgNodeId4ResolvedTeamOrgNodeId;
     private Set<Long> personIds;
     private TeamSceneEnum scene;
     private Set<Long> professionIds;
     private Boolean needSkillTags;
     private Set<Long> orgNodeIds;
+
+    public void check() {
+        if (ObjectUtil.isAllEmpty(orgNodeId4ResolvedTeamOrgNodeId, personIds, orgNodeIds)) {
+            throw new IllegalArgumentException("通用查询接口，orgNodeId和personIds不能都为空");
+        }
+    }
 }

orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/datacollection/dto/DataCollectionSkillTypeEnum.java

@@ -4,6 +4,8 @@ import com.baomidou.mybatisplus.annotation.EnumValue;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 
+import java.util.Arrays;
+
 @Getter
 @AllArgsConstructor
 public enum DataCollectionSkillTypeEnum {
@@ -18,4 +20,10 @@ public enum DataCollectionSkillTypeEnum {
     @EnumValue
     private final Integer value;
     private final String desc;
+
+    public static DataCollectionSkillTypeEnum getType(Integer value) {
+        return Arrays.stream(values()).filter(it -> it.getValue().equals(value))
+                .findFirst()
+                .orElse(null);
+    }
 }

orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/workerprofession/repository/WorkerProfessionHistoryRepository.java

@@ -62,7 +62,6 @@ public interface WorkerProfessionHistoryRepository {
 
     @Data
     class WorkerProfessionHistoryResp extends WorkerProfessionHistory {
-        private String xx;
 
         public static final String DATA_FLAG_PROFESSION = "WORKER_PROFESSION";
         public static final String DATA_FLAG_SKILL = "WORKER_PROFESSION_SKILL";

orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/workerprofession/repository/WorkerProfessionSkillTagRepository.java

@@ -5,7 +5,6 @@ import cn.axzo.foundation.dao.support.wrapper.Operator;
 import cn.axzo.foundation.page.PageReqV2;
 import cn.axzo.foundation.page.PageResp;
 import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionSkillTag;
-import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionTag;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@@ -13,6 +12,7 @@ import lombok.NoArgsConstructor;
 import lombok.experimental.SuperBuilder;
 
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author zhanghongbo
@@ -49,6 +49,15 @@ public interface WorkerProfessionSkillTagRepository {
          */
         @CriteriaField
         private String scene;
+
+        @CriteriaField(field = "orgNodeId", operator = Operator.IN)
+        private Set<Long> orgNodeIds;
+
+        @CriteriaField(field = "personId", operator = Operator.IN)
+        private Set<Long> personIds;
+
+        @CriteriaField(field = "professionId", operator = Operator.IN)
+        private Set<Long> professionIds;
     }
 
 

orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/workerprofession/repository/WorkerProfessionTagRepository.java

@@ -9,6 +9,7 @@ import lombok.*;
 import lombok.experimental.SuperBuilder;
 
 import java.util.List;
+import java.util.Set;
 
 /**
  * @author zhanghongbo
@@ -55,7 +56,19 @@ public interface WorkerProfessionTagRepository {
          * 组织节点ids
          */
         @CriteriaField(field = "orgNodeId", operator = Operator.IN)
-        private List<Long> orgNodeIds;
+        private Set<Long> orgNodeIds;
+
+        /**
+         * 工种id
+         */
+        @CriteriaField(field = "professionId", operator = Operator.IN)
+        private Set<Long> professionIds;
+
+        /**
+         * personId列表
+         */
+        @CriteriaField(field = "personId", operator = Operator.IN)
+        private Set<Long> personIds;
 
         /**
          * 0-无效 1-有效

orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/dao/workerprofession/repository/impl/WorkerProfessionHistoryRepositoryImpl.java

@@ -1,11 +1,12 @@
 package cn.axzo.orgmanax.infra.dao.workerprofession.repository.impl;
 
 import cn.axzo.foundation.dao.support.converter.PageConverter;
+import cn.axzo.foundation.dao.support.mysql.MybatisPlusOperatorProcessor;
 import cn.axzo.foundation.dao.support.mysql.QueryWrapperHelper;
+import cn.axzo.foundation.dao.support.wrapper.Operator;
 import cn.axzo.foundation.page.PageResp;
 import cn.axzo.orgmanax.infra.dao.workerprofession.dao.WorkerProfessionHistoryDao;
 import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionHistory;
-import cn.axzo.orgmanax.infra.dao.workerprofession.entity.WorkerProfessionSkillTag;
 import cn.axzo.orgmanax.infra.dao.workerprofession.repository.WorkerProfessionHistoryRepository;
 import cn.axzo.orgmanax.infra.util.CommonUtil;
 import cn.hutool.core.bean.BeanUtil;
@@ -18,6 +19,11 @@ import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Repository;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
 /**
  * @author zhanghongbo
  * @date 2025/1/6
@@ -31,6 +37,15 @@ public class WorkerProfessionHistoryRepositoryImpl implements WorkerProfessionHi
 
     @Override
     public PageResp<WorkerProfessionHistoryResp> page(PageReq req) {
+        //将某些查询转换为bizData
+        if (ObjectUtil.isNotEmpty(req.getProjectWorkerIds())) {
+            List<MybatisPlusOperatorProcessor.JSONQuery> jsonQueries = Arrays.asList(
+                    MybatisPlusOperatorProcessor.JSONQuery.builder().jsonPath("$.projectWorkerId").data(req.getProjectWorkerIds()).operator(Operator.IN).build());
+            List<MybatisPlusOperatorProcessor.JSONQuery> bizData = Optional.ofNullable(req.getBizData()).orElse(new ArrayList<>());
+            bizData.addAll(jsonQueries);
+            req.setBizData(bizData);
+        }
+
         IPage<WorkerProfessionHistory> page = PageConverter.toMybatis(req, WorkerProfessionHistory.class);
         QueryWrapper<WorkerProfessionHistory> wrapper = QueryWrapperHelper.fromBean(req, WorkerProfessionHistory.class);
 
@@ -38,10 +53,6 @@ public class WorkerProfessionHistoryRepositoryImpl implements WorkerProfessionHi
         if (!BooleanUtil.isTrue(req.getIncludeDeleted())) {
             wrapper.eq("is_delete", 0);
         }
-        //处理项目工人id
-        if (ObjectUtil.isNotEmpty(req.getProjectWorkerIds())) {
-
-        }
 
         IPage<WorkerProfessionHistoryResp> results = workerProfessionHistoryDao.page(page, wrapper)
                 .convert(e -> BeanUtil.toBean(e, WorkerProfessionHistoryResp.class));

orgmanax-server/src/main/java/cn/axzo/orgmanax/server/cooperateship/enums/CooperateShipStatusEnum.java

@@ -0,0 +1,15 @@
+package cn.axzo.orgmanax.server.cooperateship.enums;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum CooperateShipStatusEnum {
+    ACTIVE(1,"履约中"),
+    LEAVE(0, "已退场"),
+    ;
+
+    private final Integer status;
+    private final String desc;
+}

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

@@ -14,7 +14,7 @@ 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.resp.RemoveTeamCategoryCheckResp;
 import cn.axzo.orgmanax.dto.project.team.resp.SingletonOrgTeamCategoryResp;
-import cn.axzo.orgmanax.dto.project.team.resp.TeamCategoryResp;
+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;
@@ -35,7 +35,7 @@ public class OrgProjectTeamCategoryController implements OrgProjectTeamCategoryA
     private final ProjectTeamCategoryService projectTeamCategoryService;
 
     @Override
-    public ApiResult<List<TeamCategoryResp>> groupList(GroupTeamCategoryReq req) {
+    public ApiResult<List<TeamCategoryGroupResp>> groupList(GroupTeamCategoryReq req) {
         return null;
     }
 

orgmanax-server/src/main/java/cn/axzo/orgmanax/server/util/AssertUtil.java

@@ -0,0 +1,136 @@
+package cn.axzo.orgmanax.server.util;
+
+import cn.axzo.foundation.exception.BusinessException;
+import cn.axzo.orgmanax.common.config.BizResultCode;
+import cn.hutool.core.util.ArrayUtil;
+import org.slf4j.helpers.FormattingTuple;
+import org.slf4j.helpers.MessageFormatter;
+import org.springframework.util.CollectionUtils;
+
+import java.util.Collection;
+
+
+/**
+ * 断言工具类
+ *
+ * @author jiachao
+ * @date 2021/8/9
+ */
+public final class AssertUtil {
+
+  private AssertUtil() {
+  }
+
+  public static void fail(String message) {
+    throw new BusinessException(BizResultCode.BIZ_ERROR.getErrorCode(), message);
+  }
+
+  public static void fail(String message, Object... params) {
+    FormattingTuple formattingTuple = MessageFormatter.arrayFormat(message, params);
+    fail(formattingTuple.getMessage());
+  }
+
+  /**
+   * 断言条件为真。如果不是，它会抛出一个带有给定消息的异常
+   *
+   * @param msg       错误码
+   * @param condition 被检查的条件
+   * @
+   */
+  public static void isTrue(boolean condition, String msg) {
+    if (!condition) {
+      fail(msg);
+    }
+  }
+
+
+  /**
+   * 断言条件为假。如果不是，它会抛出一个带有给定消息的异常 \
+   *
+   * @param msg       错误信息
+   * @param condition 被检查的条件
+   */
+
+  public static void isFalse(boolean condition, String msg) {
+    if (condition) {
+      fail(msg);
+    }
+  }
+
+
+  /**
+   * 断言检查这个对象不是 Null。 如果是null，用给定的错误信息
+   *
+   * @param msg    错误信息
+   * @param object 检查对象
+   * @
+   */
+  public static void notNull(Object object, String msg) {
+    if (object == null) {
+      fail(msg);
+    }
+  }
+
+
+  /**
+   * 断言检查这个对象是 Null。 如果不是null，用给定的错误信息抛出异常
+   *
+   * @param msg    错误信息
+   * @param object 检查对象
+   * @
+   */
+  public static void isNull(Object object, String msg) {
+    if (object != null) {
+      fail(msg);
+    }
+  }
+
+
+  /**
+   * 断言集合不为空，如果为null或者empty，用指定错误信息抛出异常
+   *
+   * @param msg        错误信息
+   * @param collection 集合
+   * @
+   */
+  public static void notEmpty(Collection<?> collection, String msg) {
+    if (collection == null || collection.isEmpty()) {
+      fail(msg);
+    }
+  }
+
+
+  /**
+   * 断言集合为空，如果否，用指定错误信息抛出异常
+   *
+   * @param msg        错误信息
+   * @param collection 集合
+   * @
+   */
+  public static void isEmpty(Collection<?> collection, String msg) {
+    if (!CollectionUtils.isEmpty(collection)) {
+      fail(msg);
+    }
+  }
+
+
+  public static <T> void notEmpty(T[] array, String msg) {
+    if (ArrayUtil.hasNull(array)) {
+      fail(msg);
+    }
+  }
+
+  /**
+   * 断言字符串不为空，如果为null或者empty，用指定错误信息抛出异常
+   *
+   * @param msg   错误信息
+   * @param value 字符串
+   * @
+   */
+  public static void notEmpty(String value, String msg) {
+    if (value == null || value.isEmpty()) {
+      fail(msg);
+    }
+  }
+
+}

orgmanax-server/src/main/java/cn/axzo/orgmanax/server/workerprofession/controller/OrgProjectWorkerProfessionController.java

@@ -39,7 +39,7 @@ public class OrgProjectWorkerProfessionController implements OrgProjectWorkerPro
 
     @Override
     public ApiResult<Map<Long, List<String>>> sortOutProfessionCategory(@Valid ProjectWorkerProfessionSortOutProfessionCategoryReq req) {
-        return null;
+        return ApiResult.success(orgProjectWorkerProfessionService.sortOutProfessionCategory(req));
     }
 
     @Override
@@ -64,7 +64,7 @@ public class OrgProjectWorkerProfessionController implements OrgProjectWorkerPro
 
     @Override
     public ApiResult<PageResp<ProjectWorkerProfessionResp>> page(WorkerProfessionTagQueryPageReq req) {
-        return null;
+        return ApiResult.success(orgProjectWorkerProfessionService.page(req));
     }
 
     @Override

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

@@ -1,7 +1,11 @@
 package cn.axzo.orgmanax.server.workerprofession.service;
 
+import cn.axzo.foundation.page.PageResp;
 import cn.axzo.orgmanax.dto.workerprofession.dto.ProfessionDTO;
 import cn.axzo.orgmanax.dto.workerprofession.req.ProjectWorkerProfessionListValidReq;
+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 java.util.List;
 import java.util.Map;
@@ -11,6 +15,11 @@ import java.util.Map;
  * @date 2025/1/3
  */
 public interface OrgProjectWorkerProfessionService {
+    /**
+     * 获取有效的工种信息
+     * @param req
+     * @return
+     */
     Map<Long, List<ProfessionDTO>> listValid(ProjectWorkerProfessionListValidReq req);
 
     /**
@@ -19,4 +28,18 @@ public interface OrgProjectWorkerProfessionService {
      * @return
      */
     List<ProfessionDTO> listValidWorkerProfession(List<Long> projectWorkerIds);
+
+    /**
+     * 计算项目内工人工种类型
+     * @param req
+     * @return
+     */
+    Map<Long, List<String>> sortOutProfessionCategory(ProjectWorkerProfessionSortOutProfessionCategoryReq req);
+
+    /**
+     * 分页查询工种信息
+     * @param req
+     * @return
+     */
+    PageResp<ProjectWorkerProfessionResp> page(WorkerProfessionTagQueryPageReq req);
 }

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

@@ -1,9 +1,19 @@
 package cn.axzo.orgmanax.server.workerprofession.service.impl;
+import cn.axzo.orgmanax.dto.workerprofession.dto.ProjectWorkerProfessionDTO;
+import com.google.common.collect.Maps;
 
 import cn.axzo.foundation.dao.support.mysql.MybatisPlusOperatorProcessor;
 import cn.axzo.foundation.dao.support.wrapper.Operator;
+import cn.axzo.foundation.page.PageResp;
 import cn.axzo.orgmanax.api.projectworker.enums.ProjectWorkerStatusEnum;
 import cn.axzo.orgmanax.dto.common.IdentityType;
+import cn.axzo.orgmanax.dto.common.util.NumberUtil;
+import cn.axzo.orgmanax.dto.common.util.TreeUtil;
+import cn.axzo.orgmanax.dto.cooperateship.dto.OrgCooperateShipDTO;
+import cn.axzo.orgmanax.dto.cooperateship.req.ListOrgCooperateShipReq;
+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.req.ListNodeUserReq;
@@ -11,26 +21,42 @@ 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.SkillTagDTO;
+import cn.axzo.orgmanax.dto.workerprofession.model.ProfessionSkillTagTreeNode;
 import cn.axzo.orgmanax.dto.workerprofession.req.ProjectWorkerProfessionListValidReq;
+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.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;
+import cn.axzo.orgmanax.infra.util.CommonUtil;
+import cn.axzo.orgmanax.server.cooperateship.enums.CooperateShipStatusEnum;
+import cn.axzo.orgmanax.server.cooperateship.service.CooperateShipService;
 import cn.axzo.orgmanax.server.node.service.NodeService;
 import cn.axzo.orgmanax.server.nodeuser.service.NodeUserService;
+import cn.axzo.orgmanax.server.util.AssertUtil;
 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.alibaba.fastjson.JSONObject;
 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.stereotype.Service;
 import org.springframework.util.StringUtils;
 
@@ -58,6 +84,13 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
     private DataCollectionDictInfoClient dataCollectionDictInfoClient;
     private OrgProjectWorkerProfessionSkillService orgProjectWorkerProfessionSkillService;
     private WorkerProfessionHistoryRepository workerProfessionHistoryRepository;
+    private CooperateShipService cooperateShipService;
+
+    private static final ImmutableSet<Integer> TEAM_ORG_NODE_TYPES = ImmutableSet.of(
+            NodeTypeEnum.TEAM.getValue(),
+            NodeTypeEnum.PROJECT_TEAM.getValue(),
+            NodeTypeEnum.PROJECT_GROUP.getValue()
+    );
 
     private static final BinaryOperator<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> SKILL_TAG_MERGE_FUNC = (v1, v2) -> {
         if (v1.getIsDelete() < v2.getIsDelete()) {
@@ -66,6 +99,20 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
         return v2.getCreateAt().getTime() > v1.getCreateAt().getTime() ? v2 : v1;
     };
 
+    public static final BinaryOperator<ProjectWorkerProfessionDTO> LABOUR_PROFESSION_TAG_MERGE_FUNC = (v1, v2) -> {
+        // 优先返回有效的
+        if (!Objects.equals(v2.getValid(), v1.getValid())) {
+            return Objects.equals(v1.getValid(), ValidationEnum.EFFECTIVE.getCode()) ? v1 : v2;
+        }
+        // 否则返回最晚创建的
+        return v2.getCreateAt().getTime() > v1.getCreateAt().getTime() ? v2 : v1;
+    };
+
+    /**
+     * 获取有效的工种信息
+     * @param req
+     * @return
+     */
     @Override
     public Map<Long, List<ProfessionDTO>> listValid(ProjectWorkerProfessionListValidReq req) {
         List<Long> nodeIds = req.getNodeIds();
@@ -160,6 +207,240 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
         return professionDTOS;
     }
 
+    @Override
+    public Map<Long, List<String>> sortOutProfessionCategory(ProjectWorkerProfessionSortOutProfessionCategoryReq req) {
+        List<Long> projectWorkerIdList = req.getProjectWorkerIdList();
+
+        //查询工人
+        List<NodeUserDTO> nodeUserDTOS = nodeUserService.list(ListNodeUserReq.builder()
+                .projectWorkerIds(projectWorkerIdList)
+                .identityType(IdentityType.WORKER.getCode())
+                .build());
+        if (ObjectUtil.isEmpty(nodeUserDTOS)) {
+            return Collections.emptyMap();
+        }
+        Map<Long, List<NodeUserDTO>> projectWorkerStatusMap = nodeUserDTOS.stream()
+                .collect(groupingBy(nodeUserDTO -> ((NodeUserProfile.ProjectWorkerProfile) nodeUserDTO.resolveProfile()).getProjectWorkerId()));
+
+
+        Map<Long, List<String>> result = new HashMap<>();
+        //获取工种信息, 并判断工种类型
+        if (projectWorkerStatusMap.containsKey(ProjectWorkerStatusEnum.ACTIVE.getValue())) {
+            List<NodeUserDTO> activeWorker = projectWorkerStatusMap.get(ProjectWorkerStatusEnum.ACTIVE.getValue());
+            List<Long> projectWorkerIdList4Active = activeWorker.stream()
+                    .map(nodeUserDTO -> ((NodeUserProfile.ProjectWorkerProfile) nodeUserDTO.resolveProfile()).getProjectWorkerId())
+                    .collect(toList());
+            List<WorkerProfessionTagRepository.WorkerProfessionTagResp> professionTagResps4Action = workerProfessionTagRepository.list(WorkerProfessionTagRepository.PageReq.builder()
+                    .projectWorkerIds(projectWorkerIdList4Active)
+                    .scene(TeamSceneEnum.PROJECT_TEAM.name())
+                    .build());
+            //封装结果信息
+            if (ObjectUtil.isNotEmpty(professionTagResps4Action)) {
+                Map<Long, List<String>> result4Active = professionTagResps4Action.stream().collect(groupingBy(WorkerProfessionTagRepository.WorkerProfessionTagResp::getProjectWorkerId,
+                        mapping(workerProfessionTagResp -> DataCollectionSkillTypeEnum.getType(workerProfessionTagResp.getType()).getDesc(), toList())));
+                result.putAll(result4Active);
+            }
+        }
+        if (projectWorkerStatusMap.containsKey(ProjectWorkerStatusEnum.LEAVE.getValue())) {
+            List<NodeUserDTO> leaveWorker = projectWorkerStatusMap.get(ProjectWorkerStatusEnum.LEAVE.getValue());
+            List<Long> projectWorkerIdList4Leave = leaveWorker.stream()
+                    .map(nodeUserDTO -> ((NodeUserProfile.ProjectWorkerProfile) nodeUserDTO.resolveProfile()).getProjectWorkerId())
+                    .collect(toList());
+            List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> professionTagResps4Leave = workerProfessionHistoryRepository.list(WorkerProfessionHistoryRepository.PageReq.builder()
+                    .projectWorkerIds(projectWorkerIdList4Leave)
+                    .scene(TeamSceneEnum.PROJECT_TEAM.name())
+                    .build());
+
+            List<ProjectWorkerProfessionDTO> projectWorkerProfessionDTOS = doHistoryWorkerProfession(professionTagResps4Leave, ValidationEnum.EFFECTIVE);
+            //封装结果信息
+            if (ObjectUtil.isNotEmpty(projectWorkerProfessionDTOS)) {
+                Map<Long, List<String>> result4Leave = projectWorkerProfessionDTOS.stream().collect(groupingBy(ProjectWorkerProfessionDTO::getProjectWorkerId,
+                        mapping(projectWorkerProfessionDTO -> DataCollectionSkillTypeEnum.getType(projectWorkerProfessionDTO.getType()).getDesc(), toList())));
+                for (Map.Entry<Long, List<String>> entry : result4Leave.entrySet()) {
+                    List<String> typeList = result.get(entry.getKey());
+                    if (ObjectUtil.isEmpty(typeList)) {
+                        typeList = new ArrayList<>();
+                        result.put(entry.getKey(), typeList);
+                    }
+                    typeList.addAll(entry.getValue());
+                }
+            }
+        }
+        return result;
+    }
+
+    private List<ProjectWorkerProfessionDTO> doHistoryWorkerProfession(List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> historys, ValidationEnum valid) {
+        ArrayList<ProjectWorkerProfessionDTO> wps = Lists.newArrayList();
+        historys.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_PROFESSION)) {
+                    List<WorkerProfessionTag> professionTags = historyDatum.resolveWorkerProfessionTags(valid);
+                    // 需要使用有效工种
+                    Stream<ProjectWorkerProfessionDTO> stream = professionTags.stream().map(p -> {
+                        ProjectWorkerProfessionDTO profession = new ProjectWorkerProfessionDTO();
+                        profession.setId(p.getId());
+                        profession.setProfessionName(p.getProfessionName());
+                        profession.setProfessionId(p.getProfessionId());
+                        profession.setValid(p.getValid());
+                        profession.setWorkspaceId(p.getWorkspaceId());
+                        profession.setType(p.getType());
+                        profession.setProjectWorkerId(projectWorkerId);
+                        profession.setCreateAt(p.getCreateAt());
+                        profession.setUpdateAt(p.getUpdateAt());
+                        profession.setIsDelete(p.getIsDelete());
+                        return profession;
+                    });
+                    List<ProjectWorkerProfessionDTO> collect = StreamUtil.distinct(stream,
+                            p -> String.format("%s_%s", p.getProjectWorkerId(), p.getProfessionId()), LABOUR_PROFESSION_TAG_MERGE_FUNC)
+                            .collect(Collectors.toList());
+                    wps.addAll(collect);
+                }
+            }
+        });
+        return wps;
+    }
+
+    @Override
+    public PageResp<ProjectWorkerProfessionResp> page(WorkerProfessionTagQueryPageReq req) {
+        req.check();
+        Long teamOrgNodeId = null;
+        if (req.getOrgNodeId4ResolvedTeamOrgNodeId() != null) {
+            //全部转换为班组组织节点id
+            teamOrgNodeId = checkAndTransform(req.getOrgNodeId4ResolvedTeamOrgNodeId());
+        }
+
+        //获取工种信息
+        WorkerProfessionTagRepository.PageReq pageReq = WorkerProfessionTagRepository.PageReq.builder()
+                .orgNodeId(teamOrgNodeId)
+                .orgNodeIds(req.getOrgNodeIds())
+                .scene(req.getScene().name())
+                .professionIds(req.getProfessionIds())
+                .personIds(req.getPersonIds())
+                .build();
+        PageResp<WorkerProfessionTagRepository.WorkerProfessionTagResp> page = workerProfessionTagRepository.page(pageReq);
+        if (page == null || ObjectUtil.isEmpty(page)) {
+            return CommonUtil.getEmptyPage(req, ProjectWorkerProfessionResp.class);
+        }
+        List<ProjectWorkerProfessionResp> data = page.getData().stream().map(this::convertTagToResp).collect(toList());
+
+        if (BooleanUtils.isTrue(req.getNeedSkillTags())) {
+            assembleSkillTags(data);
+        }
+        return PageResp.<ProjectWorkerProfessionResp>builder()
+                .size(page.getSize())
+                .current(page.getCurrent())
+                .total(page.getTotal())
+                .data(data)
+                .build();
+    }
+
+    private void assembleSkillTags(List<ProjectWorkerProfessionResp> workProcessionTags) {
+        if (ObjectUtils.isEmpty(workProcessionTags)) {
+            return;
+        }
+
+        Set<Long> nodeIds = workProcessionTags.stream().map(ProjectWorkerProfessionResp::getOrgNodeId).collect(Collectors.toSet());
+        Set<Long> personIds = workProcessionTags.stream().map(ProjectWorkerProfessionResp::getPersonId).collect(Collectors.toSet());
+        Set<Long> professionIds = workProcessionTags.stream().map(ProjectWorkerProfessionResp::getProfessionId).collect(Collectors.toSet());
+
+        WorkerProfessionSkillTagRepository.PageReq pageReq = WorkerProfessionSkillTagRepository.PageReq.builder()
+                .orgNodeIds(nodeIds)
+                .professionIds(professionIds)
+                .personIds(personIds)
+                .build();
+        List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> skillTagResps = orgProjectWorkerProfessionSkillService.list(pageReq);
+        Map<String, List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp>> personProfessionSkills = skillTagResps.stream()
+                .collect(groupingBy(t -> buildSkillTagGroupKey(t.getPersonId(), t.getOrgNodeId(), t.getProfessionId())));
+
+        workProcessionTags.forEach(profession -> {
+            List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> skillTagList = personProfessionSkills.get(buildSkillTagGroupKey(profession.getPersonId(), profession.getOrgNodeId(), profession.getProfessionId()));
+            if (CollectionUtils.isEmpty(skillTagList)) {
+                return;
+            }
+            List<ProfessionSkillTagTreeNode> skillTreeNodes = skillTagList.stream()
+                    .map(e -> ProfessionSkillTagTreeNode.builder()
+                            .skillTagCode(e.getSkillTagCode())
+                            .skillTagName(e.getSkillTagName())
+                            .parentSkillTagCode(e.getParentSkillTagCode())
+                            .build())
+                    .collect(Collectors.toList());
+            skillTreeNodes = TreeUtil.buildTree(skillTreeNodes);
+            profession.setSkillTags(skillTreeNodes);
+        });
+    }
+
+    private String buildSkillTagGroupKey(Long personId, Long orgNodeId, Long professionId) {
+        return String.format("%d_%d_%d", personId, orgNodeId, professionId);
+    }
+
+
+    private ProjectWorkerProfessionResp convertTagToResp(WorkerProfessionTag workerProfessionTag) {
+        ProjectWorkerProfessionResp workerProfessionTagResp = BeanUtil.copyProperties(workerProfessionTag, ProjectWorkerProfessionResp.class);
+        workerProfessionTagResp.setType(Optional.ofNullable(workerProfessionTag.getType()).orElse(SkillTypeEnum.COMMON.getValue()));
+        return workerProfessionTagResp;
+    }
+
+    /**
+     * 全部转换为班组组织节点id
+     * @param orgNodeId
+     * @return
+     */
+    private Long checkAndTransform(Long orgNodeId) {
+        // 校验部门id的合法性
+        AssertUtil.isTrue(NumberUtil.isPositiveNumber(orgNodeId), String.format("非法的orgNodeId:[%d]", orgNodeId));
+        List<OrgNodeDTO> orgNodeDTOS = nodeService.list(ListNodeReq.builder().ids(Sets.newHashSet(orgNodeId)).build());
+        // 校验部门id的有效性
+        AssertUtil.notEmpty(orgNodeDTOS, String.format("无效的orgNodeId:[%d]", orgNodeId));
+        OrgNodeDTO orgNode = orgNodeDTOS.get(0);
+        // 校验部门类型的合理性
+        AssertUtil.isTrue(TEAM_ORG_NODE_TYPES.contains(orgNode.getNodeType()), String.format("无效的orgNodeType:[%d]", orgNode.getNodeType()));
+
+        //如果是班组， 直接返回
+        if (!Objects.equals(NodeTypeEnum.PROJECT_GROUP.getValue(), orgNode.getNodeType())) {
+            return orgNodeId;
+        }
+
+        //否则是小组，获取小组对应父节点的班组部门id
+        Long teamOrgNodeId4Group = getTeamOrgNodeId4Group(orgNode.getTopNodeId());
+        AssertUtil.notNull(teamOrgNodeId4Group, String.format("未找到项目内小组对应的班组的协同关系信息.orgTopNodeId:[%d]", orgNode.getTopNodeId()));
+        return teamOrgNodeId4Group;
+    }
+
+    private Long getTeamOrgNodeId4Group(Long grouptTopNodeId) {
+        if (NumberUtil.isNotPositiveNumber(grouptTopNodeId)) {
+            log.info("the orgTopNodeId is not positive.");
+            return null;
+        }
+        // 查询指定顶级部门id对应的协同关系
+        ListOrgCooperateShipReq listOrgCooperateShipReq = ListOrgCooperateShipReq.builder()
+                .organizationNodeIds(Sets.newHashSet(grouptTopNodeId))
+                .statuses(Sets.newHashSet(CooperateShipStatusEnum.ACTIVE.getStatus()))
+                .build();
+        List<OrgCooperateShipDTO> orgCooperateShipDTOS = cooperateShipService.list(listOrgCooperateShipReq);
+        if (ObjectUtil.isEmpty(orgCooperateShipDTOS)) {
+            return null;
+        }
+        OrgCooperateShipDTO orgCooperateShipDTO = orgCooperateShipDTOS.get(0);
+
+        // 查询协同关系的上级
+        ListOrgCooperateShipReq listOrgCooperateShipReq4Parent = ListOrgCooperateShipReq.builder()
+                .organizationNodeIds(Sets.newHashSet(orgCooperateShipDTO.getParentId()))
+                .statuses(Sets.newHashSet(CooperateShipStatusEnum.ACTIVE.getStatus()))
+                .build();
+        List<OrgCooperateShipDTO> orgCooperateShipDTOS4Parent = cooperateShipService.list(listOrgCooperateShipReq4Parent);
+        if (ObjectUtil.isEmpty(orgCooperateShipDTOS4Parent)) {
+            return null;
+        }
+        return orgCooperateShipDTOS4Parent.get(0).getOrganizationalNodeId();
+    }
+
     /**
      * 获取技能标签包括历史技能标签(带子技能标签)
      * @param projectWorkerIds
@@ -175,10 +456,8 @@ public class OrgProjectWorkerProfessionServiceImpl implements OrgProjectWorkerPr
         //获取历史技能标签
         WorkerProfessionHistoryRepository.PageReq pageReq4HistoryProfession = WorkerProfessionHistoryRepository.PageReq.builder()
                 .scene(TeamSceneEnum.PROJECT_TEAM.name())
+                .projectWorkerIds(projectWorkerIds)
                 .build();
-        List<MybatisPlusOperatorProcessor.JSONQuery> bizData = Arrays.asList(
-                MybatisPlusOperatorProcessor.JSONQuery.builder().jsonPath("$.projectWorkerId").data(projectWorkerIds).operator(Operator.IN).build());
-        pageReq4HistoryProfession.setBizData(bizData);
         List<WorkerProfessionHistoryRepository.WorkerProfessionHistoryResp> workerProfessionHistoryResps = workerProfessionHistoryRepository.list(pageReq4HistoryProfession);
         List<WorkerProfessionSkillTagRepository.WorkerProfessionSkillTagResp> workerProfessionSkillTagResps4History = doHistoryWorkerSkilltag(workerProfessionHistoryResps);