pefernan commented on code in PR #4105:
URL:
https://github.com/apache/incubator-kie-kogito-runtimes/pull/4105#discussion_r2494056236
##########
kogito-codegen-modules/kogito-codegen-processes/src/main/resources/class-templates/usertask/UserTasksContainerQuarkusTemplate.java:
##########
@@ -102,7 +102,11 @@ public UserTaskInstance connect(UserTaskInstance
userTaskInstance) {
impl.addEventListener(new
UnitOfWorkUserTaskEventListener(application.unitOfWorkManager()));
instance.setUserTask(application.get(UserTasks.class).userTaskById(instance.getUserTaskId()));
instance.setUserTaskEventSupport(impl);
- instance.setUserTaskLifeCycle(userTaskConfig.userTaskLifeCycle());
+ if (instance.getStatus().getName().equals("Created")) {
Review Comment:
I still don't like this, we cannot rely there's a `Created` state
##########
kogito-codegen-modules/kogito-codegen-processes/src/main/java/org/kie/kogito/codegen/usertask/UserTaskCodegen.java:
##########
@@ -168,6 +177,32 @@ protected Collection<GeneratedFile> internalGenerate() {
return generatedFiles;
}
+ private GeneratedFile generateLifeCycles() {
+ String packageName = context().getPackageName();
+
+ CompilationUnit compilationUnit =
lifeCyclesGenerator.compilationUnitOrThrow("No lifecycle template found for
user tasks");
+ compilationUnit.setPackageDeclaration(packageName);
+
+ var template =
compilationUnit.findFirst(ClassOrInterfaceDeclaration.class)
+ .orElseThrow(() -> new
ProcessCodegenException("UserTaskLifeCyclesTemplate doesn't contain a class or
interface declaration!"));
+ String userTaskLifeCycleId =
context().getApplicationProperty("kogito.usertasks.lifecycle")
Review Comment:
I'd move teh validation outside of the map
```
String userTaskLifeCycleId =
context().getApplicationProperty("kogito.usertasks.lifecycle").orElseGet("kogito");
if(!USERTASK_LIFECYCLES.contains(value)) {
throw ...
}
```
##########
kogito-codegen-modules/kogito-codegen-processes/src/main/java/org/kie/kogito/codegen/usertask/UserTaskCodegenException.java:
##########
@@ -0,0 +1,27 @@
+/*
+ * 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.codegen.usertask;
+
+public class UserTaskCodegenException extends RuntimeException {
Review Comment:
I think you can use `ProcessCodegenException`, no need to creatre a new one
##########
jbpm/jbpm-usertask/src/main/java/org/kie/kogito/usertask/impl/lifecycle/WsHumanTaskLifeCycle.java:
##########
@@ -0,0 +1,413 @@
+/*
+ * 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.usertask.impl.lifecycle;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+
+import org.kie.kogito.auth.IdentityProvider;
+import org.kie.kogito.usertask.UserTaskAssignmentStrategy;
+import org.kie.kogito.usertask.UserTaskInstance;
+import org.kie.kogito.usertask.UserTaskInstanceNotAuthorizedException;
+import org.kie.kogito.usertask.lifecycle.UserTaskLifeCycle;
+import org.kie.kogito.usertask.lifecycle.UserTaskState;
+import org.kie.kogito.usertask.lifecycle.UserTaskState.TerminationType;
+import org.kie.kogito.usertask.lifecycle.UserTaskTransition;
+import org.kie.kogito.usertask.lifecycle.UserTaskTransitionException;
+import org.kie.kogito.usertask.lifecycle.UserTaskTransitionToken;
+
+public class WsHumanTaskLifeCycle implements UserTaskLifeCycle {
+ public static final String WORKFLOW_ENGINE_USER = "WORKFLOW_ENGINE_USER";
+
+ public static final String PARAMETER_USER = "USER";
+ public static final String PARAMETER_NOTIFY = "NOTIFY";
+ private static final String PARAMETER_DELEGATED_USER = "DELEGATED_USER";
+ private static final String PARAMETER_FORWARDED_USERS = "FORWARDED_USERS";
+ private static final String PARAMETER_NOMINATED_USERS = "NOMINATED_USERS";
+
+ private static final String SKIPPABLE = "Skippable";
+
+ // Actions
+ public static final String ACTIVATE = "activate";
+ public static final String NOMINATE = "nominate";
+ public static final String CLAIM = "claim";
+ public static final String DELEGATE = "delegate";
+ public static final String RELEASE = "release";
+ public static final String FORWARD = "forward";
+ public static final String START = "start";
+ public static final String STOP = "stop";
+ public static final String COMPLETE = "complete";
+ public static final String FAIL = "fail";
+ public static final String FAULT = "fault";
+ public static final String EXIT = "exit";
+ public static final String SKIP = "skip";
+ public static final String SUSPEND = "suspend";
+ public static final String RESUME = "resume";
+
+ public static final UserTaskState CREATED = UserTaskState.initalized();
+ public static final UserTaskState READY = UserTaskState.of("Ready");
+ public static final UserTaskState RESERVED = UserTaskState.of("Reserved");
+ public static final UserTaskState INPROGRESS =
UserTaskState.of("InProgress");
+ public static final UserTaskState COMPLETED =
UserTaskState.of("Completed", TerminationType.COMPLETED);
+ public static final UserTaskState FAILED = UserTaskState.of("Failed",
TerminationType.FAILED);
+ public static final UserTaskState ERROR = UserTaskState.of("Error",
TerminationType.ERROR);
+ public static final UserTaskState EXITED = UserTaskState.of("Exited",
TerminationType.EXITED);
+ public static final UserTaskState OBSOLETE = UserTaskState.of("Obsolete",
TerminationType.OBSOLETE);
+ public static final UserTaskState SUSPENDED =
UserTaskState.of("Suspended");
+
+ private final UserTaskTransition T_CREATED_READY_ACTIVATE = new
DefaultUserTransition(ACTIVATE, CREATED, READY, this::activate);
+ private final UserTaskTransition T_CREATED_READY_NOMINATE = new
DefaultUserTransition(NOMINATE, CREATED, READY, this::nominate);
+
+ private final UserTaskTransition T_READY_READY_FORWARD = new
DefaultUserTransition(FORWARD, READY, READY, this::forward);
+ private final UserTaskTransition T_READY_RESERVED_CLAIM = new
DefaultUserTransition(CLAIM, READY, RESERVED, this::claim);
+ private final UserTaskTransition T_READY_RESERVED_DELEGATE = new
DefaultUserTransition(DELEGATE, READY, RESERVED, this::delegate);
+ private final UserTaskTransition T_READY_INPROGRESS = new
DefaultUserTransition(START, READY, INPROGRESS, this::start);
+ private final UserTaskTransition T_READY_ERROR = new
DefaultUserTransition(FAULT, READY, ERROR, this::fault);
+ private final UserTaskTransition T_READY_EXITED = new
DefaultUserTransition(EXIT, READY, EXITED, this::exit);
+ private final UserTaskTransition T_READY_OBSOLETE = new
DefaultUserTransition(SKIP, READY, OBSOLETE, this::skip);
+ private final UserTaskTransition T_READY_SUSPENDED = new
DefaultUserTransition(SUSPEND, READY, SUSPENDED, this::suspend);
+
+ private final UserTaskTransition T_RESERVED_READY_RELEASE = new
DefaultUserTransition(RELEASE, RESERVED, READY, this::release);
+ private final UserTaskTransition T_RESERVED_READY_FORWARD = new
DefaultUserTransition(FORWARD, RESERVED, READY, this::forward);
+ private final UserTaskTransition T_RESERVED_INPROGRESS = new
DefaultUserTransition(START, RESERVED, INPROGRESS, this::start);
+ private final UserTaskTransition T_RESERVED_RESERVED_DELEGATE = new
DefaultUserTransition(DELEGATE, RESERVED, RESERVED, this::delegate);
+ private final UserTaskTransition T_RESERVED_ERROR = new
DefaultUserTransition(FAULT, RESERVED, ERROR, this::fault);
+ private final UserTaskTransition T_RESERVED_EXITED = new
DefaultUserTransition(EXIT, RESERVED, EXITED, this::exit);
+ private final UserTaskTransition T_RESERVED_OBSOLETE = new
DefaultUserTransition(SKIP, RESERVED, OBSOLETE, this::skip);
+ private final UserTaskTransition T_RESERVED_SUSPENDED = new
DefaultUserTransition(SUSPEND, RESERVED, SUSPENDED, this::suspend);
+
+ private final UserTaskTransition T_INPROGRESS_RESERVED_STOP = new
DefaultUserTransition(STOP, INPROGRESS, RESERVED, this::stop);
+ private final UserTaskTransition T_INPROGRESS_RESERVED_DELEGATE = new
DefaultUserTransition(DELEGATE, INPROGRESS, RESERVED, this::delegate);
+ private final UserTaskTransition T_INPROGRESS_READY_RELEASE = new
DefaultUserTransition(RELEASE, INPROGRESS, READY, this::release);
+ private final UserTaskTransition T_INPROGRESS_READY_FORWARD = new
DefaultUserTransition(FORWARD, INPROGRESS, READY, this::forward);
+ private final UserTaskTransition T_INPROGRESS_COMPLETED = new
DefaultUserTransition(COMPLETE, INPROGRESS, COMPLETED, this::complete);
+ private final UserTaskTransition T_INPROGRESS_FAILED = new
DefaultUserTransition(FAIL, INPROGRESS, FAILED, this::fail);
+ private final UserTaskTransition T_INPROGRESS_ERROR = new
DefaultUserTransition(FAULT, INPROGRESS, ERROR, this::fault);
+ private final UserTaskTransition T_INPROGRESS_EXITED = new
DefaultUserTransition(EXIT, INPROGRESS, EXITED, this::exit);
+ private final UserTaskTransition T_INPROGRESS_OBSOLETE = new
DefaultUserTransition(SKIP, INPROGRESS, OBSOLETE, this::skip);
+ private final UserTaskTransition T_INPROGRESS_SUSPENDED = new
DefaultUserTransition(SUSPEND, INPROGRESS, SUSPENDED, this::suspend);
+
+ private final UserTaskTransition T_SUSPENDED_READY = new
DefaultUserTransition(RESUME, SUSPENDED, READY, this::resume);
+ private final UserTaskTransition T_SUSPENDED_RESERVED = new
DefaultUserTransition(RESUME, SUSPENDED, RESERVED, this::resume);
+ private final UserTaskTransition T_SUSPENDED_INPROGRESS = new
DefaultUserTransition(RESUME, SUSPENDED, INPROGRESS, this::resume);
+
+ private List<UserTaskTransition> transitions;
+
+ public WsHumanTaskLifeCycle() {
+ transitions = List.of(
+ T_CREATED_READY_ACTIVATE,
+ T_CREATED_READY_NOMINATE,
+ T_READY_READY_FORWARD,
+ T_READY_RESERVED_CLAIM,
+ T_READY_RESERVED_DELEGATE,
+ T_READY_INPROGRESS,
+ T_READY_ERROR,
+ T_READY_EXITED,
+ T_READY_OBSOLETE,
+ T_READY_SUSPENDED,
+ T_RESERVED_READY_RELEASE,
+ T_RESERVED_READY_FORWARD,
+ T_RESERVED_INPROGRESS,
+ T_RESERVED_RESERVED_DELEGATE,
+ T_RESERVED_ERROR,
+ T_RESERVED_EXITED,
+ T_RESERVED_OBSOLETE,
+ T_RESERVED_SUSPENDED,
+ T_INPROGRESS_RESERVED_STOP,
+ T_INPROGRESS_RESERVED_DELEGATE,
+ T_INPROGRESS_READY_RELEASE,
+ T_INPROGRESS_READY_FORWARD,
+ T_INPROGRESS_COMPLETED,
+ T_INPROGRESS_FAILED,
+ T_INPROGRESS_ERROR,
+ T_INPROGRESS_EXITED,
+ T_INPROGRESS_OBSOLETE,
+ T_INPROGRESS_SUSPENDED,
+ T_SUSPENDED_READY,
+ T_SUSPENDED_RESERVED,
+ T_SUSPENDED_INPROGRESS);
+ }
+
+ @Override
+ public List<UserTaskTransition> allowedTransitions(UserTaskInstance
userTaskInstance, IdentityProvider identity) {
+ checkPermission(userTaskInstance, identity);
+ return transitions.stream()
+ .filter(t -> t.source().equals(userTaskInstance.getStatus())
+ && (!t.id().equals(SKIP) ||
"true".equals(userTaskInstance.getMetadata().get("Skippable"))))
+ .toList();
+ }
+
+ @Override
+ public Optional<UserTaskTransitionToken> transition(UserTaskInstance
userTaskInstance, UserTaskTransitionToken token, IdentityProvider
identityProvider) {
+ checkPermission(userTaskInstance, identityProvider);
+ UserTaskTransition transition = transitions.stream()
+ .filter(t -> t.source().equals(userTaskInstance.getStatus())
&& t.id().equals(token.transitionId()) && t.target().equals(token.target()))
+ .findFirst()
+ .orElseThrow(() -> new UserTaskTransitionException("Invalid
transition from " + userTaskInstance.getStatus()));
+ return transition.executor().execute(userTaskInstance, token,
identityProvider);
+ }
+
+ @Override
+ public UserTaskTransitionToken newCompleteTransitionToken(UserTaskInstance
userTaskInstance, Map<String, Object> data) {
+ return newTransitionToken(COMPLETE, userTaskInstance.getStatus(),
null, data);
+ }
+
+ @Override
+ public UserTaskTransitionToken newAbortTransitionToken(UserTaskInstance
userTaskInstance, Map<String, Object> data) {
+ return newTransitionToken(FAIL, userTaskInstance.getStatus(), null,
data);
+ }
+
+ @Override
+ public UserTaskTransitionToken newTransitionToken(String transitionId,
UserTaskInstance userTaskInstance, Map<String, Object> data) {
+ if (transitionId.equals(ACTIVATE) &&
userTaskInstance.getPotentialUsers().isEmpty()) {
+ return null;
+ }
+ return newTransitionToken(transitionId, userTaskInstance.getStatus(),
(String) userTaskInstance.getMetadata().get("PreviousStatus"), data);
+ }
+
+ public UserTaskTransitionToken newTransitionToken(String transitionId,
UserTaskState state, String previousState, Map<String, Object> data) {
+ var transition = transitions.stream()
+ .filter(e -> e.source().equals(state) &&
e.id().equals(transitionId) && (!transitionId.equals(RESUME) ||
e.target().getName().equals(previousState)))
+ .findAny()
+ .orElseThrow(() -> new UserTaskTransitionException("Invalid
transition " + transitionId + " from " + state));
+
+ return new DefaultUserTaskTransitionToken(transition.id(),
transition.source(), transition.target(), data);
+ }
+
+ public Optional<UserTaskTransitionToken> activate(UserTaskInstance
userTaskInstance, UserTaskTransitionToken token, IdentityProvider
identityProvider) {
+ userTaskInstance.startNotCompletedDeadlines();
+ userTaskInstance.startNotCompletedReassignments();
+
+ String user = assignStrategy(userTaskInstance, identityProvider);
+ if (user != null) {
+ return Optional.of(newTransitionToken(CLAIM, READY, null,
Map.of(PARAMETER_USER, user)));
+ }
+ userTaskInstance.startNotStartedDeadlines();
+ userTaskInstance.startNotStartedReassignments();
+ return Optional.empty();
+ }
+
+ public Optional<UserTaskTransitionToken> nominate(UserTaskInstance
userTaskInstance, UserTaskTransitionToken token, IdentityProvider
identityProvider) {
+ if (userTaskInstance.getAdminUsers().isEmpty()) {
+ throw new UserTaskTransitionException("UserTaskInstance " +
userTaskInstance.getId() + " has no admin users");
+ }
+
Review Comment:
@josedee shouldn't we also check if the identityProvider is part of the
admin groups too?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
