Alternatives to API v1 delegates

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

AddAttributeDelegate

API v1

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

API v2

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

GetAttributeDelegate

API v1

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

API v2

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

RemoveAttributeDelegate

API v1

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

API v2

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

AddRelationDelegate

API v1

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

API v2

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

GetRelationsDelegate

API v1

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

API v2

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

RemoveRelationsDelegate

API v1

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

API v2

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

AddResourceRoleDelegate

API v1

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

API v2

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

RemoveResourceRoleDelegate

API v1

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

API v2

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

AddTermDelegate

API v1

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

API v2

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

GetTermDelegate

API v1

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

API v2

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

RemoveTermDelegate

API v1

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

API v2

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

AddComment

API v1

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

API v2

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

AddDecisionVote

API v1

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

API v2

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

ChangeIssueResponsibleCommunity

API v1

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

API v2

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

ChangeStatusDelegate

API v1

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

API v2

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

StateChanger

API v1

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

API v2

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

CountVoteResult

API v1

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

API v2

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

CreateIssue

API v1

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

API v2

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

CreateVotersList

API v1

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

API v2

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

GetModel

API v1

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

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

GetRelatedTerms

API v1

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

API v2

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

GetRelatedTermsDelegate

API v1

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

API v2

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

GetUserNames

API v1

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

API v2

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

MailSender

API v1

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

API v2

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

ProvideDefaultsDelegate

API v1

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

API v2

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

StartCollibraConnectFlowDelegate

API v1

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

API v2

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

StartWorkflowInstanceDelegate

API v1

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

API v2

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

TermIntakeDelegate

API v1

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

API v2

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