Examples with Version org.xwiki.extension.version.Version used on opensource projects

Example 1 with Version

use of org.xwiki.extension.version.Version in project xwiki-platform by xwiki.

the class RepositoryManager method importExtension.

public DocumentReference importExtension(String extensionId, ExtensionRepository repository, Type type) throws QueryException, XWikiException, ResolveException {
    TreeMap<Version, String> versions = new TreeMap<Version, String>();
    Version lastVersion = getVersions(extensionId, repository, type, versions);
    if (lastVersion == null) {
        throw new ExtensionNotFoundException("Can't find any version for the extension [" + extensionId + "] on repository [" + repository + "]");
    } else if (versions.isEmpty()) {
        // If no valid version import the last version
        versions.put(lastVersion, extensionId);
    } else {
        // Select the last valid version
        lastVersion = versions.lastKey();
    }
    Extension extension = repository.resolve(new ExtensionId(extensionId, lastVersion));
    // Get former ids versions
    Collection<ExtensionId> features = extension.getExtensionFeatures();
    for (ExtensionId feature : features) {
        try {
            getVersions(feature.getId(), repository, type, versions);
        } catch (ResolveException e) {
        // Ignore
        }
    }
    XWikiContext xcontext = this.xcontextProvider.get();
    boolean needSave = false;
    XWikiDocument document = getExistingExtensionDocumentById(extensionId);
    if (document == null) {
        // Create document
        document = xcontext.getWiki().getDocument(new DocumentReference(xcontext.getWikiId(), Arrays.asList("Extension", extension.getName()), "WebHome"), xcontext);
        for (int i = 1; !document.isNew(); ++i) {
            document = xcontext.getWiki().getDocument(new DocumentReference(xcontext.getWikiId(), Arrays.asList("Extension", extension.getName() + ' ' + i), "WebHome"), xcontext);
        }
        document.readFromTemplate(this.currentResolver.resolve(XWikiRepositoryModel.EXTENSION_TEMPLATEREFERENCE), xcontext);
        needSave = true;
    }
    // Update document
    BaseObject extensionObject = document.getXObject(XWikiRepositoryModel.EXTENSION_CLASSREFERENCE);
    if (extensionObject == null) {
        extensionObject = document.newXObject(XWikiRepositoryModel.EXTENSION_CLASSREFERENCE, xcontext);
        needSave = true;
    }
    if (!StringUtils.equals(extensionId, getValue(extensionObject, XWikiRepositoryModel.PROP_EXTENSION_ID, (String) null))) {
        extensionObject.set(XWikiRepositoryModel.PROP_EXTENSION_ID, extensionId, xcontext);
        needSave = true;
    }
    // Update extension informations
    needSave |= updateExtension(extension, extensionObject, xcontext);
    // Proxy marker
    BaseObject extensionProxyObject = document.getXObject(XWikiRepositoryModel.EXTENSIONPROXY_CLASSREFERENCE);
    if (extensionProxyObject == null) {
        extensionProxyObject = document.newXObject(XWikiRepositoryModel.EXTENSIONPROXY_CLASSREFERENCE, xcontext);
        extensionProxyObject.setIntValue(XWikiRepositoryModel.PROP_PROXY_AUTOUPDATE, 1);
        needSave = true;
    }
    needSave |= update(extensionProxyObject, XWikiRepositoryModel.PROP_PROXY_REPOSITORYID, repository.getDescriptor().getId());
    needSave |= update(extensionProxyObject, XWikiRepositoryModel.PROP_PROXY_REPOSITORYTYPE, repository.getDescriptor().getType());
    needSave |= update(extensionProxyObject, XWikiRepositoryModel.PROP_PROXY_REPOSITORYURI, repository.getDescriptor().getURI().toString());
    // Remove unexisting versions
    Set<String> validVersions = new HashSet<String>();
    List<BaseObject> versionObjects = document.getXObjects(XWikiRepositoryModel.EXTENSIONVERSION_CLASSREFERENCE);
    if (versionObjects != null) {
        for (BaseObject versionObject : versionObjects) {
            if (versionObject != null) {
                String version = getValue(versionObject, XWikiRepositoryModel.PROP_VERSION_VERSION);
                if (StringUtils.isBlank(version) || (isVersionProxyingEnabled(document) && !new DefaultVersion(version).equals(extension.getId().getVersion()))) {
                    // Empty version OR old versions should be proxied
                    document.removeXObject(versionObject);
                    needSave = true;
                } else {
                    if (!versions.containsKey(new DefaultVersion(version))) {
                        // The version does not exist on remote repository
                        if (!isVersionValid(document, versionObject, xcontext)) {
                            // The version is invalid, removing it to not make the whole extension invalid
                            document.removeXObject(versionObject);
                            needSave = true;
                        } else {
                            // The version is valid, lets keep it
                            validVersions.add(version);
                        }
                    } else {
                        // This version exist on remote repository
                        validVersions.add(version);
                    }
                }
            }
        }
    }
    List<BaseObject> dependencyObjects = document.getXObjects(XWikiRepositoryModel.EXTENSIONDEPENDENCY_CLASSREFERENCE);
    if (dependencyObjects != null) {
        for (BaseObject dependencyObject : dependencyObjects) {
            if (dependencyObject != null) {
                String version = getValue(dependencyObject, XWikiRepositoryModel.PROP_DEPENDENCY_EXTENSIONVERSION);
                if (!validVersions.contains(version)) {
                    // The version is invalid, removing it to not make the whole extension invalid
                    document.removeXObject(dependencyObject);
                    needSave = true;
                }
            }
        }
    }
    for (Map.Entry<Version, String> entry : versions.entrySet()) {
        Version version = entry.getKey();
        String id = entry.getValue();
        try {
            Extension versionExtension;
            if (version.equals(extension.getId().getVersion())) {
                versionExtension = extension;
            } else if (isVersionProxyingEnabled(document)) {
                continue;
            } else {
                versionExtension = repository.resolve(new ExtensionId(id, version));
            }
            // Update version related informations
            needSave |= updateExtensionVersion(document, versionExtension);
        } catch (Exception e) {
            this.logger.error("Failed to resolve extension with id [" + id + "] and version [" + version + "] on repository [" + repository + "]", e);
        }
    }
    if (needSave) {
        document.setAuthorReference(xcontext.getUserReference());
        if (document.isNew()) {
            document.setContentAuthorReference(xcontext.getUserReference());
            document.setCreatorReference(xcontext.getUserReference());
        }
        xcontext.getWiki().saveDocument(document, "Imported extension [" + extensionId + "] from repository [" + repository.getDescriptor() + "]", true, xcontext);
    }
    return document.getDocumentReference();
}

Example 2 with Version

use of org.xwiki.extension.version.Version in project xwiki-platform by xwiki.

the class RepositoryManager method getVersions.

private Version getVersions(String extensionId, ExtensionRepository repository, Type type, Map<Version, String> versions) throws ResolveException {
    Version lastVersion = null;
    IterableResult<Version> versionsIterable = repository.resolveVersions(extensionId, 0, -1);
    for (Version version : versionsIterable) {
        if (type == null || version.getType() == type) {
            if (!versions.containsKey(version)) {
                versions.put(version, extensionId);
            }
        }
        lastVersion = version;
    }
    return lastVersion;
}

Example 3 with Version

use of org.xwiki.extension.version.Version in project xwiki-platform by xwiki.

the class FlavorSearchJob method findValidVersion.

private Extension findValidVersion(String flavorId, String namespace, List<Version> versionList) {
    this.progressManager.pushLevelProgress(versionList.size(), flavorId);
    try {
        for (ListIterator<Version> it = versionList.listIterator(versionList.size()); it.hasPrevious(); ) {
            this.progressManager.startStep(flavorId);
            Version version = it.previous();
            Extension extension = tryInstallExtension(new ExtensionId(flavorId, version), namespace);
            this.progressManager.endStep(flavorId);
            if (extension != null) {
                return extension;
            }
        }
    } finally {
        this.progressManager.popLevelProgress(flavorId);
    }
    return null;
}

Example 4 with Version

use of org.xwiki.extension.version.Version in project xwiki-platform by xwiki.

the class DistributionPingDataProvider method provideData.

@Override
public Map<String, Object> provideData() {
    Map<String, Object> jsonMap = new HashMap<>();
    String instanceId = this.instanceIdManagerProvider.get().getInstanceId().toString();
    jsonMap.put(PROPERTY_INSTANCE_ID, instanceId);
    CoreExtension distributionExtension = this.coreExtensionRepository.getEnvironmentExtension();
    if (distributionExtension != null) {
        String distributionId = distributionExtension.getId().getId();
        if (distributionId != null) {
            jsonMap.put(PROPERTY_DISTRIBUTION_ID, distributionId);
        }
        Version distributionVersion = distributionExtension.getId().getVersion();
        if (distributionVersion != null) {
            jsonMap.put(PROPERTY_DISTRIBUTION_VERSION, distributionVersion.toString());
        }
        Collection<String> features = distributionExtension.getFeatures();
        if (!features.isEmpty()) {
            jsonMap.put(PROPERTY_DISTRIBUTION_FEATURES, distributionExtension.getFeatures().toArray());
        }
    }
    return jsonMap;
}

Example 5 with Version

use of org.xwiki.extension.version.Version in project xwiki-platform by xwiki.

the class XarExtensionScriptService method diff.

/**
 * Computes the differences, in unified format, between the documents of an installed XAR extension and the document
 * from the wiki.
 *
 * @param feature the identifier of a XAR extension (or one of its features)
 * @param wiki the wiki where the XAR extension is installed
 * @return the {@link Job} object which can be used to monitor the progress while the differences are being
 *         computed, or {@code null} in case of failure
 * @since 7.0RC1
 */
public Job diff(String feature, String wiki) {
    setError(null);
    String namespace = getWikiNamespace(wiki);
    InstallRequest installRequest = new InstallRequest();
    installRequest.addExtension(new ExtensionId(feature, (Version) null));
    if (namespace != null) {
        installRequest.addNamespace(namespace);
    }
    installRequest.setId(getDiffJobId(feature, namespace));
    try {
        return this.jobExecutor.execute(DiffXarJob.JOB_TYPE, installRequest);
    } catch (Exception e) {
        setError(e);
        return null;
    }
}