Examples with Version com.b2international.snowowl.core.version.Version used on opensource projects

Example 6 with Version

use of com.b2international.snowowl.core.version.Version in project snow-owl by b2ihealthcare.

the class SnomedRf2ExportRequest method collectExportableCodeSystemVersions.

private void collectExportableCodeSystemVersions(final RepositoryContext context, final Set<Version> versionsToExport, final TerminologyResource codeSystem, final String referenceBranch) {
    final List<Version> candidateVersions = newArrayList(getCodeSystemVersions(context, codeSystem.getResourceURI()));
    if (candidateVersions.isEmpty()) {
        return;
    }
    final Set<String> versionPaths = candidateVersions.stream().map(Version::getBranchPath).collect(Collectors.toSet());
    final Branches versionBranches = getBranches(context, versionPaths);
    final Map<String, Branch> versionBranchesByPath = Maps.uniqueIndex(versionBranches, Branch::path);
    // cutoff timestamp represents the timestamp on the current referenceBranch segments, cutting off any versions created after this timestamp
    final Branch cutoffBranch = getBranch(context, referenceBranch);
    final String latestVersionParentBranch = candidateVersions.stream().findFirst().map(v -> BranchPathUtils.createPath(v.getBranchPath()).getParentPath()).get();
    final long cutoffBaseTimestamp = getCutoffBaseTimestamp(context, cutoffBranch, latestVersionParentBranch);
    // Remove all code system versions which were created after the cut-off date, or don't have a corresponding branch
    candidateVersions.removeIf(v -> false || !versionBranchesByPath.containsKey(v.getBranchPath()) || versionBranchesByPath.get(v.getBranchPath()).baseTimestamp() > cutoffBaseTimestamp);
    versionsToExport.addAll(candidateVersions);
    // Exit early if only an extension code system should be exported, or we are already at the "base" code system
    final ResourceURI extensionOfUri = codeSystem.getExtensionOf();
    if (extensionOnly || extensionOfUri == null) {
        return;
    }
    // Otherwise, collect applicable versions using this code system's working path
    final CodeSystem extensionOfCodeSystem = CodeSystemRequests.prepareGetCodeSystem(extensionOfUri.getResourceId()).buildAsync().execute(context);
    collectExportableCodeSystemVersions(context, versionsToExport, extensionOfCodeSystem, codeSystem.getBranchPath());
}

Example 7 with Version

use of com.b2international.snowowl.core.version.Version in project snow-owl by b2ihealthcare.

the class SnomedRf2ImportRequest method doImport.

ImportResponse doImport(final BranchContext context, final File rf2Archive, final Rf2ImportConfiguration importconfig) throws Exception {
    final ResourceURI codeSystemUri = context.service(ResourceURI.class);
    final Rf2ValidationIssueReporter reporter = new Rf2ValidationIssueReporter();
    String latestVersionEffectiveTime = EffectiveTimes.format(ResourceRequests.prepareSearchVersion().one().filterByResource(codeSystemUri.withoutPath()).sortBy("effectiveTime:desc").buildAsync().execute(context).first().map(Version::getEffectiveTime).orElse(LocalDate.EPOCH), DateFormats.SHORT);
    try (final DB db = createDb()) {
        // Read effective time slices from import files
        final Rf2EffectiveTimeSlices effectiveTimeSlices = new Rf2EffectiveTimeSlices(db, isLoadOnDemandEnabled(), latestVersionEffectiveTime, importUntil == null ? null : EffectiveTimes.format(importUntil, DateFormats.SHORT));
        Stopwatch w = Stopwatch.createStarted();
        read(rf2Archive, effectiveTimeSlices, reporter);
        log.info("Preparing RF2 import took: {}", w);
        w.reset().start();
        // Log issues with rows from the import files
        logValidationIssues(reporter);
        if (reporter.hasErrors()) {
            return ImportResponse.defects(reporter.getDefects());
        }
        // Run validation that takes current terminology content into account
        final List<Rf2EffectiveTimeSlice> orderedEffectiveTimeSlices = effectiveTimeSlices.consumeInOrder();
        final Rf2GlobalValidator globalValidator = new Rf2GlobalValidator(log, ignoreMissingReferencesIn);
        /* 
			 * TODO: Use Attachment to get the release file name and/or track file and line number sources for each row 
			 * so that they can be referenced in this stage as well
			 */
        final ImportDefectAcceptor globalDefectAcceptor = reporter.getDefectAcceptor("RF2 release");
        globalValidator.validateTerminologyComponents(orderedEffectiveTimeSlices, globalDefectAcceptor, context);
        // globalValidator.validateMembers(orderedEffectiveTimeSlices, globalDefectAcceptor, context);
        // Log validation issues (but just the ones found during global validation)
        logValidationIssues(globalDefectAcceptor);
        if (reporter.hasErrors()) {
            return ImportResponse.defects(reporter.getDefects());
        }
        // Import effective time slices in chronological order
        final ImmutableSet.Builder<ComponentURI> visitedComponents = ImmutableSet.builder();
        // if not a dryRun, perform import
        if (!dryRun) {
            // Import effective time slices in chronological order
            for (Rf2EffectiveTimeSlice slice : orderedEffectiveTimeSlices) {
                slice.doImport(context, codeSystemUri, importconfig, visitedComponents);
            }
            // Update locales registered on the code system
            updateCodeSystemSettings(context, codeSystemUri);
        }
        return ImportResponse.success(visitedComponents.build(), reporter.getDefects());
    }
}

Example 8 with Version

use of com.b2international.snowowl.core.version.Version in project snow-owl by b2ihealthcare.

the class VersionCreateRequest method execute.

@Override
public Boolean execute(RepositoryContext context) {
    final String user = context.service(User.class).getUsername();
    if (!resource.isHead()) {
        throw new BadRequestException("Version '%s' cannot be created on unassigned branch '%s'.", version, resource).withDeveloperMessage("Did you mean to version '%s'?", resource.withoutPath());
    }
    if (resourcesById == null) {
        resourcesById = fetchResources(context);
    }
    if (!resourcesById.containsKey(resource)) {
        context.log().warn("Resource cannot be found during versioning: " + resourcesById + ", uri: " + resource);
        throw new NotFoundException("Resource", resource.getResourceId());
    }
    // validate new path
    RevisionBranch.BranchNameValidator.DEFAULT.checkName(version);
    TerminologyResource resourceToVersion = resourcesById.get(resource);
    // TODO resurrect or eliminate tooling dependencies
    final List<TerminologyResource> resourcesToVersion = List.of(resourcesById.get(resource));
    // final List<CodeSystem> resourcesToVersion = codeSystem.getDependenciesAndSelf()
    // .stream()
    // .map(resourcesById::get)
    // .collect(Collectors.toList());
    resourcesToVersion.stream().filter(cs -> cs.getUpgradeOf() != null).findAny().ifPresent(cs -> {
        throw new BadRequestException("Upgrade resource '%s' can not be versioned.", cs.getResourceURI());
    });
    for (TerminologyResource terminologyResource : resourcesToVersion) {
        // check that the new versionId does not conflict with any other currently available branch
        final String newVersionPath = String.join(Branch.SEPARATOR, terminologyResource.getBranchPath(), version);
        final String repositoryId = terminologyResource.getToolingId();
        if (!force) {
            // branch needs checking in the non-force cases only
            try {
                Branch branch = RepositoryRequests.branching().prepareGet(newVersionPath).build(repositoryId).execute(context);
                if (!branch.isDeleted()) {
                    throw new ConflictException("An existing version or branch with path '%s' conflicts with the specified version identifier.", newVersionPath);
                }
            } catch (NotFoundException e) {
            // branch does not exist, ignore
            }
        } else {
            // if there is no conflict, delete the branch (the request also ignores non-existent branches)
            deleteBranch(context, newVersionPath, repositoryId);
        }
    }
    acquireLocks(context, user, resourcesToVersion);
    final IProgressMonitor monitor = SubMonitor.convert(context.service(IProgressMonitor.class), TASK_WORK_STEP);
    try {
        // resourcesToVersion.forEach(resourceToVersion -> {
        // check that the specified effective time is valid in this code system
        validateVersion(context, resourceToVersion);
        // version components in the given repository
        new RepositoryRequest<>(resourceToVersion.getToolingId(), new BranchRequest<>(resourceToVersion.getBranchPath(), new RevisionIndexReadRequest<CommitResult>(context.service(RepositoryManager.class).get(resourceToVersion.getToolingId()).service(VersioningRequestBuilder.class).build(new VersioningConfiguration(user, resourceToVersion.getResourceURI(), version, description, effectiveTime, force))))).execute(context);
        // tag the repository
        doTag(context, resourceToVersion, monitor);
        // create a version for the resource
        return new BranchRequest<>(Branch.MAIN_PATH, new ResourceRepositoryCommitRequestBuilder().setBody(tx -> {
            tx.add(VersionDocument.builder().id(resource.withPath(version).withoutResourceType()).version(version).description(description).effectiveTime(EffectiveTimes.getEffectiveTime(effectiveTime)).resource(resource).branchPath(resourceToVersion.getRelativeBranchPath(version)).author(user).createdAt(Instant.now().toEpochMilli()).updatedAt(Instant.now().toEpochMilli()).toolingId(resourceToVersion.getToolingId()).url(buildVersionUrl(context, resourceToVersion)).build());
            return Boolean.TRUE;
        }).setCommitComment(CompareUtils.isEmpty(commitComment) ? String.format("Version '%s' as of '%s'", resource, version) : commitComment).build()).execute(context).getResultAs(Boolean.class);
    } finally {
        releaseLocks(context);
        if (null != monitor) {
            monitor.done();
        }
    }
}

Example 9 with Version

use of com.b2international.snowowl.core.version.Version in project snow-owl by b2ihealthcare.

the class VersionCreateRequest method validateVersion.

private void validateVersion(RepositoryContext context, TerminologyResource codeSystem) {
    if (!context.service(TerminologyRegistry.class).getTerminology(codeSystem.getToolingId()).isEffectiveTimeSupported()) {
        return;
    }
    Optional<Version> mostRecentVersion = getMostRecentVersion(context, codeSystem);
    mostRecentVersion.ifPresent(mrv -> {
        LocalDate mostRecentVersionEffectiveTime = mostRecentVersion.map(Version::getEffectiveTime).orElse(LocalDate.EPOCH);
        if (force) {
            if (!Objects.equals(version, mrv.getVersion())) {
                throw new BadRequestException("Force creating version requires the same versionId ('%s') to be used", version);
            }
            // force recreating an existing version should use the same or later effective date value, allow same here
            if (effectiveTime.equals(mostRecentVersionEffectiveTime)) {
                return;
            }
        }
        if (!effectiveTime.isAfter(mostRecentVersionEffectiveTime)) {
            throw new BadRequestException("The specified '%s' effective time is invalid. Date should be after '%s'.", effectiveTime, mostRecentVersionEffectiveTime);
        }
    });
}

Example 10 with Version

use of com.b2international.snowowl.core.version.Version in project snow-owl by b2ihealthcare.

the class SnomedExtensionCreationTest method createExtensionVersion02.

@Test
public void createExtensionVersion02() {
    IBranchPath a = BranchPathUtils.createPath(branchPath, "a");
    branching.createBranch(a).statusCode(201);
    String conceptId = createNewConcept(a);
    getComponent(branchPath, SnomedComponentType.CONCEPT, conceptId).statusCode(404);
    String codeSystemId = "SNOMEDCT-CV2";
    createCodeSystem(a, codeSystemId).statusCode(201);
    getComponent(a, SnomedComponentType.CONCEPT, conceptId).statusCode(200).body("released", equalTo(false));
    String versionId = "v1";
    LocalDate effectiveTime = LocalDate.now();
    createVersion(codeSystemId, versionId, effectiveTime).statusCode(201);
    Version version = getVersion(codeSystemId, versionId);
    assertThat(version.getEffectiveTime()).isEqualTo(effectiveTime);
    getComponent(branchPath, SnomedComponentType.CONCEPT, conceptId).statusCode(404);
    getComponent(a, SnomedComponentType.CONCEPT, conceptId).statusCode(200).body("released", equalTo(true)).body("effectiveTime", equalTo(effectiveTime.format(DateTimeFormatter.BASIC_ISO_DATE)));
}