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

Merge branch 'release-20250218' into 'master'

Browse Source 
feat:[REQ-3488]

See merge request universal/infrastructure/backend/orgmanax!202
This commit is contained in:
谭杰 2025-02-18 02:36:35 +00:00
commit eb798b1771
447 changed files with 22202 additions and 946 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/config/OrgmanaxApiConfig.java
View File

@ -8,6 +8,6 @@ import org.springframework.context.annotation.Configuration;
* @date 2022/4/25 10:48
*/
@Configuration
@EnableFeignClients(basePackages = "cn.axzo.orgmanax.api.**.feign")
@EnableFeignClients(basePackages = "cn.axzo.orgmanax.api.project.worker.feign")
public class OrgmanaxApiConfig {
}

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);
}
}

44
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/invite/feign/OrgProjectTeamInviteApi.java Normal file
View File

@ -0,0 +1,44 @@
package cn.axzo.orgmanax.api.invite.feign;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.invite.req.ApplyOrgTeamInviteReq;
import cn.axzo.orgmanax.dto.invite.req.ApproveOrgTeamInviteReq;
import cn.axzo.orgmanax.dto.invite.req.InviteBatchOrgProjectTeamReq;
import javax.validation.Valid;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
*
* TODO 三期实现
*
* 班组邀请进项目
*
* @author wangli
* @since 2024/7/17 20:36
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgProjectTeamInviteApi {
/**
* cms批量邀请工人加入项目
* todo 三期实现，迁移至invite的package下
*/
@PostMapping("/api/project/team-group/invite-batch")
ApiResult<Void> teamOwnerBatchAgreeWorkerJoinProject(@RequestBody @Valid InviteBatchOrgProjectTeamReq req);
/**
* 班组邀请进项目申请
*/
@PostMapping("/api/project/team-invite/apply")
ApiResult<Long> fakeApplyProjectTeam(@Valid @RequestBody ApplyOrgTeamInviteReq req);
/**
* 班组邀请进项目审批
*/
@PostMapping("/api/project/team-invite/approve")
ApiResult<Void> fakeApproveApplyProjectTeam(@Valid @RequestBody ApproveOrgTeamInviteReq req);
}

46
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/invite/feign/OrgProjectWorkerInviteApi.java Normal file
View File

@ -0,0 +1,46 @@
package cn.axzo.orgmanax.api.invite.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.invite.project.req.CancelProjectWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.project.req.PageProjectWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.project.req.UpdateProjectWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.project.resp.OrgProjectWorkerInviteResp;
import javax.validation.Valid;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* todo:三期实现
* 项目内工人邀请api
*
* @author 夏嘉孚
* @since 2023/2/10
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgProjectWorkerInviteApi {
/**
* 分页查询项目内工人邀请信息
*/
@PostMapping("/api/project/worker-invite/page")
ApiResult<PageResp<OrgProjectWorkerInviteResp>> page(@RequestBody @Valid PageProjectWorkerInviteReq req);
/**
* 终止邀请
*/
@PostMapping("/api/project/worker-invite/cancel")
ApiResult<Void> cancelProjectWorkerInvite(@RequestBody @Valid CancelProjectWorkerInviteReq req);
/**
* 修改接口，能兼容旧逻辑
* 【非请勿调】修改工人邀请记录的状态
*
*/
@PostMapping("/api/project/worker-invite/update")
ApiResult<Void> update(@RequestBody @Valid UpdateProjectWorkerInviteReq req);
}

80
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/invite/feign/OrgWorkerInviteApi.java Normal file
View File

@ -0,0 +1,80 @@
package cn.axzo.orgmanax.api.invite.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.invite.dto.OrgWorkerInviteDTO;
import cn.axzo.orgmanax.dto.invite.req.ApproveOrgWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.req.CountTeamWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.req.LeaveOrgWorkerTeamReq;
import cn.axzo.orgmanax.dto.invite.req.OperateOrgWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.req.PageOrgTeamWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.req.SaveOrgWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.req.UpdateOrgWorkerInviteReq;
import cn.axzo.orgmanax.dto.invite.resp.CountTeamWorkerInviteResp;
import java.util.List;
import javax.validation.Valid;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author syl
* @date 2024/12/17
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgWorkerInviteApi {
/**
* 班组 查看邀请列表(是否需要历史申请数据)
*/
@PostMapping("/api/org-gateway/team/worker-invite/page")
ApiResult<PageResp<OrgWorkerInviteDTO>> page(@RequestBody @Valid PageOrgTeamWorkerInviteReq req);
/**
* 班组长-工友申请数量
* 分组count 查询
*/
@PostMapping("/api/org-gateway/team/worker-invite/group-count")
ApiResult<List<CountTeamWorkerInviteResp>> groupCountWorkerInvite(@RequestBody @Valid CountTeamWorkerInviteReq req);
/**
* 班组长-班组操作
* 班组长同意思或拒绝工人
*/
@PostMapping("/api/org-gateway/team/worker-invite/operate")
ApiResult<Boolean> operateWorkerInvite(@RequestBody @Valid OperateOrgWorkerInviteReq req);
/**
* 班组长-邀请工人 或者 工人-申请加入班组
* 新增工人邀请
*/
@PostMapping("/api/org-gateway/team/worker-invite/save")
ApiResult<OrgWorkerInviteDTO> saveWorkerInvite(@RequestBody @Valid SaveOrgWorkerInviteReq req);
/**
* 新增工人被退出项目
*/
@PostMapping("/api/org-gateway/team/worker-invite/quit")
ApiResult<List<OrgWorkerInviteDTO>> quitWorkerProjectTeam(@RequestBody @Valid List<SaveOrgWorkerInviteReq> param);
/**
* 工人-离开班组
*/
@PostMapping("/api/org-gateway/team/worker-invite/leave")
ApiResult<OrgWorkerInviteDTO> workerLeaveTeam(@RequestBody @Valid LeaveOrgWorkerTeamReq req);
/**
* 同意指定人在指定班组邀请记录 or 撤销班组下所有邀请记录
*/
@PostMapping("/api/org-gateway/worker-invite/approve")
ApiResult<Void> approveWorkerInvite(@RequestBody @Valid ApproveOrgWorkerInviteReq req);
/**
* 修改邀请记录
*/
@PostMapping("/api/org-gateway/worker-invite/update")
ApiResult<Boolean> update(@RequestBody @Valid UpdateOrgWorkerInviteReq req);
}

2
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/nodeuser/feign/OrgNodeUserApi.java
View File

@ -2,9 +2,9 @@ package cn.axzo.orgmanax.api.nodeuser.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.nodeuser.dto.NodeUserDTO;
import cn.axzo.orgmanax.dto.nodeuser.req.ListNodeUserReq;
import cn.axzo.orgmanax.dto.nodeuser.req.ProcessNodeUserReq;
import cn.axzo.orgmanax.dto.nodeuser.dto.NodeUserDTO;
import cn.axzo.orgmanax.dto.nodeuser.req.SearchEntNodeUserReq;
import cn.axzo.orgmanax.dto.nodeuser.resp.SearchEntNodeUserResp;
import com.alibaba.fastjson.JSONObject;

27
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/nodeuser/feign/OrgUserChangeRecordApi.java Normal file
View File

@ -0,0 +1,27 @@
package cn.axzo.orgmanax.api.nodeuser.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.nodeuser.req.PageOrgUserChangedRecordReq;
import cn.axzo.orgmanax.dto.nodeuser.resp.OrgUserChangedRecordResp;
import javax.validation.Valid;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 组织人员异动api
* TODO: 第三期实现
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgUserChangeRecordApi {
/**
* 人员异动记录分页查询
*/
@PostMapping("/api/org/user/changed-record/page")
ApiResult<PageResp<OrgUserChangedRecordResp>> page(@RequestBody @Valid PageOrgUserChangedRecordReq req);
}

11
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/orgjob/feign/OrgJobApi.java
View File

@ -2,11 +2,14 @@ package cn.axzo.orgmanax.api.orgjob.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.job.dto.JobGroupDTO;
import cn.axzo.orgmanax.dto.job.dto.OrgJobDTO;
import cn.axzo.orgmanax.dto.job.req.CreateOrgJobReq;
import cn.axzo.orgmanax.dto.job.req.DeleteOrgJobReq;
import cn.axzo.orgmanax.dto.job.req.JobTreeGroupReq;
import cn.axzo.orgmanax.dto.job.req.PageOrgJobReq;
import cn.axzo.orgmanax.dto.job.req.UpdateOrgJobReq;
import java.util.List;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
@ -32,4 +35,12 @@ public interface OrgJobApi {
*/
@PostMapping("/api/job/list")
ApiResult<PageResp<OrgJobDTO>> list(@RequestBody @Validated PageOrgJobReq req);
/**
* TODO: 第三期实现
* OMS 分组岗位树
*/
@PostMapping("/api/job/job-tree/group")
ApiResult<List<JobGroupDTO>> groupAndJobTree(@RequestBody JobTreeGroupReq req);
}

15
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/orguser/feign/OrgUserApi.java
View File

@ -2,8 +2,11 @@ package cn.axzo.orgmanax.api.orguser.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.orguser.req.ListOrgUserReq;
import cn.axzo.orgmanax.dto.orguser.dto.OrgUserDTO;
import cn.axzo.orgmanax.dto.orguser.req.ListOrgUserReq;
import cn.axzo.orgmanax.dto.orguser.req.PageOrgUserReq;
import cn.axzo.orgmanax.dto.orguser.resp.PageOrgUserElementResp;
import javax.validation.Valid;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
@ -32,4 +35,14 @@ public interface OrgUserApi {
@PostMapping("/api/org-user/list")
ApiResult<PageResp<OrgUserDTO>> list(@RequestBody @Validated ListOrgUserReq req);
/**
* TODO: 第三期实现
* 通用人员列表分页查询
* 和其他接口逻辑、返回结构，完全不同，只能平迁
* @param req 分页查询入参
* @return 通用人员列表
*/
@PostMapping(value = "/api/org-user/generic/page")
ApiResult<PageResp<PageOrgUserElementResp>> genericPage(@RequestBody @Valid PageOrgUserReq req);
}

24
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/processrelationship/feign/ProcessRelationshipApi.java Normal file
View File

@ -0,0 +1,24 @@
package cn.axzo.orgmanax.api.processrelationship.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.processrelationship.dto.BusinessProcessRelationshipDTO;
import cn.axzo.orgmanax.dto.processrelationship.req.ProcessRelationListReq;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author zhanghongbo
* @date 2024/12/30
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface ProcessRelationshipApi {
/**
* 查询流程关联表
*/
@PostMapping("/api/process-relationship/page")
ApiResult<PageResp<BusinessProcessRelationshipDTO>> list(@RequestBody ProcessRelationListReq req);
}

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;
}

153
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/project/group/feign/OrgProjectGroupApi.java Normal file
View File

@ -0,0 +1,153 @@
package cn.axzo.orgmanax.api.project.group.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.project.group.req.*;
import cn.axzo.orgmanax.dto.project.group.resp.*;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import javax.validation.Valid;
import java.util.List;
/**
* 项目内小组
*
* @author wenXueFeng
* @date 2022/10/21 9:59
*/
@FeignClient(name = "org-gateway", url = "${axzo.service.org-gateway:http://org-gateway:8080}")
public interface OrgProjectGroupApi {
/**
* 项目内班组列表查询
*
* @author: zhanglei
* @date: 2023/08/21 11:03
* @param req req - 对应LabourProjectGroupQueryBo
* @return:
**/
@PostMapping("api/project-group/page")
ApiResult<List<LabourProjectGroupListV2Res>> page(@RequestBody @Valid ProjectGroupPageReq req);
/**
* CMS创建小组
* todo 三期实现
* @param req
* @return
*/
@PostMapping("api/project-group/create-group")
ApiResult<Long> create(@RequestBody @Valid GroupNodeCreateReq req);
/**
* CMS编辑小组
* todo 三期实现
*
* @param req
* @return
*/
@PostMapping("api/project-group/edit")
ApiResult<Void> edit(@RequestBody @Valid GroupNodeEditReq req);
/**
* CMS解散小组
* todo 三期实现
* @param req
* @return
*/
@PostMapping("api/project-group/delete")
ApiResult<Void> delete(@RequestBody @Valid GroupNodeDeleteReq req);
/**
* 目前用来做cms协同管理, worker里面的大部分信息都直接需要
* <p> 慎用这个接口
*
* @param workspaceId
* @return
*/
@PostMapping("api/project-group/worker/expose-workers")
ApiResult<List<ExposeGroupWorkerRespItem>> exposeWorkers(
@RequestParam("workspaceId") Long workspaceId);
// /**
// * 查询甲方班组的合作小组 TODO zhanghonghao
// */
// @PostMapping("/api/project-group/group/list")
// ApiResult<List<ProjectTeamGroupListResp>> groupList(@RequestBody ProjectTeamGroupListReq req);
/**
* 小组长权限
*
* @param groupId 小组id
* @author: wxf
* @date: 2022/11/30 14:47
* @return:
**/
@GetMapping("api/direct-group/owner/permission")
ApiResult<ProjectGroupOwnerPermissionRes> groupOwnerPermission(@RequestParam("groupId") Long groupId);
/**
* 查询没有设置小组长的小组
*
* @param workspaceId
* @return cn.axzo.apollo.core.web.Result<cn.axzo.maokai.api.labour.dto.projectgroup.ProjectGroupListRes>
* @author zhongjie
* @date 2022/11/30 16:32
**/
@GetMapping("api/direct-group/no-leader/group")
ApiResult<ProjectGroupListResp> getNoLeaderGroupList(@RequestParam("workspaceId") Long workspaceId, @RequestParam("platTeamId") Long platTeamId, @RequestParam("isReturnWorker") Boolean isReturnWorker);
/**
* 查询平台班组id + 工人id 项目内是否为小组长
*
* @param req
* @return cn.axzo.apollo.core.web.Result<cn.axzo.maokai.api.labour.dto.projectgroup.ProjectGroupRes>
* @author zhongjie
* @date 2022/11/30 16:41
**/
@PostMapping("api/direct-group/page-group-info")
ApiResult<PageResp<ProjectGroupRes>> pageGroupInfo(@RequestBody @Valid ProjectDirectGroupPageGroupReq req);
/**
* 小组成立序号
*
* @param projectTeamId
* @param groupId
* @return
*/
@GetMapping("api/direct-group/get-join-team-top-no")
ApiResult<Integer> getJoinTeamTopNo(@RequestParam("projectTeamId") Long projectTeamId,
@RequestParam("groupId") Long groupId);
/**
* 列表项目内班组班组下小组成员列表
* @param projectTeamId
* @return
*/
@GetMapping("api/direct-group/list-project-group-worker")
ApiResult<List<ProjectTeamGroupWorkerRes>> listProjectGroupWorker(@RequestParam("projectTeamId") Long projectTeamId);
/**
* @param req 与项目内小组关联节点
* @return
* @author zr
* @description 通过小组节点获取项目内小组信息
* @date 2024/1/15 17:15
**/
@PostMapping("api/direct-group/get-project-group-by-group-node-id")
ApiResult<List<ProjectGroupNodeRes>> pageProjectGroupNode(@RequestBody ProjectDirectGroupPageProjectGroupNodeReq req);
/**
* @param teamNodeId 班组节点id
* @return
* @author zr
* @description 通过班组节点获取无小组长的小组列表和未加入小组的工人列表
* @date 2024/2/4 17:15
**/
@GetMapping("api/direct-group/get-project-group-un-owner-and-worker")
ApiResult<ProjectGroupAndWorkerResp> getProjectGroupUnOwnerAndWorker(@RequestParam("teamNodeId") Long teamNodeId);
}

27
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/project/team/feign/OrgProjectTeamApi.java Normal file
View File

@ -0,0 +1,27 @@
package cn.axzo.orgmanax.api.project.team.feign;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.project.team.dto.OrgProjectTeamDTO;
import cn.axzo.orgmanax.dto.project.team.req.ListProjectTeamReq;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import java.util.List;
/**
* 项目内班组api
* 业务表
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgProjectTeamApi {
/**
* 列表接口。
*/
@PostMapping("/api/org/project-team/list")
ApiResult<List<OrgProjectTeamDTO>> list(@RequestBody @Validated ListProjectTeamReq req);
}

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

@ -0,0 +1,86 @@
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.OperateOrgTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.OrgTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.req.PageOrgTeamCategoryReq;
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.TreeOrgTeamCategoryReq;
import cn.axzo.orgmanax.dto.project.team.resp.RemoveTeamCategoryCheckResp;
import java.util.List;
import javax.validation.Valid;
import javax.validation.constraints.NotEmpty;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @Author: zhanglei
* @Name: ProjectTeamCategoryApi
* @Date: 2023/8/1 15:13
* @Desc: 班组分类，内部接口
* @Version: 1.0
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgProjectTeamCategoryApi {
/**
* todo 三期实现
* 删除项目班组的分类进行check
*/
@PostMapping("/api/project/team-category/remove/check")
ApiResult<RemoveTeamCategoryCheckResp> preCheckRemoveTeamCategory(
@RequestBody @Valid PreCheckRemoveTeamCategoryReq req);
/**
* todo 三期实现
* 添加项目班组分类
* 和 单个班组的班组类别初始化接口，逻辑相差太大，无法合并
* 这里用到宽表 org_project_worker_wide
*/
@PostMapping("/api/project/team-category/add")
ApiResult<Void> save(@RequestBody @Valid SaveProjectTeamCategoryReq req);
/**
* 删除项目班组分类
* 这里用到宽表 org_project_worker_wide
* 用到 org_project_team_category 表数据
*/
@PostMapping("/api/project/team-category/remove")
ApiResult<Void> removeTeamCategory(@RequestBody @Valid RemoveProjectTeamCategoryReq req);
/**
* todo 三期实现
* 操作班组类别
*/
@PostMapping(value = "/api/project/team-category/operate")
ApiResult<Void> operate(@RequestBody @Valid OperateOrgTeamCategoryReq req);
/**
* replace，实际上把老的删了，更换为入参
* 入参是集合类型，无法合并到通用接口
* todo 三期实现 看业务方使用场景
*/
@PostMapping(value = "/api/project/team-category/upsert")
ApiResult<Void> replace(@RequestBody @NotEmpty List<OrgTeamCategoryReq> 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);
}

23
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/project/team/feign/OrgProjectTeamLogApi.java Normal file
View File

@ -0,0 +1,23 @@
package cn.axzo.orgmanax.api.project.team.feign;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.project.team.req.ProjectTeamLogSaveReq;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author : zhanghonghao@axzo.cn
* @since : 2025/1/8
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgProjectTeamLogApi {
/**
* 创建项目班组日志
*/
@PostMapping("/api/project/team-log/create")
ApiResult<Long> create(@RequestBody ProjectTeamLogSaveReq req);
}

45
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/project/worker/feign/OrgProjectWorkerApi.java Normal file
View File

@ -0,0 +1,45 @@
package cn.axzo.orgmanax.api.project.worker.feign;
import cn.axzo.foundation.result.ApiResult;
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 org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import javax.validation.Valid;
import java.util.List;
/**
* @author zhanghongbo
* @date 2025/1/8
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgProjectWorkerApi {
/**
* 未分组工人
*
* @param req req
* @author: wxf
* @date: 2022/11/30 11:40
* @return:
* REQ-1483
**/
@PostMapping("api/project-worker/ungrouped/worker")
ApiResult<List<ProjectDirectGroupUngroupedWorkerResp>> ungroupedWorker(@RequestBody @Valid ProjectDirectGroupUngroupedWorkerReq req);
/**
* 直属小组工人
*
* @param req req
* @author: wxf
* @date: 2022/11/30 14:04
* @return:
**/
@PostMapping("api/project-worker/direct-group/worker")
ApiResult<List<ProjectDirectGroupWorkerListResp>> workerList(@RequestBody @Valid ProjectDirectGroupWorkerListReq req);
}

40
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/teamlog/feign/OrgTeamLogApi.java Normal file
View File

@ -0,0 +1,40 @@
package cn.axzo.orgmanax.api.teamlog.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.nodeuser.req.ListNodeUserReq;
import cn.axzo.orgmanax.dto.teamlog.dto.TeamLogDTO;
import cn.axzo.orgmanax.dto.teamlog.req.TeamLogPageReq;
import cn.axzo.orgmanax.dto.teamlog.req.TeamLogRecordChangeTeamOwnerReq;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author zhanghongbo
* @date 2024/12/25
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgTeamLogApi {
/**
* 分页列表接口。
* XXX：本接口默认分页，单页最多返回1000条数据。调用方使用时需注意。
*
* @param req
* @return
*
*/
@PostMapping("/api/team-log/list")
ApiResult<PageResp<TeamLogDTO>> list(@RequestBody @Validated TeamLogPageReq req);
/**
* 记录班组改变日志
* @param req
* @return
*/
@PostMapping("/api/team-log/record-change-team-owner")
ApiResult<Long> recordChangeTeamOwner(@RequestBody TeamLogRecordChangeTeamOwnerReq req);
}

30
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/unit/feign/OrgUnitContactApi.java
View File

@ -1,12 +1,16 @@
package cn.axzo.orgmanax.api.unit.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.unit.req.CreateUnitContactReq;
import cn.axzo.orgmanax.dto.unit.resp.CreateUnitContactResp;
import cn.axzo.orgmanax.dto.unit.contact.req.OperateOrgContactReq;
import cn.axzo.orgmanax.dto.unit.contact.req.PageOrgContactReq;
import cn.axzo.orgmanax.dto.unit.contact.req.SaveBatchOrgContactReq;
import cn.axzo.orgmanax.dto.unit.dto.OrgUnitContactDTO;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import javax.validation.Valid;
import java.util.List;
/**
@ -21,14 +25,26 @@ public interface OrgUnitContactApi {
* 通过单位id获取单位联系人列表
*/
@PostMapping("/api/org/unit/contact/list")
ApiResult<List<OrgUnitContactDTO>> list(List<Long> ouIds);
ApiResult<List<OrgUnitContactDTO>> list(@RequestBody List<Long> ouIds);
/**
* 批量创建单位联系人
* 批量新增单位联系人
*/
@PostMapping("/api/org/unit/contact/create")
ApiResult<List<CreateUnitContactResp>> create(List<CreateUnitContactReq> contactReqList);
@PostMapping("/api/unit/contact/save-batch")
ApiResult<List<OrgUnitContactDTO>> saveBatch(@RequestBody @Valid SaveBatchOrgContactReq req);
/**
* 编辑单位联系人 or 删除单位联系人
*/
@PostMapping("/api/unit/contact/update")
ApiResult<OrgUnitContactDTO> update(@RequestBody @Valid OperateOrgContactReq req);
/**
* 分页获取单位联系人列表
*
* @param req
* @return
*/
@PostMapping("/api/unit/contact/page")
ApiResult<PageResp<OrgUnitContactDTO>> page(@RequestBody @Valid PageOrgContactReq req);
}

41
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/unit/feign/OrgUnitPrivacySettingApi.java Normal file
View File

@ -0,0 +1,41 @@
package cn.axzo.orgmanax.api.unit.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.unit.privacy.req.PageOrgUnitPrivacySettingReq;
import cn.axzo.orgmanax.dto.unit.privacy.req.SaveOrgUnitPrivacySettingReq;
import cn.axzo.orgmanax.dto.unit.privacy.req.UpdateOrgUnitPrivacySettingReq;
import cn.axzo.orgmanax.dto.unit.privacy.resp.OrgUnitPrivacySettingsResp;
import javax.validation.Valid;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 单位隐私设置API
* @author syl
* @date 2024/12/16
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgUnitPrivacySettingApi {
/**
* 查询单位相关的隐私设置
*/
@PostMapping(value = "/api/unit/privacy-settings/page")
ApiResult<PageResp<OrgUnitPrivacySettingsResp>> page(@RequestBody @Valid PageOrgUnitPrivacySettingReq param);
/**
* 新增隐私设置数据
*/
@PostMapping(value = "/api/unit/privacy-settings/save")
ApiResult<String> save(@RequestBody @Valid SaveOrgUnitPrivacySettingReq param);
/**
* 新增隐私设置数据
*/
@PostMapping(value = "/api/unit/privacy-settings/update")
ApiResult<Boolean> update(@RequestBody @Valid UpdateOrgUnitPrivacySettingReq update);
}

40
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/unit/feign/OrgUnitQualificationApi.java
View File

@ -1,8 +1,15 @@
package cn.axzo.orgmanax.api.unit.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.unit.qualification.dto.OrgQualificationDTO;
import cn.axzo.orgmanax.dto.unit.qualification.dto.OrgQualificationOuTypeDTO;
import cn.axzo.orgmanax.dto.unit.qualification.dto.OrgQualificationsApplyDTO;
import cn.axzo.orgmanax.dto.unit.qualification.req.*;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@ -23,4 +30,37 @@ public interface OrgUnitQualificationApi {
@PostMapping("api/org/qualification/types")
ApiResult<List<Integer>> getQualificationTypesByUnitId(@RequestParam("unitId") Long unitId);
/**
* 分页获取资质
*/
@PostMapping("/api/org/qualification/list")
ApiResult<PageResp<OrgQualificationDTO>> list(@RequestBody @Validated ListQualificationReq req);
/**
* 分页获取资质申请记录
*/
@PostMapping("/api/org/qualifications-apply/list")
ApiResult<PageResp<OrgQualificationsApplyDTO>> listApply(@RequestBody @Validated ListQualificationsApplyReq req);
/**
* 分页获取资质序列/单位类型
*/
@PostMapping("/api/org/qualification-ou-type/list")
ApiResult<PageResp<OrgQualificationOuTypeDTO>> listOuType(@RequestBody @Validated ListQualificationOuTypeReq req);
/**
* 批量保存资质申请记录
*/
@PostMapping("/api/org/qualifications-apply/saveBatch")
ApiResult<List<OrgQualificationsApplyDTO>> qualificationsApplySaveBatch(@RequestBody @Validated SaveBatchQualificationsApplyReq req);
@PostMapping("/api/org/qualifications-apply/update")
ApiResult<Void> updateQualificationsApply(@RequestBody @Validated UpdateQualificationsApplyReq req);
@PostMapping("/api/org/qualification/upsert")
ApiResult<Void> upsertQualification(@RequestBody @Validated UpsertQualificationReq req);
@PostMapping("/api/org/qualification-ou-type/upsert")
ApiResult<Void> upsertQualificationOuType(@RequestBody @Validated UpsertQualificationOuTypeReq req);
}

54
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/unit/feign/OrgUnitRegisterApi.java Normal file
View File

@ -0,0 +1,54 @@
package cn.axzo.orgmanax.api.unit.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
import cn.axzo.orgmanax.dto.unit.register.dto.OrgUnitRegisterDTO;
import cn.axzo.orgmanax.dto.unit.register.dto.OrgUnitRegisterHistoryDTO;
import cn.axzo.orgmanax.dto.unit.register.req.*;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* 单位注册API
*
* @author tanjie@axzo.cn
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgUnitRegisterApi {
/**
* 分页获取单位注册信息
*/
@PostMapping("/api/org/unit/register/list")
ApiResult<PageResp<OrgUnitRegisterDTO>> list(@RequestBody @Validated ListUnitRegisterReq req);
/**
* 分页获取企业入驻历史信息
*/
@PostMapping("/api/org/unit/register/history/list")
ApiResult<PageResp<OrgUnitRegisterHistoryDTO>> listHistory(@RequestBody @Validated ListUnitRegisterHistoryReq req);
/**
* 创建单位注册信息
*/
@PostMapping("/api/org/unit/register/create")
ApiResult<OrgUnitRegisterDTO> create(@RequestBody @Validated CreateUnitRegisterReq req);
/**
* 创建企业入驻历史信息
*/
@PostMapping("/api/org/unit/register/history/create")
ApiResult<OrgUnitRegisterHistoryDTO> createHistory(@RequestBody @Validated CreateUnitRegisterHistoryReq req);
/**
* 更新单位注册信息
*/
@PostMapping("/api/org/unit/register/update")
ApiResult<OrgUnitRegisterDTO> update(@RequestBody @Validated UpdateUnitRegisterReq req);
}

100
orgmanax-api/src/main/java/cn/axzo/orgmanax/api/workerprofession/feign/OrgProjectWorkerProfessionApi.java Normal file
View File

@ -0,0 +1,100 @@
package cn.axzo.orgmanax.api.workerprofession.feign;
import cn.axzo.foundation.page.PageResp;
import cn.axzo.foundation.result.ApiResult;
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.ProjectWorkerProfessionUpdateReq;
import cn.axzo.orgmanax.dto.workerprofession.req.WorkerProfessionTagOperationConfigureReq;
import cn.axzo.orgmanax.dto.workerprofession.req.WorkerProfessionTagOperationRemoveReq;
import cn.axzo.orgmanax.dto.workerprofession.req.WorkerProfessionTagOperationUpsertReq;
import cn.axzo.orgmanax.dto.workerprofession.req.WorkerProfessionTagOperationValidUpdateReq;
import cn.axzo.orgmanax.dto.workerprofession.req.WorkerProfessionTagQueryPageReq;
import cn.axzo.orgmanax.dto.workerprofession.resp.ProjectWorkerProfessionResp;
import java.util.List;
import java.util.Map;
import javax.validation.Valid;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
/**
* @author zhanghongbo
* @date 2025/1/3
*/
@FeignClient(
value = "orgmanax",
url = "${axzo.service.orgmanax:http://orgmanax:8080}")
public interface OrgProjectWorkerProfessionApi {
/**
* CMS 批量设置工人工种 (小组详情) 批量指多人，工种单个
*
* @param req
* @return
*/
@PostMapping("/api/labour/cms/project-worker-profession/update")
ApiResult<Void> update(@Valid @RequestBody ProjectWorkerProfessionUpdateReq req);
/**
* 获取有效的工种信息
* @param req
* @return
*/
@PostMapping("/api/labour/cms/project-worker-profession/list-valid")
ApiResult<Map<Long, List<ProfessionDTO>>> listValid(@Valid @RequestBody ProjectWorkerProfessionListValidReq req);
/**
* 计算项目内工人工种类型
*/
@PostMapping("/api/labour/project-worker-profession/sort-out-profession-category")
ApiResult<Map<Long, List<String>>> sortOutProfessionCategory(@RequestBody @Valid ProjectWorkerProfessionSortOutProfessionCategoryReq req);
/**
* 设置工人工种&技能标签
*
* @param request 工人工种&技能标签信息
*/
@PostMapping(value = "/api/worker/profession/configure")
ApiResult<Void> configure(@RequestBody @Validated WorkerProfessionTagOperationConfigureReq request);
/**
* 单个工种及其关联的技能标签列表删除
*
* @param request 工种及人员的相关信息
*/
@PostMapping(value = "/api/worker/profession/remove")
ApiResult<Void> remove(@RequestBody @Validated WorkerProfessionTagOperationRemoveReq request);
/**
* 新增工种及相关的技能标签(新增|修改)
*
* @param request 工种及其关联的技能标签列表
*/
@PostMapping(value = "/api/worker/profession/upsert")
ApiResult<Void> upsert(@RequestBody @Validated WorkerProfessionTagOperationUpsertReq request);
/**
* 设置工种为无效并将相关的技能标签置为无效
*
* @param request
*/
@PostMapping(value = "/api/worker/profession/singletonProfessionValidUpdate")
ApiResult<Void> validUpdate(@RequestBody @Validated WorkerProfessionTagOperationValidUpdateReq request);
/**
*
* 通用查询接口，仅校验查询条件非空。支持返回技能标签
* XXX: 通用查询接口，
*
* @param req
* @return
*/
@PostMapping(value = "/api/worker/profession/page")
ApiResult<PageResp<ProjectWorkerProfessionResp>> page(@RequestBody @Validated WorkerProfessionTagQueryPageReq req);
}

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

@ -4,84 +4,76 @@ Content-Type: application/json
Accept: application/json
{
// "searchCount": false,
// "personIds": [9000398681,9000400039],
// "personIds": [9000400039],
// "personIds": [9000400039],
// "realNameLike": "周建镐",
"organizationalNodeId": 10456,
// "organizationalNodeId": 14423,
// "subordinatePersonId": 42936,
// "managerPersonId": 44364,
// "directManagerPersonId": 9000404206,
"organizationalUnitIds": [
5144
// 5144
],
"identityTypes": [
// 2,1
],
// "organizationalJobCode": "YoElse",
// "organizationalJobCodes": ["YoElse"],
"workspaceOuPairs": [
{
"workspaceId": 335,
"ouId": 5144
}
// {
// "workspaceId": 335,
// "ouId": 5144
// }
],
// "includeDeleted": true,
// "deletedOnly": true,
// "phone": "18530039500",
// "idNumber": "410205198601221016",
// "personId": 5354,
"personId": 3305,
// "syncDataId": 737,
// "includeDeleted": true,
// "findByTopNodeId": true,
"findByAncestorNodeId": true,
// "findByTopNodeId": true,
// "findByAncestorNodeId": true,
// "pageSize": 2,
"needs": {
// "job": true,
"job": true,
// "node": true ,
// "ancestorNode": true,
// "unit": true,
// "cooperateShip": true,
"cooperateShip": true,
// "subordinateUsers": true
"personProfile": true,
// "ancestorNodes": true,
"a": true
},
// "filterIncludeUnitTypes": [1,2],
// "filterExcludeUnitTypes": [2],
// "distinctRule": {
// "distinctByFields": [
// "identityId",
// "identityType"
// ]
// },
// "filterIncludeUnitTypes": [6],
// "filterExcludeUnitTypes": [6],
"distinctRule": {
"distinctByFields": [
// "identityId",
// "identityType",
// "personId",
// "organizationalUnitId",
// "a"
]
},
"filterIncludeWorkspaceTypes": [
1,
2,
6
// 1,
// 2,
// 6,
// 8,
// 9
],
// "filterIncludeCooperateTypes": [1,2, 6],
// "filterExcludeCooperateTypes": [6],
// "filterIncludeCooperateTypes": [1,2, 6],
"filterExcludeCooperateTypes": [6,7],
// "filterDirectManagerNotNull": true,
"filterNodeStates": [
1
// 1
],
// "filterTopNodeOnly": true,
//
//
//
"a": "a"
}
###
# 分页列表接口
POST {{host}}/api/node-user/list
Content-Type: application/json
Accept: application/json
{
// "id": 984,
"organizationalNodeId": 436,
"activeFlag": 1,
"searchCount": true,
"needs": {
"childNodeUser": true
},
"distinctRule": {
"distinctByFields": [
"identityId",
"identityType"
]
}
}
}

11
orgmanax-api/src/test/resources/http/orgjob/org-job.http
View File

@ -45,7 +45,7 @@ Accept: application/json
###
# 查询
POST {{host}}/api/job/page
POST {{host}}/api/job/list
Content-Type: application/json
Accept: application/json
@ -54,4 +54,11 @@ Accept: application/json
"jobCodes": ["coTheprojectmanager", "cosurveyor"],
"needSaasRole": true,
"needJobGroup": true
}
}
### oms岗位树
POST {{host}}/api/job/job-tree/group
Content-Type: application/json
Accept: application/json
{}

18
orgmanax-api/src/test/resources/http/project/teamcategory/team-category.http Normal file
View File

@ -0,0 +1,18 @@
###
# 分页查询班组类别
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]
}

13
orgmanax-api/src/test/resources/http/teamlog/team-log.http Normal file
View File

@ -0,0 +1,13 @@
# 查询
POST {{host}}/api/team-log/list
Content-Type: application/json
Accept: application/json
{
"page": 1,
"pageSize": 20,
"teamIds": [10358],
"type": "CHANGE_TEAM_OWNER"
}
###

12
orgmanax-common/pom.xml
View File

@ -28,6 +28,18 @@
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
</dependency>
<dependency>
<groupId>cn.axzo.orgmanax</groupId>
<artifactId>orgmanax-dto</artifactId>
</dependency>
<dependency>
<groupId>org.glassfish</groupId>
<artifactId>javax.el</artifactId>
</dependency>
<dependency>
<groupId>org.glassfish</groupId>
<artifactId>jakarta.el</artifactId>
</dependency>
</dependencies>
</project>

90
orgmanax-common/src/main/java/cn/axzo/orgmanax/common/ValidationUtil.java Normal file
View File

@ -0,0 +1,90 @@
package cn.axzo.orgmanax.common;
import cn.axzo.foundation.exception.Axssert;
import cn.axzo.orgmanax.common.config.BizResultCode;
import cn.axzo.orgmanax.dto.cooperateship.dto.OrgCooperateShipDTO;
import cn.hutool.extra.validation.BeanValidationResult;
import org.hibernate.validator.HibernateValidator;
import org.hibernate.validator.PredefinedScopeHibernateValidator;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import javax.validation.ValidatorFactory;
import java.util.Set;
/**
* @Author: LiuYang
* @Date: 2024/2/1 14:13
*/
public class ValidationUtil {
/**
* 默认{@link Validator} 对象
*/
private static final Validator validator;
static {
try(ValidatorFactory factory = Validation.buildDefaultValidatorFactory()){
validator = factory.getValidator();
}
}
/**
* 校验对象
*
* @param <T> Bean类型
* @param bean bean
* @param groups 校验组
* @return {@link Set}
*/
public static <T> Set<ConstraintViolation<T>> validate(T bean, Class<?>... groups) {
return validator.validate(bean, groups);
}
/**
* 校验对象
*
* @param <T> Bean类型
* @param bean bean
* @param groups 校验组
* @return {@link BeanValidationResult}
*/
public static <T> BeanValidationResult warpValidate(T bean, Class<?>... groups) {
return warpBeanValidationResult(validate(bean, groups));
}
/**
* 校验对象, 抛出异常
*
* @param <T> Bean类型
* @param bean bean
* @param groups 校验组
* @return {@link Set}
*/
public static <T> void warpValidateThrowError(T bean, Class<?>... groups) {
BeanValidationResult validationResult = warpValidate(bean, groups);
Axssert.check(validationResult.isSuccess(), BizResultCode.INVALID_PARAM,
validationResult.getErrorMessages().stream().map(BeanValidationResult.ErrorMessage::getMessage).findFirst().orElse(""));
}
/**
* 包装校验结果
*
* @param constraintViolations 校验结果集
* @return {@link BeanValidationResult}
*/
private static <T> BeanValidationResult warpBeanValidationResult(Set<ConstraintViolation<T>> constraintViolations) {
BeanValidationResult result = new BeanValidationResult(constraintViolations.isEmpty());
for (ConstraintViolation<T> constraintViolation : constraintViolations) {
BeanValidationResult.ErrorMessage errorMessage = new BeanValidationResult.ErrorMessage();
errorMessage.setPropertyName(constraintViolation.getPropertyPath().toString());
errorMessage.setMessage(constraintViolation.getMessage());
errorMessage.setValue(constraintViolation.getInvalidValue());
result.addErrorMessage(errorMessage);
}
return result;
}
}

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

@ -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"),

8
orgmanax-dto/pom.xml
View File

@ -42,6 +42,14 @@
<groupId>cn.axzo.trade</groupId>
<artifactId>trade-data-security-core</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
</dependency>
<dependency>
<groupId>cn.axzo.foundation</groupId>
<artifactId>event-support-lib</artifactId>
</dependency>
</dependencies>
</project>

2
orgmanax-common/src/main/java/cn/axzo/orgmanax/common/model/IBaseTree.java → orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/common/IBaseTree.java
View File

@ -1,4 +1,4 @@
package cn.axzo.orgmanax.common.model;
package cn.axzo.orgmanax.dto.common;
import java.util.List;

30
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/profile/enums/IdentityType.java → orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/common/IdentityType.java
View File

@ -1,7 +1,5 @@
package cn.axzo.orgmanax.infra.client.profile.enums;
package cn.axzo.orgmanax.dto.common;
import cn.axzo.orgmanax.infra.client.profile.dto.model.CodeDefinition;
import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonValue;
import lombok.AllArgsConstructor;
import lombok.Getter;
@ -14,7 +12,7 @@ import lombok.Getter;
*/
@Getter
@AllArgsConstructor
public enum IdentityType implements IEnum, CodeDefinition<Integer> {
public enum IdentityType {
/*人员身份类型*/
NOT_SUPPORT(0, "NOT_SUPPORT", "无效类型"),
@ -24,9 +22,29 @@ public enum IdentityType implements IEnum, CodeDefinition<Integer> {
REGULATOR(4, "REGULATOR", "监管人员"),
OPERATOR(5, "OPERATOR", "运营人员"),
;
@EnumValue
@JsonValue
private final Integer code;
private final String message;
private final String desc;
}
public static IdentityType getIdentityType(Integer code) {
IdentityType[] values = values();
for (IdentityType item : values) {
if (item.getCode().equals(code)) {
return item;
}
}
return null;
}
public static IdentityType getIdentityType(String message) {
IdentityType[] values = values();
for (IdentityType item : values) {
if (item.getMessage().equals(message)) {
return item;
}
}
return null;
}
}

19
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/common/RoleBriefDTO.java Normal file
View File

@ -0,0 +1,19 @@
package cn.axzo.orgmanax.dto.common;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Data
public class RoleBriefDTO implements Serializable {
private Long roleId;
private String roleCode;
private String name;
private String roleType;
}

8
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/common/WorkspaceOuPair.java
View File

@ -11,6 +11,14 @@ import lombok.experimental.SuperBuilder;
@Data
@SuperBuilder
public class WorkspaceOuPair {
/**
* 项目ID
*/
private Long workspaceId;
/**
* 组织单位ID
*/
private Long ouId;
}

36
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/common/util/NumberUtil.java Normal file
View File

@ -0,0 +1,36 @@
package cn.axzo.orgmanax.dto.common.util;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
* @author cn
* @version 1.0
* @description
* @date 2022/6/18 15:55
*/
@NoArgsConstructor(access = AccessLevel.PRIVATE)
@Slf4j
public class NumberUtil {
public static boolean isPositiveNumber(Number number) {
return number != null && number.floatValue() > 0;
}
public static boolean isNotPositiveNumber(Number number) {
return !isPositiveNumber(number);
}
public static Integer appVersionParse(String appVersion) {
log.info("app version parse :{}",appVersion);
try {
appVersion = appVersion.split("-")[0];
return cn.hutool.core.util.NumberUtil.parseInt(appVersion.replace("v", "")
.replace("V", "")
.replace(".", ""));
} catch (Exception e) {
return 0;
}
}
}

56
orgmanax-common/src/main/java/cn/axzo/orgmanax/common/util/TreeUtil.java → orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/common/util/TreeUtil.java
View File

@ -1,6 +1,5 @@
package cn.axzo.orgmanax.common.util;
import cn.axzo.orgmanax.common.model.IBaseTree;
package cn.axzo.orgmanax.dto.common.util;
import cn.axzo.orgmanax.dto.common.IBaseTree;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.lang.Pair;
@ -243,4 +242,55 @@ public class TreeUtil {
return rootList;
}
public static <T extends IBaseTree<T, O>, O> List<T> buildTree(List<T> treeList, Comparator<T> comparator) {
if (org.springframework.util.CollectionUtils.isEmpty(treeList)) {
return treeList;
}
Set<O> codes = treeList.stream().map(IBaseTree::getNodeCode).collect(Collectors.toSet());
List<T> rootList = treeList.stream().filter(e -> !codes.contains(e.getParentNodeCode()))
.sorted(comparator)
.collect(Collectors.toList());
List<T> children = treeList.stream().filter(e -> codes.contains(e.getParentNodeCode()))
.collect(Collectors.toList());
for (T t : rootList) {
t.setNodeChildren(buildTree(children, t.getNodeCode(), comparator));
}
return rootList;
}
public static <T extends IBaseTree<T, O>, O> List<T> buildTree(List<T> treeList, O rootCode, Comparator<T> comparator) {
if (org.springframework.util.CollectionUtils.isEmpty(treeList)) {
return treeList;
}
//root级树
List<T> rootList = treeList.stream()
.sorted(comparator)
.filter(e -> Objects.equals(e.getParentNodeCode(), rootCode))
.collect(Collectors.toList());
List<T> childrenList = treeList.stream()
.filter(e -> !Objects.equals(e.getParentNodeCode(), rootCode))
.collect(Collectors.toList());
if (org.springframework.util.CollectionUtils.isEmpty(childrenList)) {
return org.springframework.util.CollectionUtils.isEmpty(rootList) ? null : rootList;
}
for (T t : rootList) {
t.setNodeChildren(buildTree(childrenList, t.getNodeCode(), comparator));
}
return org.springframework.util.CollectionUtils.isEmpty(rootList) ? null : rootList;
}
public static <T extends IBaseTree<T, O>, O> void traverseLeafNodes(List<T> treeList, Consumer<T> consumer) {
if (CollUtil.isEmpty(treeList)) {
return;
}
for (T t : treeList) {
if (CollUtil.isEmpty(t.getNodeChildren())) {
consumer.accept(t);
} else {
traverseLeafNodes(t.getNodeChildren(), consumer);
}
}
}
}

2
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/dto/OrgCooperateShipDTO.java
View File

@ -7,6 +7,7 @@ import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.util.Date;
@ -19,6 +20,7 @@ public class OrgCooperateShipDTO implements Serializable {
/**
* 主健
*/
@NotNull
private Long id;
/**

2
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/enums/CooperateShipStatusEnum.java
View File

@ -9,7 +9,7 @@ import lombok.Getter;
public enum CooperateShipStatusEnum {
PRESENT(1, "在场"),
LEFT(2, "离场");
LEFT(0, "离场");
private final Integer code;
private final String desc;

86
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/enums/CooperateShipTypeEnum.java
View File

@ -1,11 +1,16 @@
package cn.axzo.orgmanax.dto.cooperateship.enums;
import lombok.AccessLevel;
import cn.axzo.orgmanax.dto.node.enums.NodeTypeEnum;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import lombok.AllArgsConstructor;
import lombok.Getter;
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
@AllArgsConstructor
public enum CooperateShipTypeEnum {
PROJ_PRIMARY_CONTRACTING_UNIT(1, "施工总承包"),
@ -25,4 +30,81 @@ public enum CooperateShipTypeEnum {
private final Integer code;
private final String desc;
private static final Map<Integer, CooperateShipTypeEnum> mapping = new HashMap<>();
static {
Arrays.stream(CooperateShipTypeEnum.values()).forEach(t -> mapping.put(t.getCode(), t));
}
public static CooperateShipTypeEnum getByCode(Integer code) {
return mapping.get(code);
}
/** 班组类型关系：企业/项目内班组 **/
public boolean isTeam() {
return this == ENT_TEAM || this == PROJ_TEAM;
}
/** 小组类型关系：企业/项目内小组 **/
public boolean isGroup() {
return this == ENT_GROUP || this == PROJ_GROUP;
}
public static List<CooperateShipTypeEnum> getEntEnum() {
return Arrays.asList(
ENT_COMMON
,PROJ_PRIMARY_CONTRACTING_UNIT
,PROJ_CONSTRUCTION_UNIT
,PROJ_SUPERVISION_UNIT
,PROJ_LABOR_SUBCONTRACTING
,PROJ_PROFESSIONAL_SUBCONTRACTING
,SURVEY_UNIT
,DESIGN_UNIT
,OTHER);
}
public static List<Integer> getEntEnumCode() {
return Arrays.asList(
ENT_COMMON.getCode()
,PROJ_PRIMARY_CONTRACTING_UNIT.getCode()
,PROJ_CONSTRUCTION_UNIT.getCode()
,PROJ_SUPERVISION_UNIT.getCode()
,PROJ_LABOR_SUBCONTRACTING.getCode()
,PROJ_PROFESSIONAL_SUBCONTRACTING.getCode()
,SURVEY_UNIT.getCode()
,DESIGN_UNIT.getCode()
,OTHER.getCode());
}
public static Integer convertNodeTypeToCooperateType(Integer nodeType) {
if (Objects.equals(nodeType, NodeTypeEnum.PROJECT_TEAM.getValue())) {
return PROJ_TEAM.getCode();
}
if (Objects.equals(nodeType, NodeTypeEnum.PROJECT_GROUP.getValue())) {
return PROJ_GROUP.getCode();
}
return null;
}
public boolean is(Integer code) {
return this.code.equals(code);
}
public boolean isInScopeAsNode(Integer cooperateType) {
CooperateShipTypeEnum typeByeCode = getByCode(cooperateType);
if (typeByeCode == null) {
throw new RuntimeException("Unknown cooperate type: " + cooperateType);
}
return isInScopeAsNode(typeByeCode);
}
public boolean isInScopeAsNode(CooperateShipTypeEnum type) {
if (this == type) {
return true;
}
if (this == CooperateShipTypeEnum.PROJ_TEAM) {
return type == CooperateShipTypeEnum.PROJ_GROUP;
}
return false;
}
}

110
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/enums/SaasCooperateShipCooperateTypeEnum.java
View File

@ -1,110 +0,0 @@
package cn.axzo.orgmanax.dto.cooperateship.enums;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import lombok.Getter;
@Getter
public enum SaasCooperateShipCooperateTypeEnum {
PROJ_PRIMARY_CONTRACTING_UNIT(1, "施工总承包"),
PROJ_CONSTRUCTION_UNIT(2, "建设单位"),
PROJ_SUPERVISION_UNIT(3, "监理单位"),
PROJ_LABOR_SUBCONTRACTING(4, "劳务分包"),
PROJ_PROFESSIONAL_SUBCONTRACTING(5, "专业承包"),
OMS(6, "OMS"),
ENT_COMMON(7, "企业通用"),
ENT_TEAM(8, "企业内班组"),
PROJ_TEAM(9,"项目内班组"),
ENT_GROUP(10, "企业内小组"),
PROJ_GROUP(11, "项目内小组"),
SURVEY_UNIT(12, "地勘单位"),
DESIGN_UNIT(13, "设计单位"),
OTHER(30,"其他")
;
private static final Map<Integer, SaasCooperateShipCooperateTypeEnum> mapping = new HashMap<>();
static {
Arrays.stream(SaasCooperateShipCooperateTypeEnum.values()).forEach(t -> mapping.put(t.getCode(), t));
}
public final Integer code;
public final String desc;
SaasCooperateShipCooperateTypeEnum(Integer code, String desc) {
this.code = code;
this.desc = desc;
}
public static SaasCooperateShipCooperateTypeEnum getByCode(Integer code) {
return mapping.get(code);
}
/** 班组类型关系：企业/项目内班组 **/
public boolean isTeam() {
return this == ENT_TEAM || this == PROJ_TEAM;
}
/** 小组类型关系：企业/项目内小组 **/
public boolean isGroup() {
return this == ENT_GROUP || this == PROJ_GROUP;
}
public static List<SaasCooperateShipCooperateTypeEnum> getEntEnum() {
return Arrays.asList(
ENT_COMMON
,PROJ_PRIMARY_CONTRACTING_UNIT
,PROJ_CONSTRUCTION_UNIT
,PROJ_SUPERVISION_UNIT
,PROJ_LABOR_SUBCONTRACTING
,PROJ_PROFESSIONAL_SUBCONTRACTING
,SURVEY_UNIT
,DESIGN_UNIT
,OTHER);
}
public static List<Integer> getEntEnumCode() {
return Arrays.asList(
ENT_COMMON.getCode()
,PROJ_PRIMARY_CONTRACTING_UNIT.getCode()
,PROJ_CONSTRUCTION_UNIT.getCode()
,PROJ_SUPERVISION_UNIT.getCode()
,PROJ_LABOR_SUBCONTRACTING.getCode()
,PROJ_PROFESSIONAL_SUBCONTRACTING.getCode()
,SURVEY_UNIT.getCode()
,DESIGN_UNIT.getCode()
,OTHER.getCode());
}
public static Integer convertNodeTypeToCooperateType(Integer nodeType) {
if (Objects.equals(nodeType, OrganizationalNodeTypeEnum.PROJECT_TEAM.getValue())) {
return PROJ_TEAM.getCode();
}
if (Objects.equals(nodeType, OrganizationalNodeTypeEnum.PROJECT_GROUP.getValue())) {
return PROJ_GROUP.getCode();
}
return null;
}
public boolean is(Integer code) {
return this.code.equals(code);
}
public boolean isInScopeAsNode(Integer cooperateType) {
SaasCooperateShipCooperateTypeEnum typeByeCode = getByCode(cooperateType);
if (typeByeCode == null)
throw new RuntimeException("Unknown cooperate type: " + cooperateType);
return isInScopeAsNode(typeByeCode);
}
public boolean isInScopeAsNode(SaasCooperateShipCooperateTypeEnum type) {
if (this == type)
return true;
if (this == SaasCooperateShipCooperateTypeEnum.PROJ_TEAM)
return type == SaasCooperateShipCooperateTypeEnum.PROJ_GROUP;
return false;
}
}

10
orgmanax-server/src/main/java/cn/axzo/orgmanax/server/cooperateship/event/inner/payload/CoopeateShipUpsertedPayload.java → orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/event/CoopeateShipUpsertedPayload.java
View File

@ -1,7 +1,7 @@
package cn.axzo.orgmanax.server.cooperateship.event.inner.payload;
package cn.axzo.orgmanax.dto.cooperateship.event;
import cn.axzo.foundation.event.support.AbstractDiffablePayload;
import cn.axzo.orgmanax.infra.dao.cooperateship.entity.SaasCooperateShip;
import cn.axzo.orgmanax.dto.cooperateship.dto.OrgCooperateShipDTO;
import com.alibaba.fastjson.JSONObject;
import lombok.AllArgsConstructor;
import lombok.Builder;
@ -12,8 +12,8 @@ import lombok.NoArgsConstructor;
@AllArgsConstructor
@Data
@Builder
public class CoopeateShipUpsertedPayload extends AbstractDiffablePayload<SaasCooperateShip> {
private SaasCooperateShip oldValue;
private SaasCooperateShip newValue;
public class CoopeateShipUpsertedPayload extends AbstractDiffablePayload<OrgCooperateShipDTO> {
private OrgCooperateShipDTO oldValue;
private OrgCooperateShipDTO newValue;
private JSONObject ext;
}

44
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/req/CreateOrgCooperateShipReq.java Normal file
View File

@ -0,0 +1,44 @@
package cn.axzo.orgmanax.dto.cooperateship.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@NoArgsConstructor
@AllArgsConstructor
@Data
@Builder
public class CreateOrgCooperateShipReq {
/**
* 工作台ID
*/
private Long workspaceId;
/**
* 组织节点ID
*/
private Long organizationalNodeId;
/**
* 上级节点（非顶级节点时必填）
*/
private Long parentId;
/**
* 协同关系类型
*/
private Integer cooperateType;
/**
* 协作关系
*/
private Integer partnerShip;
/**
* 操作人
*/
private Long operatorId;
}

29
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/req/ListOrgCooperateShipReq.java
View File

@ -1,5 +1,6 @@
package cn.axzo.orgmanax.dto.cooperateship.req;
import cn.hutool.core.collection.CollUtil;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
@ -7,6 +8,7 @@ import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.Collections;
import java.util.List;
import java.util.Set;
@NoArgsConstructor
@ -66,22 +68,33 @@ public class ListOrgCooperateShipReq {
private Set<Integer> partnerShips = Collections.emptySet();
/**
* 在场状态集合
* 在场状态集合, 默认为在场
*/
@Builder.Default
private Set<Integer> statuses = Collections.emptySet();
private Set<Integer> statuses = CollUtil.newHashSet(1);
/**
* 需要过滤的personId
* personId
* 根据人员进行节点过滤
*/
private Long filterPersonId;
private Long filterByPersonId;
/**
* 当personId有值时，为必填项
* 1只过滤当前节点数据 2过滤当前节点及以下数据
* 当filterByPersonId有值时，为必填项, 默认为1
* 值说明：1只过滤当前节点数据 2过滤当前节点及以下数据
*/
private Integer filterPersonType;
@Builder.Default
private Integer filterMethod = 1;
/**
* 根据岗位排除进行过滤
*/
private List<String> filterByJobCodeExclusion;
/**
* 过滤人员状态集合
*/
@Builder.Default
private Boolean filterIncludeExitPerson = false;
/**
* 是否包含祖先节点

31
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/req/UpdateOrgCooperateShipReq.java Normal file
View File

@ -0,0 +1,31 @@
package cn.axzo.orgmanax.dto.cooperateship.req;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;
@NoArgsConstructor
@AllArgsConstructor
@Data
@Builder
public class UpdateOrgCooperateShipReq {
/**
* 协同关系ID
*/
private Long id;
/**
* 状态 1-在场，0-退场
*/
private Integer status;
/**
* 退场时间
*/
private Date resignAt;
}

98
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/dto/OrgWorkerInviteDTO.java Normal file
View File

@ -0,0 +1,98 @@
package cn.axzo.orgmanax.dto.invite.dto;
import java.util.Date;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @Author zhangran
* @Date 2022/6/17 17:16
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OrgWorkerInviteDTO {
/**
* 邀请记录ID
*/
private Long id;
/**
* 班组id
*/
private Long unitId;
/**
* 班组名称
*/
private String unitName;
/**
* 工人id
*/
private Long identityId;
/**
* 工人名称
*/
private String workerName;
/**
* 工人头像地址
*/
private String workerFaceUrl;
/**
* 基础消息id
*/
private Long msgId;
/**
* 通过消息id
*/
private Long msgSucId;
/**
* 项目通过二维码邀请id
*/
private Long projectWorkerInviteId;
/**
* 状态：1-未处理；2-同意；3-拒绝；4-撤回
*/
private Integer status;
/**
* 1.工人申请 2.班组邀请 3.项目申请 4.工人申请离开
*/
private Integer type;
/**
* 邀请记录中的工人工种列表
*/
List<WorkerInviteProfessionDTO> professions;
/**
* 项目内班组id
*/
private Long projectTeamId;
/**
* 其它备注信息 json
*/
private String ext;
/**
* 岗位id
*/
private Long jobId;
/**
* 创建时间
*/
private Date createAt;
/**
* 更新时间
*/
private Date updateAt;
// /**
// * 工种和技能标签
// */
// private List<OrganizationalWorkerInviteProfessionVO> workerInviteProfessions;
}

36
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/dto/WorkerInviteProfessionDTO.java Normal file
View File

@ -0,0 +1,36 @@
package cn.axzo.orgmanax.dto.invite.dto;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 工人邀请记录-工人工种
*
* @author zhangtianyu
* @date 2023/1/29 3:36 PM
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class WorkerInviteProfessionDTO {
/**
* 工种id
*/
private Long professionId;
/**
* 工种名称
*/
private String professionName;
/**
* 技能标签列表-树形结构
*/
private List<WorkerInviteSkillTagDTO> skillTags;
/**
* 技能标签列表-平铺结构
*/
private List<WorkerInviteSkillTagDTO> expandedSkillTags;
}

40
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/dto/WorkerInviteSkillTagDTO.java Normal file
View File

@ -0,0 +1,40 @@
package cn.axzo.orgmanax.dto.invite.dto;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 工人邀请记录-技能标签
* @author zhangtianyu
* @date 2023/1/29 3:36 PM
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class WorkerInviteSkillTagDTO {
/**
* 所属工种id
*/
private Long professionId;
/**
* 父技能标签code
*/
private String parentSkillTagCode;
/**
* 技能标签code
*/
private String skillTagCode;
/**
* 技能标签名称
*/
private String skillTagName;
/**
* 子技能标签列表
*/
private List<WorkerInviteSkillTagDTO> childSkillTags;
}

31
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/enums/TeamWorkerInviteStatusEnum.java Normal file
View File

@ -0,0 +1,31 @@
package cn.axzo.orgmanax.dto.invite.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author syl
* @date 2024/12/19
*/
@Getter
@AllArgsConstructor
public enum TeamWorkerInviteStatusEnum {
/**
* 邀请状态
*/
UNTREATED(1, "未处理"),
AGREE(2, "同意"),
REFUSE(3, "拒绝"),
WITHDRAW(4, "撤回"),
ABORT(5, "终止"),
;
public final int value;
public final String desc;
}

38
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/enums/WorkerInviteType.java Normal file
View File

@ -0,0 +1,38 @@
package cn.axzo.orgmanax.dto.invite.enums;
import java.util.Arrays;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @author syl
* @date 2024/12/17
*/
@Getter
@AllArgsConstructor
public enum WorkerInviteType {
/**
* 工人加入班组
*/
WORKER_JOIN_TEAM(1, "工人加入班组"),
/**
* 工人离开班组
*/
WORKER_LEAVE_TEAM(2, "工人离开班组"),
/**
* 工人离开项目部
*/
WORKER_LEAVE_WORKSPACE(3, "工人离开项目部"),
;
private final Integer code;
private final String desc;
public static WorkerInviteType getByCode(Integer code) {
return Arrays.stream(values()).filter(it -> it.getCode().equals(code))
.findFirst()
.orElse(null);
}
}

24
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/project/req/CancelProjectWorkerInviteReq.java Normal file
View File

@ -0,0 +1,24 @@
package cn.axzo.orgmanax.dto.invite.project.req;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author syl
* @date 2024/12/19
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class CancelProjectWorkerInviteReq {
/**
* 邀请记录id
*/
@NotNull(message = "邀请记录id不能为空")
private Long inviteId;
}

46
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/project/req/PageProjectWorkerInviteReq.java Normal file
View File

@ -0,0 +1,46 @@
package cn.axzo.orgmanax.dto.invite.project.req;
import cn.axzo.foundation.page.PageReqV2;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author syl
* @date 2024/12/19
*/
@EqualsAndHashCode(callSuper = true)
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class PageProjectWorkerInviteReq extends PageReqV2 {
/**
* 流程实例id
*/
private String processInstanceId;
/**
* 项目部id
*/
private Long workspaceId;
/**
* 项目班组ID
*/
private Long projectTeamId;
/**
* 工人身份ID
*/
private Long workerIdentityId;
/**
* 邀请记录ID列表
*/
private Set<Long> inviteIds;
}

29
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/project/req/UpdateProjectWorkerInviteReq.java Normal file
View File

@ -0,0 +1,29 @@
package cn.axzo.orgmanax.dto.invite.project.req;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author syl
* @date 2024/12/19
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class UpdateProjectWorkerInviteReq {
/**
* 邀请记录id
*/
@NotNull(message = "邀请记录id不能为空")
private Long inviteId;
/**
* 状态
*/
private Integer status;
}

85
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/project/resp/OrgProjectWorkerInviteResp.java Normal file
View File

@ -0,0 +1,85 @@
package cn.axzo.orgmanax.dto.invite.project.resp;
import java.util.Date;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author 夏嘉孚
* @since 2023/2/10
*/
@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class OrgProjectWorkerInviteResp {
/**
* 邀请id 同下inviteId
*/
private Long id;
/**
* 1-待班组审批 2-待项目审批 3-审批通过，已加入项目
*/
private Integer status;
/**
* 邀请id
*/
private Long inviteId;
/**
* 工人身份ID
*/
private Long workerIdentityId;
/**
* 项目id
*/
private Long workspaceId;
/**
* 总包ID
*/
private Long entId;
/**
* 所属单位ID
*/
private Long organizationalUnitId;
/**
* 项目内班组id
*/
private Long projectTeamId;
/**
* 班组长姓名
*/
private String teamOwnerName;
/**
* 更新时间
*/
private Date updateAt;
/**
* 审批人的从业人员身份id
*/
private Long approverIdentityId;
/**
* 班组长审批时间,REQ-598
*/
private Date teamLeaderAuditDate;
/**
* 经营范围
*/
private List<String> teamCategory;
/**
* 工人工种
*/
private List<String> profession;
/**
* 流程实例id
*/
private String processInstanceId;
private String contextJsonStr;
}

68
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/ApplyOrgTeamInviteReq.java Normal file
View File

@ -0,0 +1,68 @@
package cn.axzo.orgmanax.dto.invite.req;
import cn.axzo.orgmanax.dto.project.team.dto.TeamCategoryAggregateDTO;
import java.util.List;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* 班组扫码申请进入项目 REQ
*/
@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class ApplyOrgTeamInviteReq {
/**
* 工作台ID
*/
@NotNull(message = "工作台不能为空")
private Long workspaceId;
/**
* 平台班组ID
*/
@NotNull(message = "班组不能为空")
private Long teamId;
/**
* 平台班组长身份ID
*/
private Long teamLeaderId;
/**
* 所属单位
*/
@NotNull(message = "所属单位不能为空")
private Long ouId;
/**
* 所属单位类型
*/
@NotNull(message = "所属单位类型不能为空")
private Integer ouType;
/**
* 经营范围
*/
@NotEmpty(message = "经营范围不能为空")
private List<TeamCategoryAggregateDTO> categories;
/**
* 申请操作路径 1-链接-LINK 2-二维码-QRCODE
*/
@NotNull(message = "操作路径不能为空")
@Max(2)
@Min(1)
private Integer route;
/**
* 备注
*/
@Size(max = 100)
private String applyNote;
}

24
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/ApproveOrgTeamInviteReq.java Normal file
View File

@ -0,0 +1,24 @@
package cn.axzo.orgmanax.dto.invite.req;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 审批 班组扫码申请进入项目 REQ
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ApproveOrgTeamInviteReq {
/**
* 邀请记录ID
*/
@NotNull(message = "邀请记录ID不能为空")
private Long inviteId;
}

62
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/ApproveOrgWorkerInviteReq.java Normal file
View File

@ -0,0 +1,62 @@
package cn.axzo.orgmanax.dto.invite.req;
import java.util.List;
import java.util.Set;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @ClassName OrganizationalWorkTeamInviteDeleteVO
* @Author zhangran
* @Date 2023/3/4 15:14
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class ApproveOrgWorkerInviteReq {
/**
* 邀请记录状态
* @see TeamWorkerInviteStatusEnum
*/
@NotNull(message = "inviteStatus can not null")
private Integer inviteStatus;
/**
* 班组id
*/
@NotNull(message = "班组不能为空")
private Long unitId;
/**
* 工人id
*/
private List<Long> identityIds;
/**
* 组织架构人员id
*/
private Long nodeUserId;
/**
* 项目内的班组id
*/
private Long projectTeamId;
/**
* 邀请记录ID 列表
*/
private Set<Long> inviteIds;
/**
* 项目内邀请id
*/
private List<Long> projectWorkerInviteIds;
/**
* 平台班组id
*/
private Long platTeamId;
}

34
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/CountTeamWorkerInviteReq.java Normal file
View File

@ -0,0 +1,34 @@
package cn.axzo.orgmanax.dto.invite.req;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @Author zhangran
* @Date 2022/6/17 17:26
**/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CountTeamWorkerInviteReq {
/**
* 班组id
*/
private Long unitId;
/**
* 1.工人申请 2.班组邀请 3.项目申请 4.离开班组
*/
private List<Integer> types;
/**
* 状态：1-未处理；2-同意；3-拒绝；4-撤回
*/
private List<Integer> statuses;
}

116
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/InviteBatchOrgProjectTeamReq.java Normal file
View File

@ -0,0 +1,116 @@
package cn.axzo.orgmanax.dto.invite.req;
import java.util.ArrayList;
import java.util.List;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class InviteBatchOrgProjectTeamReq {
/**
* 邀请类型，0：班组，1：小组
* */
@NotNull(message = "添加类型不能为空")
private Integer type;
/**
* 班组或小组的NodeId
* */
@NotNull(message = "nodeId不能为空")
private Long organizationNodeId;
/**
* 项目Id
* */
@NotNull(message = "项目信息不能为空")
private Long workspaceId;
/**
* 工人工种
*/
private List<ProfessionDTO> platWorkerProfessions;
/**
* 工人身份id列表
*/
@NotNull(message = "工人列表不能为空")
private List<Long> personIds;
@NotNull(message = "操作人不能为空")
private Long operatorId;
/**
* 发起人的personId
* */
private Long initiatorPersonId;
/**
* 工种
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public static class ProfessionDTO {
/**
* 工种id
*/
private Long professionId;
/**
* 工种名称
*/
private String professionName;
/**
* 技能标签 1：普工 2：技工
*/
private Integer skillType;
/**
* 技能标签列表-平铺结构
*/
//private List<T> expandedSkillTags;
/**
* 技能标签列表-树形结构
*/
private List<SkillTagDTO> skillTags = new ArrayList<>();
}
/**
* 技能标签
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public static class SkillTagDTO {
/**
* 所属工种id
*/
private Long professionId;
/**
* 父级技能标签id
*/
private String parentSkillTagCode;
/**
* 技能标签code
*/
private String skillTagCode;
/**
* 技能标签名称
*/
private String skillTagName;
/**
* 子技能标签列表
*/
private List<SkillTagDTO> skillTags;
}
}

38
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/LeaveOrgWorkerTeamReq.java Normal file
View File

@ -0,0 +1,38 @@
package cn.axzo.orgmanax.dto.invite.req;
import java.util.List;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @ClassName OrganizationalWorkerLeaveTeamVO
* @Description 工人离开班组
* @Author zhangran
* @Date 2022/6/20 15:38
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class LeaveOrgWorkerTeamReq {
/**
* 身份id
*/
@NotNull
private Long identityId;
/**
* 班组id
*/
@NotNull
private List<Long> unitIds;
/**
* 工种和技能标签
*/
private List<OrgWorkerInviteProfessionReq> workerInviteProfessions;
}

49
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/OperateOrgWorkerInviteReq.java Normal file
View File

@ -0,0 +1,49 @@
package cn.axzo.orgmanax.dto.invite.req;
import cn.axzo.orgmanax.dto.invite.enums.WorkerInviteType;
import java.util.List;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @Description 班组同意或者拒绝
* @Author zhangran
* @Date 2022/6/17 18:04
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OperateOrgWorkerInviteReq {
/**
* 班组id
*/
private Long unitId;
/**
* 邀请id
*/
@NotNull(message = "请选择工人")
private List<Long> inviteIds;
/**
* Boolean.TRUE 同意 Boolean.FALSE 拒绝
*/
@NotNull(message = "请选择审批类型")
private Boolean flagType;
/**
* 操作人personId
*/
private Long operatorPersonId;
/**
* 操作类型
* @see WorkerInviteType
*/
@NotNull(message = "type can not null")
private WorkerInviteType type;
}

66
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/OrgWorkerInviteProfessionReq.java Normal file
View File

@ -0,0 +1,66 @@
package cn.axzo.orgmanax.dto.invite.req;
import java.util.List;
import javax.validation.Valid;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @ClassName OrganizationalWorkerInviteProfessionVO
* @Author zhongjie
* @Date 2023/01/29 17:20
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OrgWorkerInviteProfessionReq {
/**
* 工种id
*/
@NotNull(message = "工种id不能为空")
private Long professionId;
/**
* 工种名称
*/
@NotEmpty(message = "工种名称不能为空")
private String professionName;
/**
* 工种code
*/
private String professionCode;
/**
* 技能标签
*/
@Valid
private List<WorkerSkillTag> skillTags;
@Data
public static class WorkerSkillTag {
/**
* 父节点技能标签Code第一级就不传
*/
private String parentSkillTagCode;
/**
* 技能标签名称
*/
@NotEmpty(message = "技能标签名称不能为空")
private String skillTagName;
/**
* 技能标签code
*/
private String skillTagCode;
}
}

46
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/PageOrgTeamWorkerInviteReq.java Normal file
View File

@ -0,0 +1,46 @@
package cn.axzo.orgmanax.dto.invite.req;
import cn.axzo.foundation.page.PageReqV2;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @Author zhangran
* @Date 2022/6/17 17:26
* @Desc 班组申请实体
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class PageOrgTeamWorkerInviteReq extends PageReqV2 {
/**
* 班组id
*/
private Long unitId;
/**
* 1.工人申请 2.班组邀请 3.项目申请 4.离开班组
*/
private List<Integer> types;
/**
* 状态：1-未处理；2-同意；3-拒绝；4-撤回
*/
private List<Integer> statuses;
/**
* 工人身份id
*/
private Long identityId;
// /**
// * 是否返回历史数据
// * 现有逻辑改造为true 时 statuses新增值 2-同意；3-拒绝
// */
// private Boolean flagHistory;
}

90
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/SaveOrgWorkerInviteReq.java Normal file
View File

@ -0,0 +1,90 @@
package cn.axzo.orgmanax.dto.invite.req;
import java.util.List;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @Description 班组同意或者拒绝
* @Author zhangran
* @Date 2022/6/17 18:04
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class SaveOrgWorkerInviteReq {
/**
* 1-工人申请 2-班组邀请
*/
@NotNull(message = "邀请类型不能为空")
private Integer teamWorkerInviteType;
/**
* 班组id
*/
@NotNull(message = "班组不能为空")
private Long unitId;
/**
* 工人身份id
*/
@NotNull(message = "请选择工人")
private Long identityId;
/**
* Boolean.TRUE 同意 Boolean.FALSE 拒绝
*/
@NotNull(message = "工人姓名")
private String workerName;
@NotNull(message = "工人姓名")
private String workerFaceUrl;
/**
* 平台班组部门nodeId
*/
// @NotNull
// @Min(value = 1)
// todo @yh 这里厍这个节点做什么？没有查到有使用的地方，然后pluto调用方也没有没加这个参数
Long organizationalNodeId;
/**
* 项目内班组邀请id
*/
private Long projectInviteId;
/**
* 工种和技能标签
*/
@Valid
//@NotNull(message = "工种不能为空")
//@Size(min = 1, message = "请至少选择一个工种")
private List<OrgWorkerInviteProfessionReq> workerInviteProfessions;
/**
* 项目内班组id
*/
private Long projectTeamId;
/**
* 其它备注信息
*/
private String ext;
private Integer quitWorkerStatus;
/**
* 岗位id
*/
private Long jobId;
/**
* 操作人id todo 实现待定
*/
private Long operatorId;
}

31
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/req/UpdateOrgWorkerInviteReq.java Normal file
View File

@ -0,0 +1,31 @@
package cn.axzo.orgmanax.dto.invite.req;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @Author zr
* @Date 2024/3/2 17:25
* @Description
**/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class UpdateOrgWorkerInviteReq {
/**
* 邀请id
*/
@NotNull(message = "邀请id不能为空")
private Long inviteId;
/**
* 项目内的邀请id
*/
@NotNull(message = "项目内的邀请id不能为空")
private Long projectWorkerInviteId;
}

27
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/invite/resp/CountTeamWorkerInviteResp.java Normal file
View File

@ -0,0 +1,27 @@
package cn.axzo.orgmanax.dto.invite.resp;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @author syl
* @date 2024/12/17
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CountTeamWorkerInviteResp {
/**
* 1.工人申请 2.班组邀请 3.项目申请 4.离开班组
*/
private Integer type;
/**
* 数量
*/
private Integer count;
}

85
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/job/dto/JobGroupDTO.java Normal file
View File

@ -0,0 +1,85 @@
package cn.axzo.orgmanax.dto.job.dto;
import cn.axzo.orgmanax.dto.common.IBaseTree;
import java.io.Serializable;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
public class JobGroupDTO implements Serializable, IBaseTree<JobGroupDTO, Long> {
/**
* 分组名
*/
private String name;
/**
* 分组code
*/
private String code;
/**
* 分组id
*/
private Long groupId;
/**
* 上级分组id
*/
private Long parentGroupId;
/**
* 排序
*/
private Integer priority;
/**
* 上级分组名
*/
private String parentGroupName;
/**
* 分组标识，其与工作台类型及参建类型在后端进行映射
* @see cn.axzo.orgmanax.dto.job.enums.OrgJobGroupFlagEnum
*/
private String flag;
private List<JobGroupDTO> nodeChildren;
private List<OrgJobDTO> jobResList;
@Override
public Long getNodeCode() {
return groupId;
}
@Override
public Long getParentNodeCode() {
return parentGroupId;
}
@Override
public List<JobGroupDTO> getNodeChildren() {
return nodeChildren;
}
@Override
public void setNodeChildren(List<JobGroupDTO> nodeChildren) {
this.nodeChildren = nodeChildren;
}
public static JobGroupDTO buildJobGroupRes(OrgJobGroupDTO orgJobGroup) {
JobGroupDTO groupRes = new JobGroupDTO();
groupRes.setGroupId(orgJobGroup.getId());
groupRes.setParentGroupId(orgJobGroup.getParentId());
groupRes.setName(orgJobGroup.getName());
groupRes.setCode(orgJobGroup.getCode());
groupRes.setPriority(orgJobGroup.getPriority());
groupRes.setFlag(orgJobGroup.getFlag());
return groupRes;
}
}

16
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/job/dto/OrgJobConstants.java
View File

@ -37,4 +37,20 @@ public interface OrgJobConstants {
String CODE_KEY = "code";
String OLD_NEW_JOB_CODE_MAP_KEY = "job_code_mapping";
Integer JOB_PAGE_SIZE = 1000;
/**
* 系统操作人的personId
*/
Long SYSTEM_OPERATOR_ID = -1L;
/**
* 默认岗位的标识
*/
Integer ORG_JOB_DEF_FLAG = 1;
/**
* 岗位人数无上限
*/
Long NO_LIMIT_COUNT = -1L;
}

3
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/job/dto/OrgJobDTO.java
View File

@ -135,10 +135,9 @@ public class OrgJobDTO implements Serializable {
/**
* 角色信息
* todo 2024年12月30日 已和周敏确认，暂不用该字段
* 二期才会用到此字段
*/
//private List<RoleDTO> saasRoles;
private List<RoleDTO> saasRoles;
public Set<Long> mergeAndDistinctRolesIds() {
Set<Long> roleIds = Sets.newHashSet();

32
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/job/enums/OrgJobGroupFlagEnum.java
View File

@ -1,10 +1,9 @@
package cn.axzo.orgmanax.dto.job.enums;
import cn.axzo.orgmanax.dto.cooperateship.enums.CooperateShipTypeEnum;
import java.util.Arrays;
import java.util.Objects;
import java.util.Optional;
import cn.axzo.orgmanax.dto.cooperateship.enums.SaasCooperateShipCooperateTypeEnum;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
@ -19,31 +18,34 @@ import lombok.Getter;
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public enum OrgJobGroupFlagEnum {
/**
* 岗位分组标识
*/
WORKSPACE_ENT("job_group:workspace_ent", null, null, 1, 1, "企业"),
WORKSPACE_PROJ("job_group:workspace_proj", null, null, 1, 2, "项目"),
WORKSPACE_OMS("job_group:workspace_oms", null, null, 1, 3, "OMS"),
ENT_COMMON("job_group:ent_common", WORKSPACE_ENT, SaasCooperateShipCooperateTypeEnum.ENT_COMMON, 2, 1, "企业通用"),
ENT_TEAM("job_group:ent_team", WORKSPACE_ENT, SaasCooperateShipCooperateTypeEnum.ENT_TEAM, 2, 2, "企业班组"),
ENT_COMMON("job_group:ent_common", WORKSPACE_ENT, CooperateShipTypeEnum.ENT_COMMON, 2, 1, "企业通用"),
ENT_TEAM("job_group:ent_team", WORKSPACE_ENT, CooperateShipTypeEnum.ENT_TEAM, 2, 2, "企业班组"),
PROJ_PRIMARY_UNIT("job_group:proj_primary_unit", WORKSPACE_PROJ, SaasCooperateShipCooperateTypeEnum.PROJ_PRIMARY_CONTRACTING_UNIT,
PROJ_PRIMARY_UNIT("job_group:proj_primary_unit", WORKSPACE_PROJ, CooperateShipTypeEnum.PROJ_PRIMARY_CONTRACTING_UNIT,
2, 1, "总包"),
PROJ_CONSTRUCTION_UNIT("job_group:proj_construction_unit", WORKSPACE_PROJ, SaasCooperateShipCooperateTypeEnum.PROJ_CONSTRUCTION_UNIT,
PROJ_CONSTRUCTION_UNIT("job_group:proj_construction_unit", WORKSPACE_PROJ, CooperateShipTypeEnum.PROJ_CONSTRUCTION_UNIT,
2, 2, "建设单位"),
PROJ_SUPERVISION_UNIT("job_group:proj_supervision_unit", WORKSPACE_PROJ, SaasCooperateShipCooperateTypeEnum.PROJ_SUPERVISION_UNIT,
PROJ_SUPERVISION_UNIT("job_group:proj_supervision_unit", WORKSPACE_PROJ, CooperateShipTypeEnum.PROJ_SUPERVISION_UNIT,
2, 3, "监理单位"),
PROJ_LABOR_UNIT("job_group:proj_labor_unit", WORKSPACE_PROJ, SaasCooperateShipCooperateTypeEnum.PROJ_LABOR_SUBCONTRACTING,
PROJ_LABOR_UNIT("job_group:proj_labor_unit", WORKSPACE_PROJ, CooperateShipTypeEnum.PROJ_LABOR_SUBCONTRACTING,
2, 4, "劳务分包"),
PROJ_PROFESSIONAL_UNIT("job_group:proj_professional_unit", WORKSPACE_PROJ,
SaasCooperateShipCooperateTypeEnum.PROJ_PROFESSIONAL_SUBCONTRACTING, 2, 5, "专业分包"),
PROJ_TEAM("job_group:proj_team", WORKSPACE_PROJ, SaasCooperateShipCooperateTypeEnum.PROJ_TEAM, 2, 9, "项目班组"),
OTHER("job_group:other", WORKSPACE_PROJ, SaasCooperateShipCooperateTypeEnum.OTHER, 2, 11, "其他"),
CooperateShipTypeEnum.PROJ_PROFESSIONAL_SUBCONTRACTING, 2, 5, "专业分包"),
PROJ_TEAM("job_group:proj_team", WORKSPACE_PROJ, CooperateShipTypeEnum.PROJ_TEAM, 2, 9, "项目班组"),
OTHER("job_group:other", WORKSPACE_PROJ, CooperateShipTypeEnum.OTHER, 2, 11, "其他"),
OMS("job_group:oms", WORKSPACE_OMS, SaasCooperateShipCooperateTypeEnum.OMS, 2, 1, "OMS通用");
OMS("job_group:oms", WORKSPACE_OMS, CooperateShipTypeEnum.OMS, 2, 1, "OMS通用");
private final String code;
private final OrgJobGroupFlagEnum parent;
private final SaasCooperateShipCooperateTypeEnum cooperateType;
private final CooperateShipTypeEnum cooperateType;
private final Integer level;
private final Integer priority;
private final String desc;
@ -99,10 +101,10 @@ public enum OrgJobGroupFlagEnum {
if (Objects.isNull(this.cooperateType)) {
return false;
}
if (SaasCooperateShipCooperateTypeEnum.ENT_COMMON.is(cooperateType)) {
if (CooperateShipTypeEnum.ENT_COMMON.is(cooperateType)) {
// 单位默认匹配上单位班组
return this.cooperateType.is(cooperateType)
|| SaasCooperateShipCooperateTypeEnum.ENT_TEAM.equals(this.cooperateType);
|| CooperateShipTypeEnum.ENT_TEAM.equals(this.cooperateType);
}
return this.cooperateType.is(cooperateType);
}

17
orgmanax-infra/src/main/java/cn/axzo/orgmanax/infra/client/profile/dto/model/IdentityPair.java → orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/job/req/JobTreeGroupReq.java
View File

@ -1,15 +1,22 @@
package cn.axzo.orgmanax.infra.client.profile.dto.model;
package cn.axzo.orgmanax.dto.job.req;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author syl
* @date 2024/12/24
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Data
@SuperBuilder
public class IdentityPair {
private Long identityId;
private Integer identityType;
public class JobTreeGroupReq {
/**
* 根据后续需求按需传参
*/
private String ext;
}

305
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/node/dto/NodeProfile.java Normal file
View File

@ -0,0 +1,305 @@
package cn.axzo.orgmanax.dto.node.dto;
import cn.axzo.orgmanax.dto.node.enums.NodeTypeEnum;
import cn.axzo.orgmanax.dto.nodeuser.req.ListNodeUserReq;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.ImmutableMap;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.*;
/**
* 部门Profile定义
*/
public class NodeProfile {
/**
* 项目班组Profile，为了方便直观看到对应关系，字段和 org_project_team 保持一致
*/
@NoArgsConstructor
@AllArgsConstructor
@SuperBuilder
@Data
public static class ProjectTeamProfile {
// 新冗余字段
/**
* 平台班组节点id
*/
private Long platTeamNodeId;
/**
* 平台班组所属团队/单位 id
*/
private Long ouId;
// org_project_team 字段
private Long projectTeamId;
/**
* 总包ID
*/
private Long entId;
/**
* 项目外班组id
*/
private Long platTeamId;
/**
* 班组长身份id
*/
private Long teamLeaderId;
/**
* 状态：1-履约中 2-已退场 3-待履约
*/
private Integer status;
/**
* 班组进场时间
*/
private Date joinAt;
/**
* 班组退场时间
*/
private Date resignAt;
/**
* 工期要求开始时间
*/
private Date beginDate;
/**
* 工期要求结束时间
*/
private Date endDate;
/**
* 班组入驻编号(前端展示)
*/
private String settledCode;
/**
* 是否删除 0:否 其他：删除
*/
private Integer isDelete;
/**
* 创建时间
*/
private Date createAt;
private Date updateAt;
/**
* 工人进场方式 1-普通进场 2-任务单进场
*/
private Integer enterProjectType = 1;
private Integer syncState;
}
@NoArgsConstructor
@AllArgsConstructor
@SuperBuilder
@Data
/**
* 项目小组Profile
*/
public static class ProjectGroupProfile {
// 新冗余字段
private Long belongProjectTeamNodeId;
// org_project_group 字段
/**
* 主键id
*/
private Long projectGroupId;
/**
* 小组类型 0-直属小组 1-合作小组
*/
private Integer type;
/**
* 小组状态 0-未激活 1-已激活 2-已结束
*/
private Integer status;
/**
* 所属的项目内班组id
*/
private Long belongProjectTeamId;
/**
* 所属的平台班组id
*/
private Long belongPlatTeamId;
/**
* (合作小组才有)原项目内班组id
*/
private Long sourceProjectTeamId;
/**
* (合作小组才有)原平台班组id
*/
private Long sourcePlatTeamId;
/**
* 是否删除 0:否 其他：删除
*/
private Long isDelete;
/**
* 创建时间
*/
private Date createAt;
private Date updateAt;
/**
* 小组长权限集
*/
private Long permissionGroup;
/**
* 小组长工人身份id
*/
private Long ownerWorkerIdentityId;
/**
* 小组长项目内工人id
*/
private Long ownerProjectWorkerId;
/**
* 小组管理类型 0-班组管理 1-小组长管理
*/
private Integer manageType;
/**
* 是否独立小组，true 独立，false 非独立
*/
private Boolean independentGroup;
}
private static final Map<Integer, Class<?>> typeClassMapping = ImmutableMap.of(
NodeTypeEnum.PROJECT_TEAM.getValue(), ProjectTeamProfile.class,
NodeTypeEnum.PROJECT_GROUP.getValue(), ProjectGroupProfile.class
);
public static Class<?> resolveProfileClass(Integer nodeType) {
return typeClassMapping.getOrDefault(nodeType, JSONObject.class);
}
@Getter
@AllArgsConstructor
public enum NodeProfileResolveTypeEnum {
PROJECT_TEAM_ID("项目班组id", Long.class, Arrays.asList("projectTeamId", "belongProjectTeamId")),
PLAT_TEAM_ID("平台班组id", Long.class, Arrays.asList("platTeamId", "belongPlatTeamId")),
PROJECT_GROUP_ID("项目小组id", Long.class, Arrays.asList("projectGroupId")),
PROJECT_GROUP_OWNER_PROJECT_WORKER_ID("项目小组owner项目工人id", Long.class, Arrays.asList("ownerProjectWorkerId")),
PROJECT_GROUP_TYPE("项目小组类型", Integer.class, Arrays.asList("type")),
PROJECT_GROUP_CREATE_AT("项目小组创建时间", Integer.class, Arrays.asList("createAt")),
PROJECT_GROUP_UPDATE_AT("项目小组修改时间", Integer.class, Arrays.asList("updateAt")),
;
private String desc;
/**
* 解析类型
*/
private Class resolveClass;
/**
* 解析字段名
*/
private List<String> resolveFieldName;
}
public static <T> T resolve(OrgNodeDTO orgNodeDTO, NodeProfileResolveTypeEnum resolveType) {
return (T)Optional.ofNullable(orgNodeDTO)
.map(OrgNodeDTO::getProfile)
.map(profile -> {
List<String> resolveFieldNames = resolveType.getResolveFieldName();
for (String field : resolveFieldNames) {
Object object = profile.getObject(field, resolveType.resolveClass);
if (object != null) {
return object;
}
}
return null;
}).orElse(null);
}
/**
* @return
*/
public static Long resolveProjectTeamId(OrgNodeDTO orgNodeDTO) {
return Optional.ofNullable(orgNodeDTO)
.map(OrgNodeDTO::getProfile)
.map(profile -> {
if (ObjectUtil.isNotEmpty(profile.getLong("projectTeamId"))) {
return profile.getLong("projectTeamId");
}
return profile.getLong("belongProjectTeamId");
}).orElse(null);
}
/**
* @return
*/
public static Long resolveProjectTeamId(OrgNodeBriefDTO orgNodeDTO) {
return Optional.ofNullable(orgNodeDTO)
.map(OrgNodeBriefDTO::getProfile)
.map(profile -> {
if (ObjectUtil.isNotEmpty(profile.getLong("projectTeamId"))) {
return profile.getLong("projectTeamId");
}
return profile.getLong("belongProjectTeamId");
}).orElse(null);
}
/**
* 需指定{@link ListNodeUserReq.Needs#getNode()} ()} 为true才有用
* @return
*/
public static Long resolvePlatTeamId(OrgNodeDTO orgNodeDTO) {
return Optional.ofNullable(orgNodeDTO)
.map(OrgNodeDTO::getProfile)
.map(profile -> {
if (ObjectUtil.isNotEmpty(profile.getLong("platTeamId"))) {
return profile.getLong("platTeamId");
}
return profile.getLong("belongPlatTeamId");
}).orElse(null);
}
/**
* 需指定{@link ListNodeUserReq.Needs#getNode()} ()} 为true才有用
* @return
*/
public static Long resolvePlatTeamId(OrgNodeBriefDTO orgNodeDTO) {
return Optional.ofNullable(orgNodeDTO)
.map(OrgNodeBriefDTO::getProfile)
.map(profile -> {
if (ObjectUtil.isNotEmpty(profile.getLong("platTeamId"))) {
return profile.getLong("platTeamId");
}
return profile.getLong("belongPlatTeamId");
}).orElse(null);
}
public static Long resolveProjectGroupId(OrgNodeDTO orgNodeDTO) {
return Optional.ofNullable(orgNodeDTO)
.map(OrgNodeDTO::getProfile)
.map(profile -> profile.getLong("projectGroupId"))
.orElse(null);
}
}

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

@ -7,6 +7,7 @@ import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.io.Serializable;
import java.util.Optional;
@NoArgsConstructor
@AllArgsConstructor
@ -56,7 +57,32 @@ public class OrgNodeBriefDTO implements Serializable {
/**
* 节点信息，json，不同的节点类型，格式不一。如班组节点的解散状态等
* @see OrgNodeBriefDTO#resolveProfile()
*/
private JSONObject profile;
/**
* 解析profile
* 调用方需要根据nodeType来解析profile，自行使用正确的对象来接收<br>
* <pre>
* NodeProfile.ProjectTeamProfile projectTeamProfile = projectTeamNode.resolveProfile(); // nodeType = 4
* NodeProfile.PlatTeamProfile platTeamProfile = platTeamNode.resolveProfile(); // nodeType = 2
* JSONObject normalProfile = normalNode.resolveProfile(); // nodeType = 1
*
* </pre>
*
* @return
* @see NodeProfile#resolveProfileClass(Integer)
*/
public <T> T resolveProfile() {
if (profile == null || profile.isEmpty()) {
return (T) profile;
}
Class<?> clazz = NodeProfile.resolveProfileClass(nodeType);
if (clazz == null) {
return (T) profile;
}
return (T) Optional.ofNullable(profile).map(p -> JSONObject.parseObject(p.toString(), clazz)).orElse(null);
}
}

29
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/node/dto/OrgNodeDTO.java
View File

@ -3,7 +3,6 @@ package cn.axzo.orgmanax.dto.node.dto;
import cn.axzo.orgmanax.dto.cooperateship.dto.OrgCooperateShipDTO;
import com.alibaba.fastjson.JSONObject;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@ -11,6 +10,7 @@ import lombok.experimental.SuperBuilder;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.Optional;
@NoArgsConstructor
@AllArgsConstructor
@ -93,6 +93,10 @@ public class OrgNodeDTO implements Serializable {
/**
* 节点信息，json，不同的节点类型，格式不一。如班组节点的解散状态等
* @see NodeProfile#resolveProjectGroupId
* @see NodeProfile#resolveProjectTeamId
* @see NodeProfile#resolvePlatTeamId
*
*/
private JSONObject profile;
@ -127,4 +131,27 @@ public class OrgNodeDTO implements Serializable {
*/
private OrgCooperateShipDTO cooperateShip;
/**
* 解析profile
* 调用方需要根据nodeType来解析profile，自行使用正确的对象来接收<br>
* <pre>
* NodeProfile.ProjectTeamProfile projectTeamProfile = projectTeamNode.resolveProfile(); // nodeType = 4
* NodeProfile.PlatTeamProfile platTeamProfile = platTeamNode.resolveProfile(); // nodeType = 2
* JSONObject normalProfile = normalNode.resolveProfile(); // nodeType = 1
*
* </pre>
*
* @return
* @see NodeProfile#resolveProfileClass(Integer)
*/
public <T> T resolveProfile() {
if (profile == null || profile.isEmpty()) {
return (T) profile;
}
Class<?> clazz = NodeProfile.resolveProfileClass(nodeType);
if (clazz == null) {
return (T) profile;
}
return (T) Optional.ofNullable(profile).map(p -> JSONObject.parseObject(p.toString(), clazz)).orElse(null);
}
}

20
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/cooperateship/enums/OrganizationalNodeTypeEnum.java → orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/node/enums/NodeTypeEnum.java
View File

@ -1,4 +1,4 @@
package cn.axzo.orgmanax.dto.cooperateship.enums;
package cn.axzo.orgmanax.dto.node.enums;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonValue;
@ -15,7 +15,7 @@ import lombok.Getter;
*/
@Getter
@AllArgsConstructor
public enum OrganizationalNodeTypeEnum {
public enum NodeTypeEnum {
/**
* 默认单位，位为65535
@ -50,39 +50,39 @@ public enum OrganizationalNodeTypeEnum {
private final String desc;
private final Integer bitValue;
private static Map<Integer, OrganizationalNodeTypeEnum> bitMap;
private static Map<Integer, NodeTypeEnum> bitMap;
public boolean isSameOrChildNodeType(Integer nodeType) {
OrganizationalNodeTypeEnum typeByeCode = getByNodeType(nodeType);
NodeTypeEnum typeByeCode = getByNodeType(nodeType);
if (typeByeCode == null)
throw new RuntimeException("Unknown node type: " + nodeType);
return isSameOrChildNodeType(typeByeCode);
}
public boolean isSameOrChildNodeType(OrganizationalNodeTypeEnum type) {
public boolean isSameOrChildNodeType(NodeTypeEnum type) {
if (this == type)
return true;
if (this == OrganizationalNodeTypeEnum.PROJECT_TEAM)
return type == OrganizationalNodeTypeEnum.PROJECT_GROUP;
if (this == NodeTypeEnum.PROJECT_TEAM)
return type == NodeTypeEnum.PROJECT_GROUP;
return false;
}
public static OrganizationalNodeTypeEnum bitValueOf(Integer valueBit) {
public static NodeTypeEnum bitValueOf(Integer valueBit) {
if (valueBit == null) {
return null;
}
if (bitMap == null) {
bitMap = Arrays.stream(values())
.collect(
Collectors.toMap(OrganizationalNodeTypeEnum::getBitValue, Function.identity()));
Collectors.toMap(NodeTypeEnum::getBitValue, Function.identity()));
}
return bitMap.get(valueBit);
}
@JsonCreator(mode = JsonCreator.Mode.DELEGATING)
public static OrganizationalNodeTypeEnum getByNodeType(Integer value) {
public static NodeTypeEnum getByNodeType(Integer value) {
return Arrays.stream(values()).filter(o -> o.getValue().equals(value)).findFirst()
.orElse(null);
}

67
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,7 +10,9 @@ import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
@EqualsAndHashCode(callSuper = true)
@ -24,6 +27,12 @@ public class ListNodeReq extends PageReqV2 {
@Builder.Default
private Set<Long> ids = Collections.emptySet();
/**
* 父级节点
*/
@Builder.Default
private Set<Long> parentIds = Collections.emptySet();
/**
* 组织单位ids
*/
@ -34,7 +43,7 @@ public class ListNodeReq extends PageReqV2 {
* 节点名称集合
*/
@Builder.Default
private Set<String> nodeNames = Collections.emptySet();;
private Set<String> nodeNames = Collections.emptySet();
/**
* 节点名称查询（模糊）
@ -45,18 +54,21 @@ public class ListNodeReq extends PageReqV2 {
* 指定部门类型
*/
@Builder.Default
private Set<Integer> includeOrgNodeTypes = Collections.emptySet();;
private Set<Integer> includeOrgNodeTypes = Collections.emptySet();
;
/**
* 排除部门类型
*/
@Builder.Default
private Set<Integer> excludeOrgNodeTypes = Collections.emptySet();;
private Set<Integer> excludeOrgNodeTypes = Collections.emptySet();
;
/**
* 顶级节点ID集合
*/
@Builder.Default
private Set<Long> topNodeIds = Collections.emptySet();;
private Set<Long> topNodeIds = Collections.emptySet();
;
/**
* 是否包含祖先节点
@ -110,23 +122,62 @@ public class ListNodeReq extends PageReqV2 {
* 根据workspace和ouId组合查询
*/
@Builder.Default
private Set<WorkspaceOuPair> workspaceOuPairs = Collections.emptySet();;
private Set<WorkspaceOuPair> workspaceOuPairs = Collections.emptySet();
;
/**
* 项目id集合
*/
@Builder.Default
private Set<Long> workspaceIds = Collections.emptySet();;
private Set<Long> workspaceIds = Collections.emptySet();
/**
* 岗位编码
*/
@Builder.Default
private Set<String> jobCodes = Collections.emptySet();;
private Set<String> jobCodes = Collections.emptySet();
/**
* 当前用户personId
*/
private Long personId;
}
/**
* 平台班组id
*/
@Builder.Default
private Set<Long> platTeamIds = Collections.emptySet();
/**
* 项目内班组id列表
*/
@Builder.Default
private Set<Long> projectTeamIds = Collections.emptySet();
/**
* 小组类型
* @see cn.axzo.orgmanax.api.project.group.enums.ProjectGroupTypeEnum
*/
private Integer projectGroupType;
/**
* 小组id列表
*/
private Collection<Long> projectGroupIds;
/**
* 小组长工人身份id列表
*/
private Collection<Long> ownerWorkerIdentityIds;
/**
* 小组长项目工人id列表
*/
private Collection<Long> ownerProjectWorkerIds;
/**
* 小组状态 0-未激活 1-已激活 2-已结束
* @see ProjectGroupStatusEnum
*/
private Integer projectGroupStatus;
}

20
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/node/req/ProcessNodeReq.java
View File

@ -14,10 +14,30 @@ import lombok.experimental.SuperBuilder;
@Data
@SuperBuilder
public class ProcessNodeReq {
/**
* 业务id
*/
private Long id;
/**
* 操作人
*/
private Long operatorId;
/**
* 描述
*/
private String description;
/**
* 执行行为
*/
private Action action;
/**
* 业务参数
*/
private JSONObject param;
@AllArgsConstructor(access = AccessLevel.PRIVATE)

2
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/dto/NodeUserBriefDTO.java
View File

@ -65,7 +65,7 @@ public class NodeUserBriefDTO implements Serializable {
/**
* 部门管理员 1是 0否
*/
private Object manager;
private Boolean manager;
/**
* 岗位id

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

@ -1,6 +1,7 @@
package cn.axzo.orgmanax.dto.nodeuser.dto;
import cn.axzo.orgmanax.dto.common.PersonProfileBriefDTO;
import cn.axzo.orgmanax.dto.common.RoleBriefDTO;
import cn.axzo.orgmanax.dto.common.WorkspaceBriefDTO;
import cn.axzo.orgmanax.dto.cooperateship.dto.OrgCooperateShipDTO;
import cn.axzo.orgmanax.dto.job.dto.OrgJobBriefDTO;
@ -16,6 +17,7 @@ import lombok.experimental.SuperBuilder;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import java.util.Optional;
@NoArgsConstructor
@AllArgsConstructor
@ -73,7 +75,7 @@ public class NodeUserDTO implements Serializable {
/**
* 部门管理员 1是 0否
*/
private Object manager;
private Boolean manager;
/**
* 岗位id
@ -146,6 +148,8 @@ public class NodeUserDTO implements Serializable {
private Integer activeFlag;
/**
* @see NodeUserDTO#resolveProfile()
* @see NodeUserProfile#resolveProjectWorkerId
* 部门人员信息，json，不同部门类型的部门用户，格式不一。
*/
private JSONObject profile;
@ -185,5 +189,39 @@ public class NodeUserDTO implements Serializable {
* 注意：平台班组是不会返回这个的。
*/
private List<NodeUserBriefDTO> subordinateUsers;
/**
* 需指定{@link ListNodeUserReq.Needs#getRole()} 为true才会返回。
* 注意：平台班组是不会返回这个的。
*/
private List<RoleBriefDTO> roles;
/**
* 解析profile
* 调用方需要根据nodeType来解析profile，自行使用正确的对象来接收<br>。
* 解析对象需要 {@link #getNode()}.nodType信息，请确认{@link ListNodeUserReq.Needs#getNode()} = true，否则仅会返回json的profile。<br>
* <pre>
* NodeUserProfile.ProjectWorkerProfile projectTeamProfile = projectTeamNodeUser.resolveProfile(); // nodeType = 4
* NodeUserProfile.PlatTeamProfile platTeamProfile = platTeamNodeUser.resolveProfile(); // nodeType = 2
* JSONObject normalProfile = normalNodeUser.resolveProfile(); // nodeType = 1
*
* </pre>
*
* @return
* @see NodeUserProfile#resolveProfileClass(Integer)
*/
public <T> T resolveProfile() {
if (profile == null || profile.isEmpty()) {
return (T) profile;
}
if (node == null || node.getNodeType() == null) {
// 没有聚合node信息的情况，直接返回JSONObject的profile
return (T) profile;
}
Class<?> clazz = NodeUserProfile.resolveProfileClass(node.getNodeType());
if (clazz == null) {
return (T) profile;
}
return (T) Optional.ofNullable(profile).map(p -> JSONObject.parseObject(p.toString(), clazz)).orElse(null);
}
}

146
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/dto/NodeUserProfile.java Normal file
View File

@ -0,0 +1,146 @@
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;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.util.Date;
import java.util.Map;
/**
* 部门人员Profile定义
*/
public class NodeUserProfile {
/**
* 项目工人Profile，为了方便直观看到对应关系，字段和 org_project_team 保持一致
*/
@NoArgsConstructor
@AllArgsConstructor
@SuperBuilder
@Data
public static class ProjectWorkerProfile {
// org_project_worker 字段
/**
* 项目班组节点id。
*/
private Long projectWorkerId;
/**
* 状态：0、未激活 1、已激活 3已退场
*/
private Integer projectWorkerStatus;
/**
* 工种类别
*/
private String professionCategoryName;
/**
* 是否删除 0:未删除 其他:已删除
*/
private Long isDelete;
/**
* 最后一次进工地的时间，进场打卡更新
* 进场打卡更新，
*/
private Date lastCheckInTime;
/**
* 最后一次出工地的时间，出场打卡更新
*/
private Date lastCheckOutTime;
/**
* 工人施工开始时间，工人所有任务单中最早开始时间
*/
private Date constructionStartTime;
/**
* 工人施工结束时间
*/
private Date constructionEndTime;
/**
* 在岗、待岗
*/
private Integer occupyStatus;
/**
* 提醒推送未备案消息次数。（xxljob在给未备案的工人发送消息。为了避免多次提醒。这里记录了一个提醒的次数。）
* 参考 maokai代码：cn.axzo.apollo.labour.service.job.PushSupervisionMsgJob#execute
*/
private Integer pushSupervisionMsgCount;
}
@NoArgsConstructor
@AllArgsConstructor
@SuperBuilder
@Data
/**
* 项目小组人员Profile
*/
public static class ProjectGroupWorkerProfile {
/**
* 项目小组人员主键id
*/
private Long projectGroupWorkerId;
/**
* 状态 状态 0-有效 1-无效
*/
private Integer status;
//
// /**
// * 所属的项目内班组id
// */
// private Long belongProjectTeamId;
//
// /**
// * (合作小组才有)原项目内班组id
// */
// private Long sourceProjectTeamId;
// /**
// * 小组id
// */
// private Long projectGroupId;
/**
* 项目内工人id
*/
private Long projectWorkerId;
// /**
// * 小组类型 0-直属小组 1-合作小组
// */
// private Integer groupType;
/**
* 是否删除 0:否 其他：删除
*/
private Long isDelete;
}
private static final Map<Integer, Class<?>> typeClassMapping = ImmutableMap.of(
NodeTypeEnum.PROJECT_TEAM.getValue(), ProjectWorkerProfile.class,
NodeTypeEnum.PROJECT_GROUP.getValue(), ProjectGroupWorkerProfile.class
);
public static Class<?> resolveProfileClass(Integer nodeType) {
if (nodeType == null) {
return JSONObject.class;
}
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");
}
}

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

@ -0,0 +1,39 @@
package cn.axzo.orgmanax.dto.nodeuser.enums;
import java.util.Arrays;
import java.util.Objects;
import java.util.Optional;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @description
* 人员异动场景
* @author luofu
* @version 1.0
* @date 2024/10/24
*/
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public enum OrgUserChangedScenarioEnum {
JOINED("JOINED", "加入"),
WITHDRAW("WITHDRAW", "离开<单位:离职,项目:退场>"),
LEAVED("LEAVED", "离场"),
CHANGED("CHANGED", "部门岗位变更");
private final String code;
private final String desc;
public static Optional<OrgUserChangedScenarioEnum> codeOf(String code) {
return Arrays.stream(values())
.filter(e -> Objects.equals(code, e.code))
.findFirst();
}
public static OrgUserChangedScenarioEnum codeOfThrowException(String code) {
return codeOf(code)
.orElseThrow(() -> new RuntimeException(String.format("invalid code.[%s]", code)));
}
}

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

@ -0,0 +1,40 @@
package cn.axzo.orgmanax.dto.nodeuser.enums;
import java.util.Arrays;
import java.util.Optional;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @description
* 人员在组织中的状态
* @author luofu
* @version 1.0
* @date 2024/10/24
*/
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public enum OrgUserStatusEnum {
INACTIVE(0, "入场中"), ACTIVE(1, "已入场"), LEAVE(3, "离场"),
WITHDRAW(4, "退场"), JOINED(5, "在职"), QUIT(6, "离职"),
NONE(-1, "非法值");
private final int code;
private final String desc;
public boolean isEqual(int code) {
return this.code == code;
}
public static Optional<OrgUserStatusEnum> codeOf(int code) {
return Arrays.stream(values())
.filter(e -> e.code == code)
.findFirst();
}
public static OrgUserStatusEnum codeOfThrowException(int code) {
return codeOf(code).orElseThrow(() -> new RuntimeException(String.format("invalid code.[%d]", code)));
}
}

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;
}
}

53
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;
@ -76,6 +77,11 @@ public class ListNodeUserReq extends PageReqV2 {
private Collection<Long> organizationalNodeIds;
private Collection<Long> excludeOrganizationalNodeIds;
/**
* 祖先节点id，即 parent.nodeId = xx，或者parent.parent.nodeId = xxx，以此类推
*/
private Collection<Long> ancestorNodeIds;
/**
* 顶级节点id
*/
@ -203,20 +209,27 @@ public class ListNodeUserReq extends PageReqV2 {
private String keyword;
/**
* 状态：1未激活 2、已激活 3、施工中 4、已退场
* @see cn.axzo.orgmanax.api.project.worker.enums.ProjectWorkerStatusEnum
*/
private Collection<Integer> projectWorkerStatuses; // TODO: 待实现
private Collection<Integer> projectWorkerStatuses;
/**
* 只查询顶级节点 topNodeId = id 的。
*/
private Boolean topNodeOnly;
/**
* orgUserStatus
*/
private Collection<String> orgUserStatus; // TODO: 待实现
private Collection<Integer> orgUserStatuses; // TODO: 待实现，具体看如何使用的，是 condition还是filter
// ~ 不同部门类型的nodeUser的差异化查询字段。如 项目内工人 的 项目班组id，平台班组id等。 start
private Long platTeamId; // TODO: 待实现
private Long projectTeamId; // TODO: 待实现
private Collection<Long> projectTeamIds; // TODO: 待实现
private Long projectWorkerId; // TODO: 待实现
private Long projectGroupId; // TODO: 待实现
private Long platTeamId;
private Long projectTeamId;
private Collection<Long> projectTeamIds;
private Long projectWorkerId;
private Collection<Long> projectWorkerIds;
private Long projectGroupId;
private Integer projectGroupWorkerStatus;
// ~ 结束。
@ -224,6 +237,7 @@ public class ListNodeUserReq extends PageReqV2 {
/**
* 包含的单位类型
* XXX：filter的参数会破坏分页。如有强分页场景，需谨慎使用
* @see cn.axzo.orgmanax.dto.unit.enums.OrganizationalUnitTypeEnum
*/
private Collection<Integer> filterIncludeUnitTypes;
/**
@ -246,6 +260,16 @@ public class ListNodeUserReq extends PageReqV2 {
* XXX：filter的参数会破坏分页。如有强分页场景，需谨慎使用
*/
private Collection<Integer> filterExcludeCooperateTypes;
/**
* 包含的节点类型
* XXX：filter的参数会破坏分页。如有强分页场景，需谨慎使用
*/
private Collection<Integer> filterIncludeNodeTypes;
/**
* 排除的节点类型
* XXX：filter的参数会破坏分页。如有强分页场景，需谨慎使用
*/
private Collection<Integer> filterExcludeNodeTypes;
/**
* 是否只返回顶级节点
* XXX：filter的参数会破坏分页。如有强分页场景，需谨慎使用
@ -264,7 +288,7 @@ public class ListNodeUserReq extends PageReqV2 {
/**
* 数据权限
*/
private String dataPermissionCacheKey; // TODO: 待实现
private String dataPermissionCacheKey;
// ~ 不同部门类型的nodeUser的差异化查询字段。如 项目内工人 的 项目班组id，平台班组id等。 end
/**
@ -285,6 +309,8 @@ public class ListNodeUserReq extends PageReqV2 {
*/
private DistinctRule distinctRule;
//
// 指定聚合信息
/**
* 聚合信息needs
@ -310,10 +336,6 @@ public class ListNodeUserReq extends PageReqV2 {
* 是否需要部门及父级部门信息，默认不返回
*/
private Boolean ancestorNodes;
/**
* 返回node and path
*/
private Boolean nodeAndPath; // TODO : 待实现
/**
* 返回参与项目数量
*/
@ -327,11 +349,6 @@ public class ListNodeUserReq extends PageReqV2 {
*/
private Boolean jobGroup; // TODO : 待实现
/**
* 是否返回下级组织人员。所在节点的下级节点的
*/
private Boolean childNodeUser; // TODO: 待实现
/**
* 是否查询下属。（同单位，directManagerPersonId等于自己的）
*/
@ -340,7 +357,7 @@ public class ListNodeUserReq extends PageReqV2 {
/**
* 是否需要角色信息
*/
private Boolean role; // TODO : 待实现
private Boolean role;
private Boolean cooperateShip;

65
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/req/PageOrgUserChangedRecordReq.java Normal file
View File

@ -0,0 +1,65 @@
package cn.axzo.orgmanax.dto.nodeuser.req;
import cn.axzo.foundation.page.PageReqV2;
import cn.axzo.orgmanax.dto.nodeuser.enums.OrgUserChangedScenarioEnum;
import java.util.Collection;
import java.util.Date;
import java.util.Set;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@EqualsAndHashCode(callSuper = true)
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class PageOrgUserChangedRecordReq extends PageReqV2 {
/**
* 自然人id集合
*/
private Set<Long> personIds;
/**
* 租户id
*/
private Long workspaceId;
/**
* 单位id
*/
private Collection<Long> ouIds;
/**
* 人员异动场景列表
* @see OrgUserChangedScenarioEnum
*/
private Collection<String> scenarios;
/**
* 搜素关键字：
* 1、姓名模糊匹配；
* 2、手机号精确匹配；
*/
private String keyword;
/**
* 查询的开始时间
*/
private Date beginTime;
/**
* 查询的结束时间
*/
private Date endTime;
/**
* 是否需要每个person 最新的记录
* 默认 不需要
*/
private Boolean needLatestFlag;
}

182
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/resp/OrgUserBasicInfoResp.java Normal file
View File

@ -0,0 +1,182 @@
package cn.axzo.orgmanax.dto.nodeuser.resp;
import cn.axzo.orgmanax.dto.nodeuser.enums.OrgUserStatusEnum;
import com.alibaba.fastjson.JSON;
import java.io.Serializable;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author luofu
* @version 1.0
* @date 2024/10/27
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OrgUserBasicInfoResp implements Serializable {
private static final long serialVersionUID = -417565663936325962L;
/**
* 用户状态
* @see OrgUserStatusEnum
*/
private String status;
/**
* 部门列表
*/
private List<OrgUserNodeInfoDTO> orgNodes;
/**
* 岗位列表
*/
private List<OrgUserJobInfoDTO> jobs;
/**
* 角色列表
*/
private List<OrgUserRoleDTO> roles;
/**
* 直属主管信息
*/
private DirectManagerDTO directManager;
@Override
public String toString() {
return JSON.toJSONString(this);
}
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class OrgUserNodeInfoDTO implements Serializable {
private static final long serialVersionUID = 1553728683787221674L;
/**
* 部门id
*/
private Long nodeId;
/**
* 部门名称
*/
private String nodeName;
/**
* 顶级部门id
*/
private Long topNodeId;
/**
* 部门主管标识
*/
private boolean manager;
/**
* 部门名称path，包含当前部门
*/
private List<String> path;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class OrgUserJobInfoDTO implements Serializable {
private static final long serialVersionUID = -4468117792583126437L;
/**
* 岗位id
*/
private Long id;
/**
* 岗位名称
*/
private String name;
/**
* 岗位编码
*/
private String code;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class OrgUserRoleDTO implements Serializable {
private static final long serialVersionUID = -6964230627747183642L;
/**
* 岗位id
*/
private Long id;
/**
* 岗位名称
*/
private String name;
/**
* 角色编码
*/
private String code;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class DirectManagerDTO implements Serializable {
private static final long serialVersionUID = 3009318843471722223L;
/**
* 直属主管id
*/
private Long personId;
/**
* 直属主管名称
*/
private String realName;
/**
* 直属主管手机号
*/
private String phone;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}
}

129
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/nodeuser/resp/OrgUserChangedRecordResp.java Normal file
View File

@ -0,0 +1,129 @@
package cn.axzo.orgmanax.dto.nodeuser.resp;
import cn.axzo.orgmanax.dto.nodeuser.enums.OrgUserChangedScenarioEnum;
import cn.axzo.orgmanax.dto.nodeuser.enums.OrgUserStatusEnum;
import java.util.Date;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrgUserChangedRecordResp {
/**
* 自然人id
*/
private Long personId;
/**
* 手机号,加密
*/
private String phone;
/**
* 用户真实姓名
*/
private String realName;
/**
* 单位id
*/
private Long ouId;
/**
* 单位名称
*/
private String ouName;
/**
* 租户id
*/
private Long workspaceId;
/**
* 租户名称
*/
private String workspaceName;
/**
* 租户类型
* GENERAL_ENT 总包企业级
* GENERAL_PROJECT 总包项目级
* GOVERNMENT 政务监管平台
* AGENCY_ENT 分包企业级
* OMS OMS工作台
*/
private String workspaceType;
/**
* 人员异动情景
* @see OrgUserChangedScenarioEnum
*/
private OrgUserChangedScenarioEnum scenario;
/**
* 备注
*/
private String remark;
/**
* 人员组织架构信息
*/
private OrgUserBasicInfoResp orgUserInfo;
/**
* 记录时间
*/
private Date recordTime;
/**
* 操作人的id
*/
private Long operatorId;
/**
* 操作人姓名
*/
private String operatorName;
/**
* 创建时间
*/
private Date createAt;
/**
* 更新时间
*/
private Date updateAt;
/**
* 用户状态
* @see OrgUserStatusEnum
*/
private String status;
/**
* 部门列表
*/
private List<OrgUserBasicInfoResp.OrgUserNodeInfoDTO> orgNodes;
/**
* 岗位列表
*/
private List<OrgUserBasicInfoResp.OrgUserJobInfoDTO> jobs;
/**
* 角色列表
*/
private List<OrgUserBasicInfoResp.OrgUserRoleDTO> roles;
/**
* 直属主管信息
*/
private OrgUserBasicInfoResp.DirectManagerDTO directManager;
}

21
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/enums/GenericUserListScenarioEnum.java Normal file
View File

@ -0,0 +1,21 @@
package cn.axzo.orgmanax.dto.orguser.enums;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* @description
* 通用人员列表场景枚举
* @author luofu
* @version 1.0
* @date 2024/8/2
*/
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public enum GenericUserListScenarioEnum {
ATTENDANCE("考勤");
private final String desc;
}

24
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/enums/IBaseUserFlagEnum.java Normal file
View File

@ -0,0 +1,24 @@
package cn.axzo.orgmanax.dto.orguser.enums;
/**
* @author luofu
* @version 1.0
* @date 2024/8/2
*/
public interface IBaseUserFlagEnum {
/**
* 获取用户标签编码
*/
String getCode();
/**
* 获取用户标签描述
*/
String getDesc();
/**
* 标签优先级
*/
int getPriority();
}

40
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/enums/OrgUserChangedScenarioEnum.java Normal file
View File

@ -0,0 +1,40 @@
package cn.axzo.orgmanax.dto.orguser.enums;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Getter;
import java.util.Arrays;
import java.util.Objects;
import java.util.Optional;
/**
* @description
* 人员异动场景
* @author luofu
* @version 1.0
* @date 2024/10/24
*/
@Getter
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public enum OrgUserChangedScenarioEnum {
JOINED("JOINED", "加入"),
WITHDRAW("WITHDRAW", "离开<单位:离职,项目:退场>"),
LEAVED("LEAVED", "离场"),
CHANGED("CHANGED", "部门岗位变更");
private final String code;
private final String desc;
public static Optional<OrgUserChangedScenarioEnum> codeOf(String code) {
return Arrays.stream(values())
.filter(e -> Objects.equals(code, e.code))
.findFirst();
}
public static OrgUserChangedScenarioEnum codeOfThrowException(String code) {
return codeOf(code)
.orElseThrow(() -> new RuntimeException(String.format("invalid code.[%s]", code)));
}
}

122
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/event/OrgUserChangedEvent.java Normal file
View File

@ -0,0 +1,122 @@
package cn.axzo.orgmanax.dto.orguser.event;
import cn.axzo.orgmanax.dto.orguser.enums.OrgUserChangedScenarioEnum;
import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.util.List;
/**
* @description 用户组织架构信息变更事件 (部门-岗位-角色等)
* @author luofu
* @version 1.0
* @date 2024/10/30
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrgUserChangedEvent implements Serializable {
private static final long serialVersionUID = 6513111764022461738L;
/**
* 自然人id
*/
private Long personId;
/**
* 单位id
*/
private Long ouId;
/**
* 租户id
*/
private Long workspaceId;
/**
* 用户状态
* 1) 在职： 5
* 2) 离职： 6
* 3) 入场中： 0
* 4) 在场： 1
* 5) 离场： 3
* 6) 已删除： 4
*/
private Integer statusCode;
/**
* 异动时间戳
*/
private Long transferTimestamp;
/**
* 人员异动场景
* @see OrgUserChangedScenarioEnum
*/
private String scenarioCode;
/**
* 备注：二维码加入 - APP端、手机号添加 - CMS端
*/
private String remark;
/**
* 补充信息信息
*/
private SupplementaryInfo supplementaryInfo;
/**
* 操作人的自然人id
*/
private Long operatorId;
@Override
public String toString() {
return JSON.toJSONString(this);
}
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class SupplementaryInfo implements Serializable{
private static final long serialVersionUID = -8577751204851100329L;
/**
* 部门id列表
*/
private List<Long> orgNodeIds;
/**
* 部门主管标识所在的部门id
*/
private Long majorOrgNodeId;
/**
* 岗位id列表
*/
private List<Long> jobIds;
/**
* 角色id列表
*/
private List<Long> roleIds;
/**
* 直属主管id
*/
private Long directManagerPersonId;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}
}

69
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/event/OrgUserStatusChangedEvent.java Normal file
View File

@ -0,0 +1,69 @@
package cn.axzo.orgmanax.dto.orguser.event;
import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
* @author luofu
* @version 1.0
* @date 2024/11/5
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrgUserStatusChangedEvent implements Serializable {
private static final long serialVersionUID = 1534318491778930088L;
/**
* 自然人id
*/
private Long personId;
/**
* 单位id
*/
private Long ouId;
/**
* 租户id
*/
private Long workspaceId;
/**
* 顶级部门id
*/
private Long topNodeId;
/**
* 用户状态
* 1) 在职： 5
* 2) 离职： 6
* 3) 入场中： 0
* 4) 在场： 1
* 5) 离场： 3
* 6) 已删除： 4
*/
private Integer statusCode;
/**
* 异动时间戳
*/
private Long transferTimestamp;
/**
* 操作人的id
*/
private Long operatorId;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}

40
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/req/ListOrgUserReq.java
View File

@ -6,6 +6,7 @@ import cn.axzo.foundation.page.PageReqV2;
import lombok.*;
import lombok.experimental.SuperBuilder;
import java.util.Date;
import java.util.List;
import java.util.Set;
@ -89,18 +90,33 @@ public class ListOrgUserReq extends PageReqV2 {
@CriteriaField(field = "status", operator = Operator.IN)
private Set<Integer> statuses;
@CriteriaField(ignore = true)
@Builder.Default
private Integer page = 1;
/**
* 最大支持1000条数据，不支持单页超过1000的查询，接入方按需分页
*/
@Builder.Default
@CriteriaField(ignore = true)
private Integer pageSize = 1000;
@CriteriaField(ignore = true)
private List<String> sort;
@CriteriaField(ignore = true)
private Boolean needPersonProfile;
/**
* 关键字查询：
* 1、用户名称模糊匹配；
* 2、手机号、身份证号精确匹配；
*/
@CriteriaField(ignore = true)
private String keyword;
/**
* 离职时间筛选起始
*/
@CriteriaField(field = "transferTime", operator = Operator.GE)
private Date leaveAtStart;
/**
* 离职时间筛选结束
*/
@CriteriaField(field = "transferTime", operator = Operator.LE)
private Date leaveAtEnd;
/**
* 是都包含删除(默认走查询未删除)
*/
@CriteriaField(ignore = true)
private Boolean includeDeleted;
}

65
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/req/PageOrgUserReq.java Normal file
View File

@ -0,0 +1,65 @@
package cn.axzo.orgmanax.dto.orguser.req;
import cn.axzo.foundation.page.PageReqV2;
import cn.axzo.orgmanax.dto.orguser.enums.GenericUserListScenarioEnum;
import com.alibaba.fastjson.JSON;
import java.util.List;
import javax.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author luofu
* @version 1.0
* @date 2024/8/2
*/
@EqualsAndHashCode(callSuper = true)
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class PageOrgUserReq extends PageReqV2 {
/**
* 人员列表使用的业务场景
* ATTENDANCE: 考勤
*
* @see GenericUserListScenarioEnum
*/
@NotNull(message = "业务场景不能为空")
private String scenario;
/**
* 项目id
*/
private Long workspaceId;
/**
* 当前用户session中的单位id
*/
private Long sessionOuId;
/**
* 搜索关键字：
* * 姓名模糊查询
* * 手机号、身份证号精确匹配
*/
private String keyword;
/**
* 单位id列表
*/
private List<Long> ouIds;
/**
* 用户标签编码列表
*/
private List<String> userFlagCodes;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}

59
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/resp/OrgUserBriefResp.java Normal file
View File

@ -0,0 +1,59 @@
package cn.axzo.orgmanax.dto.orguser.resp;
import com.alibaba.fastjson.JSON;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @description 用户基础信息
* @author luofu
* @version 1.0
* @date 2024/8/2
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class OrgUserBriefResp implements Serializable {
private static final long serialVersionUID = -1037841970293974523L;
/**
* 自然人id
*/
private Long personId;
/**
* 身份id
*/
private Long identityId;
/**
* 真实姓名
*/
private String realName;
/**
* 用户头像
*/
private String avatarUrl;
/**
* 性别
* 1：女性
* 2：男性
*/
private Integer genderCode;
/**
* 手机号
*/
private String phone;
/**
* 身份证号
*/
private String idNumber;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}

45
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/resp/OrgUserFlagEntityResp.java Normal file
View File

@ -0,0 +1,45 @@
package cn.axzo.orgmanax.dto.orguser.resp;
import cn.axzo.orgmanax.dto.orguser.enums.IBaseUserFlagEnum;
import com.alibaba.fastjson.JSON;
import java.io.Serializable;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* @description 标签实体
* @author luofu
* @version 1.0
* @date 2024/8/2
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class OrgUserFlagEntityResp implements Serializable {
private static final long serialVersionUID = -6965721030042547822L;
/**
* 标签编码
*/
private String flagCode;
/**
* 标签描述
*/
private String flagDesc;
public static OrgUserFlagEntityResp from(IBaseUserFlagEnum userFlag) {
return OrgUserFlagEntityResp.builder()
.flagCode(userFlag.getCode())
.flagDesc(userFlag.getDesc())
.build();
}
@Override
public String toString() {
return JSON.toJSONString(this);
}
}

69
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/orguser/resp/PageOrgUserElementResp.java Normal file
View File

@ -0,0 +1,69 @@
package cn.axzo.orgmanax.dto.orguser.resp;
import com.alibaba.fastjson.JSON;
import java.io.Serializable;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
/**
* @author luofu
* @version 1.0
* @date 2024/8/2
*/
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
public class PageOrgUserElementResp implements Serializable {
private static final long serialVersionUID = 4468275572308565888L;
/**
* 用户基础信息
*/
private OrgUserBriefResp brief;
/**
* 单位id
*/
private Long ouId;
/**
* 单位名称
*/
private String ouName;
/**
* 部门id
*/
private Long orgNodeId;
/**
* 部门名称
*/
private String orgNodeName;
/**
* 主管标识
*/
private Boolean managerFlag;
/**
* 岗位id - 主岗
*/
private Long jobId;
/**
* 岗位名称 - 主岗
*/
private String jobName;
/**
* 用户标签列表
*/
private List<OrgUserFlagEntityResp> userFlagEntities;
@Override
public String toString() {
return JSON.toJSONString(this);
}
}

75
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/processrelationship/dto/BusinessProcessRelationshipDTO.java Normal file
View File

@ -0,0 +1,75 @@
package cn.axzo.orgmanax.dto.processrelationship.dto;
import com.alibaba.fastjson.JSONObject;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.util.Date;
import java.util.Optional;
/**
* @Author zr
* @Date 2024/4/26 14:03
* @Description
**/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class BusinessProcessRelationshipDTO {
private static final long serialVersionUID = 1L;
/**
* 主键id
*/
private Long id;
/**
* 业务类型
* TEAM_JOIN_WORKSPACE("班组加入项目"),
* TEAM_DISSOLVE("班组解散"),
* PROJECT_TEAM_RESIGN("项目内班组离场"),
* CHANGE_TEAM_OWNER("更换班组长"),
* WORKER_APPLY_UNIT_TEAM("工人申请加入单位班组"),
*
*/
private String type;
/**
* 业务id
*/
private Long bizId;
/**
* 流程id
*/
private String processInstanceId;
/**
* 审批状态，CREATED=已创建，PROCESSING=审批中，REJECTED=已拒绝，
* APPROVED=已审批通过，ABORTED=审批中止，CANCELLED=已撤回，DELETED=已删除
*/
private String processInstanceStatus;
private JSONObject extra;
/**
* 是否删除 0否1是
*/
private Long isDelete;
/**
* 创建时间
*/
private Date createAt;
/**
* 更新时间
*/
private Date updateAt;
/**
* 创建人自然人id
*/
private Long createBy;
public JSONObject nullToEmptyExtra() {
return Optional.ofNullable(extra).orElseGet(JSONObject::new);
}
}

29
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/processrelationship/enums/BusinessProcessRelationshipTypeEnum.java Normal file
View File

@ -0,0 +1,29 @@
package cn.axzo.orgmanax.dto.processrelationship.enums;
import lombok.Getter;
/**
* @Author zr
* @Date 2024/4/26 14:12
* @Description
**/
@Getter
public enum BusinessProcessRelationshipTypeEnum {
/**
* 班组加入项目
*/
TEAM_JOIN_WORKSPACE("班组加入项目"),
TEAM_DISSOLVE("班组解散"),
PROJECT_TEAM_RESIGN("项目内班组离场"),
CHANGE_TEAM_OWNER("更换班组长"),
WORKER_APPLY_UNIT_TEAM("工人申请加入单位班组"),
;
public final String desc;
BusinessProcessRelationshipTypeEnum(String desc) {
this.desc = desc;
}
}

22
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/processrelationship/enums/ProcessInstanceStatusEnum.java Normal file
View File

@ -0,0 +1,22 @@
package cn.axzo.orgmanax.dto.processrelationship.enums;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
* 审批状态，PROCESSING=审批中，REJECTED=已拒绝，
* APPROVED=已审批通过，ABORTED=审批中止，CANCELLED=已撤回，DELETED=已删除
*/
@Getter
@AllArgsConstructor
public enum ProcessInstanceStatusEnum {
PROCESSING("审批中"),
REJECTED("已拒绝"),
APPROVED("已审批通过"),
CANCELLED("已撤回"),
ABORTED("审批中止"),
DELETED("已删除");
private final String desc;
}

47
orgmanax-dto/src/main/java/cn/axzo/orgmanax/dto/processrelationship/req/ProcessRelationListReq.java Normal file
View File

@ -0,0 +1,47 @@
package cn.axzo.orgmanax.dto.processrelationship.req;
import cn.axzo.orgmanax.dto.processrelationship.enums.BusinessProcessRelationshipTypeEnum;
import cn.axzo.orgmanax.dto.processrelationship.enums.ProcessInstanceStatusEnum;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.util.List;
@Data
@Accessors(chain = true)
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ProcessRelationListReq {
/**
* 业务类型
*
*/
private BusinessProcessRelationshipTypeEnum type;
/**
* 业务类型s
*
*/
private List<BusinessProcessRelationshipTypeEnum> typeList;
/**
* 业务id
*/
private List<Long> bizIds;
/**
* 流程id
*/
private List<String> processInstanceIds;
/**
* 审批状态，CREATED=已创建，PROCESSING=审批中，REJECTED=已拒绝，
* APPROVED=已审批通过，ABORTED=审批中止，CANCELLED=已撤回，DELETED=已删除
*/
private List<ProcessInstanceStatusEnum> processInstanceStatusList;
private Long nodeId;
}

Some files were not shown because too many files have changed in this diff Show More