import javax.jcr.version.VersionManager; //导入依赖的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.VersionManager; //导入依赖的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.VersionManager; //导入依赖的package包/类
@Override
public Page restorePage(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();
            try {
                vm.restore("/" + path, versionName, true);
                node = JcrUtils.getNodeIfExists(rootNode, path);
                return convertNodeToPage(node);
            } catch (Exception e) {
                LOG.error("Error when restore document {} to version {}", path, versionName, e);
            }
        }
        return null;
    });

}
 

import javax.jcr.version.VersionManager; //导入依赖的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.VersionManager; //导入依赖的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.VersionManager; //导入依赖的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.VersionManager; //导入依赖的package包/类
@Test
public void testGetBaseVersion() throws RepositoryException {

    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);

    when(mockVersionManager.getBaseVersion(anyString())).thenReturn(
            mockVersion);

    testObj.getBaseVersion();

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

import javax.jcr.version.VersionManager; //导入依赖的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.VersionManager; //导入依赖的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.VersionManager; //导入依赖的package包/类
@Override
public Version lastVersion(Resource resource) {
    try {
        Resource versionableResource = resource.isResourceType(NameConstants.NT_PAGE) ? resource.getChild(NameConstants.NN_CONTENT) : resource;
        VersionManager versionManager = versionableResource.getResourceResolver().adaptTo(Session.class).getWorkspace().getVersionManager();
        final Iterator<Version> allVersions = versionManager.getVersionHistory(versionableResource.getPath()).getAllVersions();
        return Iterators.getLast(allVersions);
    } catch (RepositoryException e) {
        log.error("Error receiving last version of resource [ {} ]", resource.getName());
    }
    return null;
}
 

import javax.jcr.version.VersionManager; //导入依赖的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.VersionManager; //导入依赖的package包/类
protected VersionManager getVersionManager() {
    try {
        return getSession().getWorkspace().getVersionManager();
    } catch (final RepositoryException e) {
        throw new RepositoryRuntimeException(e);
    }
}
 

import javax.jcr.version.VersionManager; //导入依赖的package包/类
@Test(expected = RepositoryRuntimeException.class)
public void testRevertToUnknownVersion() throws RepositoryException {
    final String versionUUID = "uuid";
    final VersionManager mockVersionManager = mock(VersionManager.class);
    final VersionHistory mockHistory = mock(VersionHistory.class);

    when(mockHistory.getVersionByLabel(versionUUID)).thenThrow(new VersionException());
    final VersionIterator mockVersionIterator = mock(VersionIterator.class);
    when(mockHistory.getAllVersions()).thenReturn(mockVersionIterator);
    when(mockVersionIterator.hasNext()).thenReturn(false);
    when(mockWorkspace.getVersionManager()).thenReturn(mockVersionManager);
    when(mockVersionManager.getVersionHistory(EXAMPLE_VERSIONED_PATH)).thenReturn(mockHistory);

    testObj.revertToVersion(testSession, EXAMPLE_VERSIONED_PATH, versionUUID);
}
 

import javax.jcr.version.VersionManager; //导入依赖的package包/类
@Test
public void testRemoveVersionByLabel() throws RepositoryException {
    final String versionLabel = "versionName";
    final String versionUUID = "uuid";
    final String versionName = "Bob";
    final String[] versionLabels = new String[]{ versionLabel };
    final VersionManager mockVersionManager = mock(VersionManager.class);
    final VersionHistory mockHistory = mock(VersionHistory.class);
    final Version mockVersion1 = mock(Version.class);
    final Version mockVersion2 = mock(Version.class);
    when(mockVersion1.getContainingHistory()).thenReturn(mockHistory);
    when(mockHistory.hasVersionLabel(versionLabel)).thenReturn(true);
    when(mockHistory.getVersionByLabel(versionLabel)).thenReturn(mockVersion1);
    when(mockHistory.getVersionLabels(mockVersion1)).thenReturn(versionLabels);
    when(mockWorkspace.getVersionManager()).thenReturn(mockVersionManager);
    when(mockVersionManager.getVersionHistory("/example")).thenReturn(mockHistory);
    when(mockVersionManager.getBaseVersion("/example")).thenReturn(mockVersion2);
    final Node mockFrozenNode = mock(Node.class);
    when(mockVersion1.getFrozenNode()).thenReturn(mockFrozenNode);
    when(mockFrozenNode.getIdentifier()).thenReturn(versionUUID);
    when(mockVersion1.getIdentifier()).thenReturn(versionUUID);
    when(mockVersion1.getName()).thenReturn(versionName);

    testObj.removeVersion(testSession, "/example", versionLabel);
    verify(mockHistory).removeVersion(versionName);
    verify(mockHistory).removeVersionLabel(versionLabel);
    verify(mockVersionManager, never()).checkpoint("/example");
}
 

import javax.jcr.version.VersionManager; //导入依赖的package包/类
@Test(expected = RepositoryRuntimeException.class)
public void testRemoveUnknownVersion() throws RepositoryException {
    final String versionUUID = "uuid";
    final VersionManager mockVersionManager = mock(VersionManager.class);
    final VersionHistory mockHistory = mock(VersionHistory.class);

    when(mockHistory.getVersionByLabel(versionUUID)).thenThrow(new VersionException());
    final VersionIterator mockVersionIterator = mock(VersionIterator.class);
    when(mockHistory.getAllVersions()).thenReturn(mockVersionIterator);
    when(mockVersionIterator.hasNext()).thenReturn(false);
    when(mockWorkspace.getVersionManager()).thenReturn(mockVersionManager);
    when(mockVersionManager.getVersionHistory("/example")).thenReturn(mockHistory);

    testObj.removeVersion(testSession, "/example", versionUUID);
}
 

import javax.jcr.version.VersionManager; //导入依赖的package包/类
/**
 * This test designed to be pass so long as no exception is thrown.
 * @param label
 * @throws RepositoryException
 */
private void testCreateWithValidLabel(final String label) throws RepositoryException {
    final VersionManager mockVersionManager = mock(VersionManager.class);
    final VersionHistory mockHistory = mock(VersionHistory.class);
    when(mockWorkspace.getVersionManager()).thenReturn(mockVersionManager);
    when(mockVersionManager.getVersionHistory(EXAMPLE_UNVERSIONED_PATH)).thenReturn(mockHistory);
    testObj.createVersion(testSession, EXAMPLE_UNVERSIONED_PATH, label);

    final Node unversionedNode = mockSession.getNode(EXAMPLE_UNVERSIONED_PATH);
    verify(unversionedNode).isNodeType(VERSIONABLE);
    verify(unversionedNode).addMixin(VERSIONABLE);
}
 

import javax.jcr.version.VersionManager; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    testObj = new FedoraNodes(path);
    testSession = new FedoraSessionImpl(mockSession);
    testHttpSession = new HttpSession(testSession);

    setField(testObj, "request", mockRequest);
    setField(testObj, "servletResponse", mockResponse);
    setField(testObj, "uriInfo", mockUriInfo);
    setField(testObj, "nodeService", mockNodes);
    setField(testObj, "versionService", mockVersions);
    this.mockUriInfo = getUriInfoImpl();
    setField(testObj, "pidMinter", mockPidMinter);
    setField(testObj, "containerService", mockObjects);
    setField(testObj, "session", testHttpSession);
    setField(testObj, "securityContext", mockSecurityContext);
    final Workspace mockWorkspace = mock(Workspace.class);
    when(mockWorkspace.getName()).thenReturn("default");
    when(mockSession.getWorkspace()).thenReturn(mockWorkspace);
    final VersionManager mockVM = mock(VersionManager.class);
    when(mockWorkspace.getVersionManager()).thenReturn(mockVM);
    when(mockNode.getPath()).thenReturn(path);
    when(mockContainer.getPath()).thenReturn(path);
    when(mockContainer.getEtagValue()).thenReturn("XYZ");
    when(mockNodeType.getName()).thenReturn("nt:folder");
    when(mockNode.getPrimaryNodeType()).thenReturn(mockNodeType);
    when(mockSession.getNode(path)).thenReturn(mockNode);

    setField(testObj, "idTranslator", new HttpResourceConverter(testHttpSession,
                UriBuilder.fromUri("http://localhost/fcrepo/{path: .*}")));
}
 

import javax.jcr.version.VersionManager; //导入依赖的package包/类
@Override
public VersionManager getVersionManager() throws UnsupportedRepositoryOperationException, RepositoryException {
    return null;
}
 

import javax.jcr.version.VersionManager; //导入依赖的package包/类
static VersionManager getVersionManager(Node node) throws RepositoryException {
    VersionManager versionMgr = node.getSession().getWorkspace().getVersionManager();
    return versionMgr;
}
 

import javax.jcr.version.VersionManager; //导入依赖的package包/类
public VersionManager getVersionManager(Session session) throws OleDocStoreException, RepositoryException {
    return session.getWorkspace().getVersionManager();
}