Examples with NodePointer org.openforis.idm.model.NodePointer used on opensource projects

Example 11 with NodePointer

use of org.openforis.idm.model.NodePointer in project collect by openforis.

the class RecordUpdater method updateMaxCount.

@SuppressWarnings("deprecation")
private Collection<NodePointer> updateMaxCount(Collection<NodePointer> nodePointers) {
    List<NodePointer> updatedPointers = new ArrayList<NodePointer>();
    for (NodePointer nodePointer : nodePointers) {
        Entity entity = nodePointer.getEntity();
        NodeDefinition childDef = nodePointer.getChildDefinition();
        Integer oldCount = entity.getMaxCount(childDef);
        int newCount = calculateMaxCount(nodePointer);
        entity.setMaxCount(childDef, newCount);
        if (!ObjectUtils.equals(oldCount, newCount)) {
            updatedPointers.add(nodePointer);
        }
    }
    return updatedPointers;
}

Example 12 with NodePointer

use of org.openforis.idm.model.NodePointer in project collect by openforis.

the class RecordUpdater method deleteNode.

/**
 * Deletes a node from the record.
 *
 * @param node
 * @return
 */
public NodeChangeSet deleteNode(Node<?> node) {
    Record record = node.getRecord();
    NodeChangeMap changeMap = new NodeChangeMap();
    Set<Node<?>> nodesToBeDeleted = node.getDescendantsAndSelf();
    Set<NodePointer> pointersToBeDeleted = nodesToPointers(nodesToBeDeleted);
    NodePointer nodePointer = new NodePointer(node);
    List<NodePointer> ancestorPointers = getAncestorPointers(node);
    Entity parentEntity = node.getParent();
    // calculated attributes
    List<Attribute<?, ?>> dependentCalculatedAttributes = record.determineCalculatedAttributes(nodesToBeDeleted);
    dependentCalculatedAttributes.removeAll(nodesToBeDeleted);
    if (validateAfterUpdate) {
        // relevance
        List<NodePointer> relevanceDependenciesToDeleted = record.determineRelevanceDependentNodes(nodesToBeDeleted);
        // min/max
        Collection<NodePointer> preDeletionMinMaxDependenciesToCheck = new HashSet<NodePointer>(pointersToBeDeleted);
        preDeletionMinMaxDependenciesToCheck.addAll(getAncestorsAndSelfPointers(node));
        Collection<NodePointer> minCountDependenciesToDelete = record.determineMinCountDependentNodes(preDeletionMinMaxDependenciesToCheck);
        Collection<NodePointer> maxCountDependenciesToDelete = record.determineMaxCountDependentNodes(preDeletionMinMaxDependenciesToCheck);
        // validation
        Set<Attribute<?, ?>> validationDependenciesToDeleted = record.determineValidationDependentNodes(nodesToBeDeleted);
        validationDependenciesToDeleted.removeAll(nodesToBeDeleted);
        List<Integer> ancestorIds = node.getAncestorIds();
        performNodeDeletion(node);
        changeMap.addNodeDeleteChange(record.getId(), ((CollectRecord) record).getStep(), ancestorIds, node);
        // calculated attributes
        List<Attribute<?, ?>> updatedCalculatedAttributes = recalculateValues(dependentCalculatedAttributes);
        changeMap.addValueChanges(updatedCalculatedAttributes);
        // relevance
        Set<NodePointer> pointersToRecalculateRelevanceFor = new HashSet<NodePointer>();
        pointersToRecalculateRelevanceFor.addAll(record.determineRelevanceDependentNodes(updatedCalculatedAttributes));
        pointersToRecalculateRelevanceFor.addAll(relevanceDependenciesToDeleted);
        if (parentEntity != null) {
            pointersToRecalculateRelevanceFor.addAll(record.determineRelevanceDependentNodePointers(Arrays.asList(new NodePointer(parentEntity, node.getDefinition()))));
        }
        List<NodePointer> relevanceToUpdate = record.determineRelevanceDependentNodePointers(pointersToRecalculateRelevanceFor);
        // check relevance update with detached entity in node pointer
        RelevanceUpdater relevanceUpdater = new RelevanceUpdater(relevanceToUpdate);
        Set<NodePointer> updatedRelevancePointers = relevanceUpdater.update();
        changeMap.addRelevanceChanges(updatedRelevancePointers);
        // min count
        Collection<NodePointer> pointersToCheckMinCountFor = new HashSet<NodePointer>(updatedRelevancePointers);
        pointersToCheckMinCountFor.addAll(minCountDependenciesToDelete);
        pointersToCheckMinCountFor.addAll(nodesToPointers(updatedCalculatedAttributes));
        Collection<NodePointer> minCountPointersToUpdate = record.determineMinCountDependentNodes(pointersToCheckMinCountFor);
        Collection<NodePointer> updatedMinCountPointers = updateMinCount(minCountPointersToUpdate);
        changeMap.addMinCountChanges(updatedMinCountPointers);
        // max count
        Collection<NodePointer> pointersToCheckMaxCountFor = new HashSet<NodePointer>(updatedRelevancePointers);
        pointersToCheckMaxCountFor.addAll(maxCountDependenciesToDelete);
        pointersToCheckMaxCountFor.addAll(nodesToPointers(updatedCalculatedAttributes));
        Collection<NodePointer> maxCountPointersToUpdate = record.determineMaxCountDependentNodes(pointersToCheckMaxCountFor);
        Collection<NodePointer> updatedMaxCountPointers = updateMaxCount(maxCountPointersToUpdate);
        changeMap.addMinCountChanges(updatedMaxCountPointers);
        Set<NodePointer> updatedCardinalityPointers = new HashSet<NodePointer>(updatedMinCountPointers);
        updatedCardinalityPointers.addAll(updatedMaxCountPointers);
        // validate cardinality
        Set<NodePointer> pointersToValidateCardinalityFor = new HashSet<NodePointer>(updatedMinCountPointers.size() + updatedMaxCountPointers.size());
        pointersToValidateCardinalityFor.addAll(updatedMinCountPointers);
        pointersToValidateCardinalityFor.addAll(updatedMaxCountPointers);
        // validate cardinality on ancestor node pointers because we are considering empty nodes as missing nodes
        pointersToValidateCardinalityFor.add(nodePointer);
        pointersToValidateCardinalityFor.addAll(ancestorPointers);
        validateCardinality(record, pointersToValidateCardinalityFor, changeMap);
        // validate attributes
        Set<Node<?>> nodesToCheckValidationFor = new HashSet<Node<?>>(validationDependenciesToDeleted);
        nodesToCheckValidationFor.addAll(updatedCalculatedAttributes);
        nodesToCheckValidationFor.addAll(pointersToNodes(updatedRelevancePointers));
        nodesToCheckValidationFor.addAll(pointersToNodes(updatedCardinalityPointers));
        Set<Attribute<?, ?>> attributesToRevalidate = record.determineValidationDependentNodes(nodesToCheckValidationFor);
        validateAttributes(record, attributesToRevalidate, changeMap);
    } else {
        performNodeDeletion(node);
        // calculated attributes
        List<Attribute<?, ?>> updatedCalculatedAttributes = recalculateValues(dependentCalculatedAttributes);
        changeMap.addValueChanges(updatedCalculatedAttributes);
    }
    return changeMap;
}

Example 13 with NodePointer

use of org.openforis.idm.model.NodePointer in project collect by openforis.

the class RecordUpdater method approveMissingValue.

public NodeChangeSet approveMissingValue(Entity parentEntity, String nodeName) {
    setMissingValueApproved(parentEntity, nodeName, true);
    List<NodePointer> cardinalityPointers = getAncestorPointers(parentEntity);
    cardinalityPointers.add(new NodePointer(parentEntity, nodeName));
    NodeChangeMap changeMap = new NodeChangeMap();
    validateCardinality(parentEntity.getRecord(), cardinalityPointers, changeMap);
    return changeMap;
}

Example 14 with NodePointer

use of org.openforis.idm.model.NodePointer in project collect by openforis.

the class RecordUpdater method getAncestorPointers.

private List<NodePointer> getAncestorPointers(Node<?> node) {
    List<NodePointer> pointers = new ArrayList<NodePointer>();
    Entity parent = node.getParent();
    if (parent != null && parent.getParent() != null) {
        pointers.add(new NodePointer(parent));
        pointers.addAll(getAncestorPointers(parent));
    }
    return pointers;
}