Examples with RevisionSearcher com.b2international.index.revision.RevisionSearcher used on opensource projects

Example 16 with RevisionSearcher

use of com.b2international.index.revision.RevisionSearcher in project snow-owl by b2ihealthcare.

the class ComponentEffectiveTimeRestoreChangeProcessor method process.

@Override
public void process(StagingArea staging, RevisionSearcher searcher) throws IOException {
    final Multimap<Class<? extends SnomedDocument>, SnomedDocument> componentsByType = ArrayListMultimap.create();
    staging.getChangedObjects().filter(SnomedDocument.class::isInstance).map(SnomedDocument.class::cast).filter(doc -> doc.isReleased() && EffectiveTimes.isUnset(doc.getEffectiveTime())).forEach(doc -> componentsByType.put(doc.getClass(), doc));
    if (componentsByType.isEmpty()) {
        return;
    }
    final RepositoryContext context = ClassUtils.checkAndCast(staging.getContext(), RepositoryContext.class);
    final List<String> branchesForPreviousVersion = getAvailableVersionPaths(context, staging.getBranchPath());
    if (branchesForPreviousVersion.isEmpty()) {
        return;
    }
    final Multimap<Class<? extends SnomedDocument>, String> componentHadPreviousVersionOnAnyBranch = ArrayListMultimap.create();
    for (String branchToCheck : branchesForPreviousVersion) {
        for (Class<? extends SnomedDocument> componentType : ImmutableSet.copyOf(componentsByType.keySet())) {
            final Set<String> componentIds = componentsByType.get(componentType).stream().map(SnomedDocument::getId).collect(Collectors.toSet());
            final Map<String, ? extends SnomedDocument> previousVersions = Maps.uniqueIndex(fetchPreviousComponentRevisions(staging.getIndex(), branchToCheck, componentType, componentIds), SnomedDocument::getId);
            for (SnomedDocument changedRevision : ImmutableList.copyOf(componentsByType.get(componentType))) {
                final SnomedDocument previousVersion = previousVersions.get(changedRevision.getId());
                if (previousVersion != null) {
                    if (canRestoreEffectiveTime(changedRevision, previousVersion)) {
                        SnomedDocument restoredRevision = toBuilder(changedRevision).effectiveTime(previousVersion.getEffectiveTime()).build();
                        stageChange(changedRevision, restoredRevision);
                        // successfully restored, remove from remaining item list
                        componentsByType.remove(componentType, changedRevision);
                    } else {
                        // register as a component that had an earlier version and can be ignored from the warning message beneath even if there were no prev versions to restore ET from
                        componentHadPreviousVersionOnAnyBranch.put(componentType, changedRevision.getId());
                    }
                }
            }
        }
    }
    // after checking all branches, clear everything that had at least one previous version, report anything that remains as released content without previous version
    componentHadPreviousVersionOnAnyBranch.forEach((componentType, changedRevisionId) -> {
        componentsByType.remove(componentType, changedRevisionId);
    });
    if (!componentsByType.isEmpty()) {
        log.warn("There were components which could not be restored, {}.", componentsByType.values().stream().map(SnomedDocument::getId).collect(Collectors.toSet()));
    }
}

Example 17 with RevisionSearcher

use of com.b2international.index.revision.RevisionSearcher in project snow-owl by b2ihealthcare.

the class DescriptionAcceptabilityChangeProcessor method process.

public Map<String, Multimap<Acceptability, RefSetMemberChange>> process(StagingArea staging, RevisionSearcher searcher) throws IOException {
    final Multimap<String, RefSetMemberChange> preferredMemberChanges = HashMultimap.create();
    final Multimap<String, RefSetMemberChange> acceptableMemberChanges = HashMultimap.create();
    // add active new and active dirty members
    final Stream<SnomedRefSetMemberIndexEntry> newAndDirtyMembers = Streams.concat(staging.getNewObjects(SnomedRefSetMemberIndexEntry.class).filter(member -> member.getReferenceSetType() == SnomedRefSetType.LANGUAGE), staging.getChangedRevisions(SnomedRefSetMemberIndexEntry.class).map(diff -> (SnomedRefSetMemberIndexEntry) diff.newRevision).filter(member -> member.getReferenceSetType() == SnomedRefSetType.LANGUAGE));
    newAndDirtyMembers.forEach(member -> {
        if (member.isActive()) {
            final String uuid = member.getId();
            final String refSetId = member.getRefsetId();
            final RefSetMemberChange change = new RefSetMemberChange(uuid, refSetId, MemberChangeKind.ADDED, member.isActive());
            registerChange(preferredMemberChanges, acceptableMemberChanges, member.getAcceptabilityId(), member.getReferencedComponentId(), change);
        }
    });
    // remove dirty inactive (and/or changed in acceptability) members
    final List<SnomedRefSetMemberIndexEntry> dirtyMembers = staging.getChangedRevisions(SnomedRefSetMemberIndexEntry.class).map(diff -> (SnomedRefSetMemberIndexEntry) diff.newRevision).filter(member -> member.getReferenceSetType() == SnomedRefSetType.LANGUAGE).collect(Collectors.toList());
    final Set<String> dirtyMemberIds = dirtyMembers.stream().map(SnomedRefSetMemberIndexEntry::getId).collect(Collectors.toSet());
    final List<SnomedRefSetMemberIndexEntry> detachedLanguageMembers = staging.getRemovedObjects(SnomedRefSetMemberIndexEntry.class).filter(member -> member.getReferenceSetType() == SnomedRefSetType.LANGUAGE).collect(Collectors.toList());
    final Map<String, SnomedRefSetMemberIndexEntry> currentRevisionsByMemberId = newHashMap();
    detachedLanguageMembers.forEach(member -> currentRevisionsByMemberId.put(member.getId(), member));
    searcher.get(SnomedRefSetMemberIndexEntry.class, dirtyMemberIds).forEach(member -> currentRevisionsByMemberId.put(member.getId(), member));
    for (SnomedRefSetMemberIndexEntry member : dirtyMembers) {
        final String uuid = member.getId();
        final String refSetId = member.getRefsetId();
        final RefSetMemberChange change = new RefSetMemberChange(uuid, refSetId, MemberChangeKind.REMOVED, member.isActive());
        final SnomedRefSetMemberIndexEntry before = currentRevisionsByMemberId.get(member.getId());
        if (before != null) {
            final String beforeAcceptabilityId = before.getAcceptabilityId();
            final boolean beforeActive = before.isActive();
            final boolean acceptabilityChanged = !member.getAcceptabilityId().equals(beforeAcceptabilityId);
            if (beforeActive && acceptabilityChanged) {
                registerChange(preferredMemberChanges, acceptableMemberChanges, beforeAcceptabilityId, member.getReferencedComponentId(), change);
            }
        }
        if (!member.isActive()) {
            registerChange(preferredMemberChanges, acceptableMemberChanges, member.getAcceptabilityId(), member.getReferencedComponentId(), change);
        }
    }
    for (final SnomedRefSetMemberIndexEntry before : detachedLanguageMembers) {
        if (before.isActive()) {
            final String uuid = before.getId();
            final String refSetId = before.getRefsetId();
            final String referencedComponentId = before.getReferencedComponentId();
            final String beforeAcceptabilityId = before.getAcceptabilityId();
            final RefSetMemberChange change = new RefSetMemberChange(uuid, refSetId, MemberChangeKind.REMOVED, before.isActive());
            registerChange(preferredMemberChanges, acceptableMemberChanges, beforeAcceptabilityId, referencedComponentId, change);
        }
    }
    final Map<String, Multimap<Acceptability, RefSetMemberChange>> changes = newHashMap();
    for (String descriptionId : Iterables.concat(preferredMemberChanges.keySet(), acceptableMemberChanges.keySet())) {
        if (!changes.containsKey(descriptionId)) {
            changes.put(descriptionId, HashMultimap.<Acceptability, RefSetMemberChange>create());
        }
        final Multimap<Acceptability, RefSetMemberChange> memberChanges = changes.get(descriptionId);
        memberChanges.putAll(Acceptability.PREFERRED, preferredMemberChanges.get(descriptionId));
        memberChanges.putAll(Acceptability.ACCEPTABLE, acceptableMemberChanges.get(descriptionId));
    }
    return changes;
}

Example 18 with RevisionSearcher

use of com.b2international.index.revision.RevisionSearcher in project snow-owl by b2ihealthcare.

the class RelationshipChangeProcessor method process.

@Override
public void process(StagingArea staging, RevisionSearcher searcher) throws IOException {
    final Multimap<String, RefSetMemberChange> referringRefSets = memberChangeProcessor.process(staging, searcher);
    final Set<String> referencedRelationshipIds = newHashSet(referringRefSets.keySet());
    staging.getNewObjects(SnomedRelationshipIndexEntry.class).map(SnomedRelationshipIndexEntry::getId).forEach(referencedRelationshipIds::remove);
    final Map<String, SnomedRelationshipIndexEntry> changedRelationshipsById = staging.getChangedRevisions(SnomedRelationshipIndexEntry.class).map(diff -> (SnomedRelationshipIndexEntry) diff.newRevision).collect(Collectors.toMap(relationship -> relationship.getId(), relationship -> relationship));
    final Set<String> changedRelationshipIds = newHashSet(changedRelationshipsById.keySet());
    changedRelationshipIds.addAll(referencedRelationshipIds);
    final Iterable<SnomedRelationshipIndexEntry> changedRelationshipHits = searcher.get(SnomedRelationshipIndexEntry.class, changedRelationshipIds);
    final Map<String, SnomedRelationshipIndexEntry> changedRelationshipRevisionsById = Maps.uniqueIndex(changedRelationshipHits, Revision::getId);
    for (final String id : changedRelationshipIds) {
        final SnomedRelationshipIndexEntry currentDoc = changedRelationshipRevisionsById.get(id);
        if (currentDoc == null) {
            throw new IllegalStateException(String.format("Current relationship revision should not be null for %s", id));
        }
        final SnomedRelationshipIndexEntry relationship = changedRelationshipsById.get(id);
        final Builder doc;
        if (relationship != null) {
            doc = SnomedRelationshipIndexEntry.builder(relationship);
        } else {
            doc = SnomedRelationshipIndexEntry.builder(currentDoc);
        }
        final Collection<String> currentMemberOf = currentDoc.getMemberOf();
        final Collection<String> currentActiveMemberOf = currentDoc.getActiveMemberOf();
        new ReferenceSetMembershipUpdater(referringRefSets.removeAll(id), currentMemberOf, currentActiveMemberOf).update(doc);
        stageChange(currentDoc, doc.build());
    }
}

Example 19 with RevisionSearcher

use of com.b2international.index.revision.RevisionSearcher in project snow-owl by b2ihealthcare.

the class ComponentInactivationChangeProcessor method process.

@Override
public void process(StagingArea staging, RevisionSearcher searcher) throws IOException {
    // inactivating a concept should inactivate all of its descriptions, relationships, inbound relationships, and members
    final Set<String> inactivatedComponentIds = newHashSet();
    final Set<String> inactivatedConceptIds = newHashSet();
    final Set<String> reactivatedComponentIds = newHashSet();
    final Set<String> reactivatedConceptIds = newHashSet();
    staging.getChangedRevisions(SnomedComponentDocument.class).filter(diff -> diff.hasRevisionPropertyChanges(SnomedRf2Headers.FIELD_ACTIVE)).filter(diff -> diff.newRevision instanceof SnomedComponentDocument).forEach(diff -> {
        RevisionPropertyDiff propDiff = diff.getRevisionPropertyDiff(SnomedRf2Headers.FIELD_ACTIVE);
        boolean oldValue = Boolean.parseBoolean(propDiff.getOldValue());
        boolean newValue = Boolean.parseBoolean(propDiff.getNewValue());
        // inactivation
        if (oldValue && !newValue) {
            inactivatedComponentIds.add(diff.newRevision.getId());
            if (diff.newRevision instanceof SnomedConceptDocument) {
                inactivatedConceptIds.add(diff.newRevision.getId());
            }
        } else if (!oldValue && newValue) {
            reactivatedComponentIds.add(diff.newRevision.getId());
            if (diff.newRevision instanceof SnomedConceptDocument) {
                reactivatedConceptIds.add(diff.newRevision.getId());
            }
        }
    });
    processInactivations(staging, searcher, inactivatedConceptIds, inactivatedComponentIds);
    processReactivations(staging, searcher, reactivatedConceptIds, reactivatedComponentIds);
}

Example 20 with RevisionSearcher

use of com.b2international.index.revision.RevisionSearcher in project snow-owl by b2ihealthcare.

the class SnomedValidationIssueDetailExtension method extendConceptIssueLabels.

private void extendConceptIssueLabels(BranchContext context, Collection<ValidationIssue> issues, Map<String, Object> ruleParameters) {
    final RevisionSearcher searcher = context.service(RevisionSearcher.class);
    final List<ValidationIssue> conceptIssues = issues.stream().filter(issue -> SnomedConcept.TYPE == issue.getAffectedComponent().getComponentType()).collect(Collectors.toList());
    final Map<String, ValidationIssue> memberIssues = issues.stream().filter(issue -> SnomedReferenceSetMember.TYPE == issue.getAffectedComponent().getComponentType()).collect(Collectors.toMap(issue -> issue.getAffectedComponent().getComponentId(), issue -> issue, (issue1, issue2) -> issue1));
    if (conceptIssues.isEmpty() && memberIssues.isEmpty()) {
        return;
    }
    final Builder<String, ValidationIssue> issuesByConceptId = ImmutableMultimap.builder();
    conceptIssues.forEach(issue -> issuesByConceptId.put(issue.getAffectedComponent().getComponentId(), issue));
    searcher.stream(Query.select(String[].class).from(SnomedRefSetMemberIndexEntry.class).fields(SnomedRefSetMemberIndexEntry.Fields.ID, SnomedRefSetMemberIndexEntry.Fields.REFERENCED_COMPONENT_ID).where(Expressions.builder().filter(SnomedRefSetMemberIndexEntry.Expressions.active()).filter(SnomedRefSetMemberIndexEntry.Expressions.ids(memberIssues.keySet())).build()).limit(SCROLL_SIZE).build()).forEach(hits -> {
        for (String[] hit : hits) {
            final String memberId = hit[0];
            final String containerConcpetId = hit[1];
            issuesByConceptId.put(containerConcpetId, memberIssues.get(memberId));
        }
    });
    final Multimap<String, ValidationIssue> issuesByConceptMap = issuesByConceptId.build();
    final Map<String, String> affectedComponentLabelsByConcept = getAffectedComponentLabels(context, ruleParameters, issuesByConceptMap.keySet());
    if (!affectedComponentLabelsByConcept.isEmpty()) {
        issuesByConceptMap.keySet().forEach(conceptId -> {
            issuesByConceptMap.get(conceptId).forEach(issue -> {
                issue.setAffectedComponentLabels(ImmutableList.of(affectedComponentLabelsByConcept.get(conceptId)));
            });
        });
    }
}