diff --git a/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-common/src/test/java/org/kie/kogito/index/AbstractProcessDataIndexIT.java b/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-common/src/test/java/org/kie/kogito/index/AbstractProcessDataIndexIT.java index 82341e8ff4..56204ebeac 100644 --- a/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-common/src/test/java/org/kie/kogito/index/AbstractProcessDataIndexIT.java +++ b/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-common/src/test/java/org/kie/kogito/index/AbstractProcessDataIndexIT.java @@ -274,6 +274,7 @@ public void testProcessInstanceEvents() throws IOException { public void testProcessGatewayAPI() throws IOException { String pId2 = createTestProcessInstance(); + await() .atMost(TIMEOUT) .untilAsserted(() -> getProcessInstanceById(pId2, "ACTIVE")); @@ -343,6 +344,8 @@ public void testProcessGatewayAPI() throws IOException { .statusCode(200) .body("errors", nullValue())); + System.out.println("PROCESS INSTANCE 2!!! UPDATED " + taskSchema); + await() .atMost(TIMEOUT) .untilAsserted(() -> given().spec(dataIndexSpec()).contentType(ContentType.JSON) @@ -471,6 +474,18 @@ public void testProcessGatewayAPIComments(String taskId, String processInstanceI .body("$.size()", is(1)) .body("[0].content", is(commentContent))); + await() + .atMost(TIMEOUT) + .untilAsserted(() -> given().spec(dataIndexSpec()).contentType(ContentType.JSON) + .body("{ \"query\" : \"{ UserTaskInstances (where: { processInstanceId: {equal: \\\"" + processInstanceId + "\\\"}}) { " + + "id description priority potentialGroups comments {id content updatedBy updatedAt} } }\"}") + .when().post("/graphql") + .then() + .statusCode(200) + .body("data.UserTaskInstances[0].comments", notNullValue()) + .body("data.UserTaskInstances[0].comments.size()", is(1)) + .extract().jsonPath().getMap("data.UserTaskInstances[0].comments[0]")); + Map commentMap = given().spec(dataIndexSpec()).contentType(ContentType.JSON) .body("{ \"query\" : \"{ UserTaskInstances (where: { processInstanceId: {equal: \\\"" + processInstanceId + "\\\"}}) { " + "id description priority potentialGroups comments {id content updatedBy updatedAt} } }\"}") @@ -482,6 +497,7 @@ public void testProcessGatewayAPIComments(String taskId, String processInstanceI .body("data.UserTaskInstances[0].potentialGroups[0]", equalTo("managers")) .body("data.UserTaskInstances[0].comments.size()", is(1)) .extract().jsonPath().getMap("data.UserTaskInstances[0].comments[0]"); + checkExpectedCreatedItemData(commentCreationResult, commentMap); String commentNewContent = "commentNewContent"; String commentUpdateResult = given().spec(dataIndexSpec()).contentType(ContentType.JSON) diff --git a/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/main/resources/application.properties b/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/main/resources/application.properties index a6bb6880c5..f3fa1e0237 100644 --- a/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/main/resources/application.properties +++ b/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/main/resources/application.properties @@ -11,10 +11,4 @@ mp.messaging.outgoing.kogito-usertaskinstances-events.connector=smallrye-kafka mp.messaging.outgoing.kogito-usertaskinstances-events.topic=kogito-usertaskinstances-events mp.messaging.outgoing.kogito-usertaskinstances-events.value.serializer=org.apache.kafka.common.serialization.StringSerializer mp.messaging.outgoing.kogito-usertaskinstances-events.group.id=kogito-data-index-it -mp.messaging.outgoing.kogito-usertaskinstances-events.auto.offset.reset=earliest - -mp.messaging.outgoing.kogito-variables-events.connector=smallrye-kafka -mp.messaging.outgoing.kogito-variables-events.topic=kogito-variables-events -mp.messaging.outgoing.kogito-variables-events.value.serializer=org.apache.kafka.common.serialization.StringSerializer -mp.messaging.outgoing.kogito-variables-events.group.id=kogito-data-index-it -mp.messaging.outgoing.kogito-variables-events.auto.offset.reset=earliest \ No newline at end of file +mp.messaging.outgoing.kogito-usertaskinstances-events.auto.offset.reset=earliest \ No newline at end of file diff --git a/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/test/java/org/kie/kogito/index/quarkus/kafka/KogitoServiceRandomPortQuarkusKafkaTestResource.java b/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/test/java/org/kie/kogito/index/quarkus/kafka/KogitoServiceRandomPortQuarkusKafkaTestResource.java index 6165b9d458..a24fc18a70 100644 --- a/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/test/java/org/kie/kogito/index/quarkus/kafka/KogitoServiceRandomPortQuarkusKafkaTestResource.java +++ b/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/test/java/org/kie/kogito/index/quarkus/kafka/KogitoServiceRandomPortQuarkusKafkaTestResource.java @@ -48,7 +48,6 @@ protected Map getProperties() { properties.put(KOGITO_SERVICE_URL, "http://host.testcontainers.internal:" + getTestResource().getMappedPort()); properties.put("mp.messaging.outgoing.kogito-processinstances-events.connector", "smallrye-kafka"); properties.put("mp.messaging.outgoing.kogito-usertaskinstances-events.connector", "smallrye-kafka"); - properties.put("mp.messaging.outgoing.kogito-variables-events.connector", "smallrye-kafka"); return properties; } diff --git a/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/test/resources/application.properties b/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/test/resources/application.properties index 0829044d79..12aab75b32 100644 --- a/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/test/resources/application.properties +++ b/apps-integration-tests/integration-tests-data-index-service/integration-tests-data-index-service-quarkus/src/test/resources/application.properties @@ -14,9 +14,5 @@ mp.messaging.outgoing.kogito-usertaskinstances-events.connector=smallrye-kafka mp.messaging.outgoing.kogito-usertaskinstances-events.topic=kogito-usertaskinstances-events mp.messaging.outgoing.kogito-usertaskinstances-events.value.serializer=org.apache.kafka.common.serialization.StringSerializer -mp.messaging.outgoing.kogito-variables-events.connector=smallrye-kafka -mp.messaging.outgoing.kogito-variables-events.topic=kogito-variables-events -mp.messaging.outgoing.kogito-variables-events.value.serializer=org.apache.kafka.common.serialization.StringSerializer - quarkus.http.auth.permission.source-files-addon.paths=/management/* quarkus.http.auth.permission.source-files-addon.policy=permit \ No newline at end of file diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/ProcessInstanceEventMapper.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/ProcessInstanceEventMapper.java deleted file mode 100644 index 01b70c56a2..0000000000 --- a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/ProcessInstanceEventMapper.java +++ /dev/null @@ -1,106 +0,0 @@ -/* - * Copyright 2022 Red Hat, Inc. and/or its affiliates. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.kie.kogito.index.event; - -import java.util.Set; -import java.util.function.Function; - -import org.kie.kogito.event.process.MilestoneEventBody; -import org.kie.kogito.event.process.NodeInstanceEventBody; -import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.index.model.Milestone; -import org.kie.kogito.index.model.NodeInstance; -import org.kie.kogito.index.model.ProcessDefinition; -import org.kie.kogito.index.model.ProcessInstance; -import org.kie.kogito.index.model.ProcessInstanceError; - -import static com.google.common.base.Strings.isNullOrEmpty; -import static java.util.stream.Collectors.toList; -import static org.kie.kogito.index.DateTimeUtils.toZonedDateTime; -import static org.kie.kogito.index.json.JsonUtils.getObjectMapper; - -public class ProcessInstanceEventMapper implements Function { - - @Override - public ProcessInstance apply(ProcessInstanceDataEvent event) { - if (event == null || event.getData() == null) { - return null; - } - - ProcessInstance pi = new ProcessInstance(); - pi.setId(event.getData().getId()); - pi.setProcessId(event.getData().getProcessId()); - pi.setProcessName(event.getData().getProcessName()); - pi.setRootProcessInstanceId(event.getData().getRootInstanceId()); - pi.setRootProcessId(event.getData().getRootProcessId()); - pi.setParentProcessInstanceId(event.getData().getParentInstanceId()); - pi.setRoles(event.getData().getRoles()); - pi.setVariables(getObjectMapper().valueToTree(event.getData().getVariables())); - pi.setNodes(event.getData().getNodeInstances().stream().map(nodeInstance()).collect(toList())); - pi.setState(event.getData().getState()); - pi.setStart(toZonedDateTime(event.getData().getStartDate())); - pi.setEnd(toZonedDateTime(event.getData().getEndDate())); - if (event.getData().getError() != null) { - pi.setError(new ProcessInstanceError(event.getData().getError().getNodeDefinitionId(), event.getData().getError().getErrorMessage())); - } - pi.setMilestones(event.getData().getMilestones().stream().map(milestone()).collect(toList())); - pi.setBusinessKey(event.getData().getBusinessKey()); - pi.setAddons(isNullOrEmpty(event.getKogitoAddons()) ? null : Set.of(event.getKogitoAddons().split(","))); - pi.setEndpoint(event.getSource() == null ? null : event.getSource().toString()); - pi.setLastUpdate(toZonedDateTime(event.getTime())); - pi.setVersion(event.getData().getVersion()); - pi.setDefinition(definition().apply(event)); - pi.setUpdatedBy(event.getData().getIdentity()); - return pi; - } - - private Function definition() { - return event -> { - ProcessDefinition pd = new ProcessDefinition(); - pd.setId(event.getData().getProcessId()); - pd.setName(event.getData().getProcessName()); - pd.setVersion(event.getData().getVersion()); - pd.setAddons(isNullOrEmpty(event.getKogitoAddons()) ? null : Set.of(event.getKogitoAddons().split(","))); - pd.setRoles(event.getData().getRoles()); - pd.setType(event.getKogitoProcessType()); - pd.setEndpoint(event.getSource() == null ? null : event.getSource().toString()); - return pd; - }; - } - - private Function nodeInstance() { - return nib -> { - NodeInstance ni = new NodeInstance(); - ni.setId(nib.getId()); - ni.setEnter(toZonedDateTime(nib.getTriggerTime())); - ni.setName(nib.getNodeName()); - ni.setType(nib.getNodeType()); - ni.setNodeId(nib.getNodeId()); - ni.setDefinitionId(nib.getNodeDefinitionId()); - ni.setExit(toZonedDateTime(nib.getLeaveTime())); - return ni; - }; - } - - private Function milestone() { - return m -> Milestone.builder() - .id(m.getId()) - .name(m.getName()) - .status(m.getStatus()) - .build(); - } -} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/UserTaskInstanceEventMapper.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/UserTaskInstanceEventMapper.java deleted file mode 100644 index ce9908b85a..0000000000 --- a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/UserTaskInstanceEventMapper.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * Copyright 2022 Red Hat, Inc. and/or its affiliates. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.kie.kogito.index.event; - -import java.net.URI; -import java.util.function.Function; - -import org.kie.kogito.event.process.AttachmentEventBody; -import org.kie.kogito.event.process.CommentEventBody; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; -import org.kie.kogito.index.model.Attachment; -import org.kie.kogito.index.model.Comment; -import org.kie.kogito.index.model.UserTaskInstance; - -import com.google.common.net.UrlEscapers; - -import static java.lang.String.format; -import static java.util.stream.Collectors.toList; -import static org.kie.kogito.index.DateTimeUtils.toZonedDateTime; -import static org.kie.kogito.index.json.JsonUtils.getObjectMapper; - -public class UserTaskInstanceEventMapper implements Function { - - @Override - public UserTaskInstance apply(UserTaskInstanceDataEvent event) { - if (event == null || event.getData() == null) { - return null; - } - - UserTaskInstance task = new UserTaskInstance(); - task.setId(event.getData().getId()); - task.setProcessInstanceId(event.getData().getProcessInstanceId()); - task.setProcessId(event.getData().getProcessId()); - task.setRootProcessId(event.getData().getRootProcessId()); - task.setRootProcessInstanceId(event.getData().getRootProcessInstanceId()); - task.setName(event.getData().getTaskName()); - task.setDescription(event.getData().getTaskDescription()); - task.setState(event.getData().getState()); - task.setPriority(event.getData().getTaskPriority()); - task.setStarted(toZonedDateTime(event.getData().getStartDate())); - task.setCompleted(toZonedDateTime(event.getData().getCompleteDate())); - task.setActualOwner(event.getData().getActualOwner()); - task.setAdminUsers(event.getData().getAdminUsers()); - task.setAdminGroups(event.getData().getAdminGroups()); - task.setExcludedUsers(event.getData().getExcludedUsers()); - task.setPotentialUsers(event.getData().getPotentialUsers()); - task.setPotentialGroups(event.getData().getPotentialGroups()); - task.setComments(event.getData().getComments().stream().map(comment()).collect(toList())); - task.setAttachments(event.getData().getAttachments().stream().map(attachment()).collect(toList())); - task.setInputs(getObjectMapper().valueToTree(event.getData().getInputs())); - task.setOutputs(getObjectMapper().valueToTree(event.getData().getOutputs())); - task.setEndpoint(event.getSource() == null ? null : getEndpoint(event.getSource(), event.getData().getProcessInstanceId(), event.getData().getTaskName(), event.getData().getId())); - task.setLastUpdate(toZonedDateTime(event.getTime())); - task.setReferenceName(event.getData().getReferenceName()); - return task; - } - - private Function comment() { - return c -> Comment.builder() - .id(c.getId()) - .content(c.getContent()) - .updatedBy(c.getUpdatedBy()) - .updatedAt(toZonedDateTime(c.getUpdatedAt())) - .build(); - } - - private Function attachment() { - return a -> Attachment.builder() - .id(a.getId()) - .content(a.getContent() == null ? null : a.getContent().toString()) - .name(a.getName()) - .updatedBy(a.getUpdatedBy()) - .updatedAt(toZonedDateTime(a.getUpdatedAt())) - .build(); - } - - public String getEndpoint(URI source, String pId, String taskName, String taskId) { - String name = UrlEscapers.urlPathSegmentEscaper().escape(taskName); - return source.toString() + format("/%s/%s/%s", pId, name, taskId); - } -} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceErrorDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceErrorDataEventMerger.java new file mode 100644 index 0000000000..d74df65ca1 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceErrorDataEventMerger.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceErrorDataEvent; +import org.kie.kogito.index.model.ProcessInstance; +import org.kie.kogito.index.model.ProcessInstanceError; + +@ApplicationScoped +public class ProcessInstanceErrorDataEventMerger implements ProcessInstanceEventMerger { + + @Override + public boolean accept(ProcessInstanceDataEvent event) { + return event instanceof ProcessInstanceErrorDataEvent; + } + + @Override + public void merge(ProcessInstance pi, ProcessInstanceDataEvent data) { + ProcessInstanceErrorDataEvent event = (ProcessInstanceErrorDataEvent) data; + ProcessInstanceError error = new ProcessInstanceError(); + error.setMessage(event.getData().getErrorMessage()); + error.setNodeDefinitionId(event.getData().getNodeDefinitionId()); + pi.setError(error); + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceEventMerger.java new file mode 100644 index 0000000000..63caf80ffe --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceEventMerger.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.index.model.ProcessInstance; + +public interface ProcessInstanceEventMerger { + + boolean accept(ProcessInstanceDataEvent event); + + void merge(ProcessInstance pi, ProcessInstanceDataEvent event); + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceNodeDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceNodeDataEventMerger.java new file mode 100644 index 0000000000..b4a0824305 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceNodeDataEventMerger.java @@ -0,0 +1,113 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Optional; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceNodeDataEvent; +import org.kie.kogito.event.process.ProcessInstanceNodeEventBody; +import org.kie.kogito.index.model.Milestone; +import org.kie.kogito.index.model.MilestoneStatus; +import org.kie.kogito.index.model.Node; +import org.kie.kogito.index.model.NodeInstance; +import org.kie.kogito.index.model.ProcessInstance; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import static org.kie.kogito.index.DateTimeUtils.toZonedDateTime; + +@ApplicationScoped +public class ProcessInstanceNodeDataEventMerger implements ProcessInstanceEventMerger { + private static final Logger LOGGER = LoggerFactory.getLogger(ProcessInstanceNodeDataEventMerger.class); + + @Override + public boolean accept(ProcessInstanceDataEvent event) { + return event instanceof ProcessInstanceNodeDataEvent; + } + + @Override + public void merge(ProcessInstance pi, ProcessInstanceDataEvent data) { + ProcessInstanceNodeDataEvent event = (ProcessInstanceNodeDataEvent) data; + + List nodeInstances = Optional.ofNullable(pi.getNodes()).orElse(new ArrayList<>()); + + ProcessInstanceNodeEventBody body = event.getData(); + + NodeInstance nodeInstance = nodeInstances.stream().filter(e -> body.getNodeInstanceId().equals(e.getId())).findAny().orElse(new NodeInstance()); + nodeInstances.removeIf(e -> e.getId().equals(body.getNodeInstanceId())); + + LOGGER.debug("before merging: {}", nodeInstance); + nodeInstance.setDefinitionId(body.getNodeDefinitionId()); + nodeInstance.setId(body.getNodeInstanceId()); + nodeInstance.setName(body.getNodeName()); + nodeInstance.setType(body.getNodeType()); + switch (body.getEventType()) { + case 1: + nodeInstance.setEnter(toZonedDateTime(body.getEventDate())); + break; + case 2: + nodeInstance.setExit(toZonedDateTime(body.getEventDate())); + break; + } + nodeInstances.add(nodeInstance); + + // milestone + if ("MilestoneNode".equals(event.getData().getNodeType())) { + List milestones = Optional.ofNullable(pi.getMilestones()).orElse(new ArrayList<>()); + Optional found = milestones.stream().filter(e -> body.getNodeInstanceId().equals(e.getId())).findAny(); + Milestone milestone = null; + if (found.isEmpty()) { + milestone = new Milestone(); + milestones.add(milestone); + } else { + milestone = found.get(); + } + + milestone.setId(nodeInstance.getId()); + milestone.setName(nodeInstance.getName()); + milestone.setStatus(nodeInstance.getExit() != null ? MilestoneStatus.COMPLETED.name() : MilestoneStatus.ACTIVE.name()); + milestones.add(milestone); + + pi.setMilestones(milestones); + } + + if (pi.getDefinition() != null) { + List nodes = Optional.ofNullable(pi.getDefinition().getNodes()).orElse(new ArrayList<>()); + + nodes.removeIf(e -> e.getId().equals(body.getNodeDefinitionId())); + Node node = new Node(); + node.setId(body.getNodeDefinitionId()); + node.setType(body.getNodeType()); + node.setUniqueId(body.getNodeDefinitionId()); + node.setMetadata(new HashMap<>()); + + nodes.add(node); + pi.getDefinition().setNodes(nodes); + } + LOGGER.debug("after merging: {}", nodeInstance); + pi.setNodes(nodeInstances); + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceSLADataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceSLADataEventMerger.java new file mode 100644 index 0000000000..d9bf1d3abd --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceSLADataEventMerger.java @@ -0,0 +1,37 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceSLADataEvent; +import org.kie.kogito.index.model.ProcessInstance; + +public class ProcessInstanceSLADataEventMerger implements ProcessInstanceEventMerger { + + @Override + public boolean accept(ProcessInstanceDataEvent event) { + return event instanceof ProcessInstanceSLADataEvent; + } + + @Override + public void merge(ProcessInstance pi, ProcessInstanceDataEvent event) { + // do nothing + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceStateDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceStateDataEventMerger.java new file mode 100644 index 0000000000..0b625e8e56 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceStateDataEventMerger.java @@ -0,0 +1,86 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import java.util.Set; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateEventBody; +import org.kie.kogito.index.model.ProcessDefinition; +import org.kie.kogito.index.model.ProcessInstance; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import static com.google.common.base.Strings.isNullOrEmpty; +import static org.kie.kogito.index.DateTimeUtils.toZonedDateTime; + +@ApplicationScoped +public class ProcessInstanceStateDataEventMerger implements ProcessInstanceEventMerger { + private static final Logger LOGGER = LoggerFactory.getLogger(ProcessInstanceStateDataEventMerger.class); + + @Override + public boolean accept(ProcessInstanceDataEvent event) { + return event instanceof ProcessInstanceStateDataEvent; + } + + @Override + public void merge(ProcessInstance pi, ProcessInstanceDataEvent data) { + ProcessInstanceStateDataEvent event = (ProcessInstanceStateDataEvent) data; + LOGGER.debug("Value before merging: {}", pi); + pi.setId(event.getData().getProcessInstanceId()); + pi.setVersion(event.getData().getProcessVersion()); + pi.setProcessId(event.getData().getProcessId()); + pi.setProcessName(event.getData().getProcessName()); + pi.setRootProcessInstanceId(event.getData().getRootProcessInstanceId()); + pi.setRootProcessId(event.getData().getRootProcessId()); + pi.setParentProcessInstanceId(event.getData().getParentInstanceId()); + pi.setRoles(event.getData().getRoles()); + pi.setState(event.getData().getState()); + if (event.getData().getEventType() == null || event.getData().getEventType() == ProcessInstanceStateEventBody.EVENT_TYPE_STARTED) { + pi.setStart(toZonedDateTime(event.getData().getEventDate())); + } else if (event.getData().getEventType() == ProcessInstanceStateEventBody.EVENT_TYPE_STARTED) { + pi.setEnd(toZonedDateTime(event.getData().getEventDate())); + } + pi.setBusinessKey(event.getData().getBusinessKey()); + pi.setAddons(isNullOrEmpty(event.getKogitoAddons()) ? null : Set.of(event.getKogitoAddons().split(","))); + pi.setEndpoint(event.getSource() == null ? null : event.getSource().toString()); + pi.setLastUpdate(toZonedDateTime(event.getTime())); + pi.setDefinition(definitions(event)); + pi.setCreatedBy(event.getData().getEventUser()); + LOGGER.debug("Value after merging: {}", pi); + } + + private ProcessDefinition definitions(ProcessInstanceStateDataEvent event) { + + ProcessDefinition pd = new ProcessDefinition(); + pd.setId(event.getData().getProcessId()); + pd.setName(event.getData().getProcessName()); + pd.setVersion(event.getData().getProcessVersion()); + pd.setAddons(isNullOrEmpty(event.getKogitoAddons()) ? null : Set.of(event.getKogitoAddons().split(","))); + pd.setRoles(event.getData().getRoles()); + pd.setType(event.getKogitoProcessType()); + pd.setEndpoint(event.getSource() == null ? null : event.getSource().toString()); + return pd; + + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceVariableDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceVariableDataEventMerger.java new file mode 100644 index 0000000000..8a695a484a --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/ProcessInstanceVariableDataEventMerger.java @@ -0,0 +1,70 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import java.util.HashMap; +import java.util.Map; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceVariableDataEvent; +import org.kie.kogito.event.process.ProcessInstanceVariableEventBody; +import org.kie.kogito.index.json.JsonUtils; +import org.kie.kogito.index.model.ProcessInstance; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; + +@ApplicationScoped +public class ProcessInstanceVariableDataEventMerger implements ProcessInstanceEventMerger { + + private static final Logger LOGGER = LoggerFactory.getLogger(ProcessInstanceVariableDataEventMerger.class); + + @Override + public boolean accept(ProcessInstanceDataEvent event) { + return event instanceof ProcessInstanceVariableDataEvent; + } + + @SuppressWarnings("unchecked") + @Override + public void merge(ProcessInstance pi, ProcessInstanceDataEvent data) { + ProcessInstanceVariableDataEvent event = (ProcessInstanceVariableDataEvent) data; + try { + ProcessInstanceVariableEventBody body = event.getData(); + ObjectMapper mapper = JsonUtils.getObjectMapper(); + + Map variables = null; + if (pi.getVariables() == null) { + variables = new HashMap<>(); + } else { + variables = new HashMap<>(mapper.treeToValue(pi.getVariables(), HashMap.class)); + } + variables.put(body.getVariableName(), body.getVariableValue()); + pi.setVariables(mapper.valueToTree(variables)); + } catch (JsonProcessingException e) { + LOGGER.error("error during unmarshalling variable instance", e); + } catch (IllegalArgumentException e) { + LOGGER.error("error during merging variable instance event", e); + } + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceAssignmentDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceAssignmentDataEventMerger.java new file mode 100644 index 0000000000..bbf66d19f0 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceAssignmentDataEventMerger.java @@ -0,0 +1,62 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import java.util.HashSet; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.usertask.UserTaskInstanceAssignmentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAssignmentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.index.model.UserTaskInstance; + +@ApplicationScoped +public class UserTaskInstanceAssignmentDataEventMerger implements UserTaskInstanceEventMerger { + + @Override + public boolean accept(UserTaskInstanceDataEvent event) { + return event instanceof UserTaskInstanceAssignmentDataEvent; + } + + @Override + public void merge(UserTaskInstance userTaskInstance, UserTaskInstanceDataEvent data) { + UserTaskInstanceAssignmentDataEvent event = (UserTaskInstanceAssignmentDataEvent) data; + UserTaskInstanceAssignmentEventBody body = event.getData(); + + switch (body.getAssignmentType()) { + case "USER_OWNERS": + userTaskInstance.setPotentialUsers(new HashSet<>(body.getUsers())); + break; + case "USER_GROUPS": + userTaskInstance.setPotentialGroups(new HashSet<>(body.getUsers())); + break; + case "USERS_EXCLUDED": + userTaskInstance.setExcludedUsers(new HashSet<>(body.getUsers())); + break; + case "ADMIN_GROUPS": + userTaskInstance.setAdminGroups(new HashSet<>(body.getUsers())); + break; + case "ADMIN_USERS": + userTaskInstance.setAdminUsers(new HashSet<>(body.getUsers())); + break; + } + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceAttachmentDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceAttachmentDataEventMerger.java new file mode 100644 index 0000000000..018c67d961 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceAttachmentDataEventMerger.java @@ -0,0 +1,75 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.index.DateTimeUtils; +import org.kie.kogito.index.model.Attachment; +import org.kie.kogito.index.model.UserTaskInstance; + +@ApplicationScoped +public class UserTaskInstanceAttachmentDataEventMerger implements UserTaskInstanceEventMerger { + + @Override + public boolean accept(UserTaskInstanceDataEvent event) { + return event instanceof UserTaskInstanceAttachmentDataEvent; + } + + @Override + public void merge(UserTaskInstance userTaskInstance, UserTaskInstanceDataEvent data) { + UserTaskInstanceAttachmentDataEvent event = (UserTaskInstanceAttachmentDataEvent) data; + UserTaskInstanceAttachmentEventBody body = event.getData(); + + List attachments = Optional.ofNullable(userTaskInstance.getAttachments()).orElse(new ArrayList<>()); + userTaskInstance.setAttachments(attachments); + + switch (body.getEventType()) { + case UserTaskInstanceAttachmentEventBody.EVENT_TYPE_ADDED: + case UserTaskInstanceAttachmentEventBody.EVENT_TYPE_CHANGE: + Optional found = attachments.stream().filter(e -> e.getId().equals(body.getAttachmentId())).findAny(); + Attachment attachment; + if (found.isEmpty()) { + attachment = new Attachment(); + attachments.add(attachment); + } else { + attachment = found.get(); + } + attachment.setId(body.getAttachmentId()); + attachment.setName(body.getAttachmentName()); + attachment.setContent(body.getAttachmentURI().toString()); + attachment.setUpdatedBy(body.getEventUser() != null ? body.getEventUser() : "unknown"); + attachment.setUpdatedAt(DateTimeUtils.toZonedDateTime(body.getEventDate())); + + break; + case UserTaskInstanceAttachmentEventBody.EVENT_TYPE_DELETED: + attachments.removeIf(e -> e.getId().equals(body.getAttachmentId())); + break; + } + + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceCommentDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceCommentDataEventMerger.java new file mode 100644 index 0000000000..de2191fa56 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceCommentDataEventMerger.java @@ -0,0 +1,73 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.usertask.UserTaskInstanceCommentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceCommentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.index.DateTimeUtils; +import org.kie.kogito.index.model.Comment; +import org.kie.kogito.index.model.UserTaskInstance; + +@ApplicationScoped +public class UserTaskInstanceCommentDataEventMerger implements UserTaskInstanceEventMerger { + + @Override + public boolean accept(UserTaskInstanceDataEvent event) { + return event instanceof UserTaskInstanceCommentDataEvent; + } + + @Override + public void merge(UserTaskInstance userTaskInstance, UserTaskInstanceDataEvent data) { + UserTaskInstanceCommentDataEvent event = (UserTaskInstanceCommentDataEvent) data; + UserTaskInstanceCommentEventBody body = event.getData(); + List comments = Optional.ofNullable(userTaskInstance.getComments()).orElse(new ArrayList<>()); + userTaskInstance.setComments(comments); + + switch (body.getEventType()) { + case UserTaskInstanceCommentEventBody.EVENT_TYPE_ADDED: + case UserTaskInstanceCommentEventBody.EVENT_TYPE_CHANGE: + Optional found = comments.stream().filter(e -> e.getId().equals(body.getCommentId())).findAny(); + Comment comment; + if (found.isEmpty()) { + comment = new Comment(); + comments.add(comment); + } else { + comment = found.get(); + } + comment.setId(body.getCommentId()); + comment.setContent(body.getCommentContent()); + comment.setUpdatedBy(body.getEventUser() != null ? body.getEventUser() : "unknown"); + comment.setUpdatedAt(DateTimeUtils.toZonedDateTime(body.getEventDate())); + + break; + case UserTaskInstanceCommentEventBody.EVENT_TYPE_DELETED: + comments.removeIf(e -> e.getId().equals(body.getCommentId())); + break; + } + + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceDeadlineDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceDeadlineDataEventMerger.java new file mode 100644 index 0000000000..eb858e9ecd --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceDeadlineDataEventMerger.java @@ -0,0 +1,40 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDeadlineDataEvent; +import org.kie.kogito.index.model.UserTaskInstance; + +@ApplicationScoped +public class UserTaskInstanceDeadlineDataEventMerger implements UserTaskInstanceEventMerger { + + @Override + public boolean accept(UserTaskInstanceDataEvent event) { + return event instanceof UserTaskInstanceDeadlineDataEvent; + } + + @Override + public void merge(UserTaskInstance userTaskInstance, UserTaskInstanceDataEvent data) { + // do nothing + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceEventMerger.java new file mode 100644 index 0000000000..099800f441 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceEventMerger.java @@ -0,0 +1,30 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.index.model.UserTaskInstance; + +public interface UserTaskInstanceEventMerger { + + boolean accept(UserTaskInstanceDataEvent event); + + void merge(UserTaskInstance processInstance, UserTaskInstanceDataEvent event); + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceStateEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceStateEventMerger.java new file mode 100644 index 0000000000..9429c87071 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceStateEventMerger.java @@ -0,0 +1,77 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import java.net.URI; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; +import org.kie.kogito.index.model.UserTaskInstance; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.net.UrlEscapers; + +import static java.lang.String.format; +import static org.kie.kogito.index.DateTimeUtils.toZonedDateTime; + +@ApplicationScoped +public class UserTaskInstanceStateEventMerger implements UserTaskInstanceEventMerger { + private static final Logger LOGGER = LoggerFactory.getLogger(UserTaskInstanceStateEventMerger.class); + + @Override + public boolean accept(UserTaskInstanceDataEvent event) { + return event instanceof UserTaskInstanceStateDataEvent; + } + + @Override + public void merge(UserTaskInstance task, UserTaskInstanceDataEvent data) { + UserTaskInstanceStateDataEvent event = (UserTaskInstanceStateDataEvent) data; + LOGGER.debug("value before merging: {}", task); + task.setId(event.getData().getUserTaskInstanceId()); + task.setProcessInstanceId(event.getData().getProcessInstanceId()); + task.setProcessId(event.getKogitoProcessId()); + task.setRootProcessId(event.getKogitoRootProcessId()); + task.setRootProcessInstanceId(event.getKogitoRootProcessInstanceId()); + task.setName(event.getData().getUserTaskName()); + task.setDescription(event.getData().getUserTaskDescription()); + task.setState(event.getData().getState()); + task.setPriority(event.getData().getUserTaskPriority()); + if (event.getData().getEventType() == null || event.getData().getEventType() == 1) { + task.setStarted(toZonedDateTime(event.getData().getEventDate())); + } else if (event.getData().getEventType() == 2) { + task.setCompleted(toZonedDateTime(event.getData().getEventDate())); + } + + task.setActualOwner(event.getData().getActualOwner()); + task.setEndpoint( + event.getSource() == null ? null : getEndpoint(event.getSource(), event.getData().getProcessInstanceId(), event.getData().getUserTaskName(), event.getData().getUserTaskInstanceId())); + task.setLastUpdate(toZonedDateTime(event.getData().getEventDate())); + task.setReferenceName(event.getData().getUserTaskReferenceName()); + LOGGER.debug("value after merging: {}", task); + } + + public String getEndpoint(URI source, String pId, String taskName, String taskId) { + String name = UrlEscapers.urlPathSegmentEscaper().escape(taskName); + return source.toString() + format("/%s/%s/%s", pId, name, taskId); + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceVariableDataEventMerger.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceVariableDataEventMerger.java new file mode 100644 index 0000000000..e8aad2e9c4 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/event/mapper/UserTaskInstanceVariableDataEventMerger.java @@ -0,0 +1,87 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event.mapper; + +import java.util.HashMap; +import java.util.Map; + +import javax.enterprise.context.ApplicationScoped; + +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceVariableDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceVariableEventBody; +import org.kie.kogito.index.json.JsonUtils; +import org.kie.kogito.index.model.UserTaskInstance; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; + +@ApplicationScoped +public class UserTaskInstanceVariableDataEventMerger implements UserTaskInstanceEventMerger { + + private static final Logger LOGGER = LoggerFactory.getLogger(ProcessInstanceVariableDataEventMerger.class); + + @Override + public boolean accept(UserTaskInstanceDataEvent event) { + return event instanceof UserTaskInstanceVariableDataEvent; + } + + @Override + public void merge(UserTaskInstance userTaskInstance, UserTaskInstanceDataEvent data) { + UserTaskInstanceVariableDataEvent event = (UserTaskInstanceVariableDataEvent) data; + try { + UserTaskInstanceVariableEventBody body = event.getData(); + ObjectMapper mapper = JsonUtils.getObjectMapper(); + switch (body.getVariableType()) { + case "INPUT": + Map inVars = toMap(mapper, userTaskInstance.getInputs()); + inVars.put(body.getVariableName(), body.getVariableValue()); + userTaskInstance.setInputs(mapper.valueToTree(inVars)); + break; + case "OUTPUT": + Map outVars = toMap(mapper, userTaskInstance.getOutputs()); + outVars.put(body.getVariableName(), body.getVariableValue()); + userTaskInstance.setOutputs(mapper.valueToTree(outVars)); + } + + } catch (JsonProcessingException e) { + LOGGER.error("error during unmarshalling variable instance", e); + } catch (IllegalArgumentException e) { + LOGGER.error("error during merging variable instance event", e); + } + + } + + @SuppressWarnings("unchecked") + private Map toMap(ObjectMapper mapper, ObjectNode node) throws JsonProcessingException, IllegalArgumentException { + + Map variables = null; + if (node == null) { + variables = new HashMap<>(); + } else { + variables = new HashMap<>(mapper.treeToValue(node, HashMap.class)); + + } + return variables; + } + +} diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/DataIndexParsingException.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/DataIndexParsingException.java index 601b0e4279..aa55ae3fa6 100644 --- a/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/DataIndexParsingException.java +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/DataIndexParsingException.java @@ -17,6 +17,8 @@ public class DataIndexParsingException extends RuntimeException { + private static final long serialVersionUID = 2205334685545385623L; + public DataIndexParsingException(String message, Throwable cause) { super(message, cause); } diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonProcessInstanceDataEventDeserializer.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonProcessInstanceDataEventDeserializer.java new file mode 100644 index 0000000000..e60b3e4681 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonProcessInstanceDataEventDeserializer.java @@ -0,0 +1,76 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.json; + +import java.io.IOException; + +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceErrorDataEvent; +import org.kie.kogito.event.process.ProcessInstanceNodeDataEvent; +import org.kie.kogito.event.process.ProcessInstanceSLADataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.process.ProcessInstanceVariableDataEvent; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; + +public class JsonProcessInstanceDataEventDeserializer extends StdDeserializer> { + + private static final Logger LOGGER = LoggerFactory.getLogger(JsonProcessInstanceDataEventDeserializer.class); + + private static final long serialVersionUID = 6152014726577574241L; + + public JsonProcessInstanceDataEventDeserializer() { + this(null); + } + + public JsonProcessInstanceDataEventDeserializer(Class vc) { + super(vc); + } + + @Override + public ProcessInstanceDataEvent deserialize(JsonParser jp, DeserializationContext ctxt) + throws IOException, JsonProcessingException { + JsonNode node = jp.getCodec().readTree(jp); + LOGGER.debug("Deserialize process instance data event: {}", node); + String type = node.get("type").asText(); + + switch (type) { + case "ProcessInstanceErrorDataEvent": + return (ProcessInstanceDataEvent) jp.getCodec().treeToValue(node, ProcessInstanceErrorDataEvent.class); + case "ProcessInstanceNodeDataEvent": + return (ProcessInstanceDataEvent) jp.getCodec().treeToValue(node, ProcessInstanceNodeDataEvent.class); + case "ProcessInstanceSLADataEvent": + return (ProcessInstanceDataEvent) jp.getCodec().treeToValue(node, ProcessInstanceSLADataEvent.class); + case "ProcessInstanceStateDataEvent": + return (ProcessInstanceDataEvent) jp.getCodec().treeToValue(node, ProcessInstanceStateDataEvent.class); + case "ProcessInstanceVariableDataEvent": + return (ProcessInstanceDataEvent) jp.getCodec().treeToValue(node, ProcessInstanceVariableDataEvent.class); + default: + LOGGER.warn("Unknown type {} in json data {}", type, node); + return (ProcessInstanceDataEvent) jp.getCodec().treeToValue(node, ProcessInstanceDataEvent.class); + + } + } +} \ No newline at end of file diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonUserTaskInstanceDataEventDeserializer.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonUserTaskInstanceDataEventDeserializer.java new file mode 100644 index 0000000000..7aa0437f55 --- /dev/null +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonUserTaskInstanceDataEventDeserializer.java @@ -0,0 +1,79 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.json; + +import java.io.IOException; + +import org.kie.kogito.event.usertask.UserTaskInstanceAssignmentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceCommentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDeadlineDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceVariableDataEvent; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.JsonParser; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.DeserializationContext; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.deser.std.StdDeserializer; + +public class JsonUserTaskInstanceDataEventDeserializer extends StdDeserializer> { + + private static final Logger LOGGER = LoggerFactory.getLogger(JsonUserTaskInstanceDataEventDeserializer.class); + + private static final long serialVersionUID = -6626663191296012306L; + + public JsonUserTaskInstanceDataEventDeserializer() { + this(null); + } + + public JsonUserTaskInstanceDataEventDeserializer(Class vc) { + super(vc); + } + + @Override + public UserTaskInstanceDataEvent deserialize(JsonParser jp, DeserializationContext ctxt) + throws IOException, JsonProcessingException { + JsonNode node = jp.getCodec().readTree(jp); + LOGGER.debug("Deserialize user task instance data event: {}", node); + String type = node.get("type").asText(); + + switch (type) { + case "UserTaskInstanceAssignmentDataEvent": + return (UserTaskInstanceDataEvent) jp.getCodec().treeToValue(node, UserTaskInstanceAssignmentDataEvent.class); + case "UserTaskInstanceAttachmentDataEvent": + return (UserTaskInstanceDataEvent) jp.getCodec().treeToValue(node, UserTaskInstanceAttachmentDataEvent.class); + case "UserTaskInstanceCommentDataEvent": + return (UserTaskInstanceDataEvent) jp.getCodec().treeToValue(node, UserTaskInstanceCommentDataEvent.class); + case "UserTaskInstanceDeadlineDataEvent": + return (UserTaskInstanceDataEvent) jp.getCodec().treeToValue(node, UserTaskInstanceDeadlineDataEvent.class); + case "UserTaskInstanceStateDataEvent": + return (UserTaskInstanceDataEvent) jp.getCodec().treeToValue(node, UserTaskInstanceStateDataEvent.class); + case "UserTaskInstanceVariableDataEvent": + return (UserTaskInstanceDataEvent) jp.getCodec().treeToValue(node, UserTaskInstanceVariableDataEvent.class); + default: + LOGGER.warn("Unknown type {} in json data {}", type, node); + return (UserTaskInstanceDataEvent) jp.getCodec().treeToValue(node, UserTaskInstanceDataEvent.class); + + } + } +} \ No newline at end of file diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonUtils.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonUtils.java index c267f820d3..4ebb0e428d 100644 --- a/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonUtils.java +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/json/JsonUtils.java @@ -15,8 +15,12 @@ */ package org.kie.kogito.index.json; +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; + import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.module.SimpleModule; import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule; import io.cloudevents.jackson.JsonFormat; @@ -36,6 +40,11 @@ public static ObjectMapper configure(ObjectMapper objectMapper) { objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); objectMapper.registerModule(JsonFormat.getCloudEventJacksonModule()); objectMapper.registerModule(new JavaTimeModule()); + + SimpleModule module = new SimpleModule("Kogito Cloud Events"); + module.addDeserializer(ProcessInstanceDataEvent.class, new JsonProcessInstanceDataEventDeserializer()); + module.addDeserializer(UserTaskInstanceDataEvent.class, new JsonUserTaskInstanceDataEventDeserializer()); + objectMapper.registerModule(module); return objectMapper; } } diff --git a/data-index/data-index-common/src/main/java/org/kie/kogito/index/service/IndexingService.java b/data-index/data-index-common/src/main/java/org/kie/kogito/index/service/IndexingService.java index 828a5adbc5..9005467c67 100644 --- a/data-index/data-index-common/src/main/java/org/kie/kogito/index/service/IndexingService.java +++ b/data-index/data-index-common/src/main/java/org/kie/kogito/index/service/IndexingService.java @@ -15,13 +15,22 @@ */ package org.kie.kogito.index.service; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; import java.util.List; +import java.util.Map; +import java.util.Optional; import javax.enterprise.context.ApplicationScoped; +import javax.enterprise.inject.Instance; import javax.inject.Inject; +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.index.event.mapper.ProcessInstanceEventMerger; +import org.kie.kogito.index.event.mapper.UserTaskInstanceEventMerger; import org.kie.kogito.index.model.Job; -import org.kie.kogito.index.model.NodeInstance; import org.kie.kogito.index.model.ProcessDefinition; import org.kie.kogito.index.model.ProcessInstance; import org.kie.kogito.index.model.UserTaskInstance; @@ -34,7 +43,6 @@ import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; -import static java.util.stream.Collectors.toList; import static org.kie.kogito.index.json.JsonUtils.getObjectMapper; import static org.kie.kogito.index.storage.Constants.ID; import static org.kie.kogito.index.storage.Constants.KOGITO_DOMAIN_ATTRIBUTE; @@ -51,100 +59,220 @@ public class IndexingService { @Inject DataIndexStorageService manager; - public void indexProcessInstance(ProcessInstance pi) { - ProcessInstance previousPI = manager.getProcessInstancesCache().get(pi.getId()); - if (previousPI != null) { - List nodes = previousPI.getNodes().stream().filter(n -> !pi.getNodes().contains(n)).collect(toList()); - pi.getNodes().addAll(nodes); + @Inject + Instance processInstanceMergers; + + @Inject + Instance userTaskInstanceMergers; + + public void indexProcessInstanceEvent(ProcessInstanceDataEvent event) { + Optional found = Optional.ofNullable(manager.getProcessInstancesCache().get(event.getKogitoProcessInstanceId())); + ProcessInstance pi; + if (found.isEmpty()) { + pi = new ProcessInstance(); + pi.setId(event.getKogitoProcessInstanceId()); + pi.setProcessId(event.getKogitoProcessId()); + pi.setMilestones(new ArrayList<>()); + pi.setNodes(new ArrayList<>()); } else { - pi.setCreatedBy(pi.getUpdatedBy()); + pi = found.get(); + } + + processInstanceMergers.stream().filter(e -> e.accept(event)).findAny().ifPresent(e -> e.merge(pi, event)); + + manager.getProcessInstancesCache().put(pi.getId(), pi); + LOGGER.debug("Stored Process Instance: {}", pi); + ProcessDefinition definition = pi.getDefinition(); - if (!manager.getProcessDefinitionsCache().containsKey(definition.getKey())) { + + if (definition != null) { manager.getProcessDefinitionsCache().put(definition.getKey(), definition); + LOGGER.debug("Stored Process Definitioin: {}", definition); } - manager.getProcessInstancesCache().put(pi.getId(), pi); - } - public void indexJob(Job job) { - manager.getJobsCache().put(job.getId(), job); } - public void indexUserTaskInstance(UserTaskInstance ut) { + public void indexUserTaskInstanceEvent(UserTaskInstanceDataEvent event) { + Optional found = Optional.ofNullable(manager.getUserTaskInstancesCache().get(event.getKogitoUserTaskInstanceId())); + UserTaskInstance ut; + if (found.isEmpty()) { + ut = new UserTaskInstance(); + ut.setId(event.getKogitoUserTaskInstanceId()); + ut.setAttachments(new ArrayList<>()); + ut.setComments(new ArrayList<>()); + } else { + ut = found.get(); + } + + userTaskInstanceMergers.stream().filter(e -> e.accept(event)).findAny().ifPresent(e -> e.merge(ut, event)); + LOGGER.debug("Stored User Task Instance: {}", ut); + manager.getUserTaskInstancesCache().put(ut.getId(), ut); + + } + + public void indexJob(Job job) { + manager.getJobsCache().put(job.getId(), job); } - public void indexModel(ObjectNode json) { - String processId = json.remove(PROCESS_ID).asText(); + public void indexModel(ObjectNode updateData) { + String processId = updateData.remove(PROCESS_ID).asText(); Storage cache = manager.getDomainModelCache(processId); + if (cache == null) { - // Unknown process type, ignore - LOGGER.debug("Ignoring Kogito cloud event for unknown process: {}", processId); + LOGGER.warn("Ignoring Kogito cloud event for unknown process: {}", processId); return; } - String processInstanceId = json.get(ID).asText(); + String processInstanceId = updateData.get(ID).asText(); String type = cache.getRootType(); - ObjectNode model = cache.get(processInstanceId); - ObjectNode builder = getObjectMapper().createObjectNode(); - builder.put("_type", type); - if (model == null) { - builder.setAll(json); - } else { - copyAllEventData(json, processInstanceId, model, builder); - ObjectNode kogito = indexKogitoDomain((ObjectNode) json.get(KOGITO_DOMAIN_ATTRIBUTE), (ObjectNode) model.get(KOGITO_DOMAIN_ATTRIBUTE)); - builder.set(KOGITO_DOMAIN_ATTRIBUTE, kogito); + ObjectNode persistedModel = Optional.ofNullable(cache.get(processInstanceId)).orElse(getObjectMapper().createObjectNode()); + + LOGGER.debug("About to update model \n{}\n with data {}", persistedModel, updateData); + ObjectNode newModel = merge(processId, type, processInstanceId, persistedModel, updateData); + + LOGGER.debug("Merged model\n{}\n for {} and id {}", newModel, processId, processInstanceId); + cache.put(processInstanceId, newModel); + } + + public ObjectNode merge(String processId, String type, String processInstanceId, ObjectNode persistedModel, ObjectNode updateData) { + ObjectNode newModel = getObjectMapper().createObjectNode(); + newModel.put("_type", type); + newModel.setAll(persistedModel); + newModel.put(ID, processInstanceId); + // copy variables + copyFieldsExcept(newModel, updateData, ID, PROCESS_ID, KOGITO_DOMAIN_ATTRIBUTE); + + // now merge metadata + mergeMetadata(newModel, updateData); + + return newModel; + } + + private void mergeMetadata(ObjectNode newModel, ObjectNode updateData) { + if (!updateData.has(KOGITO_DOMAIN_ATTRIBUTE)) { + // nothing to merge + return; + } + + if (!newModel.has(KOGITO_DOMAIN_ATTRIBUTE)) { + newModel.set(KOGITO_DOMAIN_ATTRIBUTE, updateData.get(KOGITO_DOMAIN_ATTRIBUTE)); + return; } - cache.put(processInstanceId, builder); + + mergeProcessInstance((ObjectNode) newModel.get(KOGITO_DOMAIN_ATTRIBUTE), (ObjectNode) updateData.get(KOGITO_DOMAIN_ATTRIBUTE)); + mergeUserTaskInstance((ObjectNode) newModel.get(KOGITO_DOMAIN_ATTRIBUTE), (ObjectNode) updateData.get(KOGITO_DOMAIN_ATTRIBUTE)); + } - private void copyAllEventData(ObjectNode json, String processInstanceId, ObjectNode model, ObjectNode builder) { - ArrayNode indexPIArray = (ArrayNode) json.get(KOGITO_DOMAIN_ATTRIBUTE).get(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE); - if (indexPIArray == null) { - builder.setAll(model); - } else { - JsonNode id = indexPIArray.get(0).get(ID); - if (!processInstanceId.equals(id.asText())) { - //For sub-process merge with current values - builder.setAll(model); + private void copyFieldsExcept(ObjectNode newModel, ObjectNode updateData, String... exceptions) { + List nonVars = Arrays.asList(exceptions); + Iterator> iterator = updateData.fields(); + while (iterator.hasNext()) { + Map.Entry element = iterator.next(); + JsonNode node = element.getValue(); + String key = element.getKey(); + if (!nonVars.contains(key)) { + newModel.set(key, node); + } + } + } + + private void mergeUserTaskInstance(ObjectNode newModel, ObjectNode updateData) { + if (!updateData.has(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE)) { + return; + } + + if (!newModel.has(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE)) { + newModel.set(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE, updateData.get(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE)); + return; + } + newModel.set(LAST_UPDATE, updateData.get(LAST_UPDATE)); + + ArrayNode currentUserTaskModel = (ArrayNode) newModel.get(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE); + ArrayNode updateUserTasks = (ArrayNode) updateData.get(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE); + + ArrayNode newArrayNode = getObjectMapper().createArrayNode(); + newArrayNode.addAll(currentUserTaskModel); + for (int i = 0; i < updateUserTasks.size(); i++) { + String indexId = updateUserTasks.get(i).get(ID).asText(); + boolean found = false; + for (int j = 0; j < currentUserTaskModel.size(); j++) { + String currentIndexId = currentUserTaskModel.get(j).get(ID).asText(); + if (indexId.equals(currentIndexId)) { + ObjectNode currentNode = (ObjectNode) newArrayNode.get(j); + ObjectNode updateNode = ((ObjectNode) updateUserTasks.get(i)); + copyFieldsExcept(currentNode, updateNode, "comments", "attachments"); + mergeFieldArray("comments", currentNode, updateNode); + mergeFieldArray("attachments", currentNode, updateNode); + found = true; + break; + } + } + if (!found) { + newArrayNode.add(updateUserTasks.get(i)); } - builder.setAll(json); } + + newModel.set(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE, newArrayNode); + return; } - private ObjectNode indexKogitoDomain(ObjectNode kogitoEvent, ObjectNode kogitoCache) { - ObjectNode kogitoBuilder = getObjectMapper().createObjectNode(); - kogitoBuilder.set(LAST_UPDATE, kogitoEvent.get(LAST_UPDATE)); + private void mergeFieldArray(String field, ObjectNode newModel, ObjectNode updateData) { + if (!updateData.has(field) || (updateData.has(field) && updateData.get(field).isNull())) { + return; + } + + if (!newModel.has(field) || (newModel.has(field) && newModel.get(field).isNull())) { + newModel.set(field, updateData.get(field)); + return; + } + + newModel.set(field, mergeArray((ArrayNode) newModel.get(field), (ArrayNode) updateData.get(field))); + + } - ArrayNode indexPIArray = (ArrayNode) kogitoEvent.get(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE); - if (indexPIArray != null) { - kogitoBuilder.set(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE, copyToArray(kogitoCache.get(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE), indexPIArray)); - kogitoBuilder.set(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE, kogitoCache.get(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE)); + private ObjectNode mergeProcessInstance(ObjectNode newModel, ObjectNode updateData) { + if (!updateData.has(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE)) { + return newModel; } - ArrayNode indexTIArray = (ArrayNode) kogitoEvent.get(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE); - if (indexTIArray != null) { - kogitoBuilder.set(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE, copyToArray(kogitoCache.get(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE), indexTIArray)); - kogitoBuilder.set(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE, kogitoCache.get(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE)); + if (!newModel.has(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE)) { + newModel.set(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE, updateData.get(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE)); + return newModel; } - return kogitoBuilder; + newModel.set(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE, mergeArray((ArrayNode) newModel.get(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE), (ArrayNode) updateData.get(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE))); + return newModel; } - private ArrayNode copyToArray(JsonNode arrayCache, ArrayNode arrayEvent) { - if (arrayCache == null || arrayCache.isNull()) { - return getObjectMapper().createArrayNode().add(arrayEvent.get(0)); + private ArrayNode mergeArray(ArrayNode newModel, ArrayNode updateData) { + ArrayNode newArrayNode = getObjectMapper().createArrayNode(); + newArrayNode.addAll(newModel); + for (int i = 0; i < updateData.size(); i++) { + String indexId = updateData.get(i).get(ID).asText(); + boolean found = false; + for (int j = 0; j < newModel.size(); j++) { + String currentIndexId = newModel.get(j).get(ID).asText(); + if (indexId.equals(currentIndexId)) { + ((ObjectNode) newArrayNode.get(j)).setAll((ObjectNode) updateData.get(i)); + found = true; + break; + } + } + if (!found) { + newArrayNode.add(updateData.get(i)); + } } - ArrayNode arrayNode = (ArrayNode) arrayCache; - String indexId = arrayEvent.get(0).get(ID).asText(); - for (int i = 0; i < arrayCache.size(); i++) { - if (indexId.equals(arrayCache.get(i).get(ID).asText())) { - arrayNode.set(i, arrayEvent.get(0)); - return arrayNode; + + Iterator iterator = newArrayNode.iterator(); + while (iterator.hasNext()) { + if (iterator.next().has("remove")) { + iterator.remove(); } } - arrayNode.add(arrayEvent.get(0)); - return arrayNode; + return newArrayNode; } } diff --git a/data-index/data-index-common/src/test/java/org/kie/kogito/index/event/DataEventDeserializerTest.java b/data-index/data-index-common/src/test/java/org/kie/kogito/index/event/DataEventDeserializerTest.java new file mode 100644 index 0000000000..03f4625fc4 --- /dev/null +++ b/data-index/data-index-common/src/test/java/org/kie/kogito/index/event/DataEventDeserializerTest.java @@ -0,0 +1,71 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.event; + +import java.io.IOException; +import java.util.HashMap; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateEventBody; +import org.kie.kogito.index.json.JsonUtils; + +import com.fasterxml.jackson.databind.ObjectMapper; + +@TestInstance(Lifecycle.PER_CLASS) +public class DataEventDeserializerTest { + + private ObjectMapper mapper; + + @BeforeAll + + public void beforeAll() { + mapper = new ObjectMapper(); + JsonUtils.configure(mapper); + } + + @Test + public void testProcessInstanceDataEvent() throws IOException { + ProcessInstanceStateDataEvent dataEvent = new ProcessInstanceStateDataEvent("source", "addons", "identity", new HashMap<>(), new ProcessInstanceStateEventBody()); + + String jsonValue = mapper.writeValueAsString(dataEvent); + ProcessInstanceDataEvent readDataEvent = mapper.readValue(jsonValue.getBytes(), ProcessInstanceDataEvent.class); + Assertions.assertEquals(readDataEvent, dataEvent); + + } + + @Test + public void testUserTaskInstanceDataEvent() throws IOException { + UserTaskInstanceStateDataEvent dataEvent = new UserTaskInstanceStateDataEvent("source", "addons", "identity", new HashMap<>(), new UserTaskInstanceStateEventBody()); + + String jsonValue = mapper.writeValueAsString(dataEvent); + UserTaskInstanceDataEvent readDataEvent = mapper.readValue(jsonValue.getBytes(), UserTaskInstanceDataEvent.class); + Assertions.assertEquals(readDataEvent, dataEvent); + + } + +} diff --git a/data-index/data-index-common/src/test/java/org/kie/kogito/index/event/UserTaskInstanceEventMapperTest.java b/data-index/data-index-common/src/test/java/org/kie/kogito/index/event/UserTaskInstanceEventMapperTest.java index 58de275f31..d60fd2a974 100644 --- a/data-index/data-index-common/src/test/java/org/kie/kogito/index/event/UserTaskInstanceEventMapperTest.java +++ b/data-index/data-index-common/src/test/java/org/kie/kogito/index/event/UserTaskInstanceEventMapperTest.java @@ -1,19 +1,21 @@ /* - * Copyright 2023 Red Hat, Inc. and/or its affiliates. + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. */ - package org.kie.kogito.index.event; import java.net.URI; @@ -23,13 +25,14 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import org.kie.kogito.index.event.mapper.UserTaskInstanceStateEventMerger; import static java.lang.String.format; import static org.assertj.core.api.Assertions.assertThat; class UserTaskInstanceEventMapperTest { - private UserTaskInstanceEventMapper mapper = new UserTaskInstanceEventMapper(); + private UserTaskInstanceStateEventMerger mapper = new UserTaskInstanceStateEventMerger(); private static Stream provideEndpoint() { String pId = UUID.randomUUID().toString(); diff --git a/data-index/data-index-graphql/src/main/java/org/kie/kogito/index/graphql/AbstractGraphQLSchemaManager.java b/data-index/data-index-graphql/src/main/java/org/kie/kogito/index/graphql/AbstractGraphQLSchemaManager.java index d41fbae9d9..76ad90ae48 100644 --- a/data-index/data-index-graphql/src/main/java/org/kie/kogito/index/graphql/AbstractGraphQLSchemaManager.java +++ b/data-index/data-index-graphql/src/main/java/org/kie/kogito/index/graphql/AbstractGraphQLSchemaManager.java @@ -140,6 +140,9 @@ public ProcessDefinition getProcessDefinition(DataFetchingEnvironment env) { protected String getServiceUrl(String endpoint, String processId) { LOGGER.debug("Process endpoint {}", endpoint); + if (endpoint == null) { + return null; + } if (endpoint.startsWith("/")) { LOGGER.warn("Process '{}' endpoint '{}', does not contain full URL, please review the kogito.service.url system property to point the public URL for this runtime.", processId, endpoint); @@ -154,7 +157,7 @@ protected String getServiceUrl(String endpoint, String processId) { } private String getContext(String processId) { - return processId.contains(".") ? processId.substring(processId.lastIndexOf('.') + 1) : processId; + return processId != null && processId.contains(".") ? processId.substring(processId.lastIndexOf('.') + 1) : processId; } protected Collection getChildProcessInstancesValues(DataFetchingEnvironment env) { diff --git a/data-index/data-index-service/data-index-service-common/pom.xml b/data-index/data-index-service/data-index-service-common/pom.xml index 4dfc464462..533146cf5b 100644 --- a/data-index/data-index-service/data-index-service-common/pom.xml +++ b/data-index/data-index-service/data-index-service-common/pom.xml @@ -13,6 +13,12 @@ Kogito Apps :: Data Index Service Common + + org.kie.kogito + data-index-test-utils + test + + org.kie.kogito data-index-storage-api @@ -87,11 +93,7 @@ quarkus-smallrye-health - - org.kie.kogito - data-index-test-utils - test - + io.quarkus quarkus-junit5 diff --git a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/json/ProcessInstanceMetaMapper.java b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/json/ProcessInstanceMetaMapper.java index 3caa719024..1249ad1e68 100644 --- a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/json/ProcessInstanceMetaMapper.java +++ b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/json/ProcessInstanceMetaMapper.java @@ -15,9 +15,16 @@ */ package org.kie.kogito.index.service.json; +import java.util.Collections; +import java.util.Map; import java.util.function.Function; import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.process.ProcessInstanceVariableDataEvent; +import org.kie.kogito.index.service.IndexingService; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import com.fasterxml.jackson.databind.node.ObjectNode; @@ -30,56 +37,80 @@ import static org.kie.kogito.index.storage.Constants.PROCESS_INSTANCES_DOMAIN_ATTRIBUTE; import static org.kie.kogito.index.storage.Constants.PROCESS_NAME; -public class ProcessInstanceMetaMapper implements Function { +public class ProcessInstanceMetaMapper implements Function, ObjectNode> { + + private static final Logger LOGGER = LoggerFactory.getLogger(IndexingService.class); @Override - public ObjectNode apply(ProcessInstanceDataEvent event) { + public ObjectNode apply(ProcessInstanceDataEvent event) { if (event == null) { return null; - } else { - ObjectNode json = getObjectMapper().createObjectNode(); - json.put(ID, isNullOrEmpty(event.getData().getRootInstanceId()) ? event.getData().getId() : event.getData().getRootInstanceId()); - json.put(PROCESS_ID, isNullOrEmpty(event.getData().getRootProcessId()) ? event.getData().getProcessId() : event.getData().getRootProcessId()); - ObjectNode kogito = getObjectMapper().createObjectNode(); - kogito.put(LAST_UPDATE, event.getTime() == null ? null : event.getTime().toInstant().toEpochMilli()); - kogito.withArray(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE).add(getProcessJson(event)); - json.set(KOGITO_DOMAIN_ATTRIBUTE, kogito); - json.setAll((ObjectNode) getObjectMapper().valueToTree(event.getData().getVariables())); - return json; } + + ObjectNode json = getObjectMapper().createObjectNode(); + json.put(ID, isNullOrEmpty(event.getKogitoRootProcessInstanceId()) ? event.getKogitoProcessInstanceId() : event.getKogitoRootProcessInstanceId()); + json.put(PROCESS_ID, isNullOrEmpty(event.getKogitoRootProcessId()) ? event.getKogitoProcessId() : event.getKogitoRootProcessId()); + ObjectNode kogito = getObjectMapper().createObjectNode(); + kogito.withArray(PROCESS_INSTANCES_DOMAIN_ATTRIBUTE).add(getProcessJson(event)); + kogito.put(LAST_UPDATE, event.getTime() == null ? null : event.getTime().toInstant().toEpochMilli()); + json.set(KOGITO_DOMAIN_ATTRIBUTE, kogito); + + if (event instanceof ProcessInstanceVariableDataEvent) { + ProcessInstanceVariableDataEvent vars = (ProcessInstanceVariableDataEvent) event; + String name = vars.getData().getVariableName(); + Object value = vars.getData().getVariableValue(); + Map newVars = Collections.singletonMap(name, value); + LOGGER.debug("Setting domain variable name {} with value {}", name, value); + json.putAll((ObjectNode) getObjectMapper().valueToTree(newVars)); + + } + return json; + } - private ObjectNode getProcessJson(ProcessInstanceDataEvent event) { + private ObjectNode getProcessJson(ProcessInstanceDataEvent event) { ObjectNode json = getObjectMapper().createObjectNode(); - json.put(ID, event.getData().getId()); - json.put(PROCESS_ID, event.getData().getProcessId()); - json.put(PROCESS_NAME, event.getData().getProcessName()); - if (!isNullOrEmpty(event.getData().getRootInstanceId())) { - json.put("rootProcessInstanceId", event.getData().getRootInstanceId()); + json.put(ID, event.getKogitoProcessInstanceId()); + json.put(PROCESS_ID, event.getKogitoProcessId()); + json.put(LAST_UPDATE, event.getTime() == null ? null : event.getTime().toInstant().toEpochMilli()); + + if (!isNullOrEmpty(event.getKogitoRootProcessInstanceId())) { + json.put("rootProcessInstanceId", event.getKogitoRootProcessInstanceId()); } - if (!isNullOrEmpty(event.getData().getParentInstanceId())) { - json.put("parentProcessInstanceId", event.getData().getParentInstanceId()); + if (!isNullOrEmpty(event.getKogitoParentProcessInstanceId())) { + json.put("parentProcessInstanceId", event.getKogitoParentProcessInstanceId()); } - if (!isNullOrEmpty(event.getData().getRootProcessId())) { - json.put("rootProcessId", event.getData().getRootProcessId()); + if (!isNullOrEmpty(event.getKogitoRootProcessId())) { + json.put("rootProcessId", event.getKogitoRootProcessId()); } - json.put("state", event.getData().getState()); + if (event.getSource() != null) { json.put("endpoint", event.getSource().toString()); } - if (event.getData().getStartDate() != null) { - json.put("start", event.getData().getStartDate().toInstant().toEpochMilli()); - } - if (event.getData().getEndDate() != null) { - json.put("end", event.getData().getEndDate().toInstant().toEpochMilli()); - } - json.put(LAST_UPDATE, event.getTime() == null ? null : event.getTime().toInstant().toEpochMilli()); - if (!isNullOrEmpty(event.getData().getBusinessKey())) { - json.put("businessKey", event.getData().getBusinessKey()); - } - if (!isNullOrEmpty(event.getData().getIdentity())) { - json.put("updatedBy", event.getData().getIdentity()); + + if (event instanceof ProcessInstanceStateDataEvent) { + ProcessInstanceStateDataEvent state = (ProcessInstanceStateDataEvent) event; + + json.put("state", state.getData().getState()); + json.put(PROCESS_NAME, state.getData().getProcessName()); + if (!isNullOrEmpty(state.getData().getBusinessKey())) { + json.put("businessKey", state.getData().getBusinessKey()); + } + if (state.getData().getEventType() != null && state.getData().getEventType() == 1) { + json.put("start", state.getData().getEventDate().toInstant().toEpochMilli()); + if (!isNullOrEmpty(state.getData().getEventUser())) { + json.put("createdBy", state.getData().getEventUser()); + } + } + if (state.getData().getEventType() != null && state.getData().getEventType() == 2) { + json.put("end", state.getData().getEventDate().toInstant().toEpochMilli()); + } + + if (!isNullOrEmpty(state.getData().getEventUser())) { + json.put("updatedBy", state.getData().getEventUser()); + } } + return json; } } diff --git a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/json/UserTaskInstanceMetaMapper.java b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/json/UserTaskInstanceMetaMapper.java index 9a783cafaa..aaea604a02 100644 --- a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/json/UserTaskInstanceMetaMapper.java +++ b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/json/UserTaskInstanceMetaMapper.java @@ -15,10 +15,21 @@ */ package org.kie.kogito.index.service.json; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; import java.util.Set; import java.util.function.Function; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAssignmentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAssignmentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceCommentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceCommentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; import com.fasterxml.jackson.databind.node.ArrayNode; import com.fasterxml.jackson.databind.node.ObjectNode; @@ -31,17 +42,17 @@ import static org.kie.kogito.index.storage.Constants.PROCESS_ID; import static org.kie.kogito.index.storage.Constants.USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE; -public class UserTaskInstanceMetaMapper implements Function { +public class UserTaskInstanceMetaMapper implements Function, ObjectNode> { @Override - public ObjectNode apply(UserTaskInstanceDataEvent event) { + public ObjectNode apply(UserTaskInstanceDataEvent event) { if (event == null) { return null; } ObjectNode json = getObjectMapper().createObjectNode(); - json.put(ID, isNullOrEmpty(event.getData().getRootProcessInstanceId()) ? event.getData().getProcessInstanceId() : event.getData().getRootProcessInstanceId()); - json.put(PROCESS_ID, isNullOrEmpty(event.getData().getRootProcessId()) ? event.getData().getProcessId() : event.getData().getRootProcessId()); + json.put(ID, isNullOrEmpty(event.getKogitoRootProcessInstanceId()) ? event.getKogitoProcessInstanceId() : event.getKogitoRootProcessInstanceId()); + json.put(PROCESS_ID, isNullOrEmpty(event.getKogitoRootProcessId()) ? event.getKogitoProcessId() : event.getKogitoRootProcessId()); ObjectNode kogito = getObjectMapper().createObjectNode(); kogito.put(LAST_UPDATE, event.getTime() == null ? null : event.getTime().toInstant().toEpochMilli()); kogito.withArray(USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE).add(getUserTaskJson(event)); @@ -49,35 +60,88 @@ public ObjectNode apply(UserTaskInstanceDataEvent event) { return json; } - private ObjectNode getUserTaskJson(UserTaskInstanceDataEvent event) { + private ObjectNode getUserTaskJson(UserTaskInstanceDataEvent event) { ObjectNode json = getObjectMapper().createObjectNode(); - json.put(ID, event.getData().getId()); - json.put("processInstanceId", event.getData().getProcessInstanceId()); - json.put("state", event.getData().getState()); - if (!isNullOrEmpty(event.getData().getTaskDescription())) { - json.put("description", event.getData().getTaskDescription()); - } - if (!isNullOrEmpty(event.getData().getTaskName())) { - json.put("name", event.getData().getTaskName()); - } - if (!isNullOrEmpty(event.getData().getTaskPriority())) { - json.put("priority", event.getData().getTaskPriority()); - } - if (!isNullOrEmpty(event.getData().getActualOwner())) { - json.put("actualOwner", event.getData().getActualOwner()); - } - mapArray("adminUsers", event.getData().getAdminUsers(), json); - mapArray("adminGroups", event.getData().getAdminGroups(), json); - mapArray("excludedUsers", event.getData().getExcludedUsers(), json); - mapArray("potentialGroups", event.getData().getPotentialGroups(), json); - mapArray("potentialUsers", event.getData().getPotentialUsers(), json); - if (event.getData().getCompleteDate() != null) { - json.put("completed", event.getData().getCompleteDate().toInstant().toEpochMilli()); - } - if (event.getData().getStartDate() != null) { - json.put("started", event.getData().getStartDate().toInstant().toEpochMilli()); - } + json.put(ID, event.getKogitoUserTaskInstanceId()); + json.put("processInstanceId", event.getKogitoProcessInstanceId()); + json.put("state", event.getKogitoUserTaskInstanceState()); json.put(LAST_UPDATE, event.getTime() == null ? null : event.getTime().toInstant().toEpochMilli()); + + if (event instanceof UserTaskInstanceStateDataEvent) { + + UserTaskInstanceStateDataEvent data = (UserTaskInstanceStateDataEvent) event; + json.put("actualOwner", data.getData().getActualOwner()); + + if (!isNullOrEmpty(data.getData().getUserTaskDescription())) { + json.put("description", data.getData().getUserTaskDescription()); + } + if (!isNullOrEmpty(data.getData().getUserTaskName())) { + json.put("name", data.getData().getUserTaskName()); + } + if (!isNullOrEmpty(data.getData().getUserTaskPriority())) { + json.put("priority", data.getData().getUserTaskPriority()); + } + + if (data.getData().getState() != null && data.getData().getState().equals("Completed")) { + json.put("completed", data.getData().getEventDate().toInstant().toEpochMilli()); + } + List events = List.of("Ready", "InProgress"); + if (data.getData().getState() != null && events.contains(data.getData().getState())) { + json.put("started", data.getData().getEventDate().toInstant().toEpochMilli()); + } + } else if (event instanceof UserTaskInstanceAssignmentDataEvent) { + UserTaskInstanceAssignmentDataEvent data = (UserTaskInstanceAssignmentDataEvent) event; + UserTaskInstanceAssignmentEventBody body = data.getData(); + switch (body.getAssignmentType()) { + case "USER_OWNERS": + mapArray("potentialUsers", new HashSet<>(body.getUsers()), json); + break; + case "USER_GROUPS": + mapArray("potentialGroups", new HashSet<>(body.getUsers()), json); + break; + case "USERS_EXCLUDED": + mapArray("excludedUsers", new HashSet<>(body.getUsers()), json); + break; + case "ADMIN_GROUPS": + mapArray("adminUsers", new HashSet<>(body.getUsers()), json); + break; + case "ADMIN_USERS": + mapArray("adminGroups", new HashSet<>(body.getUsers()), json); + break; + } + + } else if (event instanceof UserTaskInstanceAttachmentDataEvent) { + UserTaskInstanceAttachmentDataEvent data = (UserTaskInstanceAttachmentDataEvent) event; + UserTaskInstanceAttachmentEventBody body = data.getData(); + Map attachment = new HashMap<>(); + attachment.put("id", body.getAttachmentId()); + attachment.put("name", body.getAttachmentName()); + attachment.put("content", body.getAttachmentURI() != null ? body.getAttachmentURI().toString() : ""); + attachment.put("updatedBy", body.getEventUser()); + attachment.put("updatedAt", body.getEventDate()); + + if (body.getEventType() == UserTaskInstanceAttachmentEventBody.EVENT_TYPE_DELETED) { + attachment.put("remove", true); + } + + ArrayNode arrayNode = json.withArray("attachments"); + arrayNode.add(getObjectMapper().valueToTree(attachment)); + + } else if (event instanceof UserTaskInstanceCommentDataEvent) { + UserTaskInstanceCommentDataEvent data = (UserTaskInstanceCommentDataEvent) event; + UserTaskInstanceCommentEventBody body = data.getData(); + Map comment = new HashMap<>(); + comment.put("id", body.getCommentId()); + comment.put("content", body.getCommentContent()); + comment.put("updatedBy", body.getEventUser()); + comment.put("updatedAt", body.getEventDate()); + if (body.getEventType() == UserTaskInstanceCommentEventBody.EVENT_TYPE_DELETED) { + comment.put("remove", true); + } + ArrayNode arrayNode = json.withArray("comments"); + arrayNode.add(getObjectMapper().valueToTree(comment)); + } + return json; } diff --git a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/BlockingMessagingEventConsumer.java b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/BlockingMessagingEventConsumer.java index ab2c229609..9d816f31f6 100644 --- a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/BlockingMessagingEventConsumer.java +++ b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/BlockingMessagingEventConsumer.java @@ -23,10 +23,8 @@ import org.eclipse.microprofile.reactive.messaging.Incoming; import org.kie.kogito.event.DataEvent; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; -import org.kie.kogito.index.event.ProcessInstanceEventMapper; -import org.kie.kogito.index.event.UserTaskInstanceEventMapper; import org.kie.kogito.index.service.IndexingService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -45,7 +43,7 @@ public class BlockingMessagingEventConsumer { private static final Logger LOGGER = LoggerFactory.getLogger(BlockingMessagingEventConsumer.class); @Inject - Event eventPublisher; + Event> eventPublisher; @Inject IndexingService indexingService; @@ -53,18 +51,18 @@ public class BlockingMessagingEventConsumer { @Incoming(KOGITO_PROCESSINSTANCES_EVENTS) @Blocking @Transactional - public void onProcessInstanceEvent(ProcessInstanceDataEvent event) { + public void onProcessInstanceEvent(ProcessInstanceDataEvent event) { LOGGER.debug("Process instance consumer received ProcessInstanceDataEvent: \n{}", event); - indexingService.indexProcessInstance(new ProcessInstanceEventMapper().apply(event)); + indexingService.indexProcessInstanceEvent(event); eventPublisher.fire(event); } @Incoming(KOGITO_USERTASKINSTANCES_EVENTS) @Blocking @Transactional - public void onUserTaskInstanceEvent(UserTaskInstanceDataEvent event) { + public void onUserTaskInstanceEvent(UserTaskInstanceDataEvent event) { LOGGER.debug("Task instance received UserTaskInstanceDataEvent \n{}", event); - indexingService.indexUserTaskInstance(new UserTaskInstanceEventMapper().apply(event)); + indexingService.indexUserTaskInstanceEvent(event); eventPublisher.fire(event); } diff --git a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/DomainEventConsumer.java b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/DomainEventConsumer.java index 16be6bcffe..854f05b22c 100644 --- a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/DomainEventConsumer.java +++ b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/DomainEventConsumer.java @@ -23,7 +23,7 @@ import org.eclipse.microprofile.config.inject.ConfigProperty; import org.kie.kogito.event.DataEvent; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.service.IndexingService; import org.kie.kogito.index.service.json.ProcessInstanceMetaMapper; import org.kie.kogito.index.service.json.UserTaskInstanceMetaMapper; @@ -48,7 +48,7 @@ public class DomainEventConsumer { @Inject IndexingService indexingService; - public void onDomainEvent(@Observes DataEvent event) { + public void onDomainEvent(@Observes DataEvent event) { if (!indexDomain) { return; } @@ -57,12 +57,12 @@ public void onDomainEvent(@Observes DataEvent event) { indexingService.indexModel(getDomainData(event)); } - private ObjectNode getDomainData(DataEvent event) { + private ObjectNode getDomainData(DataEvent event) { if (event instanceof ProcessInstanceDataEvent) { - return new ProcessInstanceMetaMapper().apply((ProcessInstanceDataEvent) event); + return new ProcessInstanceMetaMapper().apply((ProcessInstanceDataEvent) event); } if (event instanceof UserTaskInstanceDataEvent) { - return new UserTaskInstanceMetaMapper().apply((UserTaskInstanceDataEvent) event); + return new UserTaskInstanceMetaMapper().apply((UserTaskInstanceDataEvent) event); } throw new IllegalArgumentException( format("Unknown message type: '%s' for event class: '%s'", event.getType(), event.getClass().getName())); diff --git a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/KogitoIndexEventConverter.java b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/KogitoIndexEventConverter.java index e75147bab8..3a98a43ec2 100644 --- a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/KogitoIndexEventConverter.java +++ b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/KogitoIndexEventConverter.java @@ -23,11 +23,8 @@ import org.eclipse.microprofile.reactive.messaging.Message; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.ProcessInstanceEventBody; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; -import org.kie.kogito.index.model.Job; import org.kie.kogito.index.service.DataIndexServiceException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -39,7 +36,7 @@ /** * Converts the message payload into an indexable object. The conversion takes into account that the - * message can be coded in the structured or binary format. + * message can be coded in the structured. */ @ApplicationScoped public class KogitoIndexEventConverter implements MessageConverter { @@ -64,25 +61,14 @@ private boolean isIndexable(Type type) { public Message convert(Message message, Type type) { try { if (type.getTypeName().equals(ProcessInstanceDataEvent.class.getTypeName())) { - ProcessInstanceDataEvent processInstanceDataEvent = objectMapper.readValue(message.getPayload().toString(), ProcessInstanceDataEvent.class); - if (processInstanceDataEvent.getData() == null) { - processInstanceDataEvent.setData(objectMapper.readValue(message.getPayload().toString(), ProcessInstanceEventBody.class)); - } - return message.withPayload(processInstanceDataEvent); + return message.withPayload(objectMapper.readValue(message.getPayload().toString(), ProcessInstanceDataEvent.class)); } else if (type.getTypeName().equals(KogitoJobCloudEvent.class.getTypeName())) { - KogitoJobCloudEvent event = objectMapper.readValue(message.getPayload().toString(), KogitoJobCloudEvent.class); - if (event.getData() == null) { - event.setData(objectMapper.readValue(message.getPayload().toString(), Job.class)); - } - return message.withPayload(event); + return message.withPayload(objectMapper.readValue(message.getPayload().toString(), KogitoJobCloudEvent.class)); } else if (type.getTypeName().equals(UserTaskInstanceDataEvent.class.getTypeName())) { - UserTaskInstanceDataEvent userTaskInstanceDataEvent = objectMapper.readValue(message.getPayload().toString(), UserTaskInstanceDataEvent.class); - if (userTaskInstanceDataEvent.getData() == null) { - userTaskInstanceDataEvent.setData(objectMapper.readValue(message.getPayload().toString(), UserTaskInstanceEventBody.class)); - } - return message.withPayload(userTaskInstanceDataEvent); + return message.withPayload(objectMapper.readValue(message.getPayload().toString(), UserTaskInstanceDataEvent.class)); + } else { + return message.withPayload(objectMapper.readValue(message.getPayload().toString(), (Class) type)); } - return message; } catch (IOException e) { LOGGER.error("Error converting message payload to " + type.getTypeName(), e); throw new DataIndexServiceException("Error converting message payload:\n" + message.getPayload() + " \n to" + type.getTypeName(), e); diff --git a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/ProcessInstanceDataEventDeserializer.java b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/ProcessInstanceDataEventDeserializer.java new file mode 100644 index 0000000000..760691473d --- /dev/null +++ b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/ProcessInstanceDataEventDeserializer.java @@ -0,0 +1,43 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.service.messaging; + +import org.apache.kafka.common.serialization.Deserializer; +import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.index.json.JsonUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.JsonProcessingException; + +public class ProcessInstanceDataEventDeserializer implements Deserializer> { + private static final Logger LOGGER = LoggerFactory.getLogger(ProcessInstanceDataEventDeserializer.class); + + @Override + public ProcessInstanceDataEvent deserialize(String topic, byte[] data) { + try { + return JsonUtils.getObjectMapper().readValue(new String(data), ProcessInstanceDataEvent.class); + } catch (JsonProcessingException e) { + LOGGER.error("not possible to deserialize ProcessInstanceDataEvent data {}", new String(data), e); + throw new IllegalArgumentException("not possible to deserialize data"); + } + + } + +} diff --git a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/ReactiveMessagingEventConsumer.java b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/ReactiveMessagingEventConsumer.java index c86ff60364..101cb46849 100644 --- a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/ReactiveMessagingEventConsumer.java +++ b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/ReactiveMessagingEventConsumer.java @@ -22,10 +22,8 @@ import org.eclipse.microprofile.reactive.messaging.Incoming; import org.kie.kogito.event.DataEvent; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; -import org.kie.kogito.index.event.ProcessInstanceEventMapper; -import org.kie.kogito.index.event.UserTaskInstanceEventMapper; import org.kie.kogito.index.service.IndexingService; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -47,25 +45,25 @@ public class ReactiveMessagingEventConsumer { IndexingService indexingService; @Inject - Event eventPublisher; + Event> eventPublisher; @Incoming(KOGITO_PROCESSINSTANCES_EVENTS) - public Uni onProcessInstanceEvent(ProcessInstanceDataEvent event) { + public Uni onProcessInstanceEvent(ProcessInstanceDataEvent event) { LOGGER.debug("Process instance consumer received ProcessInstanceDataEvent: \n{}", event); return Uni.createFrom().item(event) - .invoke(e -> indexingService.indexProcessInstance(new ProcessInstanceEventMapper().apply(e))) - .invoke(e -> eventPublisher.fire(e)) + .invoke(indexingService::indexProcessInstanceEvent) + .invoke(eventPublisher::fire) .onFailure() .invoke(t -> LOGGER.error("Error processing process instance ProcessInstanceDataEvent: {}", t.getMessage(), t)) .onItem().ignore().andContinueWithNull(); } @Incoming(KOGITO_USERTASKINSTANCES_EVENTS) - public Uni onUserTaskInstanceEvent(UserTaskInstanceDataEvent event) { + public Uni onUserTaskInstanceEvent(UserTaskInstanceDataEvent event) { LOGGER.debug("Task instance received UserTaskInstanceDataEvent \n{}", event); return Uni.createFrom().item(event) - .invoke(e -> indexingService.indexUserTaskInstance(new UserTaskInstanceEventMapper().apply(e))) - .invoke(e -> eventPublisher.fire(e)) + .invoke(indexingService::indexUserTaskInstanceEvent) + .invoke(eventPublisher::fire) .onFailure() .invoke(t -> LOGGER.error("Error processing task instance UserTaskInstanceDataEvent: {}", t.getMessage(), t)) .onItem().ignore().andContinueWithNull(); diff --git a/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/UserTaskInstanceDataEventDeserializer.java b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/UserTaskInstanceDataEventDeserializer.java new file mode 100644 index 0000000000..a385707507 --- /dev/null +++ b/data-index/data-index-service/data-index-service-common/src/main/java/org/kie/kogito/index/service/messaging/UserTaskInstanceDataEventDeserializer.java @@ -0,0 +1,43 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.kie.kogito.index.service.messaging; + +import org.apache.kafka.common.serialization.Deserializer; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.index.json.JsonUtils; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.JsonProcessingException; + +public class UserTaskInstanceDataEventDeserializer implements Deserializer> { + private static final Logger LOGGER = LoggerFactory.getLogger(UserTaskInstanceDataEventDeserializer.class); + + @Override + public UserTaskInstanceDataEvent deserialize(String topic, byte[] data) { + try { + return JsonUtils.getObjectMapper().readValue(new String(data), UserTaskInstanceDataEvent.class); + } catch (JsonProcessingException e) { + LOGGER.error("not possible to deserialize UserTaskInstanceDataEvent data {}", new String(data), e); + throw new IllegalArgumentException("not possible to deserialize data"); + } + + } + +} diff --git a/data-index/data-index-service/data-index-service-common/src/main/resources/META-INF/microprofile-config.properties b/data-index/data-index-service/data-index-service-common/src/main/resources/META-INF/microprofile-config.properties index bce555b749..5f607df3a9 100644 --- a/data-index/data-index-service/data-index-service-common/src/main/resources/META-INF/microprofile-config.properties +++ b/data-index/data-index-service/data-index-service-common/src/main/resources/META-INF/microprofile-config.properties @@ -50,7 +50,9 @@ mp.messaging.incoming.kogito-jobs-events.connector=quarkus-http mp.messaging.incoming.kogito-jobs-events.path=/jobs %kafka-events-support.mp.messaging.incoming.kogito-processinstances-events.connector=smallrye-kafka +%kafka-events-support.mp.messaging.incoming.kogito-processinstances-events.value.deserializer=org.kie.kogito.index.service.messaging.ProcessInstanceDataEventDeserializer %kafka-events-support.mp.messaging.incoming.kogito-usertaskinstances-events.connector=smallrye-kafka +%kafka-events-support.mp.messaging.incoming.kogito-usertaskinstances-events.value.deserializer=org.kie.kogito.index.service.messaging.UserTaskInstanceDataEventDeserializer %kafka-events-support.mp.messaging.incoming.kogito-jobs-events.connector=smallrye-kafka %kafka-events-support.quarkus.kafka.bootstrap-servers=localhost:9092 %kafka-events-support.kafka.bootstrap.servers=localhost:9092 diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractDomainIndexingServiceIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractDomainIndexingServiceIT.java index c0ae3af80e..3c0370fc89 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractDomainIndexingServiceIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractDomainIndexingServiceIT.java @@ -24,11 +24,12 @@ import javax.inject.Inject; -import org.apache.groovy.util.Maps; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Test; -import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceErrorDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateEventBody; import org.kie.kogito.index.test.TestUtils; import org.kie.kogito.persistence.protobuf.ProtobufService; @@ -38,26 +39,22 @@ import static java.util.Arrays.asList; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.fail; -import static org.hamcrest.CoreMatchers.anyOf; +import static org.awaitility.Awaitility.await; +import static org.hamcrest.CoreMatchers.anything; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.isA; import static org.hamcrest.CoreMatchers.nullValue; import static org.kie.kogito.index.DateTimeUtils.formatDateTime; -import static org.kie.kogito.index.DateTimeUtils.formatOffsetDateTime; import static org.kie.kogito.index.model.ProcessInstanceState.ACTIVE; import static org.kie.kogito.index.model.ProcessInstanceState.COMPLETED; -import static org.kie.kogito.index.model.ProcessInstanceState.ERROR; import static org.kie.kogito.index.service.GraphQLUtils.getDealsByTaskId; -import static org.kie.kogito.index.service.GraphQLUtils.getDealsByTaskIdNoActualOwner; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceById; -import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndErrorNode; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndState; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByParentProcessInstanceId; import static org.kie.kogito.index.service.GraphQLUtils.getTravelsByProcessInstanceId; import static org.kie.kogito.index.service.GraphQLUtils.getTravelsByUserTaskId; import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceById; -import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdAndActualOwner; -import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdNoActualOwner; +import static org.kie.kogito.index.test.TestUtils.deriveProcessVariableCloudEvent; import static org.kie.kogito.index.test.TestUtils.getProcessCloudEvent; import static org.kie.kogito.index.test.TestUtils.getProcessInstanceVariablesMap; import static org.kie.kogito.index.test.TestUtils.getUserTaskCloudEvent; @@ -176,9 +173,13 @@ void testAddProtoFile() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Travels", isA(Collection.class)); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); indexProcessCloudEvent(startEvent); + for (Map.Entry entry : getProcessInstanceVariablesMap().entrySet()) { + indexProcessCloudEvent(deriveProcessVariableCloudEvent(startEvent, entry.getKey(), entry.getValue())); + } + validateProcessInstance(getProcessInstanceByIdAndState(processInstanceId, ACTIVE), startEvent); given().contentType(ContentType.JSON) @@ -187,7 +188,7 @@ void testAddProtoFile() throws Exception { .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) .body("data.Travels[0].__typename", is("Travels")) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(startEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(1)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -195,21 +196,24 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(startEvent.getData().getStartDate()))) + .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(startEvent.getData().getEventDate()))) .body("data.Travels[0].metadata.processInstances[0].end", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(startEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(startEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")) .body("data.Travels[0].traveller.firstName", is("Maciej")) .body("data.Travels[0].hotel.name", is("Meriton")) .body("data.Travels[0].flight.flightNumber", is("MX555")); - ProcessInstanceDataEvent subProcessStartEvent = getProcessCloudEvent(subProcessId, subProcessInstanceId, ACTIVE, + ProcessInstanceStateDataEvent subProcessStartEvent = getProcessCloudEvent(subProcessId, subProcessInstanceId, ACTIVE, processInstanceId, processId, processInstanceId, "currentUser"); + indexProcessCloudEvent(subProcessStartEvent); + Map travellerMap = new HashMap<>(); travellerMap.put("firstName", "Maciej"); travellerMap.put("email", "mail@mail.com"); travellerMap.put("nationality", "Polish"); + Map location1Map = new HashMap<>(); location1Map.put("street", "street1"); location1Map.put("city", "city1"); @@ -224,8 +228,8 @@ void testAddProtoFile() throws Exception { travellerMap.put("locations", asList(location1Map, location2Map)); travellerMap.put("aliases", asList("alias1", "alias2")); - subProcessStartEvent.getData().update().variables(Maps.of("traveller", travellerMap)); - indexProcessCloudEvent(subProcessStartEvent); + + indexProcessCloudEvent(deriveProcessVariableCloudEvent(subProcessStartEvent, "traveller", travellerMap)); validateProcessInstance(getProcessInstanceByIdAndState(subProcessInstanceId, ACTIVE), subProcessStartEvent); validateProcessInstance(getProcessInstanceByIdAndState(processInstanceId, ACTIVE), startEvent, subProcessInstanceId); @@ -236,7 +240,7 @@ void testAddProtoFile() throws Exception { .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) .body("data.Travels[0].__typename", is("Travels")) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(subProcessStartEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(2)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -244,9 +248,9 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(startEvent.getData().getStartDate()))) + .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(startEvent.getData().getEventDate()))) .body("data.Travels[0].metadata.processInstances[0].end", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(startEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(startEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")) .body("data.Travels[0].metadata.processInstances[1].id", is(subProcessInstanceId)) @@ -255,7 +259,7 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].metadata.processInstances[1].rootProcessId", is(processId)) .body("data.Travels[0].metadata.processInstances[1].rootProcessInstanceId", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[1].parentProcessInstanceId", is(processInstanceId)) - .body("data.Travels[0].metadata.processInstances[1].start", is(formatDateTime(subProcessStartEvent.getData().getStartDate()))) + .body("data.Travels[0].metadata.processInstances[1].start", is(formatDateTime(subProcessStartEvent.getData().getEventDate()))) .body("data.Travels[0].metadata.processInstances[1].end", is(nullValue())) .body("data.Travels[0].traveller.firstName", is("Maciej")) .body("data.Travels[0].traveller.email", is("mail@mail.com")) @@ -271,12 +275,13 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].flight.arrival", is("2019-08-20T22:12:57.34Z")) .body("data.Travels[0].flight.departure", is("2019-08-20T07:12:57.34Z")); - ProcessInstanceDataEvent endEvent = getProcessCloudEvent(processId, processInstanceId, COMPLETED, null, null, null, "currentUser"); + ProcessInstanceStateDataEvent endEvent = getProcessCloudEvent(processId, processInstanceId, COMPLETED, null, null, null, "currentUser"); + indexProcessCloudEvent(endEvent); validateProcessInstance(getProcessInstanceByIdAndState(processInstanceId, COMPLETED), endEvent, subProcessInstanceId); - UserTaskInstanceDataEvent firstUserTaskEvent = getUserTaskCloudEvent(firstTaskId, subProcessId, subProcessInstanceId, + UserTaskInstanceStateDataEvent firstUserTaskEvent = getUserTaskCloudEvent(firstTaskId, subProcessId, subProcessInstanceId, processInstanceId, processId, state); indexUserTaskCloudEvent(firstUserTaskEvent); @@ -289,7 +294,7 @@ void testAddProtoFile() throws Exception { .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) .body("data.Travels[0].__typename", is("Travels")) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(firstUserTaskEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.userTasks.size()", is(1)) .body("data.Travels[0].metadata.userTasks[0].id", is(firstTaskId)) .body("data.Travels[0].metadata.userTasks[0].processInstanceId", is(subProcessInstanceId)) @@ -297,7 +302,7 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].metadata.userTasks[0].name", is("TaskName")) .body("data.Travels[0].metadata.userTasks[0].priority", is("High")) .body("data.Travels[0].metadata.userTasks[0].actualOwner", is("kogito")) - .body("data.Travels[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(firstUserTaskEvent.getTime()))) + .body("data.Travels[0].metadata.userTasks[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(2)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -305,27 +310,22 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(endEvent.getData().getStartDate()))) - .body("data.Travels[0].metadata.processInstances[0].end", is(formatDateTime(endEvent.getData().getEndDate()))) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(endEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].start", anything()) + .body("data.Travels[0].metadata.processInstances[0].end", anything()) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[1].id", is(subProcessInstanceId)) .body("data.Travels[0].metadata.processInstances[1].processId", is(subProcessId)) .body("data.Travels[0].metadata.processInstances[1].processName", is(subProcessStartEvent.getData().getProcessName())) .body("data.Travels[0].metadata.processInstances[1].rootProcessId", is(processId)) .body("data.Travels[0].metadata.processInstances[1].rootProcessInstanceId", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[1].parentProcessInstanceId", is(processInstanceId)) - .body("data.Travels[0].metadata.processInstances[1].start", is(formatDateTime(subProcessStartEvent.getData().getStartDate()))) + .body("data.Travels[0].metadata.processInstances[1].start", is(formatDateTime(subProcessStartEvent.getData().getEventDate()))) .body("data.Travels[0].metadata.processInstances[1].end", is(nullValue())) .body("data.Travels[0].metadata.processInstances[1].endpoint", is(subProcessStartEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[1].serviceUrl", is("http://localhost:8080")) - .body("data.Travels[0].metadata.processInstances[1].lastUpdate", is(formatOffsetDateTime(subProcessStartEvent.getTime()))) - .body("data.Travels[0].traveller.firstName", is("Maciej")) - .body("data.Travels[0].hotel.name", is("Meriton")) - .body("data.Travels[0].flight.flightNumber", is("MX555")) - .body("data.Travels[0].flight.arrival", is("2019-08-20T22:12:57.34Z")) - .body("data.Travels[0].flight.departure", is("2019-08-20T07:12:57.34Z")); + .body("data.Travels[0].metadata.processInstances[1].lastUpdate", anything()); - UserTaskInstanceDataEvent secondUserTaskEvent = getUserTaskCloudEvent(secondTaskId, processId, processInstanceId, null, + UserTaskInstanceStateDataEvent secondUserTaskEvent = getUserTaskCloudEvent(secondTaskId, processId, processInstanceId, null, null, state); indexUserTaskCloudEvent(secondUserTaskEvent); @@ -338,7 +338,7 @@ void testAddProtoFile() throws Exception { .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) .body("data.Travels[0].__typename", is("Travels")) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(secondUserTaskEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.userTasks.size()", is(2)) .body("data.Travels[0].metadata.userTasks[0].id", is(firstTaskId)) .body("data.Travels[0].metadata.userTasks[0].processInstanceId", is(subProcessInstanceId)) @@ -346,14 +346,14 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].metadata.userTasks[0].name", is("TaskName")) .body("data.Travels[0].metadata.userTasks[0].priority", is("High")) .body("data.Travels[0].metadata.userTasks[0].actualOwner", is("kogito")) - .body("data.Travels[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(firstUserTaskEvent.getTime()))) + .body("data.Travels[0].metadata.userTasks[0].lastUpdate", anything()) .body("data.Travels[0].metadata.userTasks[1].id", is(secondTaskId)) .body("data.Travels[0].metadata.userTasks[1].processInstanceId", is(processInstanceId)) .body("data.Travels[0].metadata.userTasks[1].description", is("TaskDescription")) .body("data.Travels[0].metadata.userTasks[1].name", is("TaskName")) .body("data.Travels[0].metadata.userTasks[1].priority", is("High")) .body("data.Travels[0].metadata.userTasks[1].actualOwner", is("kogito")) - .body("data.Travels[0].metadata.userTasks[1].lastUpdate", is(formatOffsetDateTime(secondUserTaskEvent.getTime()))) + .body("data.Travels[0].metadata.userTasks[1].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(2)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -361,9 +361,9 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(endEvent.getData().getStartDate()))) - .body("data.Travels[0].metadata.processInstances[0].end", is(formatDateTime(endEvent.getData().getEndDate()))) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(endEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].start", anything()) + .body("data.Travels[0].metadata.processInstances[0].end", anything()) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(endEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")) .body("data.Travels[0].metadata.processInstances[1].id", is(subProcessInstanceId)) @@ -372,8 +372,8 @@ void testAddProtoFile() throws Exception { .body("data.Travels[0].metadata.processInstances[1].rootProcessId", is(processId)) .body("data.Travels[0].metadata.processInstances[1].rootProcessInstanceId", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[1].parentProcessInstanceId", is(processInstanceId)) - .body("data.Travels[0].metadata.processInstances[1].start", is(formatDateTime(subProcessStartEvent.getData().getStartDate()))) - .body("data.Travels[0].metadata.processInstances[1].lastUpdate", is(formatOffsetDateTime(subProcessStartEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[1].start", anything()) + .body("data.Travels[0].metadata.processInstances[1].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[1].end", is(nullValue())) .body("data.Travels[0].metadata.processInstances[1].endpoint", is(subProcessStartEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[1].serviceUrl", is("http://localhost:8080")) @@ -397,7 +397,7 @@ void testIndexingDomainUsingUserTaskEventFirst() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Travels", isA(Collection.class)); - UserTaskInstanceDataEvent userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); + UserTaskInstanceStateDataEvent userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); indexUserTaskCloudEvent(userTaskEvent); given().contentType(ContentType.JSON) @@ -406,21 +406,19 @@ void testIndexingDomainUsingUserTaskEventFirst() throws Exception { .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) .body("data.Travels[0].__typename", is("Travels")) - .body("data.Travels[0].flight", is(nullValue())) - .body("data.Travels[0].hotel", is(nullValue())) - .body("data.Travels[0].traveller", is(nullValue())) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(userTaskEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.userTasks.size()", is(1)) .body("data.Travels[0].metadata.userTasks[0].id", is(taskId)) .body("data.Travels[0].metadata.userTasks[0].processInstanceId", is(processInstanceId)) - .body("data.Travels[0].metadata.userTasks[0].description", is(userTaskEvent.getData().getTaskDescription())) - .body("data.Travels[0].metadata.userTasks[0].name", is(userTaskEvent.getData().getTaskName())) - .body("data.Travels[0].metadata.userTasks[0].priority", is(userTaskEvent.getData().getTaskPriority())) + .body("data.Travels[0].metadata.userTasks[0].description", is(userTaskEvent.getData().getUserTaskDescription())) + .body("data.Travels[0].metadata.userTasks[0].name", is(userTaskEvent.getData().getUserTaskName())) + .body("data.Travels[0].metadata.userTasks[0].priority", is(userTaskEvent.getData().getUserTaskPriority())) .body("data.Travels[0].metadata.userTasks[0].actualOwner", is(userTaskEvent.getData().getActualOwner())) - .body("data.Travels[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(userTaskEvent.getTime()))) + .body("data.Travels[0].metadata.userTasks[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances", is(nullValue())); - ProcessInstanceDataEvent processEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + ProcessInstanceStateDataEvent processEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(processEvent); given().contentType(ContentType.JSON) @@ -429,18 +427,15 @@ void testIndexingDomainUsingUserTaskEventFirst() throws Exception { .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) .body("data.Travels[0].__typename", is("Travels")) - .body("data.Travels[0].flight.flightNumber", is("MX555")) - .body("data.Travels[0].hotel.name", is("Meriton")) - .body("data.Travels[0].traveller.firstName", is("Maciej")) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(processEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.userTasks.size()", is(1)) .body("data.Travels[0].metadata.userTasks[0].id", is(taskId)) .body("data.Travels[0].metadata.userTasks[0].processInstanceId", is(processInstanceId)) - .body("data.Travels[0].metadata.userTasks[0].description", is(userTaskEvent.getData().getTaskDescription())) - .body("data.Travels[0].metadata.userTasks[0].name", is(userTaskEvent.getData().getTaskName())) - .body("data.Travels[0].metadata.userTasks[0].priority", is(userTaskEvent.getData().getTaskPriority())) + .body("data.Travels[0].metadata.userTasks[0].description", is(userTaskEvent.getData().getUserTaskDescription())) + .body("data.Travels[0].metadata.userTasks[0].name", is(userTaskEvent.getData().getUserTaskName())) + .body("data.Travels[0].metadata.userTasks[0].priority", is(userTaskEvent.getData().getUserTaskPriority())) .body("data.Travels[0].metadata.userTasks[0].actualOwner", is(userTaskEvent.getData().getActualOwner())) - .body("data.Travels[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(userTaskEvent.getTime()))) + .body("data.Travels[0].metadata.userTasks[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(1)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -448,7 +443,7 @@ void testIndexingDomainUsingUserTaskEventFirst() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(processEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(processEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")); } @@ -466,7 +461,8 @@ void testIndexingDomainUsingProcessEventFirst() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Travels", isA(Collection.class)); - ProcessInstanceDataEvent processEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + ProcessInstanceStateDataEvent processEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(processEvent); given().contentType(ContentType.JSON) @@ -474,10 +470,7 @@ void testIndexingDomainUsingProcessEventFirst() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) - .body("data.Travels[0].flight.flightNumber", is("MX555")) - .body("data.Travels[0].hotel.name", is("Meriton")) - .body("data.Travels[0].traveller.firstName", is("Maciej")) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(processEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.userTasks", is(nullValue())) .body("data.Travels[0].metadata.processInstances.size()", is(1)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) @@ -486,11 +479,11 @@ void testIndexingDomainUsingProcessEventFirst() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(processEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(processEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")); - UserTaskInstanceDataEvent userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); + UserTaskInstanceStateDataEvent userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); indexUserTaskCloudEvent(userTaskEvent); given().contentType(ContentType.JSON) @@ -498,18 +491,15 @@ void testIndexingDomainUsingProcessEventFirst() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) - .body("data.Travels[0].flight.flightNumber", is("MX555")) - .body("data.Travels[0].hotel.name", is("Meriton")) - .body("data.Travels[0].traveller.firstName", is("Maciej")) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(userTaskEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.userTasks.size()", is(1)) .body("data.Travels[0].metadata.userTasks[0].id", is(taskId)) .body("data.Travels[0].metadata.userTasks[0].processInstanceId", is(processInstanceId)) - .body("data.Travels[0].metadata.userTasks[0].description", is(userTaskEvent.getData().getTaskDescription())) - .body("data.Travels[0].metadata.userTasks[0].name", is(userTaskEvent.getData().getTaskName())) - .body("data.Travels[0].metadata.userTasks[0].priority", is(userTaskEvent.getData().getTaskPriority())) + .body("data.Travels[0].metadata.userTasks[0].description", is(userTaskEvent.getData().getUserTaskDescription())) + .body("data.Travels[0].metadata.userTasks[0].name", is(userTaskEvent.getData().getUserTaskName())) + .body("data.Travels[0].metadata.userTasks[0].priority", is(userTaskEvent.getData().getUserTaskPriority())) .body("data.Travels[0].metadata.userTasks[0].actualOwner", is(userTaskEvent.getData().getActualOwner())) - .body("data.Travels[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(userTaskEvent.getTime()))) + .body("data.Travels[0].metadata.userTasks[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(1)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -517,7 +507,7 @@ void testIndexingDomainUsingProcessEventFirst() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(processEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(processEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")); } @@ -535,8 +525,12 @@ void testIndexingDomainParallelEvents() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Travels", isA(Collection.class)); - ProcessInstanceDataEvent processEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); - UserTaskInstanceDataEvent userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); + ProcessInstanceStateDataEvent processEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + UserTaskInstanceStateDataEvent userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); + + for (Map.Entry entry : getProcessInstanceVariablesMap().entrySet()) { + indexProcessCloudEvent(deriveProcessVariableCloudEvent(processEvent, entry.getKey(), entry.getValue())); + } CompletableFuture.allOf( CompletableFuture.runAsync(() -> indexProcessCloudEvent(processEvent)), @@ -551,15 +545,15 @@ void testIndexingDomainParallelEvents() throws Exception { .body("data.Travels[0].flight.flightNumber", is("MX555")) .body("data.Travels[0].hotel.name", is("Meriton")) .body("data.Travels[0].traveller.firstName", is("Maciej")) - .body("data.Travels[0].metadata.lastUpdate", anyOf(asList(is(formatOffsetDateTime(userTaskEvent.getTime())), is((formatOffsetDateTime(processEvent.getTime())))))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.userTasks.size()", is(1)) .body("data.Travels[0].metadata.userTasks[0].id", is(taskId)) .body("data.Travels[0].metadata.userTasks[0].processInstanceId", is(processInstanceId)) - .body("data.Travels[0].metadata.userTasks[0].description", is(userTaskEvent.getData().getTaskDescription())) - .body("data.Travels[0].metadata.userTasks[0].name", is(userTaskEvent.getData().getTaskName())) - .body("data.Travels[0].metadata.userTasks[0].priority", is(userTaskEvent.getData().getTaskPriority())) + .body("data.Travels[0].metadata.userTasks[0].description", is(userTaskEvent.getData().getUserTaskDescription())) + .body("data.Travels[0].metadata.userTasks[0].name", is(userTaskEvent.getData().getUserTaskName())) + .body("data.Travels[0].metadata.userTasks[0].priority", is(userTaskEvent.getData().getUserTaskPriority())) .body("data.Travels[0].metadata.userTasks[0].actualOwner", is(userTaskEvent.getData().getActualOwner())) - .body("data.Travels[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(userTaskEvent.getTime()))) + .body("data.Travels[0].metadata.userTasks[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(1)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -567,7 +561,7 @@ void testIndexingDomainParallelEvents() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(processEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(processEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")); } @@ -585,9 +579,14 @@ void testProcessInstanceDomainIndex() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Travels", isA(Collection.class)); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); + for (Map.Entry entry : getProcessInstanceVariablesMap().entrySet()) { + indexProcessCloudEvent(deriveProcessVariableCloudEvent(startEvent, entry.getKey(), entry.getValue())); + } + validateProcessInstance(getProcessInstanceById(processInstanceId), startEvent); given().contentType(ContentType.JSON) @@ -595,7 +594,7 @@ void testProcessInstanceDomainIndex() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(startEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(1)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -604,8 +603,8 @@ void testProcessInstanceDomainIndex() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].state", is(ACTIVE.name())) - .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(startEvent.getData().getStartDate()))) - .body("data.Travels[0].metadata.processInstances[0].lastUpdate", is(formatOffsetDateTime(startEvent.getTime()))) + .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(startEvent.getData().getEventDate()))) + .body("data.Travels[0].metadata.processInstances[0].lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances[0].end", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(startEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")) @@ -613,12 +612,15 @@ void testProcessInstanceDomainIndex() throws Exception { .body("data.Travels[0].hotel.name", is("Meriton")) .body("data.Travels[0].traveller.firstName", is("Maciej")); - ProcessInstanceDataEvent endEvent = getProcessCloudEvent(processId, processInstanceId, COMPLETED, null, null, null, "currentUser"); - endEvent.getData().update().endDate(new Date()); + ProcessInstanceStateDataEvent endEvent = getProcessCloudEvent(processId, processInstanceId, COMPLETED, null, null, null, "currentUser"); + Map variablesMap = getProcessInstanceVariablesMap(); ((Map) variablesMap.get("hotel")).put("name", "Ibis"); ((Map) variablesMap.get("flight")).put("flightNumber", "QF444"); - endEvent.getData().update().variables(variablesMap); + + for (Map.Entry entry : variablesMap.entrySet()) { + indexProcessCloudEvent(deriveProcessVariableCloudEvent(startEvent, entry.getKey(), entry.getValue())); + } indexProcessCloudEvent(endEvent); @@ -629,7 +631,7 @@ void testProcessInstanceDomainIndex() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200) .body("data.Travels[0].id", is(processInstanceId)) - .body("data.Travels[0].metadata.lastUpdate", is(formatOffsetDateTime(endEvent.getTime()))) + .body("data.Travels[0].metadata.lastUpdate", anything()) .body("data.Travels[0].metadata.processInstances.size()", is(1)) .body("data.Travels[0].metadata.processInstances[0].id", is(processInstanceId)) .body("data.Travels[0].metadata.processInstances[0].processId", is(processId)) @@ -638,27 +640,34 @@ void testProcessInstanceDomainIndex() throws Exception { .body("data.Travels[0].metadata.processInstances[0].rootProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].parentProcessInstanceId", is(nullValue())) .body("data.Travels[0].metadata.processInstances[0].state", is(COMPLETED.name())) - .body("data.Travels[0].metadata.processInstances[0].start", is(formatDateTime(endEvent.getData().getStartDate()))) - .body("data.Travels[0].metadata.processInstances[0].end", is(formatDateTime(endEvent.getData().getEndDate()))) + .body("data.Travels[0].metadata.processInstances[0].start", anything()) + .body("data.Travels[0].metadata.processInstances[0].end", anything()) .body("data.Travels[0].metadata.processInstances[0].endpoint", is(endEvent.getSource().toString())) .body("data.Travels[0].metadata.processInstances[0].serviceUrl", is("http://localhost:8080")) .body("data.Travels[0].flight.flightNumber", is("QF444")) .body("data.Travels[0].hotel.name", is("Ibis")) .body("data.Travels[0].traveller.firstName", is("Maciej")); - ProcessInstanceDataEvent event = getProcessCloudEvent(subProcessId, subProcessInstanceId, ACTIVE, processInstanceId, + ProcessInstanceStateDataEvent event = getProcessCloudEvent(subProcessId, subProcessInstanceId, ACTIVE, processInstanceId, processId, processInstanceId, "currentUser"); + indexProcessCloudEvent(event); validateProcessInstance(getProcessInstanceByParentProcessInstanceId(processInstanceId), event); - ProcessInstanceDataEvent errorEvent = getProcessCloudEvent(subProcessId, subProcessInstanceId, ERROR, processInstanceId, - processId, processInstanceId, "currentUser"); + ProcessInstanceErrorDataEvent errorEvent = TestUtils.deriveErrorProcessCloudEvent(event, "error", "nodeDefintionId", "nodeInstanceId"); + indexProcessCloudEvent(errorEvent); - validateProcessInstance( - getProcessInstanceByIdAndErrorNode(subProcessInstanceId, errorEvent.getData().getError().getNodeDefinitionId()), - errorEvent); + await() + .atMost(timeout) + .untilAsserted(() -> given().contentType(ContentType.JSON).body(getProcessInstanceById(event.getKogitoProcessInstanceId())) + .when().post("/graphql") + .then().log().ifValidationFails().statusCode(200) + .body("data.ProcessInstances[0].id", is(event.getData().getProcessInstanceId())) + .body("data.ProcessInstances[0].error.message", errorEvent.getData().getErrorMessage() == null ? is(nullValue()) : is(errorEvent.getData().getErrorMessage())) + .body("data.ProcessInstances[0].error.nodeDefinitionId", + errorEvent.getData().getNodeDefinitionId() == null ? is(nullValue()) : is(errorEvent.getData().getNodeDefinitionId()))); } @Test @@ -674,7 +683,9 @@ void testUserTaskInstanceDomainIndex() throws Exception { .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Deals", isA(Collection.class)); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); + UserTaskInstanceStateDataEvent event; + + event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); indexUserTaskCloudEvent(event); validateUserTaskInstance(getUserTaskInstanceById(taskId), event); @@ -685,7 +696,6 @@ void testUserTaskInstanceDomainIndex() throws Exception { .then().log().ifValidationFails().statusCode(200) .body("data.Deals[0].id", is(processInstanceId)) .body("data.Deals[0].__typename", is("Deals")) - .body("data.Deals[0].metadata.lastUpdate", is(formatOffsetDateTime(event.getTime()))) .body("data.Deals[0].metadata.userTasks.size()", is(1)) .body("data.Deals[0].metadata.userTasks[0].id", is(taskId)) .body("data.Deals[0].metadata.userTasks[0].description", is("TaskDescription")) @@ -693,60 +703,25 @@ void testUserTaskInstanceDomainIndex() throws Exception { .body("data.Deals[0].metadata.userTasks[0].name", is("TaskName")) .body("data.Deals[0].metadata.userTasks[0].priority", is("High")) .body("data.Deals[0].metadata.userTasks[0].actualOwner", is("kogito")) - .body("data.Deals[0].metadata.userTasks[0].started", is(formatDateTime(event.getData().getStartDate()))) - .body("data.Deals[0].metadata.userTasks[0].completed", is(formatDateTime(event.getData().getCompleteDate()))) - .body("data.Deals[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(event.getTime()))); - - event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); - event.getData().update().completeDate(new Date()); - event.getData().update().taskPriority("Low"); - event.getData().update().actualOwner("admin"); - event.getData().update().state("Completed"); - - indexUserTaskCloudEvent(event); - - validateUserTaskInstance(getUserTaskInstanceByIdAndActualOwner(taskId, "admin"), event); - - given().contentType(ContentType.JSON) - .body(getDealsByTaskId(taskId)) - .when().post("/graphql") - .then().log().ifValidationFails().statusCode(200) - .body("data.Deals[0].id", is(processInstanceId)) - .body("data.Deals[0].__typename", is("Deals")) - .body("data.Deals[0].metadata.lastUpdate", is(formatOffsetDateTime(event.getTime()))) - .body("data.Deals[0].metadata.userTasks.size()", is(1)) - .body("data.Deals[0].metadata.userTasks[0].id", is(taskId)) - .body("data.Deals[0].metadata.userTasks[0].description", is("TaskDescription")) - .body("data.Deals[0].metadata.userTasks[0].state", is("Completed")) - .body("data.Deals[0].metadata.userTasks[0].name", is("TaskName")) - .body("data.Deals[0].metadata.userTasks[0].priority", is("Low")) - .body("data.Deals[0].metadata.userTasks[0].actualOwner", is("admin")) - .body("data.Deals[0].metadata.userTasks[0].started", is(formatDateTime(event.getData().getStartDate()))) - .body("data.Deals[0].metadata.userTasks[0].completed", is(formatDateTime(event.getData().getCompleteDate()))) - .body("data.Deals[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(event.getTime()))); + .body("data.Deals[0].metadata.userTasks[0].started", is(formatDateTime(event.getData().getEventDate()))) + .body("data.Deals[0].metadata.userTasks[0].lastUpdate", anything()); + + event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state, "kogito", 2); + UserTaskInstanceStateEventBody body = UserTaskInstanceStateEventBody.create() + .eventType(2) + .userTaskInstanceId(taskId) + .state("Completed") + .userTaskName("TaskName") + .userTaskDescription("TaskDescription") + .userTaskPriority("Low") + .actualOwner("admin") + .eventDate(new Date()) + .processInstanceId(processInstanceId) + .build(); + event.setData(body); - event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state, null); indexUserTaskCloudEvent(event); - validateUserTaskInstance(getUserTaskInstanceByIdNoActualOwner(taskId), event); - - given().contentType(ContentType.JSON) - .body(getDealsByTaskIdNoActualOwner(taskId)) - .when().post("/graphql") - .then().log().ifValidationFails().statusCode(200) - .body("data.Deals[0].id", is(processInstanceId)) - .body("data.Deals[0].__typename", is("Deals")) - .body("data.Deals[0].metadata.lastUpdate", is(formatOffsetDateTime(event.getTime()))) - .body("data.Deals[0].metadata.userTasks.size()", is(1)) - .body("data.Deals[0].metadata.userTasks[0].id", is(taskId)) - .body("data.Deals[0].metadata.userTasks[0].description", is("TaskDescription")) - .body("data.Deals[0].metadata.userTasks[0].state", is("InProgress")) - .body("data.Deals[0].metadata.userTasks[0].name", is("TaskName")) - .body("data.Deals[0].metadata.userTasks[0].priority", is("High")) - .body("data.Deals[0].metadata.userTasks[0].actualOwner", nullValue()) - .body("data.Deals[0].metadata.userTasks[0].started", is(formatDateTime(event.getData().getStartDate()))) - .body("data.Deals[0].metadata.userTasks[0].completed", is(formatDateTime(event.getData().getCompleteDate()))) - .body("data.Deals[0].metadata.userTasks[0].lastUpdate", is(formatOffsetDateTime(event.getTime()))); } private String getProtoBufferFileWithoutModelType() { diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractIndexingIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractIndexingIT.java index b40ae732dc..a7b216d0bb 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractIndexingIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractIndexingIT.java @@ -19,7 +19,7 @@ import javax.inject.Inject; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; import io.smallrye.reactive.messaging.providers.connectors.InMemoryConnector; @@ -34,11 +34,11 @@ public abstract class AbstractIndexingIT { @Any public InMemoryConnector connector; - protected void indexProcessCloudEvent(ProcessInstanceDataEvent event) { + protected void indexProcessCloudEvent(ProcessInstanceDataEvent event) { connector.source(KOGITO_PROCESSINSTANCES_EVENTS).send(event); } - protected void indexUserTaskCloudEvent(UserTaskInstanceDataEvent event) { + protected void indexUserTaskCloudEvent(UserTaskInstanceDataEvent event) { connector.source(KOGITO_USERTASKINSTANCES_EVENTS).send(event); } diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractIndexingServiceIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractIndexingServiceIT.java index 29f212218b..94d9ba6f4e 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractIndexingServiceIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/AbstractIndexingServiceIT.java @@ -18,9 +18,7 @@ import java.time.Duration; import java.util.ArrayList; import java.util.Collection; -import java.util.Date; import java.util.List; -import java.util.Map; import java.util.UUID; import java.util.stream.IntStream; @@ -31,10 +29,12 @@ import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Test; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceErrorDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; -import org.kie.kogito.index.model.MilestoneStatus; import org.kie.kogito.index.storage.DataIndexStorageService; +import org.kie.kogito.index.test.TestUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -44,6 +44,7 @@ import static io.restassured.RestAssured.given; import static io.restassured.config.EncoderConfig.encoderConfig; import static org.awaitility.Awaitility.await; +import static org.hamcrest.CoreMatchers.anything; import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.isA; import static org.hamcrest.CoreMatchers.not; @@ -51,20 +52,15 @@ import static org.hamcrest.Matchers.emptyOrNullString; import static org.hamcrest.Matchers.hasItems; import static org.kie.kogito.index.DateTimeUtils.formatDateTime; -import static org.kie.kogito.index.DateTimeUtils.formatOffsetDateTime; import static org.kie.kogito.index.DateTimeUtils.formatZonedDateTime; import static org.kie.kogito.index.model.ProcessInstanceState.ACTIVE; import static org.kie.kogito.index.model.ProcessInstanceState.COMPLETED; -import static org.kie.kogito.index.model.ProcessInstanceState.ERROR; import static org.kie.kogito.index.service.GraphQLUtils.getJobById; import static org.kie.kogito.index.service.GraphQLUtils.getProcessDefinitionByIdAndVersion; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByBusinessKey; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByCreatedBy; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceById; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndAddon; -import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndErrorNode; -import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndMilestoneName; -import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndMilestoneStatus; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndNullParentProcessInstanceId; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndNullRootProcessInstanceId; import static org.kie.kogito.index.service.GraphQLUtils.getProcessInstanceByIdAndParentProcessInstanceId; @@ -77,15 +73,12 @@ import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceById; import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdAndActualOwner; import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdAndCompleted; -import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdAndPotentialGroups; -import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdAndPotentialUsers; import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdAndProcessId; import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdAndStarted; import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdAndState; import static org.kie.kogito.index.service.GraphQLUtils.getUserTaskInstanceByIdNoActualOwner; import static org.kie.kogito.index.test.TestUtils.getJobCloudEvent; import static org.kie.kogito.index.test.TestUtils.getProcessCloudEvent; -import static org.kie.kogito.index.test.TestUtils.getProcessInstanceVariablesMap; import static org.kie.kogito.index.test.TestUtils.getUserTaskCloudEvent; public abstract class AbstractIndexingServiceIT extends AbstractIndexingIT { @@ -132,7 +125,7 @@ void testDefaultGraphqlTypes() { .then().log().ifValidationFails().statusCode(200).body("data.Jobs", isA(Collection.class)); } - protected void validateProcessDefinition(String query, ProcessInstanceDataEvent event) { + protected void validateProcessDefinition(String query, ProcessInstanceStateDataEvent event) { LOGGER.debug("GraphQL query: {}", query); await() .atMost(timeout) @@ -141,58 +134,40 @@ protected void validateProcessDefinition(String query, ProcessInstanceDataEvent .then().log().ifValidationFails().statusCode(200) .body("data.ProcessDefinitions[0].id", is(event.getData().getProcessId())) .body("data.ProcessDefinitions[0].name", is(event.getData().getProcessName())) - .body("data.ProcessDefinitions[0].version", is(event.getData().getVersion())) + .body("data.ProcessDefinitions[0].version", is(event.getData().getProcessVersion())) .body("data.ProcessDefinitions[0].type", is(event.getData().getProcessType())) .body("data.ProcessDefinitions[0].addons", event.getKogitoAddons() == null ? is(nullValue()) : hasItems(event.getKogitoAddons().split(","))) .body("data.ProcessDefinitions[0].roles", event.getData().getRoles() == null ? is(nullValue()) : hasItems(event.getData().getRoles().toArray()))); } - protected void validateProcessInstance(String query, ProcessInstanceDataEvent event, String childProcessInstanceId) { + protected void validateProcessInstance(String query, ProcessInstanceStateDataEvent event, String childProcessInstanceId) { LOGGER.debug("GraphQL query: {}", query); await() .atMost(timeout) .untilAsserted(() -> given().contentType(ContentType.JSON).body(query) .when().post("/graphql") .then().log().ifValidationFails().statusCode(200) - .body("data.ProcessInstances[0].id", is(event.getData().getId())) + .body("data.ProcessInstances[0].id", is(event.getData().getProcessInstanceId())) .body("data.ProcessInstances[0].processId", is(event.getData().getProcessId())) .body("data.ProcessInstances[0].processName", is(event.getData().getProcessName())) - .body("data.ProcessInstances[0].version", is(event.getData().getVersion())) + .body("data.ProcessInstances[0].version", is(event.getData().getProcessVersion())) .body("data.ProcessInstances[0].rootProcessId", is(event.getData().getRootProcessId())) - .body("data.ProcessInstances[0].rootProcessInstanceId", is(event.getData().getRootInstanceId())) + .body("data.ProcessInstances[0].rootProcessInstanceId", is(event.getData().getRootProcessInstanceId())) .body("data.ProcessInstances[0].parentProcessInstanceId", is(event.getData().getParentInstanceId())) .body("data.ProcessInstances[0].parentProcessInstance.id", event.getData().getParentInstanceId() == null ? is(nullValue()) : is(event.getData().getParentInstanceId())) .body("data.ProcessInstances[0].parentProcessInstance.processName", event.getData().getParentInstanceId() == null ? is(nullValue()) : is(not(emptyOrNullString()))) - .body("data.ProcessInstances[0].start", is(formatDateTime(event.getData().getStartDate()))) - .body("data.ProcessInstances[0].end", event.getData().getEndDate() == null ? is(nullValue()) : is(formatDateTime(event.getData().getEndDate()))) + .body("data.ProcessInstances[0].start", anything()) .body("data.ProcessInstances[0].childProcessInstances[0].id", childProcessInstanceId == null ? is(nullValue()) : is(childProcessInstanceId)) .body("data.ProcessInstances[0].childProcessInstances[0].processName", childProcessInstanceId == null ? is(nullValue()) : is(not(emptyOrNullString()))) .body("data.ProcessInstances[0].endpoint", is(event.getSource().toString())) .body("data.ProcessInstances[0].serviceUrl", event.getSource().toString().equals("/" + event.getData().getProcessId()) ? is(nullValue()) : is("http://localhost:8080")) .body("data.ProcessInstances[0].addons", event.getKogitoAddons() == null ? is(nullValue()) : hasItems(event.getKogitoAddons().split(","))) - .body("data.ProcessInstances[0].error.message", event.getData().getError() == null ? is(nullValue()) : is(event.getData().getError().getErrorMessage())) - .body("data.ProcessInstances[0].error.nodeDefinitionId", event.getData().getError() == null ? is(nullValue()) : is(event.getData().getError().getNodeDefinitionId())) - .body("data.ProcessInstances[0].lastUpdate", is(formatOffsetDateTime(event.getTime()))) - .body("data.ProcessInstances[0].nodes.size()", is(event.getData().getNodeInstances().size())) - .body("data.ProcessInstances[0].nodes[0].id", is(event.getData().getNodeInstances().stream().findFirst().get().getId())) - .body("data.ProcessInstances[0].nodes[0].name", is(event.getData().getNodeInstances().stream().findFirst().get().getNodeName())) - .body("data.ProcessInstances[0].nodes[0].nodeId", is(event.getData().getNodeInstances().stream().findFirst().get().getNodeId())) - .body("data.ProcessInstances[0].nodes[0].type", is(event.getData().getNodeInstances().stream().findFirst().get().getNodeType())) - .body("data.ProcessInstances[0].nodes[0].definitionId", is(event.getData().getNodeInstances().stream().findFirst().get().getNodeDefinitionId())) - .body("data.ProcessInstances[0].nodes[0].enter", is(formatDateTime(event.getData().getNodeInstances().stream().findFirst().get().getTriggerTime()))) - .body("data.ProcessInstances[0].nodes[0].exit", - event.getData().getNodeInstances().stream().findFirst().get().getLeaveTime() == null ? is(nullValue()) - : is(formatDateTime(event.getData().getNodeInstances().stream().findFirst().get().getLeaveTime()))) - .body("data.ProcessInstances[0].milestones.size()", is(event.getData().getMilestones().size())) - .body("data.ProcessInstances[0].milestones[0].id", is(event.getData().getMilestones().stream().findFirst().get().getId())) - .body("data.ProcessInstances[0].milestones[0].name", is(event.getData().getMilestones().stream().findFirst().get().getName())) - .body("data.ProcessInstances[0].milestones[0].status", is(event.getData().getMilestones().stream().findFirst().get().getStatus())) - .body("data.ProcessInstances[0].definition.id", is(event.getData().getProcessId())) - .body("data.ProcessInstances[0].definition.version", is(event.getData().getVersion())) - .body("data.ProcessInstances[0].definition.name", is(event.getData().getProcessName()))); + .body("data.ProcessInstances[0].definition.name", is(event.getData().getProcessName())) + .body("data.ProcessInstances[0].lastUpdate", anything())); + } - protected void validateProcessInstance(String query, ProcessInstanceDataEvent event) { + protected void validateProcessInstance(String query, ProcessInstanceStateDataEvent event) { validateProcessInstance(query, event, null); } @@ -203,7 +178,9 @@ void testProcessInstancePagination() { IntStream.range(0, 100).forEach(i -> { String pId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, pId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, pId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); pIds.add(pId); await() @@ -240,7 +217,7 @@ void testUserTaskInstancePagination() { IntStream.range(0, 100).forEach(i -> { String taskId = UUID.randomUUID().toString(); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, UUID.randomUUID().toString(), null, null, "InProgress"); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, UUID.randomUUID().toString(), null, null, "InProgress"); indexUserTaskCloudEvent(event); taskIds.add(taskId); await() @@ -296,38 +273,31 @@ void testProcessInstanceIndex() throws Exception { String subProcessId = processId + "_sub"; String subProcessInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + ProcessInstanceStateDataEvent startEvent = (ProcessInstanceStateDataEvent) getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); - validateProcessDefinition(getProcessDefinitionByIdAndVersion(startEvent.getKogitoProcessId(), startEvent.getData().getVersion()), startEvent); + validateProcessDefinition(getProcessDefinitionByIdAndVersion(startEvent.getKogitoProcessId(), startEvent.getData().getProcessVersion()), startEvent); validateProcessInstance(getProcessInstanceById(processInstanceId), startEvent); validateProcessInstance(getProcessInstanceByIdAndState(processInstanceId, ACTIVE), startEvent); validateProcessInstance(getProcessInstanceByIdAndProcessId(processInstanceId, processId), startEvent); validateProcessInstance( - getProcessInstanceByIdAndStart(processInstanceId, formatDateTime(startEvent.getData().getStartDate())), + getProcessInstanceByIdAndStart(processInstanceId, formatDateTime(startEvent.getData().getEventDate())), startEvent); validateProcessInstance(getProcessInstanceByIdAndAddon(processInstanceId, "process-management"), startEvent); - validateProcessInstance(getProcessInstanceByIdAndMilestoneName(processInstanceId, "SimpleMilestone"), startEvent); - validateProcessInstance(getProcessInstanceByIdAndMilestoneStatus(processInstanceId, MilestoneStatus.AVAILABLE.name()), - startEvent); validateProcessInstance(getProcessInstanceByBusinessKey(startEvent.getData().getBusinessKey()), startEvent); - validateProcessInstance(getProcessInstanceByCreatedBy(startEvent.getData().getIdentity()), startEvent); - validateProcessInstance(getProcessInstanceByUpdatedBy(startEvent.getData().getIdentity()), startEvent); - - ProcessInstanceDataEvent endEvent = getProcessCloudEvent(processId, processInstanceId, COMPLETED, null, null, null, "currentUser"); - endEvent.getData().update().endDate(new Date()); - Map variablesMap = getProcessInstanceVariablesMap(); - ((Map) variablesMap.get("hotel")).put("name", "Ibis"); - ((Map) variablesMap.get("flight")).put("flightNumber", "QF444"); - endEvent.getData().update().variables(variablesMap); - endEvent.getData().getMilestones().stream().findFirst().get().update().status(MilestoneStatus.COMPLETED.name()); + validateProcessInstance(getProcessInstanceByCreatedBy(startEvent.getData().getEventUser()), startEvent); + validateProcessInstance(getProcessInstanceByUpdatedBy(startEvent.getData().getEventUser()), startEvent); + + ProcessInstanceStateDataEvent endEvent = getProcessCloudEvent(processId, processInstanceId, COMPLETED, null, null, null, "currentUser"); + indexProcessCloudEvent(endEvent); validateProcessInstance(getProcessInstanceByIdAndState(processInstanceId, COMPLETED), endEvent); - validateProcessInstance(getProcessInstanceByIdAndMilestoneStatus(processInstanceId, MilestoneStatus.COMPLETED.name()), endEvent); - ProcessInstanceDataEvent event = getProcessCloudEvent(subProcessId, subProcessInstanceId, ACTIVE, processInstanceId, + ProcessInstanceStateDataEvent event = getProcessCloudEvent(subProcessId, subProcessInstanceId, ACTIVE, processInstanceId, processId, processInstanceId, "currentUser"); + indexProcessCloudEvent(event); validateProcessInstance(getProcessInstanceByParentProcessInstanceId(processInstanceId), event); @@ -340,13 +310,19 @@ void testProcessInstanceIndex() throws Exception { validateProcessInstance(getProcessInstanceByIdAndParentProcessInstanceId(subProcessInstanceId, processInstanceId), event); - ProcessInstanceDataEvent errorEvent = getProcessCloudEvent(subProcessId, subProcessInstanceId, ERROR, processInstanceId, - processId, processInstanceId, "currentUser"); + ProcessInstanceErrorDataEvent errorEvent = TestUtils.deriveErrorProcessCloudEvent(event, "error", "nodeDefintionId", "nodeInstanceId"); + indexProcessCloudEvent(errorEvent); - validateProcessInstance( - getProcessInstanceByIdAndErrorNode(subProcessInstanceId, errorEvent.getData().getError().getNodeDefinitionId()), - errorEvent); + await() + .atMost(timeout) + .untilAsserted(() -> given().contentType(ContentType.JSON).body(getProcessInstanceById(event.getKogitoProcessInstanceId())) + .when().post("/graphql") + .then().log().ifValidationFails().statusCode(200) + .body("data.ProcessInstances[0].id", is(event.getData().getProcessInstanceId())) + .body("data.ProcessInstances[0].error.message", errorEvent.getData().getErrorMessage() == null ? is(nullValue()) : is(errorEvent.getData().getErrorMessage())) + .body("data.ProcessInstances[0].error.nodeDefinitionId", + errorEvent.getData().getNodeDefinitionId() == null ? is(nullValue()) : is(errorEvent.getData().getNodeDefinitionId()))); } @Test @@ -356,36 +332,37 @@ void testUserTaskInstanceIndex() throws Exception { String processId = "deals"; String processInstanceId = UUID.randomUUID().toString(); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); indexUserTaskCloudEvent(event); validateUserTaskInstance(getUserTaskInstanceById(taskId), event); validateUserTaskInstance(getUserTaskInstanceByIdAndActualOwner(taskId, "kogito"), event); validateUserTaskInstance(getUserTaskInstanceByIdAndProcessId(taskId, processId), event); - validateUserTaskInstance( - getUserTaskInstanceByIdAndPotentialGroups(taskId, new ArrayList<>(event.getData().getPotentialGroups())), - event); - validateUserTaskInstance( - getUserTaskInstanceByIdAndPotentialUsers(taskId, new ArrayList<>(event.getData().getPotentialUsers())), event); + validateUserTaskInstance(getUserTaskInstanceByIdAndState(taskId, event.getData().getState()), event); - validateUserTaskInstance(getUserTaskInstanceByIdAndStarted(taskId, formatDateTime(event.getData().getStartDate())), + validateUserTaskInstance(getUserTaskInstanceByIdAndStarted(taskId, formatDateTime(event.getData().getEventDate())), event); - validateUserTaskInstance( - getUserTaskInstanceByIdAndCompleted(taskId, formatDateTime(event.getData().getCompleteDate())), event); - event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); - event.getData().update().completeDate(new Date()); - event.getData().update().taskPriority("Low"); - event.getData().update().actualOwner("admin"); - event.getData().update().state("Completed"); + state = "Completed"; + event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state, "kogito", 2); + indexUserTaskCloudEvent(event); + + validateUserTaskInstance( + getUserTaskInstanceByIdAndCompleted(taskId, formatDateTime(event.getData().getEventDate())), event); + event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state, "admin", 2); indexUserTaskCloudEvent(event); validateUserTaskInstance(getUserTaskInstanceByIdAndActualOwner(taskId, "admin"), event); - event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state, null); + event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state, null, 2); + LOGGER.info("event {}", event); indexUserTaskCloudEvent(event); + LOGGER.info("value {}", given().contentType(ContentType.JSON).body(getUserTaskInstanceById(taskId)) + .when().post("/graphql") + .then().statusCode(200).extract().asString()); + validateUserTaskInstance(getUserTaskInstanceByIdNoActualOwner(taskId), event); } @@ -428,29 +405,24 @@ protected void validateJob(String query, KogitoJobCloudEvent event) { .body("data.Jobs[0].endpoint", is(event.getData().getEndpoint()))); } - protected void validateUserTaskInstance(String query, UserTaskInstanceDataEvent event) { + protected void validateUserTaskInstance(String query, UserTaskInstanceStateDataEvent event) { LOGGER.debug("GraphQL query: {}", query); await() .atMost(timeout) .untilAsserted(() -> given().contentType(ContentType.JSON).body(query) .when().post("/graphql") .then().log().ifValidationFails().statusCode(200) - .body("data.UserTaskInstances[0].id", is(event.getData().getId())) - .body("data.UserTaskInstances[0].processId", is(event.getData().getProcessId())) - .body("data.UserTaskInstances[0].rootProcessId", is(event.getData().getRootProcessId())) - .body("data.UserTaskInstances[0].rootProcessInstanceId", is(event.getData().getRootProcessInstanceId())) - .body("data.UserTaskInstances[0].description", is(event.getData().getTaskDescription())) - .body("data.UserTaskInstances[0].name", is(event.getData().getTaskName())) - .body("data.UserTaskInstances[0].priority", is(event.getData().getTaskPriority())) - .body("data.UserTaskInstances[0].actualOwner", is(event.getData().getActualOwner())) - .body("data.UserTaskInstances[0].excludedUsers", hasItems(event.getData().getExcludedUsers().toArray())) - .body("data.UserTaskInstances[0].potentialUsers", hasItems(event.getData().getPotentialUsers().toArray())) - .body("data.UserTaskInstances[0].potentialGroups", hasItems(event.getData().getPotentialGroups().toArray())) - .body("data.UserTaskInstances[0].started", is(formatDateTime(event.getData().getStartDate()))) - .body("data.UserTaskInstances[0].completed", is(formatDateTime(event.getData().getCompleteDate()))) - .body("data.UserTaskInstances[0].lastUpdate", is(formatOffsetDateTime(event.getTime()))) + .body("data.UserTaskInstances[0].id", is(event.getData().getUserTaskInstanceId())) + .body("data.UserTaskInstances[0].processInstanceId", is(event.getData().getProcessInstanceId())) + .body("data.UserTaskInstances[0].description", is(event.getData().getUserTaskDescription())) + .body("data.UserTaskInstances[0].name", is(event.getData().getUserTaskName())) + .body("data.UserTaskInstances[0].priority", is(event.getData().getUserTaskPriority())) + .body("data.UserTaskInstances[0].actualOwner", event.getData().getActualOwner() != null ? is(event.getData().getActualOwner()) : anything()) + .body("data.UserTaskInstances[0].started", anything()) + .body("data.UserTaskInstances[0].lastUpdate", anything()) .body("data.UserTaskInstances[0].endpoint", - is(event.getSource().toString() + "/" + event.getData().getProcessInstanceId() + "/" + event.getData().getTaskName() + "/" + event.getData().getId()))); + is(event.getSource().toString() + "/" + event.getData().getProcessInstanceId() + "/" + event.getData().getUserTaskName() + "/" + + event.getData().getUserTaskInstanceId()))); } } diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/graphql/AbstractWebSocketSubscriptionIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/graphql/AbstractWebSocketSubscriptionIT.java index 3b46cc2381..7b3a433053 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/graphql/AbstractWebSocketSubscriptionIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/graphql/AbstractWebSocketSubscriptionIT.java @@ -27,7 +27,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; import org.kie.kogito.index.model.ProcessInstanceState; import org.kie.kogito.index.service.AbstractIndexingIT; @@ -149,7 +149,8 @@ private void assertDomainSubscription(String processId, String processInstanceId .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Travels", isA(Collection.class)); - ProcessInstanceDataEvent event = getProcessCloudEvent(processId, processInstanceId, state, null, null, null, "currentUser"); + ProcessInstanceDataEvent event = getProcessCloudEvent(processId, processInstanceId, state, null, null, null, "currentUser"); + indexProcessCloudEvent(event); JsonObject json = cf.get(1, TimeUnit.MINUTES); @@ -157,8 +158,7 @@ private void assertDomainSubscription(String processId, String processInstanceId assertThatJson(json.toString()).and( a -> a.node("type").isEqualTo("data"), a -> a.node("payload.data." + subscriptionName + ".id").isEqualTo(processInstanceId), - a -> a.node("payload.data." + subscriptionName + ".metadata.processInstances[0].state").isEqualTo(state.name()), - a -> a.node("payload.data." + subscriptionName + ".traveller.firstName").isEqualTo("Maciej")); + a -> a.node("payload.data." + subscriptionName + ".metadata.processInstances[0].state").isEqualTo(state.name())); } private void assertProcessInstanceSubscription(String processId, String processInstanceId, ProcessInstanceState state, String subscription, String subscriptionName) throws Exception { @@ -168,7 +168,8 @@ private void assertProcessInstanceSubscription(String processId, String processI .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Travels", isA(Collection.class)); - ProcessInstanceDataEvent event = getProcessCloudEvent(processId, processInstanceId, state, null, null, null, "currentUser"); + ProcessInstanceDataEvent event = getProcessCloudEvent(processId, processInstanceId, state, null, null, null, "currentUser"); + indexProcessCloudEvent(event); JsonObject json = cf.get(1, TimeUnit.MINUTES); @@ -187,7 +188,7 @@ private void assertUserTaskInstanceSubscription(String taskId, String processId, .when().post("/graphql") .then().log().ifValidationFails().statusCode(200).body("data.Deals", isA(Collection.class)); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); + UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, state); indexUserTaskCloudEvent(event); JsonObject json = cf.get(1, TimeUnit.MINUTES); diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/graphql/query/AbstractGraphQLRuntimesQueriesIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/graphql/query/AbstractGraphQLRuntimesQueriesIT.java index 5121ae0a48..4889ec4bae 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/graphql/query/AbstractGraphQLRuntimesQueriesIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/graphql/query/AbstractGraphQLRuntimesQueriesIT.java @@ -15,6 +15,7 @@ */ package org.kie.kogito.index.service.graphql.query; +import java.net.URI; import java.util.Arrays; import java.util.List; import java.util.Map; @@ -25,9 +26,12 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; -import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceEventBody; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceCommentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceCommentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; import org.kie.kogito.index.api.KogitoRuntimeClient; import org.kie.kogito.index.event.KogitoJobCloudEvent; import org.kie.kogito.index.model.UserTaskInstance; @@ -46,9 +50,9 @@ import static org.kie.kogito.index.test.TestUtils.getJobCloudEvent; import static org.kie.kogito.index.test.TestUtils.getProcessCloudEvent; import static org.kie.kogito.index.test.TestUtils.getProcessInstance; -import static org.kie.kogito.index.test.TestUtils.getTaskAttachment; -import static org.kie.kogito.index.test.TestUtils.getTaskComment; +import static org.kie.kogito.index.test.TestUtils.getUserTaskAttachmentEvent; import static org.kie.kogito.index.test.TestUtils.getUserTaskCloudEvent; +import static org.kie.kogito.index.test.TestUtils.getUserTaskCommentEvent; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; @@ -78,7 +82,9 @@ public void setup() throws Exception { @Test void testProcessInstanceAbort() { String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"mutation{ ProcessInstanceAbort ( id: \\\"" + processInstanceId + "\\\")}\"}"); @@ -90,7 +96,9 @@ void testProcessInstanceAbort() { @Test void testProcessInstanceRetry() { String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"mutation{ ProcessInstanceRetry ( id: \\\"" + processInstanceId + "\\\")}\"}"); @@ -102,7 +110,9 @@ void testProcessInstanceRetry() { @Test void testProcessInstanceSkip() { String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"mutation{ ProcessInstanceSkip ( id: \\\"" + processInstanceId + "\\\")}\"}"); @@ -116,7 +126,8 @@ void testProcessInstanceUpdateVariables() { String variablesUpdated = "variablesUpdated"; String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"mutation{ ProcessInstanceUpdateVariables ( id: \\\"" + processInstanceId + "\\\", variables: \\\"" + variablesUpdated + "\\\")}\"}"); @@ -128,7 +139,9 @@ void testProcessInstanceUpdateVariables() { @Test void testProcessDefinitionNodes() { String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"query { ProcessInstances (where: { id: {equal: \\\"" + processInstanceId + "\\\"}}) { nodeDefinitions { id }} }\" }"); @@ -138,7 +151,9 @@ void testProcessDefinitionNodes() { @Test void testProcessInstanceDiagram() { String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"query { ProcessInstances (where: { id: {equal: \\\"" + processInstanceId + "\\\"}}) {diagram} }\" }"); @@ -150,7 +165,9 @@ void testProcessInstanceDiagram() { @Test void testProcessDefinitionSource() { String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"query { ProcessInstances (where: { id: {equal: \\\"" + processInstanceId + "\\\"}}) {source} }\" }"); @@ -162,7 +179,9 @@ void testProcessDefinitionSource() { void testNodeInstanceTrigger() { String nodeId = "nodeIdToTrigger"; String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"mutation{ NodeInstanceTrigger ( id: \\\"" + processInstanceId + "\\\", nodeId: \\\"" + nodeId + "\\\")}\"}"); @@ -175,7 +194,9 @@ void testNodeInstanceTrigger() { void testNodeInstanceRetrigger() { String nodeInstanceId = "nodeInstanceIdToRetrigger"; String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"mutation{ NodeInstanceRetrigger ( id: \\\"" + processInstanceId + "\\\", nodeInstanceId: \\\"" + nodeInstanceId + "\\\")}\"}"); @@ -188,7 +209,9 @@ void testNodeInstanceRetrigger() { void testNodeInstanceCancel() { String nodeInstanceId = "nodeInstanceIdToCancel"; String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + + ProcessInstanceStateDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + indexProcessCloudEvent(startEvent); checkOkResponse("{ \"query\" : \"mutation{ NodeInstanceCancel ( id: \\\"" + processInstanceId + "\\\", nodeInstanceId: \\\"" + nodeInstanceId + "\\\")}\"}"); @@ -232,8 +255,8 @@ void testGetTaskSchema() { String processInstanceId = UUID.randomUUID().toString(); String taskId = UUID.randomUUID().toString(); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, - null, "InProgress", user); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, 1); indexUserTaskCloudEvent(event); checkOkResponse("{ \"query\" : \"{UserTaskInstances (where: {id: {equal:\\\"" + taskId + "\\\" }}){ " + @@ -253,8 +276,8 @@ void testUpdateUserTaskInstance() { String taskId = UUID.randomUUID().toString(); String newDescription = "NewDescription"; - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, - null, "InProgress", user); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, 1); indexUserTaskCloudEvent(event); checkOkResponse("{ \"query\" : \"mutation { UserTaskInstanceUpdate ( " + @@ -279,10 +302,16 @@ void testCreateTaskComment() { String taskId = UUID.randomUUID().toString(); String comment = "Comment to add"; - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, - null, "InProgress", user); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, 1); indexUserTaskCloudEvent(event); + + UserTaskInstanceCommentDataEvent commmentEvent = getUserTaskCommentEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, UUID.randomUUID().toString(), comment, UserTaskInstanceCommentEventBody.EVENT_TYPE_ADDED); + + indexUserTaskCloudEvent(commmentEvent); + checkOkResponse("{ \"query\" : \"mutation{ UserTaskInstanceCommentCreate(" + "taskId: \\\"" + taskId + "\\\", " + "user: \\\"" + user + "\\\", " + @@ -305,11 +334,16 @@ void testUpdateUserTaskInstanceComment() { String commentId = UUID.randomUUID().toString(); String commentContent = "commentContent"; - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, - null, "InProgress", user); - UserTaskInstanceEventBody userTaskInstance = event.getData(); - userTaskInstance.setComments(List.of(getTaskComment(commentId, null, null))); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, 1); + indexUserTaskCloudEvent(event); + + UserTaskInstanceCommentDataEvent commmentEvent = getUserTaskCommentEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, commentId, commentContent, UserTaskInstanceCommentEventBody.EVENT_TYPE_ADDED); + + indexUserTaskCloudEvent(commmentEvent); + checkOkResponse("{ \"query\" : \"mutation { UserTaskInstanceCommentUpdate ( " + "user: \\\"" + user + "\\\", " + "groups: [\\\"managers\\\", \\\"users\\\", \\\"IT\\\"]," + @@ -330,10 +364,16 @@ void testDeleteUserTaskInstanceComment() { String taskId = UUID.randomUUID().toString(); String commentId = UUID.randomUUID().toString(); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, - null, "InProgress", user); - UserTaskInstanceEventBody userTaskInstance = event.getData(); - userTaskInstance.setComments(List.of(getTaskComment(commentId, null, null))); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, 1); + + indexUserTaskCloudEvent(event); + + UserTaskInstanceCommentDataEvent commmentEvent = getUserTaskCommentEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, commentId, "my content", UserTaskInstanceCommentEventBody.EVENT_TYPE_ADDED); + + indexUserTaskCloudEvent(commmentEvent); + indexUserTaskCloudEvent(event); checkOkResponse("{ \"query\" : \"mutation { UserTaskInstanceCommentDelete ( " + "user: \\\"" + user + "\\\", " + @@ -352,13 +392,20 @@ void testDeleteUserTaskInstanceComment() { void testCreateTaskAttachment() { String processInstanceId = UUID.randomUUID().toString(); String taskId = UUID.randomUUID().toString(); + String attachmentId = UUID.randomUUID().toString(); String attachmentName = "attachment name"; - String attachmentUri = "https://drive.google.com/file/d/1Z_Lipg2jzY9TNewTaskAttachmentUri"; + URI attachmentUri = URI.create("https://drive.google.com/file/d/1Z_Lipg2jzY9TNewTaskAttachmentUri"); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, - null, "InProgress", user); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, 1); indexUserTaskCloudEvent(event); + + UserTaskInstanceAttachmentDataEvent attachmentEvent = getUserTaskAttachmentEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, attachmentId, attachmentUri, attachmentName, UserTaskInstanceAttachmentEventBody.EVENT_TYPE_ADDED); + + indexUserTaskCloudEvent(attachmentEvent); + checkOkResponse("{ \"query\" : \"mutation{ UserTaskInstanceAttachmentCreate(" + "taskId: \\\"" + taskId + "\\\", " + "user: \\\"" + user + "\\\", " + @@ -372,7 +419,7 @@ void testCreateTaskAttachment() { userTaskInstanceCaptor.capture(), eq(user), eq(groups), eq(attachmentName), - eq(attachmentUri)); + eq(attachmentUri.toString())); assertUserTaskInstance(userTaskInstanceCaptor.getValue(), taskId, processId, processInstanceId, user); } @@ -382,13 +429,18 @@ void testUpdateUserTaskInstanceAttachment() { String taskId = UUID.randomUUID().toString(); String attachmentId = UUID.randomUUID().toString(); String attachmentName = "attachmentName"; - String attachmentUri = "attachmentUri"; + URI attachmentUri = URI.create("http://localhost:8080"); + + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, 1); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, - null, "InProgress", user); - UserTaskInstanceEventBody userTaskInstance = event.getData(); - userTaskInstance.setAttachments(List.of(getTaskAttachment(attachmentId, null, null, null))); indexUserTaskCloudEvent(event); + + UserTaskInstanceAttachmentDataEvent attachmentEvent = getUserTaskAttachmentEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, attachmentId, attachmentUri, attachmentName, UserTaskInstanceAttachmentEventBody.EVENT_TYPE_ADDED); + + indexUserTaskCloudEvent(attachmentEvent); + checkOkResponse("{ \"query\" : \"mutation { UserTaskInstanceAttachmentUpdate ( " + "user: \\\"" + user + "\\\", " + "groups: [\\\"managers\\\", \\\"users\\\", \\\"IT\\\"]," + @@ -400,7 +452,7 @@ void testUpdateUserTaskInstanceAttachment() { verify(dataIndexApiClient).updateUserTaskInstanceAttachment(eq("http://localhost:8080"), userTaskInstanceCaptor.capture(), - eq(user), eq(groups), eq(attachmentId), eq(attachmentName), eq(attachmentUri)); + eq(user), eq(groups), eq(attachmentId), eq(attachmentName), eq(attachmentUri.toString())); assertUserTaskInstance(userTaskInstanceCaptor.getValue(), taskId, processId, processInstanceId, user); } @@ -409,12 +461,19 @@ void testDeleteUserTaskInstanceAttachment() { String processInstanceId = UUID.randomUUID().toString(); String taskId = UUID.randomUUID().toString(); String attachmentId = UUID.randomUUID().toString(); + String attachmentName = "attachmentName"; + URI attachmentUri = URI.create("http://localhost:8080"); + + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, 1); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, - null, "InProgress", user); - UserTaskInstanceEventBody userTaskInstance = event.getData(); - userTaskInstance.setAttachments(List.of(getTaskAttachment(attachmentId, null, null, null))); indexUserTaskCloudEvent(event); + + UserTaskInstanceAttachmentDataEvent attachmentEvent = getUserTaskAttachmentEvent(taskId, processId, processInstanceId, null, + null, "InProgress", user, attachmentId, attachmentUri, attachmentName, UserTaskInstanceAttachmentEventBody.EVENT_TYPE_ADDED); + + indexUserTaskCloudEvent(attachmentEvent); + checkOkResponse("{ \"query\" : \"mutation { UserTaskInstanceAttachmentDelete ( " + "user: \\\"" + user + "\\\", " + "groups: [\\\"managers\\\", \\\"users\\\", \\\"IT\\\"]," + diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/json/ProcessInstanceMetaMapperTest.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/json/ProcessInstanceMetaMapperTest.java index 0899cf7680..326b839635 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/json/ProcessInstanceMetaMapperTest.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/json/ProcessInstanceMetaMapperTest.java @@ -18,7 +18,7 @@ import java.util.UUID; import org.junit.jupiter.api.Test; -import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; import org.kie.kogito.index.model.ProcessInstanceState; import com.fasterxml.jackson.databind.node.ObjectNode; @@ -38,15 +38,15 @@ public void testProcessInstanceMapper() { String processInstanceId = UUID.randomUUID().toString(); String rootProcessInstanceId = UUID.randomUUID().toString(); String piPrefix = KOGITO_DOMAIN_ATTRIBUTE + "." + PROCESS_INSTANCES_DOMAIN_ATTRIBUTE; - ProcessInstanceDataEvent event = getProcessCloudEvent(processId, processInstanceId, ProcessInstanceState.COMPLETED, rootProcessInstanceId, rootProcessId, rootProcessInstanceId, "currentUser"); + + ProcessInstanceStateDataEvent event = + getProcessCloudEvent(processId, processInstanceId, ProcessInstanceState.COMPLETED, rootProcessInstanceId, rootProcessId, rootProcessInstanceId, "currentUser"); + ObjectNode json = new ProcessInstanceMetaMapper().apply(event); assertThat(json).isNotNull(); assertThatJson(json.toString()).and( a -> a.node("id").isEqualTo(rootProcessInstanceId), a -> a.node("processId").isEqualTo(rootProcessId), - a -> a.node("traveller.firstName").isEqualTo("Maciej"), - a -> a.node("hotel.name").isEqualTo("Meriton"), - a -> a.node("flight.flightNumber").isEqualTo("MX555"), a -> a.node(KOGITO_DOMAIN_ATTRIBUTE).isNotNull(), a -> a.node(KOGITO_DOMAIN_ATTRIBUTE + ".lastUpdate").isEqualTo(event.getTime().toInstant().toEpochMilli()), a -> a.node(piPrefix).isArray().hasSize(1), @@ -57,9 +57,9 @@ public void testProcessInstanceMapper() { a -> a.node(piPrefix + "[0].rootProcessId").isEqualTo(rootProcessId), a -> a.node(piPrefix + "[0].state").isEqualTo(ProcessInstanceState.COMPLETED.ordinal()), a -> a.node(piPrefix + "[0].endpoint").isEqualTo(event.getSource().toString()), - a -> a.node(piPrefix + "[0].start").isEqualTo(event.getData().getStartDate().toInstant().toEpochMilli()), - a -> a.node(piPrefix + "[0].end").isEqualTo(event.getData().getEndDate().toInstant().toEpochMilli()), - a -> a.node(piPrefix + "[0].updatedBy").isEqualTo(event.getData().getIdentity().toString()), + a -> a.node(piPrefix + "[0].updatedBy").isEqualTo(event.getData().getEventUser().toString()), + a -> a.node(piPrefix + "[0].start").isEqualTo(event.getData().getEventDate().toInstant().toEpochMilli()), + a -> a.node(piPrefix + "[0].end").isAbsent(), a -> a.node(piPrefix + "[0].lastUpdate").isEqualTo(event.getTime().toInstant().toEpochMilli())); } @@ -70,16 +70,16 @@ public void testProcessInstanceMapperWithBusinessKey() { String processInstanceId = UUID.randomUUID().toString(); String rootProcessInstanceId = UUID.randomUUID().toString(); String piPrefix = KOGITO_DOMAIN_ATTRIBUTE + "." + PROCESS_INSTANCES_DOMAIN_ATTRIBUTE; - ProcessInstanceDataEvent event = getProcessCloudEvent(processId, processInstanceId, ProcessInstanceState.COMPLETED, rootProcessInstanceId, rootProcessId, rootProcessInstanceId, "currentUser"); + + ProcessInstanceStateDataEvent event = + getProcessCloudEvent(processId, processInstanceId, ProcessInstanceState.COMPLETED, rootProcessInstanceId, rootProcessId, rootProcessInstanceId, "currentUser"); + event.getData().update().businessKey("custom-key"); ObjectNode json = new ProcessInstanceMetaMapper().apply(event); assertThat(json).isNotNull(); assertThatJson(json.toString()).and( a -> a.node("id").isEqualTo(rootProcessInstanceId), a -> a.node("processId").isEqualTo(rootProcessId), - a -> a.node("traveller.firstName").isEqualTo("Maciej"), - a -> a.node("hotel.name").isEqualTo("Meriton"), - a -> a.node("flight.flightNumber").isEqualTo("MX555"), a -> a.node(KOGITO_DOMAIN_ATTRIBUTE).isNotNull(), a -> a.node(KOGITO_DOMAIN_ATTRIBUTE + ".lastUpdate").isEqualTo(event.getTime().toInstant().toEpochMilli()), a -> a.node(piPrefix).isArray().hasSize(1), @@ -90,10 +90,10 @@ public void testProcessInstanceMapperWithBusinessKey() { a -> a.node(piPrefix + "[0].rootProcessId").isEqualTo(rootProcessId), a -> a.node(piPrefix + "[0].state").isEqualTo(ProcessInstanceState.COMPLETED.ordinal()), a -> a.node(piPrefix + "[0].endpoint").isEqualTo(event.getSource().toString()), - a -> a.node(piPrefix + "[0].start").isEqualTo(event.getData().getStartDate().toInstant().toEpochMilli()), - a -> a.node(piPrefix + "[0].end").isEqualTo(event.getData().getEndDate().toInstant().toEpochMilli()), + a -> a.node(piPrefix + "[0].start").isEqualTo(event.getData().getEventDate().toInstant().toEpochMilli()), + a -> a.node(piPrefix + "[0].end").isAbsent(), a -> a.node(piPrefix + "[0].lastUpdate").isEqualTo(event.getTime().toInstant().toEpochMilli()), a -> a.node(piPrefix + "[0].businessKey").isEqualTo(event.getData().getBusinessKey()), - a -> a.node(piPrefix + "[0].updatedBy").isEqualTo(event.getData().getIdentity().toString())); + a -> a.node(piPrefix + "[0].updatedBy").isEqualTo(event.getData().getEventUser().toString())); } } diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/json/UserTaskInstanceMetaMapperTest.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/json/UserTaskInstanceMetaMapperTest.java index 6ccc6ecd0d..f70af24b07 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/json/UserTaskInstanceMetaMapperTest.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/json/UserTaskInstanceMetaMapperTest.java @@ -18,7 +18,7 @@ import java.util.UUID; import org.junit.jupiter.api.Test; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; import com.fasterxml.jackson.databind.node.ObjectNode; @@ -38,7 +38,7 @@ public void testUserTaskInstanceMapper() { String processInstanceId = UUID.randomUUID().toString(); String rootProcessInstanceId = UUID.randomUUID().toString(); String utPrefix = KOGITO_DOMAIN_ATTRIBUTE + "." + USER_TASK_INSTANCES_DOMAIN_ATTRIBUTE; - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, rootProcessInstanceId, rootProcessId, "InProgress"); + UserTaskInstanceStateDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, rootProcessInstanceId, rootProcessId, "InProgress"); ObjectNode json = new UserTaskInstanceMetaMapper().apply(event); assertThat(json).isNotNull(); assertThatJson(json.toString()).and( @@ -50,17 +50,12 @@ public void testUserTaskInstanceMapper() { a -> a.node(utPrefix + "[0].id").isEqualTo(taskId), a -> a.node(utPrefix + "[0].processInstanceId").isEqualTo(processInstanceId), a -> a.node(utPrefix + "[0].state").isEqualTo(event.getData().getState()), - a -> a.node(utPrefix + "[0].description").isEqualTo(event.getData().getTaskDescription()), - a -> a.node(utPrefix + "[0].name").isEqualTo(event.getData().getTaskName()), - a -> a.node(utPrefix + "[0].priority").isEqualTo(event.getData().getTaskPriority()), + a -> a.node(utPrefix + "[0].description").isEqualTo(event.getData().getUserTaskDescription()), + a -> a.node(utPrefix + "[0].name").isEqualTo(event.getData().getUserTaskName()), + a -> a.node(utPrefix + "[0].priority").isEqualTo(event.getData().getUserTaskPriority()), a -> a.node(utPrefix + "[0].actualOwner").isEqualTo(event.getData().getActualOwner()), - a -> a.node(utPrefix + "[0].adminUsers[0]").isEqualTo(event.getData().getAdminUsers().stream().findFirst().get()), - a -> a.node(utPrefix + "[0].adminGroups[0]").isEqualTo(event.getData().getAdminGroups().stream().findFirst().get()), - a -> a.node(utPrefix + "[0].excludedUsers[0]").isEqualTo(event.getData().getExcludedUsers().stream().findFirst().get()), - a -> a.node(utPrefix + "[0].potentialGroups[0]").isEqualTo(event.getData().getPotentialGroups().stream().findFirst().get()), - a -> a.node(utPrefix + "[0].potentialUsers[0]").isEqualTo(event.getData().getPotentialUsers().stream().findFirst().get()), - a -> a.node(utPrefix + "[0].started").isEqualTo(event.getData().getStartDate().toInstant().toEpochMilli()), - a -> a.node(utPrefix + "[0].completed").isEqualTo(event.getData().getCompleteDate().toInstant().toEpochMilli()), + a -> a.node(utPrefix + "[0].started").isEqualTo(event.getData().getEventDate().toInstant().toEpochMilli()), + a -> a.node(utPrefix + "[0].completed").isAbsent(), a -> a.node(utPrefix + "[0].lastUpdate").isEqualTo(event.getTime().toInstant().toEpochMilli())); } } diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractDomainMessagingHttpConsumerIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractDomainMessagingHttpConsumerIT.java index 6c5f27e9cf..86afd58452 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractDomainMessagingHttpConsumerIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractDomainMessagingHttpConsumerIT.java @@ -20,7 +20,7 @@ import javax.inject.Inject; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.model.ProcessInstanceState; import io.smallrye.reactive.messaging.providers.connectors.InMemoryConnector; @@ -37,13 +37,13 @@ public abstract class AbstractDomainMessagingHttpConsumerIT extends AbstractDoma public InMemoryConnector connector; protected void sendUserTaskInstanceEvent() throws Exception { - UserTaskInstanceDataEvent event = getUserTaskCloudEvent("45fae435-b098-4f27-97cf-a0c107072e8b", "travels", + UserTaskInstanceDataEvent event = getUserTaskCloudEvent("45fae435-b098-4f27-97cf-a0c107072e8b", "travels", "2308e23d-9998-47e9-a772-a078cf5b891b", null, null, "Completed"); connector.source(KOGITO_USERTASKINSTANCES_EVENTS).send(event); } protected void sendProcessInstanceEvent() throws Exception { - ProcessInstanceDataEvent event = getProcessCloudEvent("travels", "2308e23d-9998-47e9-a772-a078cf5b891b", + ProcessInstanceDataEvent event = getProcessCloudEvent("travels", "2308e23d-9998-47e9-a772-a078cf5b891b", ProcessInstanceState.ACTIVE, null, null, null, "currentUser"); connector.source(KOGITO_PROCESSINSTANCES_EVENTS).send(event); diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingConsumerIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingConsumerIT.java index d9a6e57619..fe43d9d8f0 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingConsumerIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingConsumerIT.java @@ -23,6 +23,7 @@ import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; import org.kie.kogito.index.storage.DataIndexStorageService; import io.restassured.http.ContentType; @@ -31,6 +32,7 @@ import static org.awaitility.Awaitility.await; import static org.hamcrest.CoreMatchers.is; +@Timeout(10000) public abstract class AbstractMessagingConsumerIT { Duration timeout = Duration.ofSeconds(30); diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingHttpConsumerIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingHttpConsumerIT.java index 62212149ea..f3b5ab3cfa 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingHttpConsumerIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingHttpConsumerIT.java @@ -20,14 +20,18 @@ import javax.inject.Inject; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; import org.kie.kogito.index.model.ProcessInstanceState; import io.smallrye.reactive.messaging.providers.connectors.InMemoryConnector; -import static org.kie.kogito.index.service.messaging.ReactiveMessagingEventConsumer.*; -import static org.kie.kogito.index.test.TestUtils.*; +import static org.kie.kogito.index.service.messaging.ReactiveMessagingEventConsumer.KOGITO_JOBS_EVENTS; +import static org.kie.kogito.index.service.messaging.ReactiveMessagingEventConsumer.KOGITO_PROCESSINSTANCES_EVENTS; +import static org.kie.kogito.index.service.messaging.ReactiveMessagingEventConsumer.KOGITO_USERTASKINSTANCES_EVENTS; +import static org.kie.kogito.index.test.TestUtils.getJobCloudEvent; +import static org.kie.kogito.index.test.TestUtils.getProcessCloudEvent; +import static org.kie.kogito.index.test.TestUtils.getUserTaskCloudEvent; public abstract class AbstractMessagingHttpConsumerIT extends AbstractMessagingConsumerIT { @@ -36,13 +40,13 @@ public abstract class AbstractMessagingHttpConsumerIT extends AbstractMessagingC public InMemoryConnector connector; protected void sendUserTaskInstanceEvent() throws Exception { - UserTaskInstanceDataEvent event = getUserTaskCloudEvent("45fae435-b098-4f27-97cf-a0c107072e8b", "travels", + UserTaskInstanceDataEvent event = getUserTaskCloudEvent("45fae435-b098-4f27-97cf-a0c107072e8b", "travels", "2308e23d-9998-47e9-a772-a078cf5b891b", null, null, "Completed"); connector.source(KOGITO_USERTASKINSTANCES_EVENTS).send(event); } protected void sendProcessInstanceEvent() throws Exception { - ProcessInstanceDataEvent event = getProcessCloudEvent("travels", "2308e23d-9998-47e9-a772-a078cf5b891b", + ProcessInstanceDataEvent event = getProcessCloudEvent("travels", "2308e23d-9998-47e9-a772-a078cf5b891b", ProcessInstanceState.ACTIVE, null, null, null, "currentUser"); connector.source(KOGITO_PROCESSINSTANCES_EVENTS).send(event); diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingLoadKafkaIT.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingLoadKafkaIT.java index dcab0f098f..ea013b2313 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingLoadKafkaIT.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/AbstractMessagingLoadKafkaIT.java @@ -30,7 +30,7 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.model.ProcessInstanceState; import org.kie.kogito.persistence.protobuf.ProtobufService; import org.kie.kogito.test.quarkus.kafka.KafkaTestClient; @@ -107,17 +107,18 @@ void testMessagingEvents() { String processInstanceId = UUID.randomUUID().toString(); String taskId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); + ProcessInstanceDataEvent startEvent = getProcessCloudEvent(processId, processInstanceId, ACTIVE, null, null, null, "currentUser"); sendProcessInstanceEvent(client, startEvent); - UserTaskInstanceDataEvent userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, "InProgress"); + UserTaskInstanceDataEvent userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, "InProgress"); sendUserTaskEvent(client, userTaskEvent); userTaskEvent = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, "Completed"); sendUserTaskEvent(client, userTaskEvent); - ProcessInstanceDataEvent endEvent = getProcessCloudEvent(processId, processInstanceId, COMPLETED, null, null, null, "currentUser"); + ProcessInstanceDataEvent endEvent = getProcessCloudEvent(processId, processInstanceId, COMPLETED, null, null, null, "currentUser"); + sendProcessInstanceEvent(client, endEvent); return processInstanceId; diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/DomainEventConsumerTest.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/DomainEventConsumerTest.java index 4f3385b0cc..4611350b07 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/DomainEventConsumerTest.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/DomainEventConsumerTest.java @@ -22,7 +22,9 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; import org.kie.kogito.index.model.ProcessInstanceState; import org.kie.kogito.index.service.IndexingService; import org.mockito.ArgumentCaptor; @@ -58,7 +60,7 @@ public void setup() { @Test public void testOnUserTaskInstanceDomainEventMappingException() { - UserTaskInstanceDataEvent event = mock(UserTaskInstanceDataEvent.class); + UserTaskInstanceStateDataEvent event = mock(UserTaskInstanceStateDataEvent.class); assertThatExceptionOfType(NullPointerException.class).isThrownBy(() -> consumer.onDomainEvent(event)); @@ -73,7 +75,7 @@ public void testOnUserTaskInstanceDomainEventIndexingException() { String processId = "travels"; String processInstanceId = UUID.randomUUID().toString(); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, "InProgress"); + UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, "InProgress"); assertThatExceptionOfType(RuntimeException.class).isThrownBy(() -> consumer.onDomainEvent(event)); verify(service).indexModel(any()); @@ -85,7 +87,7 @@ public void testOnUserTaskInstanceEvent() { String processId = "travels"; String processInstanceId = UUID.randomUUID().toString(); - UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, "InProgress"); + UserTaskInstanceDataEvent event = getUserTaskCloudEvent(taskId, processId, processInstanceId, null, null, "InProgress"); consumer.onDomainEvent(event); @@ -100,7 +102,7 @@ public void testOnUserTaskInstanceEvent() { @Test public void testOnProcessInstanceDomainEventMappingException() { - ProcessInstanceDataEvent event = mock(ProcessInstanceDataEvent.class); + ProcessInstanceStateDataEvent event = mock(ProcessInstanceStateDataEvent.class); assertThatExceptionOfType(NullPointerException.class).isThrownBy(() -> consumer.onDomainEvent(event)); @@ -114,7 +116,7 @@ public void testOnProcessInstanceDomainEventIndexingException() { String processId = "travels"; String processInstanceId = UUID.randomUUID().toString(); - ProcessInstanceDataEvent event = getProcessCloudEvent(processId, processInstanceId, ProcessInstanceState.ACTIVE, null, + ProcessInstanceDataEvent event = getProcessCloudEvent(processId, processInstanceId, ProcessInstanceState.ACTIVE, null, null, null, "currentUser"); assertThatExceptionOfType(RuntimeException.class).isThrownBy(() -> consumer.onDomainEvent(event)); diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/KogitoIndexEventConverterTest.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/KogitoIndexEventConverterTest.java index 174ea1cbfa..794056454d 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/KogitoIndexEventConverterTest.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/KogitoIndexEventConverterTest.java @@ -22,14 +22,12 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; -import org.kie.kogito.index.event.ProcessInstanceEventMapper; -import org.kie.kogito.index.event.UserTaskInstanceEventMapper; +import org.kie.kogito.index.event.mapper.ProcessInstanceStateDataEventMerger; import org.kie.kogito.index.json.ObjectMapperProducer; -import org.kie.kogito.index.model.Job; import org.kie.kogito.index.model.ProcessInstance; -import org.kie.kogito.index.model.UserTaskInstance; import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; @@ -48,9 +46,7 @@ class KogitoIndexEventConverterTest { private static final String BINARY_PROCESS_INSTANCE_CLOUD_EVENT_DATA = "process_instance_event.json"; - private static final String BINARY_PROCESS_INSTANCE_CLOUD_EVENT_BODY_DATA = "binary_process_instance_event_data.json"; - private static final String BINARY_USER_TASK_INSTANCE_CLOUD_EVENT_DATA = "binary_user_task_instance_event_data.json"; - private static final String BINARY_KOGITO_JOB_CLOUD_EVENT_DATA = "binary_job_event_data.json"; + @Mock IncomingHttpMetadata httpMetadata; @@ -80,88 +76,30 @@ void canConvertBufferPayload() { @Test void canConvertNotBufferPayload() { - assertThat(converter.canConvert(Message.of(new ProcessInstanceDataEvent(), Metadata.of(httpMetadata)), + assertThat(converter.canConvert(Message.of(new ProcessInstanceDataEvent<>(), Metadata.of(httpMetadata)), ProcessInstanceDataEvent.class)).isFalse(); - assertThat(converter.canConvert(Message.of(new UserTaskInstanceDataEvent(), Metadata.of(httpMetadata)), + assertThat(converter.canConvert(Message.of(new UserTaskInstanceDataEvent<>(), Metadata.of(httpMetadata)), UserTaskInstanceDataEvent.class)).isFalse(); assertThat(converter.canConvert(Message.of(KogitoJobCloudEvent.builder().build(), Metadata.of(httpMetadata)), KogitoJobCloudEvent.class)).isFalse(); } - @Test - void convertBinaryCloudProcessInstanceEventBody() throws Exception { - Buffer buffer = Buffer.buffer(readFileContent(BINARY_PROCESS_INSTANCE_CLOUD_EVENT_BODY_DATA)); - Message message = Message.of(buffer, Metadata.of(httpMetadata)); - Message result = converter.convert(message, ProcessInstanceDataEvent.class); - assertThat(result.getPayload()).isInstanceOf(ProcessInstanceDataEvent.class); - ProcessInstanceDataEvent cloudEvent = (ProcessInstanceDataEvent) result.getPayload(); - - ProcessInstance pi = new ProcessInstanceEventMapper().apply(cloudEvent); - assertThat(pi.getId()).isEqualTo("5f8b1a48-4d37-4bd2-a1a6-9b8f6097cfdd"); - assertThat(pi.getProcessId()).isEqualTo("subscription_flow"); - assertThat(pi.getProcessName()).isEqualTo("workflow"); - assertThat(pi.getVariables()).hasSize(1); - assertThat(pi.getNodes()).hasSize(14); - assertThat(pi.getState()).isEqualTo(1); - assertThat(pi.getStart()).isEqualTo("2023-05-24T10:41:14.911Z"); - assertThat(pi.getEnd()).isNull(); - assertThat(pi.getMilestones()).isEmpty(); - } - @Test void convertBinaryCloudProcessInstanceEvent() throws Exception { Buffer buffer = Buffer.buffer(readFileContent(BINARY_PROCESS_INSTANCE_CLOUD_EVENT_DATA)); Message message = Message.of(buffer, Metadata.of(httpMetadata)); Message result = converter.convert(message, ProcessInstanceDataEvent.class); - assertThat(result.getPayload()).isInstanceOf(ProcessInstanceDataEvent.class); - ProcessInstanceDataEvent cloudEvent = (ProcessInstanceDataEvent) result.getPayload(); + assertThat(result.getPayload()).isInstanceOf(ProcessInstanceStateDataEvent.class); + ProcessInstanceStateDataEvent cloudEvent = (ProcessInstanceStateDataEvent) result.getPayload(); - ProcessInstance pi = new ProcessInstanceEventMapper().apply(cloudEvent); + ProcessInstance pi = new ProcessInstance(); + new ProcessInstanceStateDataEventMerger().merge(pi, cloudEvent); assertThat(pi.getId()).isEqualTo("2308e23d-9998-47e9-a772-a078cf5b891b"); assertThat(pi.getProcessId()).isEqualTo("travels"); assertThat(pi.getProcessName()).isEqualTo("travels"); - assertThat(pi.getVariables()).hasSize(3); - assertThat(pi.getNodes()).hasSize(5); assertThat(pi.getState()).isEqualTo(1); assertThat(pi.getStart()).isEqualTo("2022-03-18T05:32:21.887Z"); assertThat(pi.getEnd()).isNull(); - assertThat(pi.getMilestones()).isEmpty(); - } - - @Test - void convertBinaryCloudKogitoJobEvent() throws Exception { - Buffer buffer = Buffer.buffer(readFileContent(BINARY_KOGITO_JOB_CLOUD_EVENT_DATA)); - Message message = Message.of(buffer, Metadata.of(httpMetadata)); - Message result = converter.convert(message, KogitoJobCloudEvent.class); - assertThat(result.getPayload()).isInstanceOf(KogitoJobCloudEvent.class); - KogitoJobCloudEvent cloudEvent = (KogitoJobCloudEvent) result.getPayload(); - - Job job = cloudEvent.getData(); - assertThat(job.getId()).isEqualTo("8350b8b6-c5d9-432d-a339-a9fc85f642d4_0"); - assertThat(job.getProcessId()).isEqualTo("timerscycle"); - assertThat(job.getProcessInstanceId()).isEqualTo("7c1d9b38-b462-47c5-8bf2-d9154f54957b"); - assertThat(job.getRepeatInterval()).isEqualTo(1000l); - assertThat(job.getCallbackEndpoint()) - .isEqualTo("http://localhost:8080/management/jobs/timerscycle/instances/7c1d9b38-b462-47c5-8bf2-d9154f54957b/timers/8350b8b6-c5d9-432d-a339-a9fc85f642d4_0"); - assertThat(job.getScheduledId()).isEqualTo("0"); - assertThat(job.getStatus()).isEqualTo("SCHEDULED"); - - } - - @Test - void convertBinaryCloudUserTaskInstanceEvent() throws Exception { - Buffer buffer = Buffer.buffer(readFileContent(BINARY_USER_TASK_INSTANCE_CLOUD_EVENT_DATA)); - Message message = Message.of(buffer, Metadata.of(httpMetadata)); - Message result = converter.convert(message, UserTaskInstanceDataEvent.class); - assertThat(result.getPayload()).isInstanceOf(UserTaskInstanceDataEvent.class); - UserTaskInstanceDataEvent cloudEvent = (UserTaskInstanceDataEvent) result.getPayload(); - - UserTaskInstance userTaskInstance = new UserTaskInstanceEventMapper().apply(cloudEvent); - assertThat(userTaskInstance.getId()).isEqualTo("45fae435-b098-4f27-97cf-a0c107072e8b"); - - assertThat(userTaskInstance.getInputs().size()).isEqualTo(6); - assertThat(userTaskInstance.getName()).isEqualTo("VisaApplication"); - assertThat(userTaskInstance.getState()).isEqualTo("Completed"); } @Test diff --git a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/ReactiveMessagingEventConsumerTest.java b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/ReactiveMessagingEventConsumerTest.java index 7fc8e7dd61..7cd6e5b757 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/ReactiveMessagingEventConsumerTest.java +++ b/data-index/data-index-service/data-index-service-common/src/test/java/org/kie/kogito/index/service/messaging/ReactiveMessagingEventConsumerTest.java @@ -23,7 +23,7 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.kie.kogito.event.DataEvent; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.event.KogitoJobCloudEvent; import org.kie.kogito.index.model.ProcessInstanceState; import org.kie.kogito.index.service.IndexingService; @@ -67,7 +67,7 @@ public void testOnProcessInstanceEvent() { .withSubscriber(UniAssertSubscriber.create()); future.awaitItem().assertCompleted(); - verify(service).indexProcessInstance(any()); + verify(service).indexProcessInstanceEvent(any()); verify(eventPublisher).fire(event); } @@ -84,33 +84,33 @@ public void testOnUserTaskInstanceEvent() { .withSubscriber(UniAssertSubscriber.create()); future.awaitItem().assertCompleted(); - verify(service).indexUserTaskInstance(any()); + verify(service).indexUserTaskInstanceEvent(any()); verify(eventPublisher).fire(event); } @Test public void testOnProcessInstanceEventException() { ProcessInstanceDataEvent event = mock(ProcessInstanceDataEvent.class); - doThrow(new RuntimeException("")).when(service).indexProcessInstance(any()); + doThrow(new RuntimeException("")).when(service).indexProcessInstanceEvent(any()); UniAssertSubscriber future = consumer.onProcessInstanceEvent(event).subscribe() .withSubscriber(UniAssertSubscriber.create()); future.awaitFailure().assertFailedWith(RuntimeException.class, ""); - verify(service).indexProcessInstance(any()); + verify(service).indexProcessInstanceEvent(any()); verify(eventPublisher, never()).fire(event); } @Test public void testOnUserTaskInstanceEventException() { UserTaskInstanceDataEvent event = mock(UserTaskInstanceDataEvent.class); - doThrow(new RuntimeException("")).when(service).indexUserTaskInstance(any()); + doThrow(new RuntimeException("")).when(service).indexUserTaskInstanceEvent(any()); UniAssertSubscriber future = consumer.onUserTaskInstanceEvent(event).subscribe() .withSubscriber(UniAssertSubscriber.create()); future.awaitFailure().assertFailedWith(RuntimeException.class, ""); - verify(service).indexUserTaskInstance(any()); + verify(service).indexUserTaskInstanceEvent(any()); verify(eventPublisher, never()).fire(event); } diff --git a/data-index/data-index-service/data-index-service-common/src/test/resources/binary_job_event_data.json b/data-index/data-index-service/data-index-service-common/src/test/resources/binary_job_event_data.json deleted file mode 100644 index 849b1f9005..0000000000 --- a/data-index/data-index-service/data-index-service-common/src/test/resources/binary_job_event_data.json +++ /dev/null @@ -1,19 +0,0 @@ -{ - "id": "8350b8b6-c5d9-432d-a339-a9fc85f642d4_0", - "expirationTime": "2020-01-16T20:40:58.918Z", - "priority": 0, - "callbackEndpoint": "http://localhost:8080/management/jobs/timerscycle/instances/7c1d9b38-b462-47c5-8bf2-d9154f54957b/timers/8350b8b6-c5d9-432d-a339-a9fc85f642d4_0", - "processInstanceId": "7c1d9b38-b462-47c5-8bf2-d9154f54957b", - "rootProcessInstanceId": null, - "processId": "timerscycle", - "rootProcessId": null, - "repeatInterval": 1000, - "repeatLimit": 2147483647, - "scheduledId": "0", - "retries": 0, - "status": "SCHEDULED", - "lastUpdate": "2020-01-16T20:40:58.206Z", - "executionCounter": 0, - "executionResponse": null, - "nodeInstanceId": "54e66e2f-2acd-4d47-b8e6-991cb6372ad8" -} \ No newline at end of file diff --git a/data-index/data-index-service/data-index-service-common/src/test/resources/binary_process_instance_event_data.json b/data-index/data-index-service/data-index-service-common/src/test/resources/binary_process_instance_event_data.json deleted file mode 100644 index 23d60bf577..0000000000 --- a/data-index/data-index-service/data-index-service-common/src/test/resources/binary_process_instance_event_data.json +++ /dev/null @@ -1,154 +0,0 @@ -{ - "id": "5f8b1a48-4d37-4bd2-a1a6-9b8f6097cfdd", - "version": "1.0", - "parentInstanceId": null, - "rootInstanceId": null, - "processId": "subscription_flow", - "processType": null, - "rootProcessId": null, - "processName": "workflow", - "startDate": "2023-05-24T10:41:14.911+00:00", - "endDate": null, - "state": 1, - "businessKey": null, - "nodeInstances": [ - { - "id": "f9c80fd0-ce2c-47fc-98b5-c0a0bae6d135", - "nodeId": "12", - "nodeDefinitionId": "_jbpm-unique-10", - "nodeName": "SubscribeAndWaitForConfirmation", - "nodeType": "CompositeContextNode", - "triggerTime": "2023-05-24T10:41:18.072+00:00", - "leaveTime": null - }, - { - "id": "e97058a4-4696-4370-92a1-fd5e0e5bf6dd", - "nodeId": "18", - "nodeDefinitionId": "_jbpm-unique-14", - "nodeName": "ConfirmSubscriptionEvent", - "nodeType": "EventNode", - "triggerTime": "2023-05-24T10:41:18.177+00:00", - "leaveTime": null - }, - { - "id": "595f9a28-3a26-4b81-851d-ac5f545f8648", - "nodeId": "22", - "nodeDefinitionId": "22", - "nodeName": "TimerNode_22", - "nodeType": "TimerNode", - "triggerTime": "2023-05-24T10:41:18.178+00:00", - "leaveTime": null - }, - { - "id": "aaabaf9b-011d-4e92-b4a5-fcc7f52a41e0", - "nodeId": "20", - "nodeDefinitionId": "20", - "nodeName": "EventSplit_20", - "nodeType": "Split", - "triggerTime": "2023-05-24T10:41:18.175+00:00", - "leaveTime": null - }, - { - "id": "c194555f-5972-4dc4-b3d7-de871ddc7aee", - "nodeId": "16", - "nodeDefinitionId": "_jbpm-unique-13", - "nodeName": "Script", - "nodeType": "ActionNode", - "triggerTime": "2023-05-24T10:41:18.174+00:00", - "leaveTime": "2023-05-24T10:41:18.174+00:00" - }, - { - "id": "732d2190-4bee-4ba9-926f-e8f623298940", - "nodeId": "15", - "nodeDefinitionId": "_jbpm-unique-12", - "nodeName": "subscribeToNewsletter", - "nodeType": "WorkItemNode", - "triggerTime": "2023-05-24T10:41:18.072+00:00", - "leaveTime": "2023-05-24T10:41:18.174+00:00" - }, - { - "id": "24af64d1-4660-4972-8794-21b6a8ca3f4a", - "nodeId": "13", - "nodeDefinitionId": "_jbpm-unique-11", - "nodeName": "EmbeddedStart", - "nodeType": "StartNode", - "triggerTime": "2023-05-24T10:41:18.072+00:00", - "leaveTime": "2023-05-24T10:41:18.072+00:00" - }, - { - "id": "409bd8d1-27c5-4d84-83a8-af5d49723dac", - "nodeId": "11", - "nodeDefinitionId": "11", - "nodeName": "ExitIfEmailExists", - "nodeType": "Split", - "triggerTime": "2023-05-24T10:41:18.029+00:00", - "leaveTime": "2023-05-24T10:41:18.072+00:00" - }, - { - "id": "2bd100e5-156b-4ace-9d99-c50f14b8b345", - "nodeId": "5", - "nodeDefinitionId": "_jbpm-unique-4", - "nodeName": "VerifyEmail", - "nodeType": "CompositeContextNode", - "triggerTime": "2023-05-24T10:41:14.917+00:00", - "leaveTime": "2023-05-24T10:41:18.029+00:00" - }, - { - "id": "8c0fc962-5f03-41f8-8f28-c7277619fa54", - "nodeId": "10", - "nodeDefinitionId": "_jbpm-unique-8", - "nodeName": "EmbeddedEnd", - "nodeType": "EndNode", - "triggerTime": "2023-05-24T10:41:18.028+00:00", - "leaveTime": "2023-05-24T10:41:18.028+00:00" - }, - { - "id": "25f47359-aeba-46f9-a86d-e271b050c0a4", - "nodeId": "9", - "nodeDefinitionId": "_jbpm-unique-7", - "nodeName": "Script", - "nodeType": "ActionNode", - "triggerTime": "2023-05-24T10:41:18.023+00:00", - "leaveTime": "2023-05-24T10:41:18.028+00:00" - }, - { - "id": "22443d26-da1c-4fda-b2ec-b84bd2a8d949", - "nodeId": "8", - "nodeDefinitionId": "_jbpm-unique-6", - "nodeName": "verifyEmail", - "nodeType": "WorkItemNode", - "triggerTime": "2023-05-24T10:41:14.922+00:00", - "leaveTime": "2023-05-24T10:41:18.023+00:00" - }, - { - "id": "f9f6d1ab-5879-4eb3-9d52-4c66c98b87f9", - "nodeId": "6", - "nodeDefinitionId": "_jbpm-unique-5", - "nodeName": "EmbeddedStart", - "nodeType": "StartNode", - "triggerTime": "2023-05-24T10:41:14.917+00:00", - "leaveTime": "2023-05-24T10:41:14.922+00:00" - }, - { - "id": "e6befc33-dfa4-4667-89dc-5821c96861b9", - "nodeId": "1", - "nodeDefinitionId": "_jbpm-unique-0", - "nodeName": "Start", - "nodeType": "StartNode", - "triggerTime": "2023-05-24T10:41:14.914+00:00", - "leaveTime": "2023-05-24T10:41:14.916+00:00" - } - ], - "variables": { - "workflowdata": { - "email": "test2@ge.com", - "name": "test2", - "emailExists": false, - "id": "5f8b1a48-4d37-4bd2-a1a6-9b8f6097cfdd", - "verified": false - } - }, - "error": null, - "roles": null, - "milestones": [] -} \ No newline at end of file diff --git a/data-index/data-index-service/data-index-service-common/src/test/resources/binary_user_task_instance_event_data.json b/data-index/data-index-service/data-index-service-common/src/test/resources/binary_user_task_instance_event_data.json deleted file mode 100644 index 46620b51c5..0000000000 --- a/data-index/data-index-service/data-index-service-common/src/test/resources/binary_user_task_instance_event_data.json +++ /dev/null @@ -1,60 +0,0 @@ -{ - "id": "45fae435-b098-4f27-97cf-a0c107072e8b", - "taskName": "VisaApplication", - "taskDescription": null, - "taskPriority": "1", - "referenceName": "Apply for visa", - "startDate": "2022-03-18T15:32:22.484+10:00", - "completeDate": "2022-03-18T15:33:05.586+10:00", - "state": "Completed", - "actualOwner": null, - "potentialUsers": [], - "potentialGroups": [], - "excludedUsers": [], - "adminUsers": [], - "adminGroups": [], - "inputs": { - "trip": { - "city": "Brisbane", - "country": "Australia", - "begin": "2022-03-01T08:00:00.000+10:00", - "end": "2022-03-31T08:00:00.000+10:00", - "visaRequired": true - }, - "NodeName": "Apply for visa", - "TaskName": "VisaApplication", - "Priority": "1", - "Skippable": "true", - "traveller": { - "firstName": "Test", - "lastName": "Test", - "email": "test@email.com", - "nationality": "Brazilian", - "address": { - "street": "", - "city": "", - "zipCode": "", - "country": "Brazil" - } - } - }, - "outputs": { - "ActorId": null, - "visaApplication": { - "firstName": "Test", - "lastName": "Test", - "city": "Brisbane", - "country": "Australia", - "duration": 150, - "passportNumber": "CDDCDCDS", - "nationality": "Brazilian", - "approved": false - } - }, - "comments": [], - "attachments": [], - "processInstanceId": "2308e23d-9998-47e9-a772-a078cf5b891b", - "rootProcessInstanceId": "", - "processId": "travels", - "rootProcessId": "" -} \ No newline at end of file diff --git a/data-index/data-index-service/data-index-service-common/src/test/resources/process_instance_event.json b/data-index/data-index-service/data-index-service-common/src/test/resources/process_instance_event.json index daf703b4f9..5db94f6a01 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/resources/process_instance_event.json +++ b/data-index/data-index-service/data-index-service-common/src/test/resources/process_instance_event.json @@ -1,105 +1,23 @@ { "id": "867ff7b4-2e49-49b3-882a-76f65a2c4124", "source": "http://localhost:8080/travels", - "type": "ProcessInstanceEvent", + "type": "ProcessInstanceStateDataEvent", "time": "2022-03-18T15:33:05.608395+10:00", "data": { - "id": "2308e23d-9998-47e9-a772-a078cf5b891b", + "processInstanceId": "2308e23d-9998-47e9-a772-a078cf5b891b", "parentInstanceId": "", - "rootInstanceId": "", + "rootProcessInstanceId": "", "processId": "travels", "version": "1.0", "rootProcessId": "", "processName": "travels", - "startDate": "2022-03-18T15:32:21.887+10:00", - "endDate": null, + "eventDate": "2022-03-18T15:32:21.887+10:00", "state": 1, - "businessKey": "F7RTPS", - "nodeInstances": [ - { - "id": "2b407977-cab4-41ec-b1e6-c34076d9381a", - "nodeId": "3", - "nodeDefinitionId": "_E611283E-30B0-46B9-8305-768A002C7518", - "nodeName": "visasrejected", - "nodeType": "EventNode", - "triggerTime": "2022-03-18T15:33:05.597+10:00", - "leaveTime": null - }, - { - "id": "808f4f5e-6473-448e-aac6-ee1017610c1f", - "nodeId": "4", - "nodeDefinitionId": "_7F75E8BD-3032-47EC-814F-66B197CA99C5", - "nodeName": "visasapproved", - "nodeType": "EventNode", - "triggerTime": "2022-03-18T15:33:05.597+10:00", - "leaveTime": null - }, - { - "id": "2c644506-a5c6-475e-8098-26980d08f796", - "nodeId": "13", - "nodeDefinitionId": "_A8C9F331-8433-411D-91DB-B2060D4F8D14", - "nodeName": "wait for visa decision", - "nodeType": "Split", - "triggerTime": "2022-03-18T15:33:05.595+10:00", - "leaveTime": null - }, - { - "id": "99e2e499-f997-4528-b1fc-2531470a057a", - "nodeId": "1", - "nodeDefinitionId": "_BDA56801-1155-4AF2-94D4-7DAADED2E3C0", - "nodeName": "Send visa application", - "nodeType": "ActionNode", - "triggerTime": "2022-03-18T15:33:05.588+10:00", - "leaveTime": "2022-03-18T15:33:05.595+10:00" - }, - { - "id": "18f6b068-b7bf-4307-a3f9-be5606b726ca", - "nodeId": "6", - "nodeDefinitionId": "_24FBB8D6-EF2D-4DCC-846D-D8C5E21849D2", - "nodeName": "Apply for visa", - "nodeType": "HumanTaskNode", - "triggerTime": "2022-03-18T15:32:22.481+10:00", - "leaveTime": "2022-03-18T15:33:05.588+10:00" - } - ], - "variables": { - "trip": { - "city": "Brisbane", - "country": "Australia", - "begin": "2022-03-01T08:00:00.000+10:00", - "end": "2022-03-31T08:00:00.000+10:00", - "visaRequired": true - }, - "visaApplication": { - "firstName": "Test", - "lastName": "Test", - "city": "Brisbane", - "country": "Australia", - "duration": 150, - "passportNumber": "CDDCDCDS", - "nationality": "Brazilian", - "approved": false - }, - "traveller": { - "firstName": "Test", - "lastName": "Test", - "email": "test@email.com", - "nationality": "Brazilian", - "address": { - "street": "", - "city": "", - "zipCode": "", - "country": "Brazil" - } - } - }, - "error": null, - "roles": null, - "milestones": [] + "businessKey": "F7RTPS" }, "specversion": "1.0", "kogitoprocinstanceid": "2308e23d-9998-47e9-a772-a078cf5b891b", "kogitoprocid": "travels", "kogitoaddons": "cloudevents,process-svg,prometheus-monitoring,monitoring,infinispan-persistence,process-management", - "kogitousertaskist": "1" + "kogitoProcessInstanceState" : "1" } \ No newline at end of file diff --git a/data-index/data-index-service/data-index-service-common/src/test/resources/user_task_instance_event.json b/data-index/data-index-service/data-index-service-common/src/test/resources/user_task_instance_event.json index 690d9b0073..8e461d20c3 100644 --- a/data-index/data-index-service/data-index-service-common/src/test/resources/user_task_instance_event.json +++ b/data-index/data-index-service/data-index-service-common/src/test/resources/user_task_instance_event.json @@ -1,67 +1,24 @@ { "id": "7680a3b6-2c5e-4d97-9964-5602341a1965", "source": "http://localhost:8080/travels", - "type": "UserTaskInstanceEvent", + "type": "UserTaskInstanceStateDataEvent", "time": "2022-03-18T15:33:05.608476+10:00", "data": { - "id": "45fae435-b098-4f27-97cf-a0c107072e8b", - "taskName": "VisaApplication", - "taskDescription": null, - "taskPriority": "1", - "referenceName": "Apply for visa", - "startDate": "2022-03-18T15:32:22.484+10:00", - "completeDate": "2022-03-18T15:33:05.586+10:00", + "eventDate": "2022-03-18T15:32:22.484+10:00", + "eventUser" : "my user", + "userTaskDefinitionId" : "123", + "userTaskInstanceId": "45fae435-b098-4f27-97cf-a0c107072e8b", + + "userTaskName": "VisaApplication", + "userTaskPriority": "1", + "userTaskDescription": null, + + "userTaskReferenceName": "Apply for visa", + "state": "Completed", - "actualOwner": null, - "potentialUsers": [], - "potentialGroups": [], - "excludedUsers": [], - "adminUsers": [], - "adminGroups": [], - "inputs": { - "trip": { - "city": "Brisbane", - "country": "Australia", - "begin": "2022-03-01T08:00:00.000+10:00", - "end": "2022-03-31T08:00:00.000+10:00", - "visaRequired": true - }, - "NodeName": "Apply for visa", - "TaskName": "VisaApplication", - "Priority": "1", - "Skippable": "true", - "traveller": { - "firstName": "Test", - "lastName": "Test", - "email": "test@email.com", - "nationality": "Brazilian", - "address": { - "street": "", - "city": "", - "zipCode": "", - "country": "Brazil" - } - } - }, - "outputs": { - "ActorId": null, - "visaApplication": { - "firstName": "Test", - "lastName": "Test", - "city": "Brisbane", - "country": "Australia", - "duration": 150, - "passportNumber": "CDDCDCDS", - "nationality": "Brazilian", - "approved": false - } - }, - "comments": [], - "attachments": [], - "processInstanceId": "2308e23d-9998-47e9-a772-a078cf5b891b", - "rootProcessInstanceId": "", - "processId": "travels", - "rootProcessId": "" + "actualOwner": "henry", + "processInstanceId": "2308e23d-9998-47e9-a772-a078cf5b891b" + }, "specversion": "1.0", "kogitoprocinstanceid": "2308e23d-9998-47e9-a772-a078cf5b891b", diff --git a/data-index/data-index-storage/data-index-storage-api/src/main/java/org/kie/kogito/index/model/ProcessInstance.java b/data-index/data-index-storage/data-index-storage-api/src/main/java/org/kie/kogito/index/model/ProcessInstance.java index a70e7335af..29a1dd064c 100644 --- a/data-index/data-index-storage/data-index-storage-api/src/main/java/org/kie/kogito/index/model/ProcessInstance.java +++ b/data-index/data-index-storage/data-index-storage-api/src/main/java/org/kie/kogito/index/model/ProcessInstance.java @@ -82,13 +82,8 @@ public void setDefinition(ProcessDefinition definition) { @Override public String toString() { - return "ProcessInstance{" + - "variables=" + variables + - ", nodes=" + nodes + - ", milestones=" + milestones + - ", definition=" + definition + - ", addons=" + addons + - ", error=" + error + - "} " + super.toString(); + return super.toString() + " -> ProcessInstance [variables=" + variables + ", nodes=" + nodes + ", milestones=" + milestones + ", addons=" + addons + ", error=" + error + ", definition=" + + definition + "]"; } + } diff --git a/data-index/data-index-storage/data-index-storage-api/src/main/java/org/kie/kogito/index/model/UserTaskInstanceMeta.java b/data-index/data-index-storage/data-index-storage-api/src/main/java/org/kie/kogito/index/model/UserTaskInstanceMeta.java index 3863a4ea9a..a4c26eab87 100644 --- a/data-index/data-index-storage/data-index-storage-api/src/main/java/org/kie/kogito/index/model/UserTaskInstanceMeta.java +++ b/data-index/data-index-storage/data-index-storage-api/src/main/java/org/kie/kogito/index/model/UserTaskInstanceMeta.java @@ -103,9 +103,7 @@ public String getActualOwner() { } public void setActualOwner(String actualOwner) { - if (actualOwner != null && !actualOwner.trim().isEmpty()) { - this.actualOwner = actualOwner; - } + this.actualOwner = actualOwner; } public Set getAdminGroups() { diff --git a/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/TestUtils.java b/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/TestUtils.java index 95ee2eb5ba..cbc8fbfdd2 100644 --- a/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/TestUtils.java +++ b/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/TestUtils.java @@ -21,7 +21,6 @@ import java.io.InputStream; import java.net.URI; import java.nio.charset.StandardCharsets; -import java.time.Instant; import java.time.ZonedDateTime; import java.time.temporal.ChronoUnit; import java.util.Date; @@ -29,19 +28,24 @@ import java.util.List; import java.util.Map; import java.util.Objects; -import java.util.Set; import java.util.UUID; +import org.apache.commons.lang3.RandomStringUtils; import org.eclipse.microprofile.config.ConfigProvider; -import org.kie.kogito.event.process.AttachmentEventBody; -import org.kie.kogito.event.process.CommentEventBody; -import org.kie.kogito.event.process.MilestoneEventBody; -import org.kie.kogito.event.process.NodeInstanceEventBody; -import org.kie.kogito.event.process.ProcessErrorEventBody; -import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.ProcessInstanceEventBody; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceEventBody; +import org.kie.kogito.event.process.ProcessInstanceErrorDataEvent; +import org.kie.kogito.event.process.ProcessInstanceErrorEventBody; +import org.kie.kogito.event.process.ProcessInstanceEventMetadata; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateEventBody; +import org.kie.kogito.event.process.ProcessInstanceVariableDataEvent; +import org.kie.kogito.event.process.ProcessInstanceVariableEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceAttachmentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceCommentDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceCommentEventBody; +import org.kie.kogito.event.usertask.UserTaskInstanceEventMetadata; +import org.kie.kogito.event.usertask.UserTaskInstanceStateDataEvent; +import org.kie.kogito.event.usertask.UserTaskInstanceStateEventBody; import org.kie.kogito.index.event.KogitoJobCloudEvent; import org.kie.kogito.index.model.Attachment; import org.kie.kogito.index.model.Comment; @@ -56,7 +60,6 @@ import com.fasterxml.jackson.databind.node.ObjectNode; -import static java.util.Collections.emptyMap; import static java.util.Collections.singleton; import static org.kie.kogito.index.json.JsonUtils.getObjectMapper; @@ -93,46 +96,83 @@ public static String readFileContent(String file) throws IOException { } } - public static ProcessInstanceDataEvent getProcessCloudEvent(String processId, String processInstanceId, ProcessInstanceState status, String rootProcessInstanceId, String rootProcessId, + public static ProcessInstanceStateDataEvent getProcessCloudEvent(String processId, String processInstanceId, ProcessInstanceState status, String rootProcessInstanceId, String rootProcessId, String parentProcessInstanceId, String identity) { - ProcessInstanceEventBody body = ProcessInstanceEventBody.create() - .id(processInstanceId) + int eventType = status.equals(ProcessInstanceState.COMPLETED) ? ProcessInstanceStateEventBody.EVENT_TYPE_ENDED : ProcessInstanceStateEventBody.EVENT_TYPE_STARTED; + ProcessInstanceStateEventBody body = ProcessInstanceStateEventBody.create() + .processInstanceId(processInstanceId) .parentInstanceId(parentProcessInstanceId) - .rootInstanceId(rootProcessInstanceId) - .processId(processId) - .version("1.0") + .rootProcessInstanceId(rootProcessInstanceId) .rootProcessId(rootProcessId) - .processName(String.format("%s-name", processId)) - .startDate(new Date()) - .endDate(status == ProcessInstanceState.COMPLETED ? Date.from(Instant.now().plus(1, ChronoUnit.HOURS)) : null) + .processId(processId) + .processVersion("1.0") + .processName(RandomStringUtils.randomAlphabetic(10)) + .eventDate(new Date()) .state(status.ordinal()) - .businessKey(String.format("%s-key", processId)) - .identity(identity) - .variables(getProcessInstanceVariablesMap()) - .milestones(Set.of( - MilestoneEventBody.create() - .id(MILESTONE_ID) - .name("SimpleMilestone") - .status(MilestoneStatus.AVAILABLE.name()) - .build())) + .businessKey(RandomStringUtils.randomAlphabetic(10)) .roles("admin") - .nodeInstance(NodeInstanceEventBody.create() - .id(processInstanceId + "-1") - .triggerTime(new Date()) - .nodeName("Start") - .nodeType("StartNode") - .nodeId("1") - .nodeDefinitionId("StartEvent_1") - .leaveTime(status == ProcessInstanceState.COMPLETED ? Date.from(Instant.now().plus(1, ChronoUnit.HOURS)) : null) - .build()) - .error(status == ProcessInstanceState.ERROR ? ProcessErrorEventBody.create() - .nodeDefinitionId("StartEvent_1") - .errorMessage("Something went wrong") - .build() : null) + .eventUser(identity) + .eventType(eventType) + .build(); + + return new ProcessInstanceStateDataEvent(URI.create("http://localhost:8080/" + processId).toString(), "jobs-management,prometheus-monitoring,process-management", (String) identity, + body.metaData(), body); + + } + + public static ProcessInstanceErrorDataEvent deriveErrorProcessCloudEvent(ProcessInstanceStateDataEvent event, String errorMessage, String nodeDefinition, String nodeInstanceId) { + + ProcessInstanceErrorEventBody body = ProcessInstanceErrorEventBody.create() + .eventDate(new Date()) + .eventUser(event.getData().getEventUser()) + .processId(event.getData().getProcessId()) + .processInstanceId(event.getData().getProcessInstanceId()) + .processVersion(event.getData().getProcessVersion()) + .errorMessage(errorMessage) + .nodeDefinitionId(nodeDefinition) + .nodeInstanceId(nodeInstanceId) + .build(); + + Map metadata = new HashMap<>(); + metadata.put(ProcessInstanceEventMetadata.PROCESS_INSTANCE_ID_META_DATA, event.getKogitoProcessInstanceId()); + metadata.put(ProcessInstanceEventMetadata.PROCESS_VERSION_META_DATA, event.getKogitoProcessInstanceVersion()); + metadata.put(ProcessInstanceEventMetadata.PROCESS_ID_META_DATA, event.getKogitoProcessId()); + metadata.put(ProcessInstanceEventMetadata.PROCESS_INSTANCE_STATE_META_DATA, event.getKogitoProcessInstanceState()); + metadata.put(ProcessInstanceEventMetadata.PROCESS_TYPE_META_DATA, event.getKogitoProcessType()); + metadata.put(ProcessInstanceEventMetadata.PARENT_PROCESS_INSTANCE_ID_META_DATA, event.getKogitoParentProcessInstanceId()); + metadata.put(ProcessInstanceEventMetadata.ROOT_PROCESS_ID_META_DATA, event.getKogitoRootProcessId()); + metadata.put(ProcessInstanceEventMetadata.ROOT_PROCESS_INSTANCE_ID_META_DATA, event.getKogitoRootProcessInstanceId()); + + return new ProcessInstanceErrorDataEvent(event.getSource().toString(), event.getKogitoAddons(), event.getKogitoIdentity(), metadata, body); + + } + + public static ProcessInstanceVariableDataEvent deriveProcessVariableCloudEvent(ProcessInstanceStateDataEvent event, String variableName, Object value) { + + ProcessInstanceVariableEventBody body = ProcessInstanceVariableEventBody.create() + .eventDate(new Date()) + .eventUser(event.getData().getEventUser()) + .variableId(variableName) + .variableName(variableName) + .variableValue(value) + .processId(event.getData().getProcessId()) + .processInstanceId(event.getData().getProcessInstanceId()) + .processVersion(event.getData().getProcessVersion()) .build(); - return new ProcessInstanceDataEvent(URI.create("http://localhost:8080/" + processId).toString(), "jobs-management,prometheus-monitoring,process-management", identity, body.metaData(), body); + Map metadata = new HashMap<>(); + metadata.put(ProcessInstanceEventMetadata.PROCESS_INSTANCE_ID_META_DATA, event.getKogitoProcessInstanceId()); + metadata.put(ProcessInstanceEventMetadata.PROCESS_VERSION_META_DATA, event.getKogitoProcessInstanceVersion()); + metadata.put(ProcessInstanceEventMetadata.PROCESS_ID_META_DATA, event.getKogitoProcessId()); + metadata.put(ProcessInstanceEventMetadata.PROCESS_INSTANCE_STATE_META_DATA, event.getKogitoProcessInstanceState()); + metadata.put(ProcessInstanceEventMetadata.PROCESS_TYPE_META_DATA, event.getKogitoProcessType()); + metadata.put(ProcessInstanceEventMetadata.PARENT_PROCESS_INSTANCE_ID_META_DATA, event.getKogitoParentProcessInstanceId()); + metadata.put(ProcessInstanceEventMetadata.ROOT_PROCESS_ID_META_DATA, event.getKogitoRootProcessId()); + metadata.put(ProcessInstanceEventMetadata.ROOT_PROCESS_INSTANCE_ID_META_DATA, event.getKogitoRootProcessInstanceId()); + + return new ProcessInstanceVariableDataEvent(event.getSource().toString(), event.getKogitoAddons(), event.getKogitoIdentity(), metadata, body); + } public static ProcessInstance getProcessInstance(String processId, String processInstanceId, Integer status, String rootProcessInstanceId, String rootProcessId) { @@ -201,56 +241,101 @@ private static ObjectNode getProcessInstanceVariablesJson() { return getObjectMapper().valueToTree(getProcessInstanceVariablesMap()); } - public static UserTaskInstanceDataEvent getUserTaskCloudEvent(String taskId, String processId, String processInstanceId, String rootProcessInstanceId, String rootProcessId, String state) { - return getUserTaskCloudEvent(taskId, processId, processInstanceId, rootProcessInstanceId, rootProcessId, state, "kogito"); + public static UserTaskInstanceStateDataEvent getUserTaskCloudEvent(String taskId, String processId, String processInstanceId, String rootProcessInstanceId, String rootProcessId, String state) { + return getUserTaskCloudEvent(taskId, processId, processInstanceId, rootProcessInstanceId, rootProcessId, state, "kogito", 1); } - public static UserTaskInstanceDataEvent getUserTaskCloudEvent(String taskId, String processId, String processInstanceId, String rootProcessInstanceId, String rootProcessId, String state, - String actualOwner) { + public static UserTaskInstanceStateDataEvent getUserTaskCloudEvent(String taskId, String processId, String processInstanceId, String rootProcessInstanceId, String rootProcessId, String state, + String actualOwner, Integer eventType) { - UserTaskInstanceEventBody body = UserTaskInstanceEventBody.create() - .id(taskId) + UserTaskInstanceStateEventBody body = UserTaskInstanceStateEventBody.create() + .eventType(eventType) + .userTaskInstanceId(taskId) .state(state) - .taskName("TaskName") - .taskDescription("TaskDescription") - .taskPriority("High") + .userTaskName("TaskName") + .userTaskDescription("TaskDescription") + .userTaskPriority("High") .actualOwner(actualOwner) - .startDate(new Date()) - .completeDate(Date.from(Instant.now().plus(1, ChronoUnit.HOURS))) - .adminGroups(singleton("admin")) - .adminUsers(singleton("kogito")) - .excludedUsers(singleton("excluded")) - .potentialGroups(singleton("potentialGroup")) - .potentialUsers(singleton("potentialUser")) + .eventDate(new Date()) .processInstanceId(processInstanceId) - .rootProcessInstanceId(rootProcessInstanceId) - .processId(processId) - .rootProcessId(rootProcessId) - .comments(singleton(getTaskComment("commentId" + taskId, "kogito", "Comment 1"))) - .attachments(singleton(getTaskAttachment("attachmentId" + taskId, "kogito", "http://linltodoc.com/1", "doc1"))) - .inputs(emptyMap()) - .outputs(emptyMap()) .build(); + UserTaskInstanceStateDataEvent event = new UserTaskInstanceStateDataEvent(URI.create("http://localhost:8080/" + processId).toString(), null, null, body.metaData(), body); + event.setKogitoProcessId(processId); + event.setKogitoProcessInstanceId(processInstanceId); + event.setKogitoRootProcessId(rootProcessId); + event.setKogitoRootProcessInstanceId(rootProcessInstanceId); + return event; + } + + public static UserTaskInstanceAttachmentDataEvent getUserTaskAttachmentEvent(String taskId, String processId, String processInstanceId, String rootProcessInstanceId, String rootProcessId, + String state, + String actualOwner, String attachmentId, URI attachmentURI, String attachmentName, Integer eventType) { + + UserTaskInstanceAttachmentEventBody attachmentBody = UserTaskInstanceAttachmentEventBody.create() + .attachmentId(attachmentId) + .attachmentName(attachmentName) + .attachmentURI(attachmentURI) + .eventDate(new Date()) + .eventType(UserTaskInstanceAttachmentEventBody.EVENT_TYPE_ADDED) + .userTaskInstanceId(taskId) + .build(); + + Map metadata = new HashMap<>(); + metadata.put(UserTaskInstanceEventMetadata.USER_TASK_INSTANCE_ID_META_DATA, taskId); + metadata.put(ProcessInstanceEventMetadata.PROCESS_INSTANCE_ID_META_DATA, processInstanceId); + metadata.put(UserTaskInstanceEventMetadata.USER_TASK_INSTANCE_STATE_META_DATA, state); + + UserTaskInstanceAttachmentDataEvent attachmentEvent = + new UserTaskInstanceAttachmentDataEvent(URI.create("http://localhost:8080/" + processId).toString(), null, null, metadata, attachmentBody); + attachmentEvent.setKogitoProcessId(processId); + attachmentEvent.setKogitoProcessInstanceId(processInstanceId); + attachmentEvent.setKogitoRootProcessId(rootProcessId); + attachmentEvent.setKogitoRootProcessInstanceId(rootProcessInstanceId); + return attachmentEvent; + } + + public static UserTaskInstanceCommentDataEvent getUserTaskCommentEvent(String taskId, String processId, String processInstanceId, String rootProcessInstanceId, String rootProcessId, + String state, + String actualOwner, String commentId, String commentContent, Integer eventType) { + + UserTaskInstanceCommentEventBody attachmentBody = UserTaskInstanceCommentEventBody.create() + .commentId(commentId) + .commentContent(commentContent) + .eventDate(new Date()) + .eventType(UserTaskInstanceAttachmentEventBody.EVENT_TYPE_ADDED) + .userTaskInstanceId(taskId) + .build(); + + Map metadata = new HashMap<>(); + metadata.put(UserTaskInstanceEventMetadata.USER_TASK_INSTANCE_ID_META_DATA, taskId); + metadata.put(ProcessInstanceEventMetadata.PROCESS_INSTANCE_ID_META_DATA, processInstanceId); + metadata.put(UserTaskInstanceEventMetadata.USER_TASK_INSTANCE_STATE_META_DATA, state); - return new UserTaskInstanceDataEvent(URI.create("http://localhost:8080/" + processId).toString(), null, null, body.metaData(), body); + UserTaskInstanceCommentDataEvent attachmentEvent = + new UserTaskInstanceCommentDataEvent(URI.create("http://localhost:8080/" + processId).toString(), null, null, metadata, attachmentBody); + attachmentEvent.setKogitoProcessId(processId); + attachmentEvent.setKogitoProcessInstanceId(processInstanceId); + attachmentEvent.setKogitoRootProcessId(rootProcessId); + attachmentEvent.setKogitoRootProcessInstanceId(rootProcessInstanceId); + return attachmentEvent; } - public static AttachmentEventBody getTaskAttachment(String id, String user, String name, String content) { - return AttachmentEventBody.create() - .id(id) - .updatedBy(user) - .name(name) - .content(content == null ? null : URI.create(content)) - .updatedAt(new Date()) + public static UserTaskInstanceAttachmentEventBody getTaskAttachment(String id, String user, String name, String content) { + return UserTaskInstanceAttachmentEventBody.create() + .attachmentId(id) + .eventUser(user) + .attachmentName(name) + .attachmentURI(content == null ? null : URI.create(content)) + .eventDate(new Date()) .build(); } - public static CommentEventBody getTaskComment(String id, String user, String comment) { - return CommentEventBody.create() - .id(id) - .content(comment) - .updatedBy(user) - .updatedAt(new Date()) + public static UserTaskInstanceCommentEventBody getTaskComment(String id, String user, String comment) { + return UserTaskInstanceCommentEventBody.create() + .commentId(id) + .commentContent(comment) + .eventUser(user) + .eventDate(new Date()) .build(); } diff --git a/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/quarkus/DataIndexInMemoryQuarkusTestResource.java b/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/quarkus/DataIndexInMemoryQuarkusTestResource.java index 9bc75a8335..a59433838d 100644 --- a/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/quarkus/DataIndexInMemoryQuarkusTestResource.java +++ b/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/quarkus/DataIndexInMemoryQuarkusTestResource.java @@ -39,11 +39,8 @@ protected Map getProperties() { properties.put("mp.messaging.outgoing.kogito-processinstances-events.url", dataIndexUrl + "/processes"); properties.put("mp.messaging.outgoing.kogito-usertaskinstances-events.connector", "quarkus-http"); properties.put("mp.messaging.outgoing.kogito-usertaskinstances-events.url", dataIndexUrl + "/tasks"); - properties.put("mp.messaging.outgoing.kogito-variables-events.connector", "quarkus-http"); - properties.put("mp.messaging.outgoing.kogito-variables-events.url", dataIndexUrl); properties.put("mp.messaging.outgoing.kogito-jobs-events.connector", "quarkus-http"); properties.put("mp.messaging.outgoing.kogito-jobs-events.url", dataIndexUrl + "/jobs"); - properties.put("kogito.events.variables.enabled", "false"); return properties; } diff --git a/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/quarkus/http/AbstractDataIndexHttpQuarkusTestResource.java b/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/quarkus/http/AbstractDataIndexHttpQuarkusTestResource.java index 100084dfa4..5b4fabe8e7 100644 --- a/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/quarkus/http/AbstractDataIndexHttpQuarkusTestResource.java +++ b/data-index/data-index-test-utils/src/main/java/org/kie/kogito/index/test/quarkus/http/AbstractDataIndexHttpQuarkusTestResource.java @@ -43,11 +43,8 @@ protected Map getDataIndexConnectionProperties() { properties.put("mp.messaging.outgoing.kogito-processinstances-events.url", dataIndexUrl + "/processes"); properties.put("mp.messaging.outgoing.kogito-usertaskinstances-events.connector", "quarkus-http"); properties.put("mp.messaging.outgoing.kogito-usertaskinstances-events.url", dataIndexUrl + "/tasks"); - properties.put("mp.messaging.outgoing.kogito-variables-events.connector", "quarkus-http"); - properties.put("mp.messaging.outgoing.kogito-variables-events.url", dataIndexUrl); properties.put("mp.messaging.outgoing.kogito-jobs-events.connector", "quarkus-http"); properties.put("mp.messaging.outgoing.kogito-jobs-events.url", dataIndexUrl + "/jobs"); - properties.put("kogito.events.variables.enabled", "false"); return properties; } diff --git a/data-index/kogito-addons-quarkus-data-index-persistence/kogito-addons-quarkus-data-index-persistence-common/runtime/src/main/java/org/kie/kogito/index/addon/DataIndexEventPublisher.java b/data-index/kogito-addons-quarkus-data-index-persistence/kogito-addons-quarkus-data-index-persistence-common/runtime/src/main/java/org/kie/kogito/index/addon/DataIndexEventPublisher.java index ebf34ecdbe..550f37a24e 100644 --- a/data-index/kogito-addons-quarkus-data-index-persistence/kogito-addons-quarkus-data-index-persistence-common/runtime/src/main/java/org/kie/kogito/index/addon/DataIndexEventPublisher.java +++ b/data-index/kogito-addons-quarkus-data-index-persistence/kogito-addons-quarkus-data-index-persistence-common/runtime/src/main/java/org/kie/kogito/index/addon/DataIndexEventPublisher.java @@ -27,9 +27,7 @@ import org.kie.kogito.event.DataEvent; import org.kie.kogito.event.EventPublisher; import org.kie.kogito.event.process.ProcessInstanceDataEvent; -import org.kie.kogito.event.process.UserTaskInstanceDataEvent; -import org.kie.kogito.index.event.ProcessInstanceEventMapper; -import org.kie.kogito.index.event.UserTaskInstanceEventMapper; +import org.kie.kogito.event.usertask.UserTaskInstanceDataEvent; import org.kie.kogito.index.model.Job; import org.kie.kogito.index.service.IndexingService; import org.slf4j.Logger; @@ -50,11 +48,20 @@ public class DataIndexEventPublisher implements EventPublisher { public void publish(DataEvent event) { LOGGER.debug("Sending event to embedded data index: {}", event); switch (event.getType()) { - case "ProcessInstanceEvent": - indexingService.indexProcessInstance(new ProcessInstanceEventMapper().apply((ProcessInstanceDataEvent) event)); + case "ProcessInstanceErrorDataEvent": + case "ProcessInstanceNodeDataEvent": + case "ProcessInstanceSLADataEvent": + case "ProcessInstanceStateDataEvent": + case "ProcessInstanceVariableDataEvent": + indexingService.indexProcessInstanceEvent((ProcessInstanceDataEvent) event); break; - case "UserTaskInstanceEvent": - indexingService.indexUserTaskInstance(new UserTaskInstanceEventMapper().apply((UserTaskInstanceDataEvent) event)); + case "UserTaskInstanceAssignmentDataEvent": + case "UserTaskInstanceAttachmentDataEvent": + case "UserTaskInstanceCommentDataEvent": + case "UserTaskInstanceDeadlineDataEvent": + case "UserTaskInstanceStateDataEvent": + case "UserTaskInstanceVariableDataEvent": + indexingService.indexUserTaskInstanceEvent((UserTaskInstanceDataEvent) event); break; case "JobEvent": try { diff --git a/data-index/kogito-addons-quarkus-data-index-persistence/kogito-addons-quarkus-data-index-persistence-common/runtime/src/test/java/org/kie/kogito/index/addon/DataIndexEventPublisherTest.java b/data-index/kogito-addons-quarkus-data-index-persistence/kogito-addons-quarkus-data-index-persistence-common/runtime/src/test/java/org/kie/kogito/index/addon/DataIndexEventPublisherTest.java index bbe9867547..48a5114b5b 100644 --- a/data-index/kogito-addons-quarkus-data-index-persistence/kogito-addons-quarkus-data-index-persistence-common/runtime/src/test/java/org/kie/kogito/index/addon/DataIndexEventPublisherTest.java +++ b/data-index/kogito-addons-quarkus-data-index-persistence/kogito-addons-quarkus-data-index-persistence-common/runtime/src/test/java/org/kie/kogito/index/addon/DataIndexEventPublisherTest.java @@ -24,9 +24,8 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.kie.kogito.event.AbstractDataEvent; import org.kie.kogito.event.DataEvent; -import org.kie.kogito.event.process.ProcessInstanceDataEvent; +import org.kie.kogito.event.process.ProcessInstanceStateDataEvent; import org.kie.kogito.index.model.Job; -import org.kie.kogito.index.model.ProcessInstance; import org.kie.kogito.index.service.IndexingService; import org.mockito.ArgumentCaptor; import org.mockito.Mock; @@ -70,13 +69,14 @@ public void setup() { @Test void onProcessInstanceEvent() { - ArgumentCaptor eventCaptor = ArgumentCaptor.forClass(ProcessInstance.class); - ProcessInstanceDataEvent event = getProcessCloudEvent(PROCESS_ID, PROCESS_INSTANCE_ID, COMPLETED, + + ArgumentCaptor eventCaptor = ArgumentCaptor.forClass(ProcessInstanceStateDataEvent.class); + ProcessInstanceStateDataEvent event = getProcessCloudEvent(PROCESS_ID, PROCESS_INSTANCE_ID, COMPLETED, ROOT_PROCESS_INSTANCE_ID, ROOT_PROCESS_ID, ROOT_PROCESS_INSTANCE_ID, "currentUser"); dataIndexEventPublisher.publish(event); - verify(indexingService).indexProcessInstance(eventCaptor.capture()); + verify(indexingService).indexProcessInstanceEvent(eventCaptor.capture()); } @Test diff --git a/persistence-commons/persistence-commons-protobuf/src/main/java/org/kie/kogito/persistence/protobuf/ProtobufMonitorService.java b/persistence-commons/persistence-commons-protobuf/src/main/java/org/kie/kogito/persistence/protobuf/ProtobufMonitorService.java index 340e7bbfe7..d1a3eeec5c 100644 --- a/persistence-commons/persistence-commons-protobuf/src/main/java/org/kie/kogito/persistence/protobuf/ProtobufMonitorService.java +++ b/persistence-commons/persistence-commons-protobuf/src/main/java/org/kie/kogito/persistence/protobuf/ProtobufMonitorService.java @@ -15,13 +15,13 @@ */ package org.kie.kogito.persistence.protobuf; -import java.io.File; import java.io.IOException; import java.nio.file.FileSystems; import java.nio.file.FileVisitResult; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.PathMatcher; +import java.nio.file.Paths; import java.nio.file.SimpleFileVisitor; import java.nio.file.WatchEvent; import java.nio.file.WatchKey; @@ -74,16 +74,22 @@ public class ProtobufMonitorService { public void startMonitoring() { if (protoFiles.isPresent()) { String folderPath = protoFiles.get(); - File protoFolder = new File(folderPath); - if (!protoFolder.exists()) { - throw new ProtobufFileMonitorException(format("Could not find proto files folder at: %s", folderPath)); + Path protoFolder = Paths.get(folderPath); + if (!Files.exists(protoFolder)) { + LOGGER.warn("Could not find proto files folder at: {}. Disabling ProtobufMonitorService", folderPath); + return; } - registerFilesFromFolder(protoFolder.toPath()); + if (!Files.isReadable(protoFolder)) { + LOGGER.warn("The folder {} does not have read access. Cannot register protofiles from that folder", folderPath); + return; + } + LOGGER.info("The folder {} is being used to registering files", folderPath); + registerFilesFromFolder(protoFolder); if (Boolean.TRUE.equals(monitor)) { executorService = Executors.newSingleThreadExecutor(); - executorService.submit(new FolderWatcher(registerProtoFile(), protoFolder.toPath())); + executorService.submit(new FolderWatcher(registerProtoFile(), protoFolder)); } } }