> For the complete documentation index, see [llms.txt](https://developer.collibra.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.collibra.com/workflows/designing-workflows/processes/shape-repository/service-task/delegates/alternatives-to-api-v1-delegates.md).

# Alternatives to API v1 delegates

This section provides examples of alternatives to Java Core API v1 delegates.

## AddAttributeDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Add attribute" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.attribute.AddAttributeDelegate">
  <extensionElements>
    <activiti:field name="value">
      <activiti:string><![CDATA[attribute content]]></activiti:string>
    </activiti:field>
    <activiti:field name="ownerId">
      <activiti:expression><![CDATA[${item.id}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="typeId">
      <activiti:expression><![CDATA[${givenAttributeTypeId}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Add attribute" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.attribute.AddAttributeRequest;
    def attribute = attributeApi.addAttribute(AddAttributeRequest.builder()
        .assetId(item.id)
        .typeId(string2Uuid(givenAttributeTypeId)))
        .value("attribute content")
        .build())
    execution.setVariable("output", attribute)
  ]]></script>
</scriptTask>
```

{% endcode %}

## GetAttributeDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Get attribute" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.attribute.GetAttributeDelegate">
  <extensionElements>
    <activiti:field name="attributeId">
      <activiti:expression><![CDATA[${givenAttributeId}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Get attribute" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    def attribute = attributeApi.getAttribute(string2Uuid(givenAttributeId));
    execution.setVariable("output", attribute)
  ]]></script>
</scriptTask>
```

{% endcode %}

## RemoveAttributeDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Remove attribute" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.attribute.RemoveAttributeDelegate">
  <extensionElements>
    <activiti:field name="attributeId">
      <activiti:expression><![CDATA[${givenAttributeId}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Remove attribute" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    attributeApi.removeAttribute(string2Uuid(givenAttributeId));
  ]]></script>
</scriptTask>
```

{% endcode %}

## AddRelationDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Add relation" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.relation.GetRelationsDelegate">
  <extensionElements>
    <activiti:field name="sourceTermId">
      <activiti:expression><![CDATA[${item.id}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="targetTermId">
      <activiti:expression><![CDATA[${givenTargetResourceId}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="binaryFactTypeId">
      <activiti:expression><![CDATA[${givenRelationTypeId}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Add relation" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.relation.AddRelationRequest;
    def relation = relationApi.addRelation(AddRelationRequest.builder()
        .typeId(string2Uuid(givenRelationTypeId))
        .sourceId(item.id)
        .targetId(givenTargetResourceId)
        .build());
    execution.setVariable("output", relation)
  ]]></script>
</scriptTask>
```

{% endcode %}

## GetRelationsDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Remove relation" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.relation.GetRelationsDelegate">
  <extensionElements>
    <activiti:field name="sourceTermId">
      <activiti:expression><![CDATA[${item.id}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Remove relation" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.relation.FindRelationsRequest;        
    def relations = relationApi.findRelations(FindRelationsRequest.builder()
        .sourceId(item.id)
        .build())
    .getResults();
    execution.setVariable("output", relations)
  ]]></script>
</scriptTask>
```

{% endcode %}

## RemoveRelationsDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Remove relation" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.relation.RemoveRelationsDelegate">
  <extensionElements>
    <activiti:field name="sourceTermId">
      <activiti:expression><![CDATA[${item.id}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Remove relation" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.relation.FindRelationsRequest;        
    def relations = relationApi.findRelations(FindRelationsRequest.builder()
        .sourceId(item.id)
        .build())
    .getResults();
    relationApi.removeRelations(new ArrayList(relations.collect{ it.getId() }));
  ]]></script>
</scriptTask>
```

{% endcode %}

## AddResourceRoleDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Assign owner" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.roles.AddResourceRoleDelegate">
  <extensionElements>
    <activiti:field name="resourceId">
      <activiti:expression><![CDATA[${item.id}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="userName">
      <activiti:expression><![CDATA[${startUser}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="roleId">
      <activiti:expression><![CDATA[${roleId}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Assign owner" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.responsibility.AddResponsibilityRequest
    def userName = execution.getVariable("startUser")
    def ownerUserId = userApi.getUserByUsername(userName).getId();           
    responsibilityApi.addResponsibility(AddResponsibilityRequest.builder()
        .resourceId(item.id)
        .resourceDiscriminator(item.getResourceDiscriminator())
        .roleId(string2Uuid(roleId))
        .ownerId(ownerUserId)
        .build())
  ]]></script>
</scriptTask>
```

{% endcode %}

## RemoveResourceRoleDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Remove current Owner role" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.roles.RemoveResourceRoleDelegate">
  <extensionElements>
    <activiti:field name="roleName">
      <activiti:string><![CDATA[Owner]]></activiti:string>
    </activiti:field>
    <activiti:field name="userName">
      <activiti:expression><![CDATA[${ownerName}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="resourceId">
      <activiti:expression><![CDATA[${domain.id}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Remove current Owner role" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.responsibility.FindResponsibilitiesRequest
    def ownerUserId = userApi.getUserByUsername(ownerName).getId();
    def ownerRoleId = users.getRoleId("Owner");
    def responsibilities = responsibilityApi.findResponsibilities(FindResponsibilitiesRequest.builder()
        .resourceIds(Collections.singletonList(domain.id))
        .ownerIds(Collections.singletonList(ownerUserId))
        .roleIds(Collections.singletonList(ownerRoleId))
        .build())
     .getResults()
    responsibilityApi.removeResponsibilities(new ArrayList(responsibilities.collect{ it.getId() }));
  ]]></script>
</scriptTask>
```

{% endcode %}

## AddTermDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Add term" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.term.AddTermDelegate">
  <extensionElements>
    <activiti:field name="signifier">
      <activiti:expression>${givenSignifier}</activiti:expression>
    </activiti:field>
    <activiti:field name="vocabularyId">
      <activiti:expression>${givenVocabularyId}</activiti:expression>
    </activiti:field>
    <activiti:field name="typeId">
      <activiti:expression>${givenTypeId}</activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Add asset" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.asset.AddAssetRequest;
    import com.collibra.dgc.core.api.model.instance.Asset;
    Asset asset = assetApi.addAsset(AddAssetRequest.builder()
        .name(givenSignifier)
        .displayName(givenSignifier)
        .typeId(string2Uuid(givenTypeId))
        .domainId(string2Uuid(givenVocabularyId))
        .build())
    execution.setVariable("output", asset)
  ]]></script>
</scriptTask>
```

{% endcode %}

## GetTermDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Get term" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.term.GetTermDelegate">
  <extensionElements>
    <activiti:field name="termId">
      <activiti:expression><![CDATA[${giventTermId}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Get asset" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.model.instance.Asset;
    Asset asset = assetApi.getAsset(givenAssetId);
    execution.setVariable("output", asset)
  ]]></script>
</scriptTask>
```

{% endcode %}

## RemoveTermDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Remove term" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.term.RemoveTermDelegate">
  <extensionElements>
    <activiti:field name="termId">
      <activiti:expression><![CDATA[${givenTermId}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Remove asset" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    assetApi.removeAsset(givenAssetId);
  ]]></script>
</scriptTask>
```

{% endcode %}

## AddComment

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Add comment" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.AddComment">
  <extensionElements>
    <activiti:field name="comment">
      <activiti:string>The content of the comment.</activiti:string>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Store comment" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.comment.AddCommentRequest
    commentApi.addComment(AddCommentRequest.builder()
        .content("The content of the comment.")
        .baseResourceId(item.getId())
        .baseResourceDiscriminator(item.getResourceDiscriminator())
        .build())
  ]]></script>
</scriptTask>
```

{% endcode %}

## AddDecisionVote

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Add vote outcome to list" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.AddDecisionVote"></serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Add vote outcome to list" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    def voter = execution.getVariable("voter");
    Boolean approved = (Boolean) execution.getVariable("approve");
    comment = execution.getVariable("comment");
    vote = [
        "name" : voter,
        "approved": approved,
        "comment": comment?.toString()
    ]
    voting = execution.getVariable("votingResult");
    voting.add(vote);
    checkEarlyComplete(execution, voting);
    execution.setVariable("votingResult", voting);
    def checkEarlyComplete(execution, voting) {
        Boolean earlyComplete = (Boolean) execution.getVariable("earlyComplete");
        if (earlyComplete) {
            Long percentage = (Long) execution.getVariable("votePercentage");
            List<String> voters = (List<String>) execution.getVariable("voters");
            double approved = 0;
            double disapproved = 0;
            double totalVoters = voters.size();
            for (Map vote : voting) {
                if (vote.approved) {
                    approved++;
                }
                else {
                    disapproved++;
                }
            }
            if (approved / totalVoters >= percentage / 100.0) {
                execution.setVariable("completion", Boolean.TRUE);
            }
            else if (disapproved / totalVoters > (100 - percentage) / 100.0) {
                execution.setVariable("completion", Boolean.TRUE);
            }
        }
    }
  ]]></script>
</scriptTask>
```

{% endcode %}

## ChangeIssueResponsibleCommunity

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Move the Issue" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.ChangeIssueResponsibleCommunity">
  <extensionElements>
    <activiti:field name="responsibleCommunity">
      <activiti:expression>${responsibleCommunity}</activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Move the Issue" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script>
    import com.collibra.dgc.core.api.dto.instance.issue.MoveIssueRequest
    issueApi.moveIssue(MoveIssueRequest.builder()
        .issueId(item.id)
        .communityId(responsibleCommunity)
        .build())
  </script>
</scriptTask>
```

{% endcode %}

## ChangeStatusDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Mark as Accepted" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.ChangeStatusDelegate">
  <extensionElements>
    <activiti:field name="targetStatusId">
      <activiti:string><![CDATA[00000000-0000-0000-0000-000000005009]]></activiti:string>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Mark as Accepted" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.asset.ChangeAssetRequest
    String acceptedStatusId = "00000000-0000-0000-0000-000000005009"
    assetApi.changeAsset(ChangeAssetRequest.builder()
        .id(item.id)
        .statusId(string2Uuid(acceptedStatusId))
        .build())
  ]]></script>
</scriptTask>
```

{% endcode %}

## StateChanger

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Mark as Accepted" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.StateChanger">
  <extensionElements>
    <activiti:field name="targetStatusId">
      <activiti:string><![CDATA[00000000-0000-0000-0000-000000005009]]></activiti:string>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Mark as Accepted" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.asset.ChangeAssetRequest
    String acceptedStatusId = "00000000-0000-0000-0000-000000005009"
    assetApi.changeAsset(ChangeAssetRequest.builder()
        .id(item.id)
        .statusId(string2Uuid(acceptedStatusId))
        .build())
  ]]></script>
</scriptTask>
```

{% endcode %}

## CountVoteResult

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Count voting result" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.CountVoteResult"></serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Count voting result" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    def voting = execution.getVariable("votingResult")
    boolean result = getResult(voting, execution)
    execution.setVariable("votingSuccess", result)
    def getResult(voting, execution) {
        Long percentage = (Long) execution.getVariable("votePercentage");
        if (!voting.isEmpty()) {
            int requiredToVote = ((List<String>) execution.getVariable("voters")).size();
            int approved = getNumberOfApprovals(voting);
            double fraction = percentage / 100.0;
            return approved >= requiredToVote * fraction;
        }
        return false;
    }
    def getNumberOfApprovals(List<Map> voting) {
        int approved = 0;
        for (Map vote : voting) {
                if (vote.approved) {
                    approved++;
                }
            }
        return approved;
    }
  ]]></script>
</scriptTask>
```

{% endcode %}

## CreateIssue

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Create issue" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.CreateIssue">
  <extensionElements>
    <activiti:field name="subject">
      <activiti:expression>${subject}</activiti:expression>
    </activiti:field>
    <activiti:field name="description">
      <activiti:expression>${description}</activiti:expression>
    </activiti:field>
    <activiti:field name="priority">
      <activiti:expression>${priority}</activiti:expression>
    </activiti:field>
    <activiti:field name="relations">
      <activiti:expression>${relations}</activiti:expression>
    </activiti:field>
    <activiti:field name="classifications">
      <activiti:expression>${classifications}</activiti:expression>
    </activiti:field>
    <activiti:field name="requester">
      <activiti:expression>${requester}</activiti:expression>
    </activiti:field>
    <activiti:field name="responsibleCommunity">
      <activiti:expression>${responsibleCommunity}</activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Create issue" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.issue.RelatedAssetReference;
    import com.collibra.dgc.core.api.dto.instance.issue.AddIssueRequest;
    import com.collibra.dgc.core.api.dto.user.FindUsersRequest;
    def requesterId = userApi.getUserByUsername(requester).getId()
    def descriptionString = execution.getVariable("description")?.toString() ?: ""
    def communityId = responsibleCommunity
    def relatedAssets = execution.getVariable("relatedAssets") ?: []
    def relatedAssetsList = []
    relatedAssets.each{
        relatedAssetId ->
        def relatedAssetRef = RelatedAssetReference.builder()
            .assetId(relatedAssetId)
            .direction(true)
            .relationTypeId(string2Uuid(impactsRelationId))
            .build()
        relatedAssetsList.add(relatedAssetRef)
    }
    def newIssueUuid = issueApi.addIssue(AddIssueRequest.builder()
        .name(subject)
        .description(descriptionString)
        .priority(priority)
        .responsibleCommunityId(communityId)
        .relatedAssets(relatedAssetsList)
        .categoryIds(classifications)
        .typeId(string2Uuid(dataIssueId))
        .requesterId(requesterId)
        .build())
    .getId()
    execution.setVariable("outputCreatedTermId", newIssueUuid))
  ]]></script>
</scriptTask>
```

{% endcode %}

## CreateVotersList

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Create list of voters" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.CreateVotersList">
  <extensionElements>
    <activiti:field name="voterUserExpression">
      <activiti:expression><![CDATA[${voterUserExpression}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Create list of voters" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    def voterUserExpression = execution.getVariable("voterUserExpression")
    final Set<String> voters = new HashSet<>();
    for (String userExpression : utility.toList(voterUserExpression)) {
        voters.addAll(users.getUserNamesWithError(userExpression));
    }
    execution.setVariable("voters", new ArrayList<>(voters));
    execution.setVariable("votingResult", []);
    execution.setVariable("completion", Boolean.FALSE);
  ]]></script>
</scriptTask>
```

{% endcode %}

## GetModel

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Get Model" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.GetModel">
  <extensionElements>
    <activiti:field name="viewConfig">
      <activiti:expression>${viewConfig}</activiti:expression>
    </activiti:field>
    <activiti:field name="varNames">
      <activiti:string>VOC_ID</activiti:string>
    </activiti:field>
    <activiti:field name="varValues">
      <activiti:expression>${item.id}</activiti:expression>
    </activiti:field>
    <activiti:field name="resultVariable">
      <activiti:string>assets</activiti:string>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

| API v2                                                                               |
| ------------------------------------------------------------------------------------ |
| This delegate is not supported and there is no alternative or possibility to use it. |

## GetRelatedTerms

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Get related terms" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.GetRelatedTerms">
  <extensionElements>
    <activiti:field name="relationRole">
      <activiti:expression>"role(Business Steward)"</activiti:expression>
    </activiti:field>
    <activiti:field name="resultVariable">
      <activiti:string>relations</activiti:string>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Get related terms" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.model.meta.type.RelationType;
    import com.collibra.dgc.core.api.dto.meta.relationtype.FindRelationTypesRequest;
    import com.collibra.dgc.core.api.model.instance.Relation;
    import com.collibra.dgc.core.api.dto.instance.relation.FindRelationsRequest;
    import com.collibra.dgc.core.api.model.reference.NamedResourceReference;
    import com.collibra.dgc.workflow.api.exception.WorkflowException;
    List<RelationType> relationTypes = relationTypeApi.findRelationTypes(FindRelationTypesRequest.builder()
        .role("groups")
        .build())
    .getResults()
    if (relationTypes.isEmpty()) {
        throw new WorkflowException("No relation types for provided role 'groups'");
    }
    List<UUID> relatedAssetIds = new ArrayList<>();
    for (RelationType relationType : relationTypes) {
        List<Relation> relations = relationApi.findRelations(FindRelationsRequest.builder()
            .sourceId(item.id)
            .relationTypeId(relationType.getId())
            .build())
        .getResults();
        for (Relation relation : relations) {
            relatedAssetIds.add(relation.getTarget().getId());
        }
    }
    execution.setVariable("relations", relatedAssetIds);
  ]]></script>
</scriptTask>
```

{% endcode %}

## GetRelatedTermsDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Get related terms" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.GetRelatedTermsDelegate">
  <extensionElements>
    <activiti:field name="termId">
      <activiti:expression><![CDATA[${item.id}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="direction">
      <activiti:string>true</activiti:string>
    </activiti:field>
    <activiti:field name="relationTypeId">
      <activiti:string>"00000000-0000-0000-0000-000000007021"</activiti:string>
    </activiti:field>
    <activiti:field name="resultVariableName">
      <activiti:string>"relatedAssets"</activiti:string>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Get related terms" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.model.instance.Asset;
    import com.collibra.dgc.core.api.model.instance.Relation;
    import com.collibra.dgc.core.api.dto.instance.relation.FindRelationsRequest;
    assetId = item.id;
    direction = Boolean.TRUE;
    groupsRelationTypeId = string2Uuid("00000000-0000-0000-0000-000000007021");
    List<Asset> relatedAssets = new ArrayList<>();
    if (direction) {
        List<Relation> relations = relationApi.findRelations(FindRelationsRequest.builder()
            .sourceId(assetId)
            .relationTypeId(groupsRelationTypeId)
            .build())
        .getResults();
        for (Relation relation : relations) {
            relatedAssets.add(relation.getSource());
        }
    }
    else {
        List<Relation> relations = relationApi.findRelations(FindRelationsRequest.builder()
            .targetId(assetId)
            .relationTypeId(groupsRelationTypeId)
            .build())
        .getResults();
        for (Relation relation : relations) {
            relatedAssets.add(relation.getTarget());
        }
    }
    execution.setVariable("relatedAssets", relatedAssets);
  ]]></script>
</scriptTask>
```

{% endcode %}

## GetUserNames

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Get user names" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.GetUserNames">
  <extensionElements>
    <activiti:field name="userNames">
      <activiti:expression><![CDATA[${userName}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="userExpressions">
      <activiti:expression><![CDATA[${role}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="groupNames">
      <activiti:expression><![CDATA[${group}]]></activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Get user names" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.model.user.User;
    import com.collibra.dgc.core.api.model.usergroup.UserGroup;
    import com.collibra.dgc.core.api.dto.usergroup.FindUserGroupsRequest;
    Set<String> userNameResult = new HashSet<String>();
    userNameResult.addAll(utility.toList("${userName}"));
    userNameResult.addAll(users.getUserNames("${role}"));
    List<UserGroup> userGroupList = userGroupApi.findUserGroups(FindUserGroupsRequest.builder()
        .name("${group}")
        .nameMatchMode(MatchMode.EXACT)
        .build())
    .getResults()
    for (UserGroup userGroup : userGroupList) {
        List<User> userList = userApi.findUsers(FindUsersRequest.builder()
            .groupId(userGroup.getId())
            .build())
        .getResults()
        for (User user : userList) {
            userNameResult.add(user.getUserName());
        }
    }
    execution.setVariable("assembledUserNames", userNameResult);
  ]]></script>
</scriptTask>
```

{% endcode %}

## MailSender

{% code title="API v1" %}

```xml
com.collibra.dgc.core.workflow.activiti.delegate.MailSender
```

{% endcode %}

{% code title="API v2" %}

```xml
com.collibra.dgc.workflow.api.listener.ActionMailSender
```

{% endcode %}

## ProvideDefaultsDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Check optional variables" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.ProvideDefaultsDelegate">
  <extensionElements>
    <activiti:field name="names">
      <activiti:string><![CDATA[resultTemplate,reminderTemplate]]></activiti:string>
    </activiti:field>
    <activiti:field name="defaults">
      <activiti:string><![CDATA[result,reminder]]></activiti:string>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Check Optional Variables" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.workflow.api.exception.WorkflowException
    List<String> namesList = utility.toList(execution.getVariable("names"))
    List<String> defaultsList = utility.toList(execution.getVariable("defaults"))
    if(namesList.size() != defaultsList.size()) {
        loggerApi.error("names list contains " + namesList.size() + " elements while the default values list contains " +
defaultsList.size() + " elements. Those sizes should be equal.")
        String errorMessage = translation.getMessage("workflowNamesAndDefaultsSizeDontMatch",namesList.size(),defaultsList.size())
        String errorTitle = translation.getMessage("workflowValueNotAllowed");
        WorkflowException workflowException = new WorkflowException(errorMessage);
        ex.setTitleMessage(errorTitle);
        throw workflowException;
    }
    for (int i = 0; i < namesList.size(); i++) {
        String currentName = namesList.get(i).trim();
        String currentDefault = defaultsList.get(i);
        if (!execution.hasVariable(currentName)) {
            execution.setVariable(currentName, currentDefault);
        }
    }
  ]]></script>
</scriptTask>
```

{% endcode %}

## StartCollibraConnectFlowDelegate

{% code title="API v1" %}

```xml
com.collibra.dgc.core.workflow.activiti.delegate.StartCollibraConnectFlowDelegate
```

{% endcode %}

{% code title="API v2" %}

```xml
com.collibra.dgc.workflow.api.delegate.StartCollibraConnectFlowDelegate
```

{% endcode %}

## StartWorkflowInstanceDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Start workflow" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.StartWorkflowInstanceDelegate">
  <extensionElements>
    <activiti:field name="processId">
      <activiti:string><![CDATA[subWorkflow]]></activiti:string>
    </activiti:field>
    <activiti:field name="resourceId">
      <activiti:expression><![CDATA[${targetTermId}]]></activiti:expression>
    </activiti:field>
    <activiti:field name="resourceType">
      <activiti:string><![CDATA[TE]]></activiti:string>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Start workflow" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.workflow.StartWorkflowInstancesRequest;
    import com.collibra.dgc.core.api.model.workflow.WorkflowBusinessItemType;
    def workflowDefinitionId = workflowDefinitionApi.getWorkflowDefinitionByProcessId(subWorkflow).getId();
    workflowInstanceApi.startWorkflowInstances(StartWorkflowInstancesRequest.builder()
        .workflowDefinitionId(workflowDefinitionId)
        .addBusinessItemId(string2Uuid(${targetTermId}))
        .businessItemType(WorkflowBusinessItemType.valueOf("ASSET"))
        .build())
  ]]></script>
</scriptTask>
```

{% endcode %}

## TermIntakeDelegate

{% code title="API v1" %}

```xml
<serviceTask id="servicetask1" name="Create Term" activiti:class="com.collibra.dgc.core.workflow.activiti.delegate.TermIntakeDelegate">
  <extensionElements>
    <activiti:field name="signifier">
      <activiti:expression>${signifier}</activiti:expression>
    </activiti:field>
    <activiti:field name="conceptType">
      <activiti:expression>${conceptType}</activiti:expression>
    </activiti:field>
    <activiti:field name="vocabulary">
      <activiti:expression>${intakeVocabulary}</activiti:expression>
    </activiti:field>
    <activiti:field name="definition">
      <activiti:expression>${definition}</activiti:expression>
    </activiti:field>
    <activiti:field name="description">
      <activiti:expression>${description}</activiti:expression>
    </activiti:field>
    <activiti:field name="example">
      <activiti:expression>${example}</activiti:expression>
    </activiti:field>
    <activiti:field name="usesrelation">
      <activiti:expression>${usesrelation}</activiti:expression>
    </activiti:field>
    <activiti:field name="note">
      <activiti:expression>${note}</activiti:expression>
    </activiti:field>
  </extensionElements>
</serviceTask>
```

{% endcode %}

{% code title="API v2" %}

```xml
<scriptTask id="scripttask1" name="Create Asset" scriptFormat="groovy" activiti:autoStoreVariables="false">
  <script><![CDATA[
    import com.collibra.dgc.core.api.dto.instance.asset.AddAssetRequest;
    import com.collibra.dgc.core.api.dto.instance.attribute.AddAttributeRequest;
    import com.collibra.dgc.core.api.dto.instance.relation.AddRelationRequest;
    def note = execution.getVariable("note")
    def definition = execution.getVariable("definition")  
    def newAssetUuid = assetApi.addAsset(AddAssetRequest.builder()
        .name(signifier)
        .displayName(signifier)
        .typeId(conceptType)
        .domainId(string2Uuid(intakeVocabulary))
        .build())
    .getId()
    addAttributeToAsset(newAssetUuid,definition,definitionAttributeTypeUuid)
    addAttributeToAsset(newAssetUuid,note,noteAttributeTypeUuid)
    addRelationsWithOneSourceAndMultipleTargetsToAsset(newAssetUuid,usesRelationTypeUuid,usesrelation)
    execution.setVariable("outputCreatedTermId",uuid2String(newAssetUuid))
    def addAttributeToAsset(assetUuid,attributeValue,attributeTypeUuid) {
        if (attributeValue == null){
            return;
        }
        attributeApi.addAttribute(AddAttributeRequest.builder()
            .assetId(assetUuid)
            .typeId(string2Uuid(attributeTypeUuid))
            .value(attributeValue.toString())
            .build())
    } 
    def addRelationsWithOneSourceAndMultipleTargetsToAsset(sourceUuid,relationTypeUuid,targetUuidList) {
        def addRelationsRequests = []
        loggerApi.info("Source: " + sourceUuid.toString())
        loggerApi.info("Type: " + relationTypeUuid.toString())
        loggerApi.info("Target: " + targetUuidList.toString())
        loggerApi.info("Target Class" + targetUuidList.getClass().toString())
        targetUuidList.each{ t ->
        loggerApi.info("T Class" + t.getClass().toString())
        addRelationsRequests.add(AddRelationRequest.builder()
            .sourceId(sourceUuid)
            .targetId(t)
            .typeId(string2Uuid(relationTypeUuid))
            .build())
        }
        relationApi.addRelations(addRelationsRequests)
    }
  ]]></script>
</scriptTask>
```

{% endcode %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://developer.collibra.com/workflows/designing-workflows/processes/shape-repository/service-task/delegates/alternatives-to-api-v1-delegates.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
