Java Version.getVersionedNodeRef方法代码示例

import org.alfresco.service.cmr.version.Version; //导入方法依赖的package包/类
/**
 * Test retrieving the current version for a node with multiple versions
 */
public void testGetCurrentVersion()
{
    NodeRef versionableNode = createNewVersionableNode();
    createVersion(versionableNode);
    createVersion(versionableNode);
    createVersion(versionableNode);
    
    VersionHistory vh = this.versionService.getVersionHistory(versionableNode);
    Version version = vh.getRootVersion(); 
    
    // Get current version from live node
    NodeRef node = version.getVersionedNodeRef();
    Version currentVersion = versionService.getCurrentVersion(node); 
    assertNotNull("Failed to retrieve the current version from the head", currentVersion);
    
    try
    {
        // Get current version from the version node (frozen state version node) - not allowed (MNT-15447)
        node = version.getFrozenStateNodeRef();
        currentVersion = versionService.getCurrentVersion(node);
        fail("Getting the current version is only allowed on live nodes, not on version nodes.");
    }
    catch (IllegalArgumentException ex)
    {
        // expected
    }
}
 

import org.alfresco.service.cmr.version.Version; //导入方法依赖的package包/类
@Test
public void testCreateVersion() throws Exception
{

    ChildAssociationRef contentWithVersionsAssocRef = createContent(node2_1,
                                                                    "ContentWithVersions");
    NodeRef contentWithVersionsNodeRef = contentWithVersionsAssocRef.getChildRef();
    Reference reference = Reference.fromNodeRef(contentWithVersionsNodeRef);
    assertNotNull(reference);
    NodeRef actualContentWithVersionsNodeRef = 
                    reference.execute(new GetActualNodeRefMethod(environment));

    VersionHistory versionHistory = versionService.getVersionHistory(contentWithVersionsNodeRef);
    assertNull(versionHistory);
    VersionHistory actualVersionHistory = versionService.getVersionHistory(actualContentWithVersionsNodeRef);
    assertNull(actualVersionHistory);

    Version newVersion = versionService.createVersion(contentWithVersionsNodeRef,
                                                      null);

    NodeRef newVersionNodeRef = newVersion.getVersionedNodeRef();
    assertNotNull(Reference.fromNodeRef(newVersionNodeRef));

    versionHistory = versionService.getVersionHistory(newVersionNodeRef);
    assertNotNull(versionHistory);

    Collection<Version> allVersions = versionHistory.getAllVersions();
    assertEquals(1,
                 allVersions.size());

    actualVersionHistory = versionService.getVersionHistory(actualContentWithVersionsNodeRef);
    assertNotNull(actualVersionHistory);

    Collection<Version> allActualVersions = versionHistory.getAllVersions();
    assertEquals(1,
                 allActualVersions.size());

    Version actualVersion = actualVersionHistory.getHeadVersion();

    NodeRef newActualVersionNodeRef = actualVersion.getVersionedNodeRef();
    assertNull(Reference.fromNodeRef(newActualVersionNodeRef));

    assertEquals(newActualVersionNodeRef,
                 actualContentWithVersionsNodeRef);
}
 

import org.alfresco.service.cmr.version.Version; //导入方法依赖的package包/类
@Operation("revert")
@WebApiDescription(title = "Revert Version",
        description="Reverts (ie. promotes) specified version to become a new, most recent, version",
        successStatus = HttpServletResponse.SC_OK)
public Node revertById(String nodeId, String versionId, VersionOptions versionOptions, Parameters parameters, WithResponse withResponse)
{
    Version v = findVersion(nodeId, versionId);

    if (v != null)
    {
        CheckOutCheckInService cociService = sr.getCheckOutCheckInService();

        NodeRef nodeRef = v.getVersionedNodeRef();

        String versionComment = versionOptions.getComment();

        VersionType versionType = VersionType.MINOR;
        Boolean versionMajor = versionOptions.getMajorVersion();
        if ((versionMajor != null) && (versionMajor))
        {
            versionType = VersionType.MAJOR;
        }

        Map<String, Serializable> versionProperties = new HashMap<>(2);
        versionProperties.put(VersionModel.PROP_VERSION_TYPE, versionType);
        if (versionComment != null)
        {
            versionProperties.put(VersionModel.PROP_DESCRIPTION, versionComment);
        }

        //cancel editing if we want to revert
        if (sr.getNodeService().hasAspect(nodeRef, ContentModel.ASPECT_WORKING_COPY))
        {
            nodeRef = cociService.cancelCheckout(nodeRef);
        }

        // TODO review default for deep and/or whether we should make it an option
        versionService.revert(nodeRef, v, false);

        // Checkout/Checkin the node - to store the new version in version history
        NodeRef wcNodeRef = cociService.checkout(nodeRef);
        cociService.checkin(wcNodeRef, versionProperties);

        // get latest version
        v = versionService.getVersionHistory(nodeRef).getHeadVersion();

        Node node = nodes.getFolderOrDocumentFullInfo(v.getFrozenStateNodeRef(), null, null, parameters, null);
        mapVersionInfo(v, node);
        return node;
    }

    throw new EntityNotFoundException(nodeId+"-"+versionId);
}
 

import org.alfresco.service.cmr.version.Version; //导入方法依赖的package包/类
@Override
@WebApiDescription(title = "Delete version")
public void delete(String nodeId, String versionId, Parameters parameters)
{
    Version v = findVersion(nodeId, versionId);

    // live (aka versioned) nodeRef
    NodeRef nodeRef = v.getVersionedNodeRef();

    if (sr.getPermissionService().hasPermission(nodeRef, PermissionService.DELETE) != AccessStatus.ALLOWED)
    {
        throw new PermissionDeniedException("Cannot delete version");
    }

    versionService.deleteVersion(nodeRef, v);

    Map<QName, Serializable> props = sr.getNodeService().getProperties(nodeRef);
    if (props.get(ContentModel.PROP_VERSION_LABEL) == null)
    {
        // attempt to delete last version - we do not yet support this (see REPO-835 & REPO-834)
        // note: alternatively, the client can remove the "cm:versionable" aspect (if permissions allow) to clear the version history and disable versioning
        throw new IntegrityException("Cannot delete last version (did you mean to disable versioning instead ?) ["+nodeId+","+versionId+"]", null);
        
        /*
        if (props.get(ContentModel.PROP_VERSION_TYPE) != null)
        {
            // minor fix up to versionable aspect - ie. remove versionType
            behaviourFilter.disableBehaviour(nodeRef, ContentModel.ASPECT_VERSIONABLE);
            behaviourFilter.disableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
            try
            {
                sr.getNodeService().removeProperty(nodeRef, ContentModel.PROP_VERSION_TYPE);
            }
            finally
            {
                behaviourFilter.enableBehaviour(nodeRef, ContentModel.ASPECT_AUDITABLE);
                behaviourFilter.enableBehaviour(nodeRef, ContentModel.ASPECT_VERSIONABLE);
            }
        }
        */
    }
}