Java NodeRef.getStoreRef方法代碼示例

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
@Override
protected NodeEntity selectNodeByNodeRef(NodeRef nodeRef)
{
    StoreEntity store = new StoreEntity();
    StoreRef storeRef = nodeRef.getStoreRef();
    store.setProtocol(storeRef.getProtocol());
    store.setIdentifier(storeRef.getIdentifier());
    
    NodeEntity node = new NodeEntity();
    // Store
    node.setStore(store);
    // UUID
    String uuid = nodeRef.getId();
    if (uuid.length() > 36)
    {
        return null;            // Avoid DB2 query failure if someone passes in a made-up UUID
    }
    node.setUuid(uuid);
    
    return template.selectOne(SELECT_NODE_BY_NODEREF, node);
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
protected List<ChildAssociationRef> removeArchivedRenditionsFrom(final NodeRef sourceNode,
        final List<ChildAssociationRef> renditionAssocs)
{
    // This is a workaround for a bug in the NodeService (no JIRA number yet) whereby a call to
    // nodeService.getChildAssocs can return all children, including children in the archive store.
    final List<ChildAssociationRef> result = new ArrayList<>();

    // check if there even is an archive for the store of the node
    final NodeRef archivedNode = this.nodeArchiveService.getStoreArchiveNode(sourceNode.getStoreRef());
    final StoreRef archiveStore = archivedNode != null ? archivedNode.getStoreRef() : null;

    for (final ChildAssociationRef chAssRef : renditionAssocs)
    {
        // If the rendition has *not* been deleted, then it should remain in the result list.
        final StoreRef renditionStoreRef = chAssRef.getChildRef().getStoreRef();
        if (!EqualsHelper.nullSafeEquals(archiveStore, renditionStoreRef))
        {
            result.add(chAssRef);
        }
    }

    return result;
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
/**
 * Get the head version given a node reference
 *
 * @param nodeRef   the node reference
 * @return          the 'head' version
 */
private Version getHeadVersion(NodeRef nodeRef)
{
    Version version = null;
    StoreRef storeRef = nodeRef.getStoreRef();

    NodeRef versionHistoryNodeRef = getVersionHistoryNodeRef(nodeRef);
    if (versionHistoryNodeRef != null)
    {
        List<ChildAssociationRef> versionsAssoc = this.dbNodeService.getChildAssocs(versionHistoryNodeRef, RegexQNamePattern.MATCH_ALL, VersionModel.CHILD_QNAME_VERSIONS);
        for (ChildAssociationRef versionAssoc : versionsAssoc)
        {
            NodeRef versionNodeRef = versionAssoc.getChildRef();
            List<AssociationRef> successors = this.dbNodeService.getTargetAssocs(versionNodeRef, VersionModel.ASSOC_SUCCESSOR);
            if (successors.size() == 0)
            {
                String storeProtocol = (String)this.dbNodeService.getProperty(
                        versionNodeRef,
                        QName.createQName(NAMESPACE_URI, VersionModel.PROP_FROZEN_NODE_STORE_PROTOCOL));
                String storeId = (String)this.dbNodeService.getProperty(
                        versionNodeRef,
                        QName.createQName(NAMESPACE_URI, VersionModel.PROP_FROZEN_NODE_STORE_ID));
                StoreRef versionStoreRef = new StoreRef(storeProtocol, storeId);
                if (storeRef.equals(versionStoreRef) == true)
                {
                    version = getVersion(versionNodeRef);
                }
            }
        }
    }

    return version;
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
private Version getLatestVersion(NodeRef nodeRef)
{
    Version version = null;
    StoreRef storeRef = nodeRef.getStoreRef();

    NodeRef versionHistoryNodeRef = getVersionHistoryNodeRef(nodeRef);
    if (versionHistoryNodeRef != null)
    {
        List<ChildAssociationRef> versionsAssoc = this.dbNodeService.getChildAssocs(versionHistoryNodeRef, RegexQNamePattern.MATCH_ALL, VersionModel.CHILD_QNAME_VERSIONS);
        for (ChildAssociationRef versionAssoc : versionsAssoc)
        {
            NodeRef versionNodeRef = versionAssoc.getChildRef();
            List<AssociationRef> predecessors = this.dbNodeService.getSourceAssocs(versionNodeRef, VersionModel.ASSOC_SUCCESSOR);
            if (predecessors.size() == 0)
            {
                String storeProtocol = (String)this.dbNodeService.getProperty(
                        versionNodeRef,
                        QName.createQName(NAMESPACE_URI, VersionModel.PROP_FROZEN_NODE_STORE_PROTOCOL));
                String storeId = (String)this.dbNodeService.getProperty(
                        versionNodeRef,
                        QName.createQName(NAMESPACE_URI, VersionModel.PROP_FROZEN_NODE_STORE_ID));
                StoreRef versionStoreRef = new StoreRef(storeProtocol, storeId);
                if (storeRef.equals(versionStoreRef) == true)
                {
                    version = getVersion(versionNodeRef);
                }
            }
        }
    }

    return version;
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
@Override
public String stringifyRepositoryLocation(RepositoryNodeRef repositoryNodeRef) throws ReferenceEncodingException
{
    NodeRef nodeRef = repositoryNodeRef.getNodeRef();
    StoreRef storeRef = nodeRef.getStoreRef();

    return NODE + DELIMITER + storeRef.getProtocol() + DELIMITER + storeRef.getIdentifier() + DELIMITER
                + nodeRef.getId();
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
@Override
public Pair<String, String> hash(NodeRef nodeRef)
{
    String uuid = nodeRef.getId();

    if (uuid.length() != 36)
    {
        throw new RuntimeException("Invalid noderf id length " + uuid);
    }

    String bigInt16String = uuid.replaceAll("-",
                                            "");
    if (bigInt16String.length() != 32)
    {
        throw new RuntimeException("Invalid noderf id format " + uuid);
    }

    BigInteger bigIntId = new BigInteger(bigInt16String,
                                         16);
    StoreRef storeRef = nodeRef.getStoreRef();
    String storeProtocolHash = storeProtocolStore.hash(storeRef.getProtocol());
    String storeIdHash = storeIdStore.hash(storeRef.getIdentifier());
    if (storeProtocolHash == null || storeIdHash == null)
    {
        throw new RuntimeException("Missing hash for " + storeRef);
    }
    String storeHash = storeProtocolHash + storeIdHash;
    return new Pair<String, String>(storeHash,
                                    bigIntId.toString(radix));

}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
@Override
public Reference propagateNodeRefMutations(NodeRef mutatedNodeRef, Reference reference)
{
    StoreRef storeRef = mutatedNodeRef.getStoreRef();
    String storeId = storeRef.getIdentifier();
    String protocol = storeRef.getProtocol();

    if (Version2Model.STORE_ID.equals(storeId) || VersionModel.STORE_ID.equals(storeId)
                || VersionBaseModel.STORE_PROTOCOL.equals(protocol))
    {
        Resource resource = reference.getResource();
        if (resource instanceof RepositoryResource)
        {
            RepositoryResource repositoryResource = (RepositoryResource) resource;
            RepositoryLocation location = repositoryResource.getLocation();
            if (location instanceof RepositoryNodeRef)
            {
                RepositoryNodeRef repositoryNodeRef = (RepositoryNodeRef) location;
                NodeRef nodeRef = repositoryNodeRef.getNodeRef();
                NodeRef nodeRefPropagation = new NodeRef(mutatedNodeRef.getStoreRef(),
                                                         nodeRef.getId());
                Resource resourcePropagation = new RepositoryResource(new RepositoryNodeRef(nodeRefPropagation));

                return new Reference(reference.getEncoding(),
                                     reference.getProtocol(),
                                     resourcePropagation,
                                     reference.getParameters());
            }
        }
    }

    // default branch

    return reference;
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
@Override
public NodeRef getRootNode(NodeService nodeService, SearchService searchService, NamespaceService namespaceService, String rootPath, NodeRef rootNodeRef)
{
    ParameterCheck.mandatory("NodeService", nodeService);
    ParameterCheck.mandatory("SearchService", searchService);
    ParameterCheck.mandatory("NamespaceService", namespaceService);
    ParameterCheck.mandatory("RootPath", rootPath);
    ParameterCheck.mandatory("RootNodeRef", rootNodeRef);

    // String username = AuthenticationUtil.getFullyAuthenticatedUser();
    StoreRef storeRef = rootNodeRef.getStoreRef();

    AuthenticationUtil.RunAsWork<NodeRef> action = new GetRootNode(nodeService, searchService, namespaceService, rootPath, rootNodeRef, storeRef);
    return getBaseName(AuthenticationUtil.runAs(action, AuthenticationUtil.getSystemUserName()));
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
public NodeRef getArchivedNode(NodeRef originalNodeRef)
{
    StoreRef orginalStoreRef = originalNodeRef.getStoreRef();
    NodeRef archiveRootNodeRef = nodeService.getStoreArchiveNode(orginalStoreRef);
    // create the likely location of the archived node
    NodeRef archivedNodeRef = new NodeRef(
            archiveRootNodeRef.getStoreRef(),
            originalNodeRef.getId());
    return archivedNodeRef;
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
protected NodeRef getNode(NodeRef rootNodeRef, String path)
{
    RepositoryLocation repositoryLocation = new RepositoryLocation(rootNodeRef.getStoreRef(), path, RepositoryLocation.LANGUAGE_PATH);
    String[] pathElements = repositoryLocation.getPathElements();
    
    NodeRef nodeRef = rootNodeRef;
    if (pathElements.length > 0)
    {
        nodeRef = resolveQNamePath(rootNodeRef, pathElements);
    }
    
    return nodeRef;
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
/**
 * Construct
 * 
 * @param nodeRef NodeRef
 */
public Location(NodeRef nodeRef)
{
    ParameterCheck.mandatory("Node Ref", nodeRef);
    this.storeRef = nodeRef.getStoreRef();
    this.nodeRef = nodeRef;
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
private void restore(NodeRef origfolderOrContentRef)
{
    NodeRef archiveRootNode = nodeService.getStoreArchiveNode(this.rootNodeRef.getStoreRef());
    
    NodeRef archiveNodeRef = new NodeRef(archiveRootNode.getStoreRef(), origfolderOrContentRef.getId());
    nodeService.restoreNode(archiveNodeRef, null, null, null);
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
/**
 * This test method restores some deleted nodes from the archive store.
 */
public void testRestoreDeletedItems() throws Exception
{
    AuthenticationUtil.setFullyAuthenticatedUser(AuthenticationUtil.getAdminUserName());
    
    JSONObject archivedNodesJson = getArchivedNodes();
    JSONObject dataJsonObj = archivedNodesJson.getJSONObject("data");
    JSONArray archivedNodesArray = dataJsonObj.getJSONArray(AbstractArchivedNodeWebScript.DELETED_NODES);
    
    int archivedNodesLength = archivedNodesArray.length();
    assertTrue("Insufficient archived nodes for test to run.", archivedNodesLength > 1);
    
    // Take a specific archived node and restore it.
    JSONObject firstArchivedNode = archivedNodesArray.getJSONObject(0);
    
    // So we have identified a specific Node in the archive that we want to restore.
    String nodeRefString = firstArchivedNode.getString(AbstractArchivedNodeWebScript.NODEREF);
    assertTrue("nodeRef string is invalid", NodeRef.isNodeRef(nodeRefString));
    NodeRef nodeRef = new NodeRef(nodeRefString);
    
    // This is not the StoreRef where the node originally lived e.g. workspace://SpacesStore
    // This is its current StoreRef i.e. archive://SpacesStore
    final StoreRef currentStoreRef = nodeRef.getStoreRef();
    
    String restoreUrl = getArchiveUrl(currentStoreRef) + "/" + nodeRef.getId();
    
    
    int archivedNodesCountBeforeRestore = getArchivedNodesCount();

    // Send the PUT REST call.
    String jsonString = new JSONStringer().object()
        .key("restoreLocation").value("")
        .endObject()
    .toString();
    Response rsp = sendRequest(new PutRequest(restoreUrl, jsonString, "application/json"), 200);
    
    assertEquals("Expected archive to shrink by one", archivedNodesCountBeforeRestore - 1, getArchivedNodesCount());
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
private String makeUrl(NodeRef node, String locatorName)
{
    StoreRef storeRef = node.getStoreRef();
    StringBuilder url = new StringBuilder("/api/");
    url.append(storeRef.getProtocol()).append("/")
    .append(storeRef.getIdentifier()).append("/")
    .append(node.getId()).append("/")
    .append("nodelocator").append("/")
    .append(locatorName);
    return url.toString();
}
 

import org.alfresco.service.cmr.repository.NodeRef; //導入方法依賴的package包/類
@Override
public void afterVersionRevert(NodeRef nodeRef, Version version)
{
    NodeRef versionNodeRef = version.getFrozenStateNodeRef();
    if (!this.nodeService.hasAspect(versionNodeRef, ForumModel.ASPECT_DISCUSSABLE))
    {
        return;
    }
    
    // Get the discussion assoc references from the version store
    List<ChildAssociationRef> childAssocRefs = this.nodeService.getChildAssocs(VersionUtil.convertNodeRef(versionNodeRef), ForumModel.ASSOC_DISCUSSION,
            RegexQNamePattern.MATCH_ALL);
    for (ChildAssociationRef childAssocRef : childAssocRefs)
    {
        // Get the child reference
        NodeRef childRef = childAssocRef.getChildRef();
        NodeRef referencedNode = (NodeRef) this.dbNodeService.getProperty(childRef, ContentModel.PROP_REFERENCE);

        if (referencedNode != null && this.nodeService.exists(referencedNode) == false)
        {
            StoreRef orginalStoreRef = referencedNode.getStoreRef();
            NodeRef archiveRootNodeRef = this.nodeService.getStoreArchiveNode(orginalStoreRef);
            if (archiveRootNodeRef == null)
            {
                // Store doesn't support archiving
                continue;
            }
            NodeRef archivedNodeRef = new NodeRef(archiveRootNodeRef.getStoreRef(), referencedNode.getId());

            if (!this.nodeService.exists(archivedNodeRef) || !nodeService.hasAspect(archivedNodeRef, ContentModel.ASPECT_ARCHIVED))
            {
                // Node doesn't support archiving or it was deleted within parent node.
                continue;
            }

            NodeRef existingChild = this.nodeService.getChildByName(nodeRef, childAssocRef.getTypeQName(), this.nodeService
                    .getProperty(archivedNodeRef, ContentModel.PROP_NAME).toString());
            if (existingChild != null)
            {
                this.nodeService.deleteNode(existingChild);
            }

            this.nodeService.restoreNode(archivedNodeRef, null, null, null);
        }
    }
}