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

public void policyBehaviour(AssociationRef assocRef)
{
    final QName assocTypeQName = assocRef.getTypeQName();
    if ( !excludedAssocTypes.contains(assocTypeQName))
    {
        NodeRef nodeRef = assocRef.getSourceRef();
        
        if (nodeService.exists(nodeRef))
        {
            List<ChildAssociationRef> parentsAssocRefs = this.nodeService.getParentAssocs(nodeRef);
            for (ChildAssociationRef parentAssocRef : parentsAssocRefs)
            {
                triggerRules(parentAssocRef.getParentRef(), nodeRef);
                if (logger.isDebugEnabled() == true)
                {
                    logger.debug(
                            "OnUpdateAssoc rule triggered (parent); " +
                                    "nodeRef=" + parentAssocRef.getParentRef());
                }
            }
        }
    }
}
 

@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());
    }
}
 

@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 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
    }
}
 

/**
 * @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);
    }
}
 

/**
 * @see NodeServicePolicies.OnDeleteAssociationPolicy#onDeleteAssociation(AssociationRef)
 */
protected void invokeOnDeleteAssociation(AssociationRef nodeAssocRef)
{
    NodeRef sourceNodeRef = nodeAssocRef.getSourceRef();
    
    if (ignorePolicy(sourceNodeRef))
    {
        return;
    }
    
    QName assocTypeQName = nodeAssocRef.getTypeQName();
    // get qnames to invoke against
    Set<QName> qnames = getTypeAndAspectQNames(sourceNodeRef);
    // execute policy for node type and aspects
    NodeServicePolicies.OnDeleteAssociationPolicy policy = onDeleteAssociationDelegate.get(sourceNodeRef, qnames, assocTypeQName);
    policy.onDeleteAssociation(nodeAssocRef);
}
 

/**
 * @see NodeServicePolicies.BeforeDeleteAssociationPolicy#beforeDeleteAssociation(AssociationRef)
 */
protected void invokeBeforeDeleteAssociation(AssociationRef nodeAssocRef)
{
    NodeRef sourceNodeRef = nodeAssocRef.getSourceRef();
    
    if (ignorePolicy(sourceNodeRef))
    {
        return;
    }
    
    QName assocTypeQName = nodeAssocRef.getTypeQName();
    // get qnames to invoke against
    Set<QName> qnames = getTypeAndAspectQNames(sourceNodeRef);
    // execute policy for node type and aspects
    NodeServicePolicies.BeforeDeleteAssociationPolicy policy = beforeDeleteAssociationDelegate.get(sourceNodeRef, qnames, assocTypeQName);
    policy.beforeDeleteAssociation(nodeAssocRef);
}
 

/**
 * @see NodeServicePolicies.OnCreateAssociationPolicy#onCreateAssociation(AssociationRef)
 */
protected void invokeOnCreateAssociation(AssociationRef nodeAssocRef)
{
    NodeRef sourceNodeRef = nodeAssocRef.getSourceRef();
    
    if (ignorePolicy(sourceNodeRef))
    {
        return;
    }
    
    QName assocTypeQName = nodeAssocRef.getTypeQName();
    // get qnames to invoke against
    Set<QName> qnames = getTypeAndAspectQNames(sourceNodeRef);
    // execute policy for node type and aspects
    NodeServicePolicies.OnCreateAssociationPolicy policy = onCreateAssociationDelegate.get(sourceNodeRef, qnames, assocTypeQName);
    policy.onCreateAssociation(nodeAssocRef);
}
 

@Override
public AssociationRef getBaseName(AssociationRef assocRef)
{
    if (assocRef == null)
    {
        return null;
    }

    return new AssociationRef(assocRef.getId(),
            getBaseName(assocRef.getSourceRef()),
            assocRef.getTypeQName(),
            getBaseName(assocRef.getTargetRef()));
}
 

/**
 * @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);
    }
}
 

@Override
public AssociationRef getName(AssociationRef assocRef)
{
    if (assocRef == null)
    {
        return null;
    }

    return new AssociationRef(assocRef.getId(),
            getName(assocRef.getSourceRef()),
            assocRef.getTypeQName(),
            getName(assocRef.getTargetRef()));
}
 

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

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

/**
 * 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);
        }
    }
    
}
 

/**
 * Returns the type definition of an association or <code>null</code> if no
 * type definition could be found.
 */
public TypeDefinitionWrapper getType(AssociationRef assocRef)
{
    QName typeQName = assocRef.getTypeQName();
    return getOpenCMISDictionaryService().findAssocType(typeQName);
}
 

@Override
public List<AssociationRef> getSourceAssocs(NodeRef targetRef, QNamePattern qnamePattern)
{
    NodeServiceTrait theTrait = getTrait();
    Reference reference = Reference.fromNodeRef(targetRef);

    if (reference != null)
    {

        List<AssociationRef> materialAssocs = new ArrayList<AssociationRef>();

        if (smartStore.canMaterialize(reference))
        {
            List<AssociationRef> sourceAssocs = theTrait.getSourceAssocs(smartStore.materialize(reference),
                                                                         qnamePattern);
            for (AssociationRef associationRef : sourceAssocs)
            {
                NodeRef sourceRef = associationRef.getSourceRef();
                Reference sourceReference = NodeProtocol.newReference(sourceRef,
                                                                      reference
                                                                                  .execute(new GetParentReferenceMethod()));
                AssociationRef virtualAssocRef = new AssociationRef(associationRef.getId(),
                                                                    sourceReference.toNodeRef(),
                                                                    associationRef.getTypeQName(),
                                                                    targetRef);
                materialAssocs.add(virtualAssocRef);
            }
        }

        // Download sources are deliberately not virtualized due to
        // performance and complexity issues.
        // However they could be detected using
        // if (qnamePattern.isMatch(DownloadModel.ASSOC_REQUESTED_NODES))

        return materialAssocs;
    }
    else
    {
        return theTrait.getSourceAssocs(targetRef,
                                        qnamePattern);
    }
}
 

@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;
}