JAVA简易审批流-06

叁歲伎倆 2023-10-13 19:34 44阅读 0赞

@Service
    public class ProApprovalFlowDomainServiceImpl implements ProApprovalFlowDomainService {
        @Autowired
        private ProApprovalFlowDao approvalFlowDao;
    
        @Override
        public ProApprovalFlowDto load(Long flowId) {
            Assert.notNull(flowId, "flowId is required");
            return ProApprovalAssembler.flowToDto(approvalFlowDao.load(flowId));
        }
    }

@Service
    public class ProApprovalFlowInstanceDomainServiceImpl implements ProApprovalFlowInstanceDomainService {
        @Autowired
        private ProApprovalFlowInstanceDao instanceDao;
    
        @Override
        public int save(ProApprovalFlowInstanceEntity entity) {
            Assert.notNull(entity, "ProApprovalFlowInstanceEntity is null");
            return instanceDao.save(entity);
        }
    
        @Override
        public int modify(ProApprovalFlowInstanceEntity entity) {
            Assert.notNull(entity, "ProApprovalFlowInstanceEntity is null");
            Assert.notNull(entity.getFlowInstanceId(), FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            return instanceDao.modify(entity);
        }
    
        @Override
        public void updateCurNode(Long flowInstanceId, Long currentNode) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            Assert.notNull(currentNode, "currentNode is required");
            UserVO user = CommonUtil.getCurrentUser();
            instanceDao.modifyCurNode(flowInstanceId, currentNode, user.getUserAccount(), user.getUserCN());
        }
    
        @Override
        public int abort(Long flowInstanceId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            UserVO user = CommonUtil.getCurrentUser();
            return instanceDao.modifyStatus(flowInstanceId, ApprovalEnum.ABORT.name(), user.getUserAccount(),
                user.getUserCN());
        }
    
        @Override
        public int delete(Long flowInstanceId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            return instanceDao.delete(flowInstanceId);
        }
    
        @Override
        public int modifyStatus(Long flowInstanceId, String status) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            Assert.notNull(status, "status is required");
            UserVO user = CommonUtil.getCurrentUser();
            return instanceDao.modifyStatus(flowInstanceId, status, user.getUserAccount(), user.getUserCN());
        }
    
        @Override
        public void modifyResubmitNode(Long flowInstanceId, Long resubmitNodeId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            instanceDao.modifyResubmitNode(flowInstanceId, resubmitNodeId);
        }
    
        @Override
        public void modifyOwner(ModifyOwnerDto modifyOwnerDto) {
            UserVO user = CommonUtil.getCurrentUser();
            modifyOwnerDto.setLastUpdater(user.getUserAccount());
            modifyOwnerDto.setLastUpdaterName(user.getUserCN());
            instanceDao.modifyOwner(modifyOwnerDto);
        }
    
        @Override
        public ProApprovalFlowInstanceDto load(Long flowInstanceId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            return ProApprovalAssembler.instanceToDto(instanceDao.load(flowInstanceId));
        }
    
        @Override
        public ProApprovalFlowInstanceDto loadByBizTypeBizDataId(String bizType, String bizDataId) {
            Assert.hasText(bizType, "bizType is required");
            Assert.hasText(bizDataId, "bizDataId is required");
            return ProApprovalAssembler.instanceToDto(instanceDao.loadByBizTypeBizDataId(bizType, bizDataId));
        }
    
        @Override
        public ProApprovalFlowInstanceDto getInstanceInfo(String bizType, String bizDataId) {
            Assert.hasText(bizType, "bizType is required");
            Assert.hasText(bizDataId, "bizDataId is required");
            return ProApprovalAssembler.instanceToDto(instanceDao.getInstanceInfo(bizType, bizDataId));
        }
    }

@Service
    public class ProApprovalFlowNodeDomainServiceImpl implements ProApprovalFlowNodeDomainService {
        @Autowired
        private ProApprovalFlowNodeDao nodeDao;
    
        @Autowired
        private ApprovalSubmitUtil submitUtil;
    
        @Override
        public List<ProApprovalFlowNodeDto> getByFlowId(ProApprovalFlowInstanceDto instanceInfo) {
            List<ProApprovalFlowNodeEntity> nodeEntityList = nodeDao.getByFlowId(instanceInfo.getFlowId());
            List<ProApprovalFlowNodeDto> nodeDtoList = new ArrayList<>();
            for (ProApprovalFlowNodeEntity entity : nodeEntityList) {
                ProApprovalFlowNodeDto dto = new ProApprovalFlowNodeDto();
                BeanUtils.copyProperties(entity, dto);
                nodeDtoList.add(dto);
            }
            Map<Integer, ProApprovalFlowNodeDto> nodeMap =
                nodeDtoList.stream().collect(Collectors.toMap(ProApprovalFlowNodeDto::getSortNum, item -> item));
            List<ProApprovalFlowNodeDto> nodeList = new ArrayList<>();
            submitUtil.getNode(nodeMap.get(1), instanceInfo, nodeList, nodeMap);
            return nodeList;
        }
    
        @Override
        public String queryLastVersion(Long flowId) {
            Assert.notNull(flowId, ApprovalConstants.FLOW_ID_NULL_ERROR_MSG);
            return nodeDao.queryLastVersion(flowId);
        }
    
        @Override
        public ProApprovalFlowNodeDto load(Long flowNodeId) {
            Assert.notNull(flowNodeId, "flowNodeId is required");
            return ProApprovalAssembler.nodeToDto(nodeDao.load(flowNodeId));
        }
    
        @Override
        public List<ProApprovalFlowNodeDto> loadByFlowIdAndVersion(Long flowId, String flowNodeVersion) {
            Assert.notNull(flowId, ApprovalConstants.FLOW_ID_NULL_ERROR_MSG);
            Assert.hasText(flowNodeVersion, VERSION_NULL_ERROR_MSG);
            List<ProApprovalFlowNodeEntity> nodeList = nodeDao.loadByFlowIdAndVersion(flowId, flowNodeVersion, null);
            List<ProApprovalFlowNodeDto> result = new ArrayList<>();
            nodeList.forEach(item -> {
                ProApprovalFlowNodeDto nodeDto = new ProApprovalFlowNodeDto();
                BeanUtils.copyProperties(item, nodeDto);
                result.add(nodeDto);
            });
            return result;
        }
    
        @Override
        public ProApprovalFlowNodeDto loadByFlowIdAndVersion(Long flowId, String flowNodeVersion, Integer sortNum) {
            Assert.notNull(flowId, ApprovalConstants.FLOW_ID_NULL_ERROR_MSG);
            Assert.hasText(flowNodeVersion, VERSION_NULL_ERROR_MSG);
            Assert.notNull(sortNum, "sortNum is required");
            List<ProApprovalFlowNodeEntity> list = nodeDao.loadByFlowIdAndVersion(flowId, flowNodeVersion, sortNum);
            return ProApprovalAssembler.nodeToDto(list.get(0));
        }
    
        @Override
        public ProApprovalFlowNodeDto loadByFlowCodeAndVersion(Long flowId, String flowNodeCode, String flowNodeVersion) {
            Assert.notNull(flowId, ApprovalConstants.FLOW_ID_NULL_ERROR_MSG);
            Assert.hasText(flowNodeCode, "flowNodeCode is required");
            Assert.hasText(flowNodeVersion, VERSION_NULL_ERROR_MSG);
            ProApprovalFlowNodeEntity entity = nodeDao.loadByFlowCodeAndVersion(flowId, flowNodeCode, flowNodeVersion);
            return ProApprovalAssembler.nodeToDto(entity);
        }
    }

@Service
    @Slf4j
    public class ProApprovalFlowNodeHandlerDomainServiceImpl implements ProApprovalFlowNodeHandlerDomainService {
        @Autowired
        private ProApprovalFlowNodeHandlerDao nodeHandlerDao;
    
        @Override
        public int save(ProApprovalFlowNodeHandlerEntity entity) {
            Assert.notNull(entity, "ProApprovalFlowApproverEntity is null");
            return nodeHandlerDao.save(entity);
        }
    
        @Override
        public void deleteByInstanceId(Long flowInstanceId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            nodeHandlerDao.deleteByInstanceId(flowInstanceId);
        }
    
        @Override
        public void deleteNodeHandler(Long flowInstanceId, Long flowNodeId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            Assert.notNull(flowNodeId, FLOW_NODE_ID_NULL_ERROR_MSG);
            nodeHandlerDao.deleteNodeHandler(flowInstanceId, flowNodeId);
        }
    
        @Override
        public void referral(ProApprovalFlowInstanceDto instance, String originHandler, String forwardUser,
            String forwardUserName) {
            Assert.notNull(instance.getFlowInstanceId(), FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            Assert.notNull(originHandler, "originHandler is required");
            Assert.notNull(forwardUser, "forwardUser is required");
            Assert.notNull(forwardUserName, "forwardUserName is required");
    
            nodeHandlerDao.deleteOldHandler(instance.getFlowInstanceId(), instance.getCurrentNode(), originHandler);
    
            ProApprovalFlowNodeHandlerEntity handlerEntity = new ProApprovalFlowNodeHandlerEntity();
            handlerEntity.setFlowInstanceId(instance.getFlowInstanceId());
            handlerEntity.setFlowNodeId(instance.getCurrentNode());
            handlerEntity.setHandler(forwardUser);
            handlerEntity.setHandlerName(forwardUserName);
            handlerEntity.setHandlerType(HandlerTypeEnum.APPROVER.name());
            CommonUtil.setUser(handlerEntity);
            nodeHandlerDao.save(handlerEntity);
        }
    
        @Override
        public List<ProApprovalFlowNodeHandlerDto> loadByInstance(Long flowInstanceId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            List<ProApprovalFlowNodeHandlerEntity> list =
                    nodeHandlerDao.loadByInstance(flowInstanceId);
            List<ProApprovalFlowNodeHandlerDto> result = new ArrayList<>();
            list.forEach(item -> {
                ProApprovalFlowNodeHandlerDto dto = new ProApprovalFlowNodeHandlerDto();
                BeanUtils.copyProperties(item, dto);
                result.add(dto);
            });
            return result;
        }
    
        @Override
        public List<ProApprovalFlowNodeHandlerDto> loadByInstanceAndNodeId(Long flowInstanceId, Long flowNodeId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            Assert.notNull(flowNodeId, FLOW_NODE_ID_NULL_ERROR_MSG);
            return loadByInstanceAndNodeId(flowInstanceId, flowNodeId, null);
        }
    
        @Override
        public List<ProApprovalFlowNodeHandlerDto> loadByInstanceAndNodeId(Long flowInstanceId, Long flowNodeId,
            String handlerType) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            Assert.notNull(flowNodeId, FLOW_NODE_ID_NULL_ERROR_MSG);
            List<ProApprovalFlowNodeHandlerEntity> list =
                nodeHandlerDao.loadByInstanceAndNodeId(flowInstanceId, flowNodeId, handlerType);
            List<ProApprovalFlowNodeHandlerDto> result = new ArrayList<>();
            list.forEach(item -> {
                ProApprovalFlowNodeHandlerDto dto = new ProApprovalFlowNodeHandlerDto();
                BeanUtils.copyProperties(item, dto);
                result.add(dto);
            });
            return result;
        }
    }

@Service
    public class ProApprovalFlowTodoDomainServiceImpl implements ProApprovalFlowTodoDomainService {
        @Autowired
        private ProApprovalFlowTodoDao todoDao;
    
        @Override
        public int save(ProApprovalFlowTodoEntity entity) {
            Assert.notNull(entity, "ProApprovalFlowTodoEntity is null");
            return todoDao.save(entity);
        }
    
        @Override
        public int modify(ProApprovalFlowTodoDto todoDto) {
            Assert.notNull(todoDto, "ProApprovalFlowTodoDto is null");
            Assert.notNull(todoDto.getFlowInstanceId(), FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            ProApprovalFlowTodoEntity entity = new ProApprovalFlowTodoEntity();
            BeanUtils.copyProperties(todoDto, entity);
            CommonUtil.setUser(entity, false);
            return todoDao.modify(entity);
        }
    
        @Override
        public void invalid(Long flowInstanceId, String result) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            Assert.notNull(result, "result is required");
            ProApprovalFlowTodoEntity condition = new ProApprovalFlowTodoEntity();
            condition.setFlowInstanceId(flowInstanceId);
            List<ProApprovalFlowTodoEntity> list = todoDao.query(condition);
            if (!ObjectUtils.isEmpty(list)) {
                UserVO user = CommonUtil.getCurrentUser();
                for (ProApprovalFlowTodoEntity entity : list) {
                    todoDao.invalid(entity.getId(), entity.getComment(), result, user.getUserAccount(), user.getUserCN());
                }
            }
        }
    
        @Override
        public void invalid(List<ProApprovalFlowTodoDto> todoList) {
            if (!ObjectUtils.isEmpty(todoList)) {
                UserVO user = CommonUtil.getCurrentUser();
                for (ProApprovalFlowTodoDto dto : todoList) {
                    todoDao.invalid(dto.getId(), dto.getResult(), dto.getComment(), user.getUserAccount(),
                        user.getUserCN());
                }
            }
        }
    
        @Override
        public int delete(Long flowInstanceId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            return todoDao.delete(flowInstanceId);
        }
    
        @Override
        public Optional<ProApprovalFlowTodoDto> loadByHandler(Long flowInstanceId, Long flowNodeId, String handler) {
            ProApprovalFlowTodoEntity condition = new ProApprovalFlowTodoEntity();
            condition.setFlowInstanceId(flowInstanceId);
            condition.setFlowNodeId(flowNodeId);
            condition.setHandler(handler);
            condition.setResult(ApprovalEnum.UNHANDLED.name());
            condition.setActiveFlag(YES);
            List<ProApprovalFlowTodoDto> list = query(condition);
            if (ObjectUtils.isEmpty(list)) {
                return Optional.empty();
            }
            return Optional.of(list.get(0));
        }
    
        @Override
        public List<ProApprovalFlowTodoDto> loadByCurNode(Long flowInstanceId, Long flowNodeId) {
            ProApprovalFlowTodoEntity condition = new ProApprovalFlowTodoEntity();
            condition.setFlowInstanceId(flowInstanceId);
            condition.setFlowNodeId(flowNodeId);
            condition.setActiveFlag(YES);
            return query(condition);
        }
    
        @Override
        public List<ProApprovalFlowTodoDto> loadByInstance(Long flowInstanceId) {
            ProApprovalFlowTodoEntity condition = new ProApprovalFlowTodoEntity();
            condition.setFlowInstanceId(flowInstanceId);
            condition.setActiveFlag(YES);
            return query(condition);
        }
    
        @Override
        public List<ProApprovalFlowTodoDto> query(ProApprovalFlowTodoEntity condition) {
            Assert.notNull(condition, "condition is null");
            Assert.notNull(condition.getFlowInstanceId(), FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            List<ProApprovalFlowTodoEntity> list = todoDao.query(condition);
            List<ProApprovalFlowTodoDto> result = new ArrayList<>();
            list.forEach(item -> {
                ProApprovalFlowTodoDto todoDto = new ProApprovalFlowTodoDto();
                BeanUtils.copyProperties(item, todoDto);
                result.add(todoDto);
            });
            return result;
        }
    
        @Override
        public List<ProApprovalFlowTodoDto> queryApprovalRecord(String account, String bizDataId, String flowNodeCode) {
            List<ProApprovalFlowTodoEntity> list = todoDao.queryApprovalRecord(account, bizDataId, flowNodeCode);
            List<ProApprovalFlowTodoDto> result = new ArrayList<>();
            list.forEach(item -> {
                ProApprovalFlowTodoDto todoDto = new ProApprovalFlowTodoDto();
                BeanUtils.copyProperties(item, todoDto);
                result.add(todoDto);
            });
            return result;
        }
    }

@Service
    public class ProApprovalLogDomainServiceImpl implements ProApprovalFlowLogDomainService {
        @Autowired
        private ProApprovalFlowLogDao logDao;
    
        @Override
        public void save(Long flowInstanceId, Long flowNodeId, String opType, String remark) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            Assert.notNull(flowNodeId, "flowNodeId is required");
            Assert.notNull(opType, "opType is required");
            ProApprovalFlowLogEntity entity = new ProApprovalFlowLogEntity();
            entity.setFlowInstanceId(flowInstanceId);
            entity.setFlowNodeId(flowNodeId);
            entity.setOpType(opType);
            entity.setRemark(remark);
            CommonUtil.setUser(entity);
            logDao.save(entity);
        }
    
        @Override
        public int delete(Long flowInstanceId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            return logDao.delete(flowInstanceId);
        }
    
        @Override
        public List<ProApprovalFlowLogDto> loadByFlowInstanceId(Long flowInstanceId) {
            Assert.notNull(flowInstanceId, FLOW_INSTANCE_ID_NULL_ERROR_MSG);
            List<ProApprovalFlowLogEntity> list = logDao.loadByFlowInstanceId(flowInstanceId);
            List<ProApprovalFlowLogDto> result = new ArrayList<>();
            list.forEach(item -> {
                ProApprovalFlowLogDto logDto = new ProApprovalFlowLogDto();
                BeanUtils.copyProperties(item, logDto);
                result.add(logDto);
            });
            return result;
        }
    }