Java Code Examples for org.alfresco.service.cmr.repository.AssociationRef#getTargetRef()

/**
 * Freeze associations
 *
 * @param versionNodeRef   the version node reference
 * @param associations     the list of associations
 * 
 * @since 3.3 (Ent)
 */
private void freezeAssociations(NodeRef versionNodeRef, List<AssociationRef> associations)
{
    for (AssociationRef targetAssocRef : associations)
    {
        HashMap<QName, Serializable> properties = new HashMap<QName, Serializable>();
        
        QName sourceTypeRef = nodeService.getType(targetAssocRef.getSourceRef());
        
        NodeRef targetRef = targetAssocRef.getTargetRef();
        
        // Set the reference property to point to the target node
        properties.put(ContentModel.PROP_REFERENCE, targetRef);
        properties.put(Version2Model.PROP_QNAME_ASSOC_DBID, targetAssocRef.getId());
        
        // Create peer version reference
        dbNodeService.createNode(
                versionNodeRef,
                Version2Model.CHILD_QNAME_VERSIONED_ASSOCS,
                targetAssocRef.getTypeQName(),
                sourceTypeRef,
                properties);
    }
}
 

@Override
public NodeRef getTargetAssocs(NodeRef nodeRef, QName associationQName)
{
    List<AssociationRef> assocs = apiFacet.getNodeService().getTargetAssocs(nodeRef,
                                                                            associationQName);

    if (assocs != null && assocs.size() >= 1)
    {
        AssociationRef associationRef = assocs.get(0);
        NodeRef targetRef = associationRef.getTargetRef();
        return targetRef;
    }
    else
    {
        return null;
    }
}
 

/**
 * @see AssocSourceMultiplicityIntegrityEvent
 * @see AssocTargetMultiplicityIntegrityEvent
 */
public void onDeleteAssociation(AssociationRef nodeAssocRef)
{
    if (! storesToIgnore.contains(tenantService.getBaseName(nodeAssocRef.getSourceRef().getStoreRef()).toString()))
    {
        IntegrityEvent event = null;
        // check source multiplicity
        event = new AssocSourceMultiplicityIntegrityEvent(
                nodeService,
                dictionaryService,
                nodeAssocRef.getTargetRef(),
                nodeAssocRef.getTypeQName(),
                true);
        save(event);
        // check target multiplicity
        event = new AssocTargetMultiplicityIntegrityEvent(
                nodeService,
                dictionaryService,
                nodeAssocRef.getSourceRef(),
                nodeAssocRef.getTypeQName(),
                true);
        save(event);
    }
}
 

@Test
public void testDuplicateAssociationDetection() throws Exception
{
    AssociationRef assocRef = createAssociation();
    NodeRef sourceRef = assocRef.getSourceRef();
    NodeRef targetRef = assocRef.getTargetRef();
    QName qname = assocRef.getTypeQName();
    try
    {
        // attempt repeat
        nodeService.createAssociation(sourceRef, targetRef, qname);
        fail("Duplicate assocation not detected");
    }
    catch (AssociationExistsException e)
    {
        // expected
    }
}
 

@Test
public void testGetTargetAssocs() throws Exception
{
    AssociationRef assocRef = createAssociation();
    NodeRef sourceRef = assocRef.getSourceRef();
    NodeRef targetRef = assocRef.getTargetRef();
    QName qname = assocRef.getTypeQName();
    // get the target assocs
    List<AssociationRef> targetAssocs = nodeService.getTargetAssocs(sourceRef, qname);
    assertEquals("Incorrect number of targets", 1, targetAssocs.size());
    assertTrue("Target not found", targetAssocs.contains(assocRef));
    
    // Check that IDs are present
    for (AssociationRef targetAssoc : targetAssocs)
    {
        assertNotNull("Association does not have ID", targetAssoc.getId());
    }
}
 

@Test
public void testGetSourceAssocs() throws Exception
{
    AssociationRef assocRef = createAssociation();
    NodeRef sourceRef = assocRef.getSourceRef();
    NodeRef targetRef = assocRef.getTargetRef();
    QName qname = assocRef.getTypeQName();
    // get the source assocs
    List<AssociationRef> sourceAssocs = nodeService.getSourceAssocs(targetRef, qname);
    assertEquals("Incorrect number of source assocs", 1, sourceAssocs.size());
    assertTrue("Source not found", sourceAssocs.contains(assocRef));
    
    // Check that IDs are present
    for (AssociationRef sourceAssoc : sourceAssocs)
    {
        assertNotNull("Association does not have ID", sourceAssoc.getId());
    }
}
 

/**
 * 
 * @param ref AssociationRef
 */
public AssociationRefKey(AssociationRef ref)
{
    this.sourceRef = ref.getSourceRef();
    this.targetRef = ref.getTargetRef();
    this.assocTypeQName = ref.getTypeQName();
}
 

public static NodeRef getSingleAssocNode(Collection<AssociationRef> assocs, boolean getTarget)
{
    if(assocs != null && assocs.size()==1 )
    {
        AssociationRef association = assocs.iterator().next();
        return getTarget ? association.getTargetRef() : association.getSourceRef();
    }
    return null;
}
 

/**
 * @see AssocSourceTypeIntegrityEvent
 * @see AssocTargetTypeIntegrityEvent
 * @see AssocSourceMultiplicityIntegrityEvent
 * @see AssocTargetMultiplicityIntegrityEvent
 */
public void onCreateAssociation(AssociationRef nodeAssocRef)
{
    if (! storesToIgnore.contains(tenantService.getBaseName(nodeAssocRef.getSourceRef().getStoreRef()).toString()))
    {
        IntegrityEvent event = null;
        // check source type
        event = new AssocSourceTypeIntegrityEvent(
                nodeService,
                dictionaryService,
                nodeAssocRef.getSourceRef(),
                nodeAssocRef.getTypeQName());
        save(event);
        // check target type
        event = new AssocTargetTypeIntegrityEvent(
                nodeService,
                dictionaryService,
                nodeAssocRef.getTargetRef(),
                nodeAssocRef.getTypeQName());
        save(event);
        // check source multiplicity
        event = new AssocSourceMultiplicityIntegrityEvent(
                nodeService,
                dictionaryService,
                nodeAssocRef.getTargetRef(),
                nodeAssocRef.getTypeQName(),
                false);
        save(event);
        // check target multiplicity
        event = new AssocTargetMultiplicityIntegrityEvent(
                nodeService,
                dictionaryService,
                nodeAssocRef.getSourceRef(),
                nodeAssocRef.getTypeQName(),
                false);
        save(event);
    }
}
 

protected CollectionWithPagingInfo<Node> listNodePeerAssocs(List<AssociationRef> assocRefs, Parameters parameters, boolean returnTarget)
{
    Map<QName, String> qnameMap = new HashMap<>(3);

    Map<String, UserInfo> mapUserInfo = new HashMap<>(10);

    List<String> includeParam = parameters.getInclude();

    List<Node> collection = new ArrayList<Node>(assocRefs.size());
    for (AssociationRef assocRef : assocRefs)
    {
        // minimal info by default (unless "include"d otherwise)
        NodeRef nodeRef = (returnTarget ? assocRef.getTargetRef() : assocRef.getSourceRef());

        Node node = nodes.getFolderOrDocument(nodeRef, null, null, includeParam, mapUserInfo);

        QName assocTypeQName = assocRef.getTypeQName();

        if (! EXCLUDED_NS.contains(assocTypeQName.getNamespaceURI()))
        {
            String assocType = qnameMap.get(assocTypeQName);
            if (assocType == null)
            {
                assocType = assocTypeQName.toPrefixString(namespaceService);
                qnameMap.put(assocTypeQName, assocType);
            }

            node.setAssociation(new Assoc(assocType));

            collection.add(node);
        }
    }
    
    return listPage(collection, parameters.getPaging());
}
 

@Override
public List<AssociationRef> getTargetAssocs(NodeRef sourceRef, QNamePattern qnamePattern)
{
    NodeServiceTrait theTrait = getTrait();
    List<AssociationRef> targetAssocs = null;

    Reference reference = Reference.fromNodeRef(sourceRef);
    if (reference != null)
    {
        if (smartStore.canMaterialize(reference))
        {
            NodeRef materializedReferece = smartStore.materialize(reference);
            targetAssocs = theTrait.getTargetAssocs(materializedReferece,
                                                    qnamePattern);
        }
        else
        {
            targetAssocs = new LinkedList<>();
        }
    }
    else
    {
        targetAssocs = theTrait.getTargetAssocs(sourceRef,
                                                qnamePattern);
    }

    List<AssociationRef> virtualizedIfNeededTargetAssocs = null;

    Reference sourceReference = Reference.fromNodeRef(sourceRef);
    if (sourceReference != null)
    {
        virtualizedIfNeededTargetAssocs = new LinkedList<>();

        for (AssociationRef associationRef : targetAssocs)
        {
            NodeRef targetNodeRef = associationRef.getTargetRef();
            Reference targetReference = NodeProtocol.newReference(targetNodeRef,
                                                                  sourceReference
                                                                              .execute(new GetParentReferenceMethod()));
            AssociationRef virtualAssocRef = new AssociationRef(associationRef.getId(),
                                                                sourceRef,
                                                                associationRef.getTypeQName(),
                                                                targetReference.toNodeRef(targetNodeRef
                                                                            .getStoreRef()));
            virtualizedIfNeededTargetAssocs.add(virtualAssocRef);
        }

    }
    else
    {
        virtualizedIfNeededTargetAssocs = targetAssocs;

        if (DownloadModel.TYPE_DOWNLOAD.equals(environment.getType(sourceRef)))
        {
            if (qnamePattern.isMatch(DownloadModel.ASSOC_REQUESTED_NODES))
            {
                List<AssociationRef> virtualTargetAssocs = getDownloadTargetAssocs(sourceRef);
                virtualizedIfNeededTargetAssocs.addAll(virtualTargetAssocs);
            }
        }
    }

    return virtualizedIfNeededTargetAssocs;
}
 

/**
 * Copy any remaining associations that could not be copied or ignored during the copy process.
 * See <a href=http://issues.alfresco.com/jira/browse/ALF-958>ALF-958: Target associations aren't copied</a>.
 */
private void copyPendingAssociations(Map<NodeRef, NodeRef> copiedNodeRefs)
{
    // Prepare storage for post-copy association handling
    List<Pair<AssociationRef, AssocCopyTargetAction>> postCopyAssocs =
            TransactionalResourceHelper.getList(KEY_POST_COPY_ASSOCS);
    for (Pair<AssociationRef, AssocCopyTargetAction> pair : postCopyAssocs)
    {
        AssociationRef assocRef = pair.getFirst();
        AssocCopyTargetAction action = pair.getSecond();
        // Was the original target copied?
        NodeRef newSourceForAssoc = copiedNodeRefs.get(assocRef.getSourceRef());
        if (newSourceForAssoc == null)
        {
            // Developer #fail
            throw new IllegalStateException("Post-copy association has a source that was NOT copied.");
        }
        NodeRef oldTargetForAssoc = assocRef.getTargetRef();
        NodeRef newTargetForAssoc = copiedNodeRefs.get(oldTargetForAssoc);      // May be null
        QName assocTypeQName = assocRef.getTypeQName();
        switch (action)
        {
            case USE_ORIGINAL_TARGET:
                internalNodeService.createAssociation(newSourceForAssoc, oldTargetForAssoc, assocTypeQName);
                break;
            case USE_COPIED_TARGET:
                // Do nothing if the target was not copied
                if (newTargetForAssoc != null)
                {
                    internalNodeService.createAssociation(newSourceForAssoc, newTargetForAssoc, assocTypeQName);
                }
                break;
            case USE_COPIED_OTHERWISE_ORIGINAL_TARGET:
                if (newTargetForAssoc == null)
                {
                    internalNodeService.createAssociation(newSourceForAssoc, oldTargetForAssoc, assocTypeQName);
                }
                else
                {
                    internalNodeService.createAssociation(newSourceForAssoc, newTargetForAssoc, assocTypeQName);
                }
                break;
            default:
                throw new IllegalStateException("Unknown association action: " + action);
        }
    }
    
}