import javax.jcr.version.VersionHistory; //导入依赖的package包/类
@Override
public Page getPageByVersion(final String path, final String versionName) {
    return jcrTemplate.execute(session -> {
        Node rootNode = session.getRootNode();
        Node node = JcrUtils.getNodeIfExists(rootNode, path);
        if (node != null) {
            VersionManager vm = session.getWorkspace().getVersionManager();
            VersionHistory history = vm.getVersionHistory("/" + path);
            Version version = history.getVersion(versionName);
            if (version != null) {
                Node frozenNode = version.getFrozenNode();
                return convertNodeToPage(frozenNode);
            } else {
                return null;
            }
        } else {
            return null;
        }
    });
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
protected List<T> getVersionList(Node node, NodeFilter nodeFilter) {
    try {
        List<T> versionList = new ArrayList<T>();
        //VersionHistory versionHistory = node.getVersionHistory();
        VersionHistory versionHistory = JcrUtils.getVersionManager(node.getSession()).getVersionHistory(node.getPath());
        VersionIterator versionIterator = versionHistory.getAllVersions();
        versionIterator.skip(1);
        while (versionIterator.hasNext()) {
            Version version = versionIterator.nextVersion();
            NodeIterator nodeIterator = version.getNodes();
            while (nodeIterator.hasNext()) {
                T entityVersion = getJcrom().fromNode(getEntityClass(), nodeIterator.nextNode(), nodeFilter);
                //Version baseVersion = node.getBaseVersion();
                Version baseVersion = JcrUtils.getVersionManager(node.getSession()).getBaseVersion(node.getPath());
                getJcrom().setBaseVersionInfo(entityVersion, baseVersion.getName(), baseVersion.getCreated());
                versionList.add(entityVersion);
            }
        }
        return versionList;
    } catch (RepositoryException e) {
        throw new JcrMappingException("Could not get version list", e);
    }
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
@Override
public List<PageVersion> getPageVersions(final String path) {
    return jcrTemplate.execute(session -> {
        Node rootNode = session.getRootNode();
        Node node = JcrUtils.getNodeIfExists(rootNode, path);
        if (node != null) {
            VersionManager vm = session.getWorkspace().getVersionManager();
            VersionHistory history = vm.getVersionHistory("/" + path);
            List<PageVersion> versions = new ArrayList<>();
            for (VersionIterator it = history.getAllVersions(); it.hasNext(); ) {
                Version version = (Version) it.next();
                if (!"jcr:rootVersion".equals(version.getName())) {
                    versions.add(convertNodeToPageVersion(version));
                }
            }
            return versions;
        } else {
            return null;
        }
    });
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
private void initialize() throws RepositoryException {
    if (versionName.equals("latest")) {
        populate(resource, resource.getPath(), 0);
        versionDate = Properties.lastModified(resource);
    }

    VersionManager versionManager = resource.getResourceResolver().adaptTo(Session.class).getWorkspace().getVersionManager();
    try {
        VersionHistory history = versionManager.getVersionHistory(this.resource.getPath());
        VersionIterator versionIterator = history.getAllVersions();
        while (versionIterator.hasNext()) {
            Version next = versionIterator.nextVersion();
            versionSelection.add(new VersionSelectionImpl(next.getName(), next.getCreated().getTime()));
            if (next.getName().equalsIgnoreCase(versionName)) {
                String versionPath = next.getFrozenNode().getPath();
                Resource versionResource = resource.getResourceResolver().resolve(versionPath);
                populate(versionResource, versionPath, 0);
                versionDate = next.getCreated().getTime();
            }
        }
    } catch (javax.jcr.UnsupportedRepositoryOperationException e) {
        log.debug(String.format("node %s not versionable", this.resource.getPath()));
    }
    versionSelection.add(new VersionSelectionImpl("latest", Properties.lastModified(resource)));
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
@Override
public void removeVersion(final FedoraSession session, final String absPath, final String label) {
    final Session jcrSession = getJcrSession(session);
    final Workspace workspace = jcrSession.getWorkspace();
    try {
        final Version v = getVersionForLabel(workspace, absPath, label);
        if (v == null) {
            throw new PathNotFoundException("Unknown version \"" + label + "\"!");
        } else if (workspace.getVersionManager().getBaseVersion(absPath).equals(v) ) {
            throw new VersionException("Cannot remove most recent version snapshot.");
        } else {
            // remove labels
            final VersionHistory history = v.getContainingHistory();
            final String[] versionLabels = history.getVersionLabels(v);
            for ( final String versionLabel : versionLabels ) {
                LOGGER.debug("Removing label: {}", versionLabel);
                history.removeVersionLabel( versionLabel );
            }
            history.removeVersion( v.getName() );
        }
    } catch (final RepositoryException e) {
        throw new RepositoryRuntimeException(e);
    }
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
private static String checkpoint(final Session session, final String absPath, final String label)
        throws RepositoryException {
    if (!validLabel(label)) {
        throw new VersionException("Invalid label: " + label);
    }

    LOGGER.trace("Setting version checkpoint for {}", absPath);
    final Workspace workspace = session.getWorkspace();
    final VersionManager versionManager = workspace.getVersionManager();
    final VersionHistory versionHistory = versionManager.getVersionHistory(absPath);
    if (versionHistory.hasVersionLabel(label)) {
        throw new LabelExistsVersionException("The specified label \"" + label
                + "\" is already assigned to another version of this resource!");
    }
    final Version v = versionManager.checkpoint(absPath);
    if (v == null) {
        return null;
    }
    versionHistory.addVersionLabel(v.getName(), label, false);
    return v.getFrozenNode().getIdentifier();
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
@Override
public FedoraResource getVersion(final String label) {
    try {
        final Node n = getFrozenNode(label);

        if (n != null) {
            return new FedoraResourceImpl(n);
        }

        if (isVersioned()) {
            final VersionHistory hist = getVersionManager().getVersionHistory(getPath());

            if (hist.hasVersionLabel(label)) {
                LOGGER.debug("Found version for {} by label {}.", this, label);
                return new FedoraResourceImpl(hist.getVersionByLabel(label).getFrozenNode());
            }
        }

        LOGGER.warn("Unknown version {} with label {}!", getPath(), label);
        return null;
    } catch (final RepositoryException e) {
        throw new RepositoryRuntimeException(e);
    }

}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
@Test
public void testRevertToVersionByLabel() throws RepositoryException {
    final String versionLabel = "v";
    final VersionManager mockVersionManager = mock(VersionManager.class);
    final VersionHistory mockHistory = mock(VersionHistory.class);
    final Version mockVersion1 = mock(Version.class);
    final Version mockPreRevertVersion = mock(Version.class);
    when(mockVersionManager.checkin(EXAMPLE_VERSIONED_PATH)).thenReturn(mockPreRevertVersion);
    when(mockPreRevertVersion.getContainingHistory()).thenReturn(mockHistory);
    when(mockHistory.hasVersionLabel(versionLabel)).thenReturn(true);
    when(mockHistory.getVersionByLabel(versionLabel)).thenReturn(mockVersion1);
    when(mockWorkspace.getVersionManager()).thenReturn(mockVersionManager);
    when(mockVersionManager.getVersionHistory(EXAMPLE_VERSIONED_PATH)).thenReturn(mockHistory);

    testObj.revertToVersion(testSession, EXAMPLE_VERSIONED_PATH, versionLabel);
    verify(mockVersionManager).restore(mockVersion1, true);

    verify(mockVersionManager, never()).checkpoint(EXAMPLE_VERSIONED_PATH);
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
@Test
public void testGetVersionLabels() throws RepositoryException {
    when(mockNode.isNodeType(FROZEN_NODE)).thenReturn(true);
    final VersionHistory mockVersionHistory = mock(VersionHistory.class);
    final Version mockVersion = mock(Version.class);
    when(mockVersion.getName()).thenReturn("uuid");
    final Workspace mockWorkspace = mock(Workspace.class);
    when(mockSession.getWorkspace()).thenReturn(mockWorkspace);
    final VersionManager mockVersionManager = mock(VersionManager.class);
    when(mockWorkspace.getVersionManager()).thenReturn(mockVersionManager);
    final VersionIterator mockVersionIterator = mock(VersionIterator.class);
    when(mockVersionHistory.getAllVersions()).thenReturn(mockVersionIterator);
    when(mockVersionIterator.hasNext()).thenReturn(false);

    when(mockVersionManager.getVersionHistory(anyString())).thenReturn(
            mockVersionHistory);

    testObj.getVersions();

    verify(mockVersionManager).getVersionHistory(anyString());
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
@Override
public List<VersionFile> getVersionFiles(String path) throws Exception{
	path = processPath(path);
	Node rootNode=getRootNode();
	if (!rootNode.hasNode(path)) {
		throw new RuleException("File [" + path + "] not exist.");
	}
	List<VersionFile> files = new ArrayList<VersionFile>();
	Node fileNode = rootNode.getNode(path);
	VersionHistory versionHistory = versionManager.getVersionHistory(fileNode.getPath());
	VersionIterator iterator = versionHistory.getAllVersions();
	while (iterator.hasNext()) {
		Version version = iterator.nextVersion();
		String versionName = version.getName();
		if (versionName.startsWith("jcr:")) {
			continue; // skip root version
		}
		Node fnode = version.getFrozenNode();
		VersionFile file = new VersionFile();
		file.setName(version.getName());
		file.setPath(fileNode.getPath());
		Property prop = fnode.getProperty(CRATE_USER);
		file.setCreateUser(prop.getString());
		prop = fnode.getProperty(CRATE_DATE);
		file.setCreateDate(prop.getDate().getTime());
		if(fnode.hasProperty(VERSION_COMMENT)){
			prop=fnode.getProperty(VERSION_COMMENT);
			file.setComment(prop.getString());
		}
		files.add(file);
	}
	return files;
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
private InputStream readVersionFile(String path, String version) throws Exception{
	path = processPath(path);
	Node rootNode=getRootNode();
	if (!rootNode.hasNode(path)) {
		throw new RuleException("File [" + path + "] not exist.");
	}
	Node fileNode = rootNode.getNode(path);
	VersionHistory versionHistory = versionManager.getVersionHistory(fileNode.getPath());
	Version v = versionHistory.getVersion(version);
	Node fnode = v.getFrozenNode();
	Property property = fnode.getProperty(DATA);
	Binary fileBinary = property.getBinary();
	return fileBinary.getStream();
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
protected T getVersion(Node node, String versionName, NodeFilter nodeFilter) {
    try {
        //VersionHistory versionHistory = node.getVersionHistory();
        VersionHistory versionHistory = JcrUtils.getVersionManager(node.getSession()).getVersionHistory(node.getPath());
        Version version = versionHistory.getVersion(versionName);
        return getJcrom().fromNode(getEntityClass(), version.getNodes().nextNode(), nodeFilter);
    } catch (RepositoryException e) {
        throw new JcrMappingException("Could not get version", e);
    }
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
protected void removeVersion(Node node, String versionName) {
    try {
        //VersionHistory versionHistory = node.getVersionHistory();
        VersionHistory versionHistory = JcrUtils.getVersionManager(node.getSession()).getVersionHistory(node.getPath());
        versionHistory.removeVersion(versionName);
    } catch (RepositoryException e) {
        throw new JcrMappingException("Could not remove version", e);
    }
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
protected long getVersionSize(Node node) {
    try {
        //VersionHistory versionHistory = node.getVersionHistory();
        VersionHistory versionHistory = JcrUtils.getVersionManager(node.getSession()).getVersionHistory(node.getPath());
        return versionHistory.getAllVersions().getSize() - 1;
    } catch (RepositoryException e) {
        throw new JcrMappingException("Could not get version history size", e);
    }
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
protected String updateVersion(Session session, Node nodeByUUID) throws RepositoryException, OleDocStoreException {
    session.save();
    String currentVersion = null;
    if (isVersioningEnabled()) {
        VersionManager versionManager = getVersionManager(session);
        versionManager.checkpoint(nodeByUUID.getPath());
        VersionHistory versionHistory = versionManager.getVersionHistory(nodeByUUID.getPath());
        VersionIterator allVersions = versionHistory.getAllVersions();
        while (allVersions.hasNext()) {
            currentVersion = allVersions.nextVersion().getName();
        }
        logger.info("Version updated for UUID:" + nodeByUUID.getIdentifier() + "  ====  version:" + currentVersion);
    }
    return currentVersion;
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
public VersionHistory getVersionHistory(String s) throws UnsupportedRepositoryOperationException, RepositoryException {
    if (versionHistories.get(s) == null) {
        versionHistories.put(s, new RegistryVersionHistory(session,s));
    }

    return versionHistories.get(s);

}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
static Resource mockResource(String path, String versionName, Date date) throws RepositoryException {
    Resource resource = mock(Resource.class, Answers.RETURNS_DEEP_STUBS.get());
    when(resource.getPath()).thenReturn(path);
    when(resource.getValueMap()).thenReturn(mock(ValueMap.class));

    Node node = mock(Node.class, Answers.RETURNS_DEEP_STUBS.get());
    when(resource.adaptTo(Node.class)).thenReturn(node);

    ResourceResolver resourceResolver = mock(ResourceResolver.class);
    when(resource.getResourceResolver()).thenReturn(resourceResolver);
    when(resourceResolver.resolve(path)).thenReturn(resource);

    Session session = mock(Session.class, Answers.RETURNS_DEEP_STUBS.get());
    when(resourceResolver.adaptTo(Session.class)).thenReturn(session);

    VersionManager versionManager = mock(VersionManager.class);
    when(session.getWorkspace().getVersionManager()).thenReturn(versionManager);

    VersionHistory history = mock(VersionHistory.class);
    when(versionManager.getVersionHistory(path)).thenReturn(history);

    Version version = mock(Version.class, Answers.RETURNS_DEEP_STUBS.get());
    when(version.getName()).thenReturn(versionName);
    final GregorianCalendar calendar = new GregorianCalendar();
    calendar.setTime(date);
    when(version.getCreated()).thenReturn(calendar);
    when(version.getFrozenNode().getPath()).thenReturn(path);


    VersionIterator versionIterator = mock(VersionIterator.class);
    when(versionIterator.hasNext()).thenReturn(true, false);
    when(versionIterator.nextVersion()).thenReturn(version);
    when(history.getAllVersions()).thenReturn(versionIterator);
    return resource;
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
/**
 * When we revert to a version, we snapshot first so that the "revert" action can be undone,
 * this method generates a label suitable for that snapshot version to make it clear why
 * it shows up in user's version history.
 * @param targetLabel
 * @param history
 * @return
 * @throws RepositoryException
 */
private static String getPreRevertVersionLabel(final String targetLabel, final VersionHistory history)
        throws RepositoryException {
    final String baseLabel = "auto-snapshot-before-" + targetLabel;
    for (int i = 0; i < Integer.MAX_VALUE; i ++) {
        final String label = baseLabel + (i == 0 ? "" : "-" + i);
        if (!history.hasVersionLabel(label)) {
            return label;
        }
    }
    return baseLabel;
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
private static Version getVersionForLabel(final Workspace workspace, final String absPath,
                                   final String label) throws RepositoryException {
    // first see if there's a version label
    final VersionHistory history = workspace.getVersionManager().getVersionHistory(absPath);

    if (history.hasVersionLabel(label)) {
        return history.getVersionByLabel(label);
    }
    return null;
}
 

import javax.jcr.version.VersionHistory; //导入依赖的package包/类
@Override
public Stream<FedoraVersion> getVersions() {
    try {
        final VersionHistory history = getVersionManager().getVersionHistory(getPath());
        @SuppressWarnings("unchecked")
        final Iterator<Version> versions = history.getAllVersions();
        return iteratorToStream(versions)
            /* discard jcr:rootVersion */
            .filter(UncheckedPredicate.uncheck(version ->
                        !version.getName().equals(history.getRootVersion().getName())))
            /* omit unlabelled versions */
            .filter(UncheckedPredicate.uncheck(version -> {
                final String[] labels = history.getVersionLabels(version);
                if (labels.length == 0) {
                    LOGGER.warn("An unlabelled version for {} was found! Omitting from version listing!",
                            getPath());
                } else if (labels.length > 1) {
                    LOGGER.warn("Multiple version labels found for {}! Using first label, \"{}\".", getPath(),
                            labels[0]);
                }
                return labels.length > 0;
            }))
            .map(uncheck(version ->
                    new FedoraVersionImpl(history.getVersionLabels(version)[0], version.getCreated().toInstant())));
    } catch (final RepositoryException ex) {
        throw new RepositoryRuntimeException(ex);
    }
}