groups.add(copy(group, deep)); inputPorts.add(copy(port)); outputPorts.add(copy(port)); labels.add(copy(label)); processors.add(copy(processor)); remoteProcessGroups.add(copy(remoteGroup)); funnels.add(copy(funnel)); connections.add(copy(connection)); controllerServices.add(copy(controllerService)); connections.addAll(copy(original.getConnections())); groups.addAll(copy(original.getProcessGroups())); inputPorts.addAll(copy(original.getInputPorts())); outputPorts.addAll(copy(original.getOutputPorts())); labels.addAll(copy(original.getLabels())); processors.addAll(copy(original.getProcessors()));
@Override public TemplateDTO exportTemplate(final String id) { final Template template = templateDAO.getTemplate(id); final TemplateDTO templateDetails = template.getDetails(); final TemplateDTO templateDTO = dtoFactory.createTemplateDTO(template); templateDTO.setSnippet(dtoFactory.copySnippetContents(templateDetails.getSnippet())); return templateDTO; }
@Override public AccessPolicyEntity createAccessPolicy(final Revision revision, final AccessPolicyDTO accessPolicyDTO) { final Authorizable tenantAuthorizable = authorizableLookup.getTenant(); final String creator = NiFiUserUtils.getNiFiUserIdentity(); final AccessPolicy newAccessPolicy = accessPolicyDAO.createAccessPolicy(accessPolicyDTO); final ComponentReferenceEntity componentReference = createComponentReferenceEntity(newAccessPolicy.getResource()); final AccessPolicyDTO newAccessPolicyDto = dtoFactory.createAccessPolicyDto(newAccessPolicy, newAccessPolicy.getGroups().stream().map(mapUserGroupIdToTenantEntity()).collect(Collectors.toSet()), newAccessPolicy.getUsers().stream().map(userId -> { final RevisionDTO userRevision = dtoFactory.createRevisionDTO(revisionManager.getRevision(userId)); return entityFactory.createTenantEntity(dtoFactory.createTenantDTO(userDAO.getUser(userId)), userRevision, dtoFactory.createPermissionsDto(tenantAuthorizable)); }).collect(Collectors.toSet()), componentReference); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(authorizableLookup.getAccessPolicyById(accessPolicyDTO.getId())); return entityFactory.createAccessPolicyEntity(newAccessPolicyDto, dtoFactory.createRevisionDTO(new FlowModification(revision, creator)), permissions); }
public Set<AffectedComponentEntity> createAffectedComponentEntities(final Set<ComponentNode> affectedComponents, final RevisionManager revisionManager) { return affectedComponents.stream() .map(component -> { final AffectedComponentDTO affectedComponent = createAffectedComponentDto(component); final PermissionsDTO permissions = createPermissionsDto(component); final RevisionDTO revision = createRevisionDTO(revisionManager.getRevision(component.getIdentifier())); return entityFactory.createAffectedComponentEntity(affectedComponent, revision, permissions); }) .collect(Collectors.toSet()); }
/** * Creates a FlowBreadcrumbEntity from the specified parent ProcessGroup. * * @param group group * @return dto */ private FlowBreadcrumbEntity createBreadcrumbEntity(final ProcessGroup group) { if (group == null) { return null; } final FlowBreadcrumbDTO dto = createBreadcrumbDto(group); final PermissionsDTO permissions = createPermissionsDto(group); final FlowBreadcrumbEntity entity = entityFactory.createFlowBreadcrumbEntity(dto, permissions); if (group.getParent() != null) { entity.setParentBreadcrumb(createBreadcrumbEntity(group.getParent())); } return entity; }
private AccessPolicyEntity createAccessPolicyEntity(final AccessPolicy accessPolicy) { final RevisionDTO revision = dtoFactory.createRevisionDTO(revisionManager.getRevision(accessPolicy.getIdentifier())); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(authorizableLookup.getAccessPolicyById(accessPolicy.getIdentifier())); final ComponentReferenceEntity componentReference = createComponentReferenceEntity(accessPolicy.getResource()); return entityFactory.createAccessPolicyEntity( dtoFactory.createAccessPolicyDto(accessPolicy, accessPolicy.getGroups().stream().map(mapUserGroupIdToTenantEntity()).collect(Collectors.toSet()), accessPolicy.getUsers().stream().map(mapUserIdToTenantEntity()).collect(Collectors.toSet()), componentReference), revision, permissions); }
private AccessPolicySummaryEntity createAccessPolicySummaryEntity(final AccessPolicy ap) { final ComponentReferenceEntity componentReference = createComponentReferenceEntity(ap.getResource()); final AccessPolicySummaryDTO apSummary = dtoFactory.createAccessPolicySummaryDto(ap, componentReference); final PermissionsDTO apPermissions = dtoFactory.createPermissionsDto(authorizableLookup.getAccessPolicyById(ap.getIdentifier())); final RevisionDTO apRevision = dtoFactory.createRevisionDTO(revisionManager.getRevision(ap.getIdentifier())); return entityFactory.createAccessPolicySummaryEntity(apSummary, apRevision, apPermissions); }
@Override public AccessPolicyEntity deleteAccessPolicy(final Revision revision, final String accessPolicyId) { final AccessPolicy accessPolicy = accessPolicyDAO.getAccessPolicy(accessPolicyId); final ComponentReferenceEntity componentReference = createComponentReferenceEntity(accessPolicy.getResource()); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(authorizableLookup.getAccessPolicyById(accessPolicyId)); final Set<TenantEntity> userGroups = accessPolicy != null ? accessPolicy.getGroups().stream().map(mapUserGroupIdToTenantEntity()).collect(Collectors.toSet()) : null; final Set<TenantEntity> users = accessPolicy != null ? accessPolicy.getUsers().stream().map(mapUserIdToTenantEntity()).collect(Collectors.toSet()) : null; final AccessPolicyDTO snapshot = deleteComponent( revision, new Resource() { @Override public String getIdentifier() { return accessPolicy.getResource(); } @Override public String getName() { return accessPolicy.getResource(); } @Override public String getSafeDescription() { return "Policy " + accessPolicyId; } }, () -> accessPolicyDAO.deleteAccessPolicy(accessPolicyId), false, // no need to clean up any policies as it's already been removed above dtoFactory.createAccessPolicyDto(accessPolicy, userGroups, users, componentReference)); return entityFactory.createAccessPolicyEntity(snapshot, null, permissions); }
@Override public HistoryDTO getActions(final HistoryQueryDTO historyQueryDto) { // extract the query criteria final HistoryQuery historyQuery = new HistoryQuery(); historyQuery.setStartDate(historyQueryDto.getStartDate()); historyQuery.setEndDate(historyQueryDto.getEndDate()); historyQuery.setSourceId(historyQueryDto.getSourceId()); historyQuery.setUserIdentity(historyQueryDto.getUserIdentity()); historyQuery.setOffset(historyQueryDto.getOffset()); historyQuery.setCount(historyQueryDto.getCount()); historyQuery.setSortColumn(historyQueryDto.getSortColumn()); historyQuery.setSortOrder(historyQueryDto.getSortOrder()); // perform the query final History history = auditService.getActions(historyQuery); // only retain authorized actions final HistoryDTO historyDto = dtoFactory.createHistoryDto(history); if (history.getActions() != null) { final List<ActionEntity> actionEntities = new ArrayList<>(); for (final Action action : history.getActions()) { final AuthorizationResult result = authorizeAction(action); actionEntities.add(entityFactory.createActionEntity(dtoFactory.createActionDto(action), Result.Approved.equals(result.getResult()))); } historyDto.setActions(actionEntities); } // create the response return historyDto; }
/** * Creates an ActionDTO for the specified Action. * * @param action action * @return dto */ public ActionDTO createActionDto(final Action action) { final ActionDTO actionDto = new ActionDTO(); actionDto.setId(action.getId()); actionDto.setSourceId(action.getSourceId()); actionDto.setSourceName(action.getSourceName()); actionDto.setSourceType(action.getSourceType().toString()); actionDto.setTimestamp(action.getTimestamp()); actionDto.setUserIdentity(action.getUserIdentity()); actionDto.setOperation(action.getOperation().toString()); actionDto.setActionDetails(createActionDetailsDto(action.getActionDetails())); actionDto.setComponentDetails(createComponentDetailsDto(action.getComponentDetails())); return actionDto; }
if (snippetContents.getControllerServices() != null) { for (final ControllerServiceDTO serviceDTO : snippetContents.getControllerServices()) { final ControllerServiceDTO service = dtoFactory.copy(serviceDTO); service.setId(generateId(serviceDTO.getId(), idGenerationSeed, isCopy)); service.setState(ControllerServiceState.DISABLED.name()); if (snippetContents.getLabels() != null) { for (final LabelDTO labelDTO : snippetContents.getLabels()) { final LabelDTO label = dtoFactory.copy(labelDTO); label.setId(generateId(labelDTO.getId(), idGenerationSeed, isCopy)); label.setParentGroupId(groupId); if (snippetContents.getFunnels() != null) { for (final FunnelDTO funnelDTO : snippetContents.getFunnels()) { final FunnelDTO cp = dtoFactory.copy(funnelDTO); cp.setId(generateId(funnelDTO.getId(), idGenerationSeed, isCopy)); cp.setParentGroupId(groupId); funnels.add(cp); connectableMap.put(funnelDTO.getParentGroupId() + "-" + funnelDTO.getId(), dtoFactory.createConnectableDto(cp)); if (snippetContents.getInputPorts() != null) { for (final PortDTO portDTO : snippetContents.getInputPorts()) { final PortDTO cp = dtoFactory.copy(portDTO); cp.setId(generateId(portDTO.getId(), idGenerationSeed, isCopy)); cp.setParentGroupId(groupId); final ConnectableDTO portConnectable = dtoFactory.createConnectableDto(cp, ConnectableType.INPUT_PORT); connectableMap.put(portDTO.getParentGroupId() + "-" + portDTO.getId(), portConnectable);
@Override public Set<AffectedComponentEntity> getComponentsAffectedByVariableRegistryUpdate(final VariableRegistryDTO variableRegistryDto) { final ProcessGroup group = processGroupDAO.getProcessGroup(variableRegistryDto.getProcessGroupId()); if (group == null) { throw new ResourceNotFoundException("Could not find Process Group with ID " + variableRegistryDto.getProcessGroupId()); } final Map<String, String> variableMap = new HashMap<>(); variableRegistryDto.getVariables().stream() // have to use forEach here instead of using Collectors.toMap because value may be null .map(VariableEntity::getVariable) .forEach(var -> variableMap.put(var.getName(), var.getValue())); final Set<AffectedComponentEntity> affectedComponentEntities = new HashSet<>(); final Set<String> updatedVariableNames = getUpdatedVariables(group, variableMap); for (final String variableName : updatedVariableNames) { final Set<ComponentNode> affectedComponents = group.getComponentsAffectedByVariable(variableName); affectedComponentEntities.addAll(dtoFactory.createAffectedComponentEntities(affectedComponents, revisionManager)); } return affectedComponentEntities; }
final ProcessorNode procNode = (ProcessorNode) component; if (procNode.isRunning()) { affectedComponentDtos.add(dtoFactory.createAffectedComponentDto(procNode)); affectedComponentDtos.add(dtoFactory.createAffectedComponentDto(serviceNode));
case AffectedComponentDTO.COMPONENT_TYPE_PROCESSOR: final ProcessorEntity procEntity = serviceFacade.getProcessor(componentEntity.getId()); return dtoFactory.createAffectedComponentEntity(procEntity); case AffectedComponentDTO.COMPONENT_TYPE_INPUT_PORT: { final PortEntity portEntity = serviceFacade.getInputPort(componentEntity.getId()); return dtoFactory.createAffectedComponentEntity(portEntity, AffectedComponentDTO.COMPONENT_TYPE_INPUT_PORT); return dtoFactory.createAffectedComponentEntity(portEntity, AffectedComponentDTO.COMPONENT_TYPE_OUTPUT_PORT); return dtoFactory.createAffectedComponentEntity(serviceEntity); case AffectedComponentDTO.COMPONENT_TYPE_REMOTE_INPUT_PORT: { final RemoteProcessGroupEntity remoteGroupEntity = serviceFacade.getRemoteProcessGroup(componentEntity.getComponent().getProcessGroupId()); return dtoFactory.createAffectedComponentEntity(portDto, AffectedComponentDTO.COMPONENT_TYPE_REMOTE_INPUT_PORT, remoteGroupEntity); return dtoFactory.createAffectedComponentEntity(portDto, AffectedComponentDTO.COMPONENT_TYPE_REMOTE_OUTPUT_PORT, remoteGroupEntity);
@Override public ActionEntity getAction(final Integer actionId) { // get the action final Action action = auditService.getAction(actionId); // ensure the action was found if (action == null) { throw new ResourceNotFoundException(String.format("Unable to find action with id '%s'.", actionId)); } final AuthorizationResult result = authorizeAction(action); final boolean authorized = Result.Approved.equals(result.getResult()); if (!authorized) { throw new AccessDeniedException(result.getExplanation()); } // return the action return entityFactory.createActionEntity(dtoFactory.createActionDto(action), authorized); }
@Override public AccessPolicyEntity updateAccessPolicy(final Revision revision, final AccessPolicyDTO accessPolicyDTO) { final Authorizable authorizable = authorizableLookup.getAccessPolicyById(accessPolicyDTO.getId()); final RevisionUpdate<AccessPolicyDTO> snapshot = updateComponent(revision, authorizable, () -> accessPolicyDAO.updateAccessPolicy(accessPolicyDTO), accessPolicy -> { final Set<TenantEntity> users = accessPolicy.getUsers().stream().map(mapUserIdToTenantEntity()).collect(Collectors.toSet()); final Set<TenantEntity> userGroups = accessPolicy.getGroups().stream().map(mapUserGroupIdToTenantEntity()).collect(Collectors.toSet()); final ComponentReferenceEntity componentReference = createComponentReferenceEntity(accessPolicy.getResource()); return dtoFactory.createAccessPolicyDto(accessPolicy, userGroups, users, componentReference); }); final PermissionsDTO permissions = dtoFactory.createPermissionsDto(authorizable); return entityFactory.createAccessPolicyEntity(snapshot.getComponent(), dtoFactory.createRevisionDTO(snapshot.getLastModification()), permissions); }
variableDto.setProcessGroupId(processGroup.getIdentifier()); final Set<AffectedComponentEntity> affectedComponentEntities = createAffectedComponentEntities(processGroup.getComponentsAffectedByVariable(variableName), revisionManager);
copySnippet.getConnections().add(copy(connection)); copySnippet.getInputPorts().add(copy(port)); copySnippet.getOutputPorts().add(copy(port)); copySnippet.getProcessGroups().add(copy(processGroup, true)); copySnippet.getProcessors().add(copy(processor)); copySnippet.getLabels().add(copy(label)); copySnippet.getFunnels().add(copy(funnel)); copySnippet.getRemoteProcessGroups().add(copy(remoteGroup)); copySnippet.getControllerServices().add(copy(controllerService));
variableDto.setProcessGroupId(group.getIdentifier()); final Set<AffectedComponentEntity> affectedComponentEntities = createAffectedComponentEntities(group.getComponentsAffectedByVariable(variableDto.getName()), revisionManager);
public PortDTO copy(final PortDTO original) { final PortDTO copy = new PortDTO(); copy.setPosition(original.getPosition()); copy.setId(original.getId()); copy.setName(original.getName()); copy.setComments(original.getComments()); copy.setParentGroupId(original.getParentGroupId()); copy.setState(original.getState()); copy.setType(original.getType()); copy.setTransmitting(original.isTransmitting()); copy.setConcurrentlySchedulableTaskCount(original.getConcurrentlySchedulableTaskCount()); copy.setUserAccessControl(copy(original.getUserAccessControl())); copy.setGroupAccessControl(copy(original.getGroupAccessControl())); copy.setValidationErrors(copy(original.getValidationErrors())); copy.setVersionedComponentId(original.getVersionedComponentId()); return copy; }