You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@syncope.apache.org by il...@apache.org on 2017/08/28 09:13:20 UTC
[5/8] syncope git commit: [SYNCOPE-1054] Replacing Activiti with
Flowable - still 5.x
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/FlowableUserWorkflowAdapter.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/FlowableUserWorkflowAdapter.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/FlowableUserWorkflowAdapter.java
new file mode 100644
index 0000000..82d1add
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/FlowableUserWorkflowAdapter.java
@@ -0,0 +1,941 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.annotation.Resource;
+import org.activiti.bpmn.converter.BpmnXMLConverter;
+import org.activiti.bpmn.model.BpmnModel;
+import org.activiti.editor.constants.ModelDataJsonConstants;
+import org.activiti.editor.language.json.converter.BpmnJsonConverter;
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.form.FormProperty;
+import org.activiti.engine.form.FormType;
+import org.activiti.engine.form.TaskFormData;
+import org.activiti.engine.history.HistoricActivityInstance;
+import org.activiti.engine.history.HistoricTaskInstance;
+import org.activiti.engine.impl.persistence.entity.HistoricFormPropertyEntity;
+import org.activiti.engine.query.Query;
+import org.activiti.engine.repository.Deployment;
+import org.activiti.engine.repository.Model;
+import org.activiti.engine.repository.ProcessDefinition;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.task.Task;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.syncope.common.lib.SyncopeClientException;
+import org.apache.syncope.common.lib.patch.PasswordPatch;
+import org.apache.syncope.common.lib.patch.UserPatch;
+import org.apache.syncope.common.lib.to.UserTO;
+import org.apache.syncope.common.lib.to.WorkflowDefinitionTO;
+import org.apache.syncope.common.lib.to.WorkflowFormPropertyTO;
+import org.apache.syncope.common.lib.to.WorkflowFormTO;
+import org.apache.syncope.core.provisioning.api.PropagationByResource;
+import org.apache.syncope.common.lib.types.ResourceOperation;
+import org.apache.syncope.common.lib.types.WorkflowFormPropertyType;
+import org.apache.syncope.core.spring.security.AuthContextUtils;
+import org.apache.syncope.core.spring.BeanUtils;
+import org.apache.syncope.core.persistence.api.attrvalue.validation.InvalidEntityException;
+import org.apache.syncope.core.persistence.api.attrvalue.validation.ParsingValidationException;
+import org.apache.syncope.core.persistence.api.dao.NotFoundException;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.provisioning.api.WorkflowResult;
+import org.apache.syncope.core.workflow.flowable.spring.DomainProcessEngine;
+import org.apache.syncope.core.workflow.api.WorkflowDefinitionFormat;
+import org.apache.syncope.core.workflow.api.WorkflowException;
+import org.apache.syncope.core.workflow.java.AbstractUserWorkflowAdapter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * <a href="http://www.flowable.org/">Flowable</a> based implementation.
+ */
+public class FlowableUserWorkflowAdapter extends AbstractUserWorkflowAdapter {
+
+ protected static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
+
+ protected static final String[] PROPERTY_IGNORE_PROPS = { "type" };
+
+ public static final String WF_PROCESS_ID = "userWorkflow";
+
+ public static final String USER = "user";
+
+ public static final String WF_EXECUTOR = "wfExecutor";
+
+ public static final String FORM_SUBMITTER = "formSubmitter";
+
+ public static final String USER_TO = "userTO";
+
+ public static final String ENABLED = "enabled";
+
+ public static final String USER_PATCH = "userPatch";
+
+ public static final String EMAIL_KIND = "emailKind";
+
+ public static final String TASK = "task";
+
+ public static final String TOKEN = "token";
+
+ public static final String PASSWORD = "password";
+
+ public static final String PROP_BY_RESOURCE = "propByResource";
+
+ public static final String PROPAGATE_ENABLE = "propagateEnable";
+
+ public static final String ENCRYPTED_PWD = "encryptedPwd";
+
+ public static final String TASK_IS_FORM = "taskIsForm";
+
+ public static final String MODEL_DATA_JSON_MODEL = "model";
+
+ public static final String STORE_PASSWORD = "storePassword";
+
+ public static final String EVENT = "event";
+
+ @Resource(name = "adminUser")
+ protected String adminUser;
+
+ @Autowired
+ protected DomainProcessEngine engine;
+
+ @Override
+ public String getPrefix() {
+ return "ACT_";
+ }
+
+ protected void throwException(final ActivitiException e, final String defaultMessage) {
+ if (e.getCause() != null) {
+ if (e.getCause().getCause() instanceof SyncopeClientException) {
+ throw (SyncopeClientException) e.getCause().getCause();
+ } else if (e.getCause().getCause() instanceof ParsingValidationException) {
+ throw (ParsingValidationException) e.getCause().getCause();
+ } else if (e.getCause().getCause() instanceof InvalidEntityException) {
+ throw (InvalidEntityException) e.getCause().getCause();
+ }
+ }
+
+ throw new WorkflowException(defaultMessage, e);
+ }
+
+ protected void updateStatus(final User user) {
+ List<Task> tasks = engine.getTaskService().createTaskQuery().processInstanceId(user.getWorkflowId()).list();
+ if (tasks.isEmpty() || tasks.size() > 1) {
+ LOG.warn("While setting user status: unexpected task number ({})", tasks.size());
+ } else {
+ user.setStatus(tasks.get(0).getTaskDefinitionKey());
+ }
+ }
+
+ protected String getFormTask(final User user) {
+ String result = null;
+
+ List<Task> tasks = engine.getTaskService().createTaskQuery().processInstanceId(user.getWorkflowId()).list();
+ if (tasks.isEmpty() || tasks.size() > 1) {
+ LOG.debug("While checking if form task: unexpected task number ({})", tasks.size());
+ } else {
+ try {
+ TaskFormData formData = engine.getFormService().getTaskFormData(tasks.get(0).getId());
+ if (formData != null && !formData.getFormProperties().isEmpty()) {
+ result = tasks.get(0).getId();
+ }
+ } catch (ActivitiException e) {
+ LOG.warn("Could not get task form data", e);
+ }
+ }
+
+ return result;
+ }
+
+ protected Set<String> getPerformedTasks(final User user) {
+ final Set<String> result = new HashSet<>();
+
+ engine.getHistoryService().createHistoricActivityInstanceQuery().executionId(user.getWorkflowId()).list().
+ forEach((task) -> {
+ result.add(task.getActivityId());
+ });
+
+ return result;
+ }
+
+ /**
+ * Saves resources to be propagated and password for later - after form submission - propagation.
+ *
+ * @param user user
+ * @param password password
+ * @param propByRes current propagation actions against resources
+ */
+ protected void saveForFormSubmit(final User user, final String password, final PropagationByResource propByRes) {
+ String formTaskId = getFormTask(user);
+ if (formTaskId != null) {
+ // SYNCOPE-238: This is needed to simplify the task query in this.getForms()
+ engine.getTaskService().setVariableLocal(formTaskId, TASK_IS_FORM, Boolean.TRUE);
+ engine.getRuntimeService().setVariable(user.getWorkflowId(), PROP_BY_RESOURCE, propByRes);
+ if (propByRes != null) {
+ propByRes.clear();
+ }
+
+ if (StringUtils.isNotBlank(password)) {
+ engine.getRuntimeService().setVariable(user.getWorkflowId(), ENCRYPTED_PWD, encrypt(password));
+ }
+ }
+ }
+
+ @Override
+ protected WorkflowResult<Pair<String, Boolean>> doCreate(
+ final UserTO userTO,
+ final boolean disablePwdPolicyCheck,
+ final Boolean enabled,
+ final boolean storePassword) {
+
+ Map<String, Object> variables = new HashMap<>();
+ variables.put(WF_EXECUTOR, AuthContextUtils.getUsername());
+ variables.put(USER_TO, userTO);
+ variables.put(ENABLED, enabled);
+ variables.put(STORE_PASSWORD, storePassword);
+
+ ProcessInstance processInstance = null;
+ try {
+ processInstance = engine.getRuntimeService().startProcessInstanceByKey(WF_PROCESS_ID, variables);
+ } catch (ActivitiException e) {
+ throwException(e, "While starting " + WF_PROCESS_ID + " instance");
+ }
+
+ User user = engine.getRuntimeService().getVariable(processInstance.getProcessInstanceId(), USER, User.class);
+
+ Boolean updatedEnabled =
+ engine.getRuntimeService().getVariable(processInstance.getProcessInstanceId(), ENABLED, Boolean.class);
+ if (updatedEnabled != null) {
+ user.setSuspended(!updatedEnabled);
+ }
+
+ // this will make UserValidator not to consider password policies at all
+ if (disablePwdPolicyCheck) {
+ user.removeClearPassword();
+ }
+
+ updateStatus(user);
+ user = userDAO.save(user);
+
+ Boolean propagateEnable = engine.getRuntimeService().getVariable(
+ processInstance.getProcessInstanceId(), PROPAGATE_ENABLE, Boolean.class);
+ if (propagateEnable == null) {
+ propagateEnable = enabled;
+ }
+
+ PropagationByResource propByRes = new PropagationByResource();
+ propByRes.set(ResourceOperation.CREATE, userDAO.findAllResourceKeys(user.getKey()));
+
+ saveForFormSubmit(user, userTO.getPassword(), propByRes);
+
+ Set<String> tasks = getPerformedTasks(user);
+
+ return new WorkflowResult<>(
+ new ImmutablePair<>(user.getKey(), propagateEnable), propByRes, tasks);
+ }
+
+ protected Set<String> doExecuteTask(final User user, final String task, final Map<String, Object> moreVariables) {
+ Set<String> preTasks = getPerformedTasks(user);
+
+ Map<String, Object> variables = new HashMap<>();
+ variables.put(WF_EXECUTOR, AuthContextUtils.getUsername());
+ variables.put(TASK, task);
+
+ // using BeanUtils to access all user's properties and trigger lazy loading - we are about to
+ // serialize a User instance for availability within workflow tasks, and this breaks transactions
+ BeanUtils.copyProperties(user, entityFactory.newEntity(User.class));
+ variables.put(USER, user);
+
+ if (moreVariables != null && !moreVariables.isEmpty()) {
+ variables.putAll(moreVariables);
+ }
+
+ if (StringUtils.isBlank(user.getWorkflowId())) {
+ throw new WorkflowException(new NotFoundException("Empty workflow id for " + user));
+ }
+
+ List<Task> tasks = engine.getTaskService().createTaskQuery().processInstanceId(user.getWorkflowId()).list();
+ if (tasks.size() == 1) {
+ try {
+ engine.getTaskService().complete(tasks.get(0).getId(), variables);
+ } catch (ActivitiException e) {
+ throwException(e, "While completing task '" + tasks.get(0).getName() + "' for " + user);
+ }
+ } else {
+ LOG.warn("Expected a single task, found {}", tasks.size());
+ }
+
+ Set<String> postTasks = getPerformedTasks(user);
+ postTasks.removeAll(preTasks);
+ postTasks.add(task);
+
+ return postTasks;
+ }
+
+ @Override
+ protected WorkflowResult<String> doActivate(final User user, final String token) {
+ Set<String> tasks = doExecuteTask(user, "activate", Collections.singletonMap(TOKEN, (Object) token));
+
+ updateStatus(user);
+ User updated = userDAO.save(user);
+
+ return new WorkflowResult<>(updated.getKey(), null, tasks);
+ }
+
+ @Override
+ protected WorkflowResult<Pair<UserPatch, Boolean>> doUpdate(final User user, final UserPatch userPatch) {
+ Set<String> tasks = doExecuteTask(user, "update", Collections.singletonMap(USER_PATCH, (Object) userPatch));
+
+ updateStatus(user);
+ User updated = userDAO.save(user);
+
+ PropagationByResource propByRes = engine.getRuntimeService().getVariable(
+ user.getWorkflowId(), PROP_BY_RESOURCE, PropagationByResource.class);
+ UserPatch updatedPatch = engine.getRuntimeService().getVariable(
+ user.getWorkflowId(), USER_PATCH, UserPatch.class);
+
+ saveForFormSubmit(
+ updated, updatedPatch.getPassword() == null ? null : updatedPatch.getPassword().getValue(), propByRes);
+
+ Boolean propagateEnable = engine.getRuntimeService().getVariable(
+ user.getWorkflowId(), PROPAGATE_ENABLE, Boolean.class);
+
+ return new WorkflowResult<>(
+ new ImmutablePair<>(updatedPatch, propagateEnable), propByRes, tasks);
+ }
+
+ @Override
+ public WorkflowResult<String> requestCertify(final User user) {
+ String authUser = AuthContextUtils.getUsername();
+ engine.getRuntimeService().setVariable(user.getWorkflowId(), FORM_SUBMITTER, authUser);
+
+ LOG.debug("Executing request-certify");
+ Set<String> performedTasks = doExecuteTask(user, "request-certify", null);
+
+ PropagationByResource propByRes = engine.getRuntimeService().getVariable(
+ user.getWorkflowId(), PROP_BY_RESOURCE, PropagationByResource.class);
+
+ saveForFormSubmit(user, null, propByRes);
+
+ return new WorkflowResult<>(user.getKey(), null, performedTasks);
+ }
+
+ @Override
+ protected WorkflowResult<String> doSuspend(final User user) {
+ Set<String> performedTasks = doExecuteTask(user, "suspend", null);
+ updateStatus(user);
+ User updated = userDAO.save(user);
+
+ return new WorkflowResult<>(updated.getKey(), null, performedTasks);
+ }
+
+ @Override
+ protected WorkflowResult<String> doReactivate(final User user) {
+ Set<String> performedTasks = doExecuteTask(user, "reactivate", null);
+ updateStatus(user);
+
+ User updated = userDAO.save(user);
+
+ return new WorkflowResult<>(updated.getKey(), null, performedTasks);
+ }
+
+ @Override
+ protected void doRequestPasswordReset(final User user) {
+ Map<String, Object> variables = new HashMap<>(2);
+ variables.put(USER_TO, dataBinder.getUserTO(user, true));
+ variables.put(EVENT, "requestPasswordReset");
+
+ doExecuteTask(user, "requestPasswordReset", variables);
+ userDAO.save(user);
+ }
+
+ @Override
+ protected WorkflowResult<Pair<UserPatch, Boolean>> doConfirmPasswordReset(
+ final User user, final String token, final String password) {
+
+ Map<String, Object> variables = new HashMap<>(4);
+ variables.put(TOKEN, token);
+ variables.put(PASSWORD, password);
+ variables.put(USER_TO, dataBinder.getUserTO(user, true));
+ variables.put(EVENT, "confirmPasswordReset");
+
+ Set<String> tasks = doExecuteTask(user, "confirmPasswordReset", variables);
+
+ userDAO.save(user);
+
+ PropagationByResource propByRes = engine.getRuntimeService().getVariable(
+ user.getWorkflowId(), PROP_BY_RESOURCE, PropagationByResource.class);
+ UserPatch updatedPatch = engine.getRuntimeService().getVariable(
+ user.getWorkflowId(), USER_PATCH, UserPatch.class);
+ Boolean propagateEnable = engine.getRuntimeService().getVariable(
+ user.getWorkflowId(), PROPAGATE_ENABLE, Boolean.class);
+
+ return new WorkflowResult<>(
+ new ImmutablePair<>(updatedPatch, propagateEnable), propByRes, tasks);
+ }
+
+ @Override
+ protected void doDelete(final User user) {
+ doExecuteTask(user, "delete", null);
+
+ PropagationByResource propByRes = new PropagationByResource();
+ propByRes.set(ResourceOperation.DELETE, userDAO.findAllResourceKeys(user.getKey()));
+
+ saveForFormSubmit(user, null, propByRes);
+
+ if (engine.getRuntimeService().createProcessInstanceQuery().
+ processInstanceId(user.getWorkflowId()).active().list().isEmpty()) {
+
+ userDAO.delete(user.getKey());
+
+ if (!engine.getHistoryService().createHistoricProcessInstanceQuery().
+ processInstanceId(user.getWorkflowId()).list().isEmpty()) {
+
+ engine.getHistoryService().deleteHistoricProcessInstance(user.getWorkflowId());
+ }
+ } else {
+ updateStatus(user);
+ userDAO.save(user);
+ }
+ }
+
+ @Override
+ public WorkflowResult<String> execute(final UserTO userTO, final String taskId) {
+ User user = userDAO.authFind(userTO.getKey());
+
+ final Map<String, Object> variables = new HashMap<>();
+ variables.put(USER_TO, userTO);
+
+ Set<String> performedTasks = doExecuteTask(user, taskId, variables);
+ updateStatus(user);
+ User updated = userDAO.save(user);
+
+ return new WorkflowResult<>(updated.getKey(), null, performedTasks);
+ }
+
+ protected WorkflowFormPropertyType fromFlowableFormType(final FormType flowableFormType) {
+ WorkflowFormPropertyType result = WorkflowFormPropertyType.String;
+
+ if ("string".equals(flowableFormType.getName())) {
+ result = WorkflowFormPropertyType.String;
+ }
+ if ("long".equals(flowableFormType.getName())) {
+ result = WorkflowFormPropertyType.Long;
+ }
+ if ("enum".equals(flowableFormType.getName())) {
+ result = WorkflowFormPropertyType.Enum;
+ }
+ if ("date".equals(flowableFormType.getName())) {
+ result = WorkflowFormPropertyType.Date;
+ }
+ if ("boolean".equals(flowableFormType.getName())) {
+ result = WorkflowFormPropertyType.Boolean;
+ }
+
+ return result;
+ }
+
+ protected WorkflowFormTO getFormTO(final Task task) {
+ return getFormTO(task, engine.getFormService().getTaskFormData(task.getId()));
+ }
+
+ protected WorkflowFormTO getFormTO(final Task task, final TaskFormData fd) {
+ WorkflowFormTO formTO =
+ getFormTO(task.getProcessInstanceId(), task.getId(), fd.getFormKey(), fd.getFormProperties());
+ BeanUtils.copyProperties(task, formTO);
+
+ return formTO;
+ }
+
+ protected WorkflowFormTO getFormTO(final HistoricTaskInstance task) {
+ final List<HistoricFormPropertyEntity> props = new ArrayList<>();
+
+ engine.getHistoryService().createHistoricDetailQuery().taskId(task.getId()).list().stream().
+ filter(historicDetail -> (historicDetail instanceof HistoricFormPropertyEntity)).
+ forEachOrdered(historicDetail -> {
+ props.add((HistoricFormPropertyEntity) historicDetail);
+ });
+
+ WorkflowFormTO formTO = getHistoricFormTO(
+ task.getProcessInstanceId(), task.getId(), task.getFormKey(), props);
+ BeanUtils.copyProperties(task, formTO);
+
+ HistoricActivityInstance historicActivityInstance = engine.getHistoryService().
+ createHistoricActivityInstanceQuery().
+ executionId(task.getExecutionId()).activityType("userTask").activityName(task.getName()).singleResult();
+
+ if (historicActivityInstance != null) {
+ formTO.setCreateTime(historicActivityInstance.getStartTime());
+ formTO.setDueDate(historicActivityInstance.getEndTime());
+ }
+
+ return formTO;
+ }
+
+ protected WorkflowFormTO getHistoricFormTO(
+ final String processInstanceId,
+ final String taskId,
+ final String formKey,
+ final List<HistoricFormPropertyEntity> props) {
+
+ WorkflowFormTO formTO = new WorkflowFormTO();
+
+ User user = userDAO.findByWorkflowId(processInstanceId);
+ if (user == null) {
+ throw new NotFoundException("User with workflow id " + processInstanceId);
+ }
+ formTO.setUsername(user.getUsername());
+
+ formTO.setTaskId(taskId);
+ formTO.setKey(formKey);
+
+ formTO.setUserTO(engine.getRuntimeService().getVariable(processInstanceId, USER_TO, UserTO.class));
+ formTO.setUserPatch(engine.getRuntimeService().getVariable(processInstanceId, USER_PATCH, UserPatch.class));
+
+ props.stream().map(prop -> {
+ WorkflowFormPropertyTO propertyTO = new WorkflowFormPropertyTO();
+ propertyTO.setId(prop.getPropertyId());
+ propertyTO.setName(prop.getPropertyId());
+ propertyTO.setValue(prop.getPropertyValue());
+ return propertyTO;
+ }).forEachOrdered(propertyTO -> {
+ formTO.getProperties().add(propertyTO);
+ });
+
+ return formTO;
+ }
+
+ @SuppressWarnings("unchecked")
+ protected WorkflowFormTO getFormTO(
+ final String processInstanceId,
+ final String taskId,
+ final String formKey,
+ final List<FormProperty> properties) {
+
+ WorkflowFormTO formTO = new WorkflowFormTO();
+
+ User user = userDAO.findByWorkflowId(processInstanceId);
+ if (user == null) {
+ throw new NotFoundException("User with workflow id " + processInstanceId);
+ }
+ formTO.setUsername(user.getUsername());
+
+ formTO.setTaskId(taskId);
+ formTO.setKey(formKey);
+
+ formTO.setUserTO(engine.getRuntimeService().getVariable(processInstanceId, USER_TO, UserTO.class));
+ formTO.setUserPatch(engine.getRuntimeService().getVariable(processInstanceId, USER_PATCH, UserPatch.class));
+
+ properties.stream().map(fProp -> {
+ WorkflowFormPropertyTO propertyTO = new WorkflowFormPropertyTO();
+ BeanUtils.copyProperties(fProp, propertyTO, PROPERTY_IGNORE_PROPS);
+ propertyTO.setType(fromFlowableFormType(fProp.getType()));
+ if (propertyTO.getType() == WorkflowFormPropertyType.Date) {
+ propertyTO.setDatePattern((String) fProp.getType().getInformation("datePattern"));
+ }
+ if (propertyTO.getType() == WorkflowFormPropertyType.Enum) {
+ propertyTO.getEnumValues().putAll((Map<String, String>) fProp.getType().getInformation("values"));
+ }
+ return propertyTO;
+ }).forEachOrdered(propertyTO -> {
+ formTO.getProperties().add(propertyTO);
+ });
+
+ return formTO;
+ }
+
+ @Transactional(readOnly = true)
+ @Override
+ public List<WorkflowFormTO> getForms() {
+ List<WorkflowFormTO> forms = new ArrayList<>();
+
+ String authUser = AuthContextUtils.getUsername();
+ if (adminUser.equals(authUser)) {
+ forms.addAll(getForms(engine.getTaskService().createTaskQuery().
+ taskVariableValueEquals(TASK_IS_FORM, Boolean.TRUE)));
+ } else {
+ User user = userDAO.findByUsername(authUser);
+ if (user == null) {
+ throw new NotFoundException("Syncope User " + authUser);
+ }
+
+ forms.addAll(getForms(engine.getTaskService().createTaskQuery().
+ taskVariableValueEquals(TASK_IS_FORM, Boolean.TRUE).
+ taskCandidateOrAssigned(user.getKey())));
+
+ List<String> candidateGroups = new ArrayList<>();
+ userDAO.findAllGroupNames(user).forEach(group -> {
+ candidateGroups.add(group);
+ });
+ if (!candidateGroups.isEmpty()) {
+ forms.addAll(getForms(engine.getTaskService().createTaskQuery().
+ taskVariableValueEquals(TASK_IS_FORM, Boolean.TRUE).
+ taskCandidateGroupIn(candidateGroups)));
+ }
+ }
+
+ return forms;
+ }
+
+ protected <T extends Query<?, ?>, U extends Object> List<WorkflowFormTO> getForms(final Query<T, U> query) {
+ List<WorkflowFormTO> forms = new ArrayList<>();
+
+ query.list().forEach(obj -> {
+ try {
+ if (obj instanceof HistoricTaskInstance) {
+ forms.add(getFormTO((HistoricTaskInstance) obj));
+ } else if (obj instanceof Task) {
+ forms.add(getFormTO((Task) obj));
+ } else {
+ throw new ActivitiException(
+ "Failure retrieving form", new IllegalArgumentException("Invalid task type"));
+ }
+ } catch (ActivitiException e) {
+ LOG.debug("No form found for task {}", obj, e);
+ }
+ });
+
+ return forms;
+ }
+
+ @Override
+ public WorkflowFormTO getForm(final String workflowId) {
+ Task task;
+ try {
+ task = engine.getTaskService().createTaskQuery().processInstanceId(workflowId).singleResult();
+ } catch (ActivitiException e) {
+ throw new WorkflowException("While reading form for workflow instance " + workflowId, e);
+ }
+
+ TaskFormData formData;
+ try {
+ formData = engine.getFormService().getTaskFormData(task.getId());
+ } catch (ActivitiException e) {
+ LOG.debug("No form found for task {}", task.getId(), e);
+ formData = null;
+ }
+
+ WorkflowFormTO result = null;
+ if (formData != null && !formData.getFormProperties().isEmpty()) {
+ result = getFormTO(task);
+ }
+
+ return result;
+ }
+
+ protected Pair<Task, TaskFormData> checkTask(final String taskId, final String authUser) {
+ Task task;
+ try {
+ task = engine.getTaskService().createTaskQuery().taskId(taskId).singleResult();
+ if (task == null) {
+ throw new ActivitiException("NULL result");
+ }
+ } catch (ActivitiException e) {
+ throw new NotFoundException("Flowable Task " + taskId, e);
+ }
+
+ TaskFormData formData;
+ try {
+ formData = engine.getFormService().getTaskFormData(task.getId());
+ } catch (ActivitiException e) {
+ throw new NotFoundException("Form for Flowable Task " + taskId, e);
+ }
+
+ if (!adminUser.equals(authUser)) {
+ User user = userDAO.findByUsername(authUser);
+ if (user == null) {
+ throw new NotFoundException("Syncope User " + authUser);
+ }
+ }
+
+ return new ImmutablePair<>(task, formData);
+ }
+
+ @Override
+ public WorkflowFormTO claimForm(final String taskId) {
+ String authUser = AuthContextUtils.getUsername();
+ Pair<Task, TaskFormData> checked = checkTask(taskId, authUser);
+
+ if (!adminUser.equals(authUser)) {
+ List<Task> tasksForUser = engine.getTaskService().createTaskQuery().taskId(taskId).taskCandidateUser(
+ authUser).list();
+ if (tasksForUser.isEmpty()) {
+ throw new WorkflowException(
+ new IllegalArgumentException(authUser + " is not candidate for task " + taskId));
+ }
+ }
+
+ Task task;
+ try {
+ engine.getTaskService().setOwner(taskId, authUser);
+ task = engine.getTaskService().createTaskQuery().taskId(taskId).singleResult();
+ } catch (ActivitiException e) {
+ throw new WorkflowException("While reading task " + taskId, e);
+ }
+
+ return getFormTO(task, checked.getValue());
+ }
+
+ private Map<String, String> getPropertiesForSubmit(final WorkflowFormTO form) {
+ Map<String, String> props = new HashMap<>();
+ form.getProperties().stream().
+ filter(prop -> (prop.isWritable())).
+ forEachOrdered(prop -> {
+ props.put(prop.getId(), prop.getValue());
+ });
+
+ return Collections.unmodifiableMap(props);
+ }
+
+ @Override
+ public WorkflowResult<UserPatch> submitForm(final WorkflowFormTO form) {
+ String authUser = AuthContextUtils.getUsername();
+ Pair<Task, TaskFormData> checked = checkTask(form.getTaskId(), authUser);
+
+ if (!checked.getKey().getOwner().equals(authUser)) {
+ throw new WorkflowException(new IllegalArgumentException("Task " + form.getTaskId() + " assigned to "
+ + checked.getKey().getOwner() + " but submitted by " + authUser));
+ }
+
+ User user = userDAO.findByWorkflowId(checked.getKey().getProcessInstanceId());
+ if (user == null) {
+ throw new NotFoundException("User with workflow id " + checked.getKey().getProcessInstanceId());
+ }
+
+ Set<String> preTasks = getPerformedTasks(user);
+ try {
+ engine.getFormService().submitTaskFormData(form.getTaskId(), getPropertiesForSubmit(form));
+ engine.getRuntimeService().setVariable(user.getWorkflowId(), FORM_SUBMITTER, authUser);
+ } catch (ActivitiException e) {
+ throwException(e, "While submitting form for task " + form.getTaskId());
+ }
+
+ Set<String> postTasks = getPerformedTasks(user);
+ postTasks.removeAll(preTasks);
+ postTasks.add(form.getTaskId());
+
+ updateStatus(user);
+ User updated = userDAO.save(user);
+
+ // see if there is any propagation to be done
+ PropagationByResource propByRes = engine.getRuntimeService().getVariable(
+ user.getWorkflowId(), PROP_BY_RESOURCE, PropagationByResource.class);
+
+ // fetch - if available - the encrypted password
+ String clearPassword = null;
+ String encryptedPwd = engine.getRuntimeService().getVariable(user.getWorkflowId(), ENCRYPTED_PWD, String.class);
+ if (StringUtils.isNotBlank(encryptedPwd)) {
+ clearPassword = decrypt(encryptedPwd);
+ }
+
+ // supports approval chains
+ saveForFormSubmit(user, clearPassword, propByRes);
+
+ UserPatch userPatch = engine.getRuntimeService().getVariable(user.getWorkflowId(), USER_PATCH, UserPatch.class);
+ if (userPatch == null) {
+ userPatch = new UserPatch();
+ userPatch.setKey(updated.getKey());
+ userPatch.setPassword(new PasswordPatch.Builder().onSyncope(true).value(clearPassword).build());
+
+ if (propByRes != null) {
+ userPatch.getPassword().getResources().addAll(propByRes.get(ResourceOperation.CREATE));
+ }
+ }
+
+ return new WorkflowResult<>(userPatch, propByRes, postTasks);
+ }
+
+ protected Model getModel(final ProcessDefinition procDef) {
+ try {
+ Model model = engine.getRepositoryService().createModelQuery().
+ deploymentId(procDef.getDeploymentId()).singleResult();
+ if (model == null) {
+ throw new NotFoundException("Could not find Model for deployment " + procDef.getDeploymentId());
+ }
+ return model;
+ } catch (Exception e) {
+ throw new WorkflowException("While accessing process " + procDef.getKey(), e);
+ }
+ }
+
+ @Override
+ public List<WorkflowDefinitionTO> getDefinitions() {
+ try {
+ return engine.getRepositoryService().createProcessDefinitionQuery().latestVersion().list().stream().
+ map(procDef -> {
+ WorkflowDefinitionTO defTO = new WorkflowDefinitionTO();
+ defTO.setKey(procDef.getKey());
+ defTO.setName(procDef.getName());
+
+ try {
+ defTO.setModelId(getModel(procDef).getId());
+ } catch (NotFoundException e) {
+ LOG.warn("No model found for definition {}, ignoring", procDef.getDeploymentId(), e);
+ }
+
+ defTO.setMain(WF_PROCESS_ID.equals(procDef.getKey()));
+
+ return defTO;
+ }).collect(Collectors.toList());
+ } catch (ActivitiException e) {
+ throw new WorkflowException("While listing available process definitions", e);
+ }
+ }
+
+ protected ProcessDefinition getProcessDefinitionByKey(final String key) {
+ try {
+ return engine.getRepositoryService().createProcessDefinitionQuery().
+ processDefinitionKey(key).latestVersion().singleResult();
+ } catch (ActivitiException e) {
+ throw new WorkflowException("While accessing process " + key, e);
+ }
+
+ }
+
+ protected ProcessDefinition getProcessDefinitionByDeploymentId(final String deploymentId) {
+ try {
+ return engine.getRepositoryService().createProcessDefinitionQuery().
+ deploymentId(deploymentId).latestVersion().singleResult();
+ } catch (ActivitiException e) {
+ throw new WorkflowException("While accessing deployment " + deploymentId, e);
+ }
+
+ }
+
+ protected void exportProcessModel(final String key, final OutputStream os) {
+ Model model = getModel(getProcessDefinitionByKey(key));
+
+ try {
+ ObjectNode modelNode = (ObjectNode) OBJECT_MAPPER.readTree(model.getMetaInfo());
+ modelNode.put(ModelDataJsonConstants.MODEL_ID, model.getId());
+ modelNode.replace(MODEL_DATA_JSON_MODEL,
+ OBJECT_MAPPER.readTree(engine.getRepositoryService().getModelEditorSource(model.getId())));
+
+ os.write(modelNode.toString().getBytes());
+ } catch (IOException e) {
+ LOG.error("While exporting workflow definition {}", model.getId(), e);
+ }
+ }
+
+ protected void exportProcessResource(final String deploymentId, final String resourceName, final OutputStream os) {
+ InputStream procDefIS = engine.getRepositoryService().
+ getResourceAsStream(deploymentId, resourceName);
+ try {
+ IOUtils.copy(procDefIS, os);
+ } catch (IOException e) {
+ LOG.error("While exporting {}", resourceName, e);
+ } finally {
+ IOUtils.closeQuietly(procDefIS);
+ }
+ }
+
+ @Override
+ public void exportDefinition(final String key, final WorkflowDefinitionFormat format, final OutputStream os) {
+ switch (format) {
+ case JSON:
+ exportProcessModel(key, os);
+ break;
+
+ case XML:
+ default:
+ ProcessDefinition procDef = getProcessDefinitionByKey(key);
+ exportProcessResource(procDef.getDeploymentId(), procDef.getResourceName(), os);
+ }
+ }
+
+ @Override
+ public void exportDiagram(final String key, final OutputStream os) {
+ ProcessDefinition procDef = getProcessDefinitionByKey(key);
+ if (procDef == null) {
+ throw new NotFoundException("Workflow process definition for " + key);
+ }
+ exportProcessResource(procDef.getDeploymentId(), procDef.getDiagramResourceName(), os);
+ }
+
+ @Override
+ public void importDefinition(final String key, final WorkflowDefinitionFormat format, final String definition) {
+ ProcessDefinition procDef = getProcessDefinitionByKey(key);
+ String resourceName = procDef == null ? key + ".bpmn20.xml" : procDef.getResourceName();
+ Deployment deployment;
+ switch (format) {
+ case JSON:
+ JsonNode definitionNode;
+ try {
+ definitionNode = OBJECT_MAPPER.readTree(definition);
+ if (definitionNode.has(MODEL_DATA_JSON_MODEL)) {
+ definitionNode = definitionNode.get(MODEL_DATA_JSON_MODEL);
+ }
+ if (!definitionNode.has(BpmnJsonConverter.EDITOR_CHILD_SHAPES)) {
+ throw new IllegalArgumentException(
+ "Could not find JSON node " + BpmnJsonConverter.EDITOR_CHILD_SHAPES);
+ }
+
+ BpmnModel bpmnModel = new BpmnJsonConverter().convertToBpmnModel(definitionNode);
+ deployment = FlowableDeployUtils.deployDefinition(
+ engine,
+ resourceName,
+ new BpmnXMLConverter().convertToXML(bpmnModel));
+ } catch (Exception e) {
+ throw new WorkflowException("While creating or updating process " + key, e);
+ }
+ break;
+
+ case XML:
+ default:
+ deployment = FlowableDeployUtils.deployDefinition(
+ engine,
+ resourceName,
+ definition.getBytes());
+ }
+
+ procDef = getProcessDefinitionByDeploymentId(deployment.getId());
+ if (!key.equals(procDef.getKey())) {
+ throw new WorkflowException("Mismatching key: expected " + key + ", found " + procDef.getKey());
+ }
+ FlowableDeployUtils.deployModel(engine, procDef);
+ }
+
+ @Override
+ public void deleteDefinition(final String key) {
+ ProcessDefinition procDef = getProcessDefinitionByKey(key);
+ if (WF_PROCESS_ID.equals(procDef.getKey())) {
+ throw new WorkflowException("Cannot delete the main process " + WF_PROCESS_ID);
+ }
+
+ try {
+ engine.getRepositoryService().deleteDeployment(procDef.getDeploymentId());
+ } catch (Exception e) {
+ throw new WorkflowException("While deleting " + key, e);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/FlowableUtils.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/FlowableUtils.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/FlowableUtils.java
new file mode 100644
index 0000000..b6a0fa6
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/FlowableUtils.java
@@ -0,0 +1,31 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable;
+
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.springframework.transaction.annotation.Transactional;
+
+public class FlowableUtils {
+
+ @Transactional(readOnly = true)
+ public boolean isUserIngroup(final User user, final String groupName) {
+ return user.getMemberships().stream().
+ anyMatch(membership -> groupName != null && groupName.equals(membership.getRightEnd().getName()));
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeEntitiesVariableType.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeEntitiesVariableType.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeEntitiesVariableType.java
new file mode 100644
index 0000000..88b43ac
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeEntitiesVariableType.java
@@ -0,0 +1,35 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable;
+
+import org.activiti.engine.impl.variable.SerializableType;
+import org.apache.syncope.core.persistence.api.entity.Entity;
+
+/**
+ * Flowable variable type for handling Syncope entities as Flowable variables.
+ * Main purpose: avoid Flowable to handle Syncope entities as JPA entities,
+ * since this can cause troubles with transactions.
+ */
+public class SyncopeEntitiesVariableType extends SerializableType {
+
+ @Override
+ public boolean isAbleToStore(final Object value) {
+ return value instanceof Entity;
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeGroupManager.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeGroupManager.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeGroupManager.java
new file mode 100644
index 0000000..f73e45d
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeGroupManager.java
@@ -0,0 +1,122 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.activiti.engine.identity.Group;
+import org.activiti.engine.identity.GroupQuery;
+import org.activiti.engine.impl.GroupQueryImpl;
+import org.activiti.engine.impl.Page;
+import org.activiti.engine.impl.persistence.entity.GroupEntity;
+import org.activiti.engine.impl.persistence.entity.GroupIdentityManager;
+import org.apache.syncope.core.persistence.api.dao.GroupDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class SyncopeGroupManager implements GroupIdentityManager, SyncopeSession {
+
+ @Autowired
+ private UserDAO userDAO;
+
+ @Autowired
+ private GroupDAO groupDAO;
+
+ @Override
+ public Class<?> getType() {
+ return GroupIdentityManager.class;
+ }
+
+ @Override
+ public Group createNewGroup(final String groupId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public GroupQuery createNewGroupQuery() {
+ return new SyncopeGroupQueryImpl(groupDAO);
+ }
+
+ @Override
+ public void deleteGroup(final String groupId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<Group> findGroupsByUser(final String userId) {
+ List<Group> result = Collections.emptyList();
+ User user = userDAO.findByUsername(userId);
+ if (user != null) {
+ result = new ArrayList<>();
+ for (String groupName : userDAO.findAllGroupNames(user)) {
+ result.add(new GroupEntity(groupName));
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ public List<Group> findGroupByQueryCriteria(final GroupQueryImpl query, final Page page) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public long findGroupCountByQueryCriteria(final GroupQueryImpl query) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<Group> findGroupsByNativeQuery(final Map<String, Object> parameterMap, final int firstResult,
+ final int maxResults) {
+
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public long findGroupCountByNativeQuery(final Map<String, Object> parameterMap) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void insertGroup(final Group group) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void updateGroup(final Group updatedGroup) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean isNewGroup(final Group group) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void flush() {
+ }
+
+ @Override
+ public void close() {
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeGroupQueryImpl.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeGroupQueryImpl.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeGroupQueryImpl.java
new file mode 100644
index 0000000..035b1a0
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeGroupQueryImpl.java
@@ -0,0 +1,159 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.identity.Group;
+import org.activiti.engine.identity.GroupQuery;
+import org.activiti.engine.impl.persistence.entity.GroupEntity;
+import org.apache.syncope.core.persistence.api.dao.AnyDAO;
+import org.apache.syncope.core.persistence.api.dao.GroupDAO;
+
+public class SyncopeGroupQueryImpl implements GroupQuery {
+
+ private final GroupDAO groupDAO;
+
+ private String groupId;
+
+ private List<Group> result;
+
+ public SyncopeGroupQueryImpl(final GroupDAO groupDAO) {
+ this.groupDAO = groupDAO;
+ }
+
+ @Override
+ public GroupQuery groupId(final String groupId) {
+ try {
+ this.groupId = groupId;
+ } catch (NumberFormatException e) {
+ // ignore
+ }
+
+ return this;
+ }
+
+ @Override
+ public GroupQuery groupName(final String groupName) {
+ return this;
+ }
+
+ @Override
+ public GroupQuery groupNameLike(final String groupNameLike) {
+ return this;
+ }
+
+ @Override
+ public GroupQuery groupType(final String groupType) {
+ return this;
+ }
+
+ @Override
+ public GroupQuery groupMember(final String groupMemberUserId) {
+ return this;
+ }
+
+ @Override
+ public GroupQuery orderByGroupId() {
+ return this;
+ }
+
+ @Override
+ public GroupQuery orderByGroupName() {
+ return this;
+ }
+
+ @Override
+ public GroupQuery orderByGroupType() {
+ return this;
+ }
+
+ @Override
+ public GroupQuery asc() {
+ return this;
+ }
+
+ @Override
+ public GroupQuery desc() {
+ return this;
+ }
+
+ private Group fromSyncopeGroup(final org.apache.syncope.core.persistence.api.entity.group.Group group) {
+ return new GroupEntity(group.getKey());
+ }
+
+ private void execute() {
+ if (groupId != null) {
+ org.apache.syncope.core.persistence.api.entity.group.Group syncopeGroup = groupDAO.findByName(groupId);
+ if (syncopeGroup == null) {
+ result = Collections.emptyList();
+ } else {
+ result = Collections.singletonList(fromSyncopeGroup(syncopeGroup));
+ }
+ }
+ if (result == null) {
+ result = new ArrayList<>();
+ for (int page = 1; page <= (groupDAO.count() / AnyDAO.DEFAULT_PAGE_SIZE) + 1; page++) {
+ result.addAll(groupDAO.findAll(page, AnyDAO.DEFAULT_PAGE_SIZE).stream().
+ map(group -> fromSyncopeGroup(group)).collect(Collectors.toList()));
+ }
+ }
+ }
+
+ @Override
+ public long count() {
+ if (result == null) {
+ execute();
+ }
+ return result.size();
+ }
+
+ @Override
+ public Group singleResult() {
+ if (result == null) {
+ execute();
+ }
+ if (result.isEmpty()) {
+ throw new ActivitiException("Empty result");
+ }
+
+ return result.get(0);
+ }
+
+ @Override
+ public List<Group> list() {
+ if (result == null) {
+ execute();
+ }
+ return result;
+ }
+
+ @Override
+ public List<Group> listPage(final int firstResult, final int maxResults) {
+ return list();
+ }
+
+ @Override
+ public GroupQuery potentialStarter(final String procDefId) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeSession.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeSession.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeSession.java
new file mode 100644
index 0000000..f15d18d
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeSession.java
@@ -0,0 +1,26 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable;
+
+import org.activiti.engine.impl.interceptor.Session;
+
+public interface SyncopeSession extends Session {
+
+ Class<?> getType();
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeSessionFactory.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeSessionFactory.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeSessionFactory.java
new file mode 100644
index 0000000..4758d4e
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeSessionFactory.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.apache.syncope.core.workflow.flowable;
+
+import org.activiti.engine.impl.interceptor.Session;
+import org.activiti.engine.impl.interceptor.SessionFactory;
+
+public class SyncopeSessionFactory implements SessionFactory {
+
+ private SyncopeSession syncopeSession;
+
+ @Override
+ public Class<?> getSessionType() {
+ return syncopeSession.getType();
+ }
+
+ @Override
+ public Session openSession() {
+ return syncopeSession;
+ }
+
+ public SyncopeSession getSyncopeSession() {
+ return syncopeSession;
+ }
+
+ public void setSyncopeSession(final SyncopeSession syncopeSession) {
+ this.syncopeSession = syncopeSession;
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeUserManager.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeUserManager.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeUserManager.java
new file mode 100644
index 0000000..a6cc201
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeUserManager.java
@@ -0,0 +1,166 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.activiti.engine.identity.Group;
+import org.activiti.engine.identity.Picture;
+import org.activiti.engine.identity.User;
+import org.activiti.engine.identity.UserQuery;
+import org.activiti.engine.impl.Page;
+import org.activiti.engine.impl.UserQueryImpl;
+import org.activiti.engine.impl.persistence.entity.GroupEntity;
+import org.activiti.engine.impl.persistence.entity.IdentityInfoEntity;
+import org.activiti.engine.impl.persistence.entity.UserEntity;
+import org.activiti.engine.impl.persistence.entity.UserIdentityManager;
+import org.apache.syncope.core.persistence.api.dao.GroupDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class SyncopeUserManager implements UserIdentityManager, SyncopeSession {
+
+ @Autowired
+ private UserDAO userDAO;
+
+ @Autowired
+ private GroupDAO groupDAO;
+
+ @Override
+ public Class<?> getType() {
+ return UserIdentityManager.class;
+ }
+
+ @Override
+ public Boolean checkPassword(final String userKey, final String password) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public User createNewUser(final String userKey) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public UserQuery createNewUserQuery() {
+ return new SyncopeUserQueryImpl(userDAO, groupDAO);
+ }
+
+ @Override
+ public void deleteUser(final String userKey) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<Group> findGroupsByUser(final String username) {
+ List<Group> result = Collections.emptyList();
+ org.apache.syncope.core.persistence.api.entity.user.User user = userDAO.findByUsername(username);
+ if (user != null) {
+ result = new ArrayList<>();
+ for (String groupName : userDAO.findAllGroupNames(user)) {
+ result.add(new GroupEntity(groupName));
+ }
+ }
+
+ return result;
+ }
+
+ @Override
+ public UserEntity findUserById(final String username) {
+ UserEntity result = null;
+ org.apache.syncope.core.persistence.api.entity.user.User user = userDAO.findByUsername(username);
+ if (user != null) {
+ result = new UserEntity(username);
+ }
+
+ return result;
+ }
+
+ @Override
+ public void flush() {
+ }
+
+ @Override
+ public void close() {
+ }
+
+ @Override
+ public void insertUser(final User user) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public boolean isNewUser(final User user) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void updateUser(final User updatedUser) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Picture getUserPicture(final String string) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setUserPicture(final String string, final Picture pctr) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<User> findUserByQueryCriteria(final UserQueryImpl query, final Page page) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public long findUserCountByQueryCriteria(final UserQueryImpl query) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public IdentityInfoEntity findUserInfoByUserIdAndKey(final String userKey, final String key) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<String> findUserInfoKeysByUserIdAndType(final String userKey, final String type) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<User> findPotentialStarterUsers(final String proceDefId) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<User> findUsersByNativeQuery(final Map<String, Object> parameterMap,
+ final int firstResult, final int maxResults) {
+
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public long findUserCountByNativeQuery(final Map<String, Object> parameterMap) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeUserQueryImpl.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeUserQueryImpl.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeUserQueryImpl.java
new file mode 100644
index 0000000..1e73f99
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/SyncopeUserQueryImpl.java
@@ -0,0 +1,206 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.identity.User;
+import org.activiti.engine.identity.UserQuery;
+import org.activiti.engine.impl.persistence.entity.UserEntity;
+import org.apache.syncope.core.persistence.api.dao.AnyDAO;
+import org.apache.syncope.core.persistence.api.dao.GroupDAO;
+import org.apache.syncope.core.persistence.api.dao.UserDAO;
+import org.apache.syncope.core.persistence.api.entity.group.Group;
+import org.apache.syncope.core.persistence.api.entity.user.UMembership;
+
+public class SyncopeUserQueryImpl implements UserQuery {
+
+ private final UserDAO userDAO;
+
+ private final GroupDAO groupDAO;
+
+ private String username;
+
+ private String memberOf;
+
+ private List<User> result;
+
+ public SyncopeUserQueryImpl(final UserDAO userDAO, final GroupDAO groupDAO) {
+ this.userDAO = userDAO;
+ this.groupDAO = groupDAO;
+ }
+
+ @Override
+ public UserQuery userId(final String id) {
+ this.username = id;
+ return this;
+ }
+
+ @Override
+ public UserQuery userFirstName(final String firstName) {
+ return this;
+ }
+
+ @Override
+ public UserQuery userFirstNameLike(final String firstNameLike) {
+ return this;
+ }
+
+ @Override
+ public UserQuery userLastName(final String lastName) {
+ return this;
+ }
+
+ @Override
+ public UserQuery userLastNameLike(final String lastNameLike) {
+ return this;
+ }
+
+ @Override
+ public UserQuery userFullNameLike(final String fullNameLike) {
+ return this;
+ }
+
+ @Override
+ public UserQuery userEmail(final String email) {
+ return this;
+ }
+
+ @Override
+ public UserQuery userEmailLike(final String emailLike) {
+ return this;
+ }
+
+ @Override
+ public UserQuery memberOfGroup(final String groupId) {
+ memberOf = groupId;
+ return this;
+ }
+
+ @Override
+ public UserQuery orderByUserId() {
+ return this;
+ }
+
+ @Override
+ public UserQuery orderByUserFirstName() {
+ return this;
+ }
+
+ @Override
+ public UserQuery orderByUserLastName() {
+ return this;
+ }
+
+ @Override
+ public UserQuery orderByUserEmail() {
+ return this;
+ }
+
+ @Override
+ public UserQuery asc() {
+ return this;
+ }
+
+ @Override
+ public UserQuery desc() {
+ return this;
+ }
+
+ private User fromSyncopeUser(final org.apache.syncope.core.persistence.api.entity.user.User user) {
+ return new UserEntity(user.getUsername());
+ }
+
+ private void execute() {
+ if (username != null) {
+ org.apache.syncope.core.persistence.api.entity.user.User user = userDAO.findByUsername(username);
+ if (user == null) {
+ result = Collections.<User>emptyList();
+ } else if (memberOf == null || userDAO.findAllGroupNames(user).contains(memberOf)) {
+ result = Collections.singletonList(fromSyncopeUser(user));
+ }
+ }
+ if (memberOf != null) {
+ Group group = groupDAO.findByName(memberOf);
+ if (group == null) {
+ result = Collections.<User>emptyList();
+ } else {
+ result = new ArrayList<>();
+ List<UMembership> memberships = groupDAO.findUMemberships(group);
+ memberships.stream().map(membership -> fromSyncopeUser(membership.getLeftEnd())).
+ filter((user) -> (!result.contains(user))).
+ forEachOrdered((user) -> {
+ result.add(user);
+ });
+ }
+ }
+ // THIS CAN BE *VERY* DANGEROUS
+ if (result == null) {
+ result = new ArrayList<>();
+ for (int page = 1; page <= (userDAO.count() / AnyDAO.DEFAULT_PAGE_SIZE) + 1; page++) {
+ result.addAll(userDAO.findAll(page, AnyDAO.DEFAULT_PAGE_SIZE).stream().
+ map(user -> fromSyncopeUser(user)).collect(Collectors.toList()));
+ }
+ }
+ }
+
+ @Override
+ public long count() {
+ if (result == null) {
+ execute();
+ }
+ return result.size();
+ }
+
+ @Override
+ public User singleResult() {
+ if (result == null) {
+ execute();
+ }
+ if (result.isEmpty()) {
+ throw new ActivitiException("Empty result");
+ }
+
+ return result.get(0);
+ }
+
+ @Override
+ public List<User> list() {
+ if (result == null) {
+ execute();
+ }
+ return result;
+ }
+
+ @Override
+ public List<User> listPage(final int firstResult, final int maxResults) {
+ if (result == null) {
+ execute();
+ }
+ return result.subList(firstResult, firstResult + maxResults - 1);
+ }
+
+ @Override
+ public UserQuery potentialStarter(final String string) {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/spring/DomainProcessEngine.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/spring/DomainProcessEngine.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/spring/DomainProcessEngine.java
new file mode 100644
index 0000000..c8e9141
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/spring/DomainProcessEngine.java
@@ -0,0 +1,114 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable.spring;
+
+import java.util.Collections;
+import java.util.Map;
+import javax.sql.DataSource;
+import org.activiti.engine.DynamicBpmnService;
+import org.activiti.engine.FormService;
+import org.activiti.engine.HistoryService;
+import org.activiti.engine.IdentityService;
+import org.activiti.engine.ManagementService;
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.ProcessEngineConfiguration;
+import org.activiti.engine.RepositoryService;
+import org.activiti.engine.RuntimeService;
+import org.activiti.engine.TaskService;
+import org.activiti.engine.impl.ProcessEngineImpl;
+import org.apache.syncope.core.spring.security.AuthContextUtils;
+
+/**
+ * {@link ProcessEngine} delegating actual method invocation to the inner map of {@link ProcessEngine} instances,
+ * one for each Syncope domain.
+ */
+public class DomainProcessEngine implements ProcessEngine {
+
+ private final Map<String, ProcessEngine> engines;
+
+ public DomainProcessEngine(final Map<String, ProcessEngine> engines) {
+ this.engines = Collections.synchronizedMap(engines);
+ }
+
+ public Map<String, ProcessEngine> getEngines() {
+ return engines;
+ }
+
+ @Override
+ public String getName() {
+ return engines.get(AuthContextUtils.getDomain()).getName();
+ }
+
+ @Override
+ public void close() {
+ for (ProcessEngine engine : engines.values()) {
+ engine.close();
+ }
+ }
+
+ @Override
+ public RepositoryService getRepositoryService() {
+ return engines.get(AuthContextUtils.getDomain()).getRepositoryService();
+ }
+
+ @Override
+ public RuntimeService getRuntimeService() {
+ return engines.get(AuthContextUtils.getDomain()).getRuntimeService();
+ }
+
+ @Override
+ public FormService getFormService() {
+ return engines.get(AuthContextUtils.getDomain()).getFormService();
+ }
+
+ @Override
+ public TaskService getTaskService() {
+ return engines.get(AuthContextUtils.getDomain()).getTaskService();
+ }
+
+ @Override
+ public HistoryService getHistoryService() {
+ return engines.get(AuthContextUtils.getDomain()).getHistoryService();
+ }
+
+ @Override
+ public IdentityService getIdentityService() {
+ return engines.get(AuthContextUtils.getDomain()).getIdentityService();
+ }
+
+ @Override
+ public ManagementService getManagementService() {
+ return engines.get(AuthContextUtils.getDomain()).getManagementService();
+ }
+
+ @Override
+ public ProcessEngineConfiguration getProcessEngineConfiguration() {
+ return engines.get(AuthContextUtils.getDomain()).getProcessEngineConfiguration();
+ }
+
+ @Override
+ public DynamicBpmnService getDynamicBpmnService() {
+ return engines.get(AuthContextUtils.getDomain()).getDynamicBpmnService();
+ }
+
+ public DataSource getDataSource() {
+ ProcessEngineImpl engine = (ProcessEngineImpl) engines.get(AuthContextUtils.getDomain());
+ return engine.getProcessEngineConfiguration().getDataSource();
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/spring/DomainProcessEngineFactoryBean.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/spring/DomainProcessEngineFactoryBean.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/spring/DomainProcessEngineFactoryBean.java
new file mode 100644
index 0000000..620d6b9
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/spring/DomainProcessEngineFactoryBean.java
@@ -0,0 +1,104 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable.spring;
+
+import java.util.HashMap;
+import java.util.Map;
+import javax.sql.DataSource;
+import org.activiti.engine.ProcessEngine;
+import org.activiti.engine.impl.cfg.SpringBeanFactoryProxyMap;
+import org.activiti.spring.SpringExpressionManager;
+import org.activiti.spring.SpringProcessEngineConfiguration;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.FactoryBean;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.transaction.PlatformTransactionManager;
+
+/**
+ * Spring factory for {@link DomainProcessEngine} which takes the provided {@link SpringProcessEngineConfiguration} as
+ * template for each of the configured Syncope domains.
+ */
+public class DomainProcessEngineFactoryBean
+ implements FactoryBean<DomainProcessEngine>, DisposableBean, ApplicationContextAware {
+
+ private ApplicationContext ctx;
+
+ private DomainProcessEngine engine;
+
+ @Override
+ public void setApplicationContext(final ApplicationContext ctx) throws BeansException {
+ this.ctx = ctx;
+ }
+
+ @Override
+ public DomainProcessEngine getObject() throws Exception {
+ if (engine == null) {
+ Map<String, ProcessEngine> engines = new HashMap<>();
+
+ for (Map.Entry<String, DataSource> entry : ctx.getBeansOfType(DataSource.class).entrySet()) {
+ if (!entry.getKey().startsWith("local")) {
+ String domain = StringUtils.substringBefore(entry.getKey(), DataSource.class.getSimpleName());
+ DataSource dataSource = entry.getValue();
+ PlatformTransactionManager transactionManager = ctx.getBean(
+ domain + "TransactionManager", PlatformTransactionManager.class);
+ Object entityManagerFactory = ctx.getBean(domain + "EntityManagerFactory");
+
+ SpringProcessEngineConfiguration conf = ctx.getBean(SpringProcessEngineConfiguration.class);
+ conf.setDataSource(dataSource);
+ conf.setTransactionManager(transactionManager);
+ conf.setTransactionsExternallyManaged(true);
+ conf.setJpaEntityManagerFactory(entityManagerFactory);
+ if (conf.getBeans() == null) {
+ conf.setBeans(new SpringBeanFactoryProxyMap(ctx));
+ }
+ if (conf.getExpressionManager() == null) {
+ conf.setExpressionManager(new SpringExpressionManager(ctx, conf.getBeans()));
+ }
+
+ engines.put(domain, conf.buildProcessEngine());
+ }
+ }
+
+ engine = new DomainProcessEngine(engines);
+ }
+
+ return engine;
+ }
+
+ @Override
+ public Class<DomainProcessEngine> getObjectType() {
+ return DomainProcessEngine.class;
+ }
+
+ @Override
+ public boolean isSingleton() {
+ return true;
+ }
+
+ @Override
+ public void destroy() throws Exception {
+ if (engine != null) {
+ engine.close();
+ }
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/AbstractFlowableServiceTask.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/AbstractFlowableServiceTask.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/AbstractFlowableServiceTask.java
new file mode 100644
index 0000000..c3a5ba1
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/AbstractFlowableServiceTask.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.apache.syncope.core.workflow.flowable.task;
+
+import org.activiti.engine.ProcessEngine;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * Abstract base class for Flowable's service tasks in Syncope, with Spring support.
+ */
+@Component
+public abstract class AbstractFlowableServiceTask {
+
+ protected static final Logger LOG = LoggerFactory.getLogger(AbstractFlowableServiceTask.class);
+
+ @Autowired
+ protected ProcessEngine engine;
+
+ @Transactional(rollbackFor = { Throwable.class })
+ public void execute(final String executionId) {
+ doExecute(executionId);
+ }
+
+ protected abstract void doExecute(final String executionId);
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/AutoActivate.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/AutoActivate.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/AutoActivate.java
new file mode 100644
index 0000000..8aeb9f9
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/AutoActivate.java
@@ -0,0 +1,31 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable.task;
+
+import org.apache.syncope.core.workflow.flowable.FlowableUserWorkflowAdapter;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AutoActivate extends AbstractFlowableServiceTask {
+
+ @Override
+ protected void doExecute(final String executionId) {
+ engine.getRuntimeService().setVariable(executionId, FlowableUserWorkflowAdapter.PROPAGATE_ENABLE, Boolean.TRUE);
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/Create.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/Create.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/Create.java
new file mode 100644
index 0000000..be9bfec
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/Create.java
@@ -0,0 +1,52 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable.task;
+
+import org.apache.syncope.common.lib.to.UserTO;
+import org.apache.syncope.core.persistence.api.entity.EntityFactory;
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.provisioning.api.data.UserDataBinder;
+import org.apache.syncope.core.workflow.flowable.FlowableUserWorkflowAdapter;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class Create extends AbstractFlowableServiceTask {
+
+ @Autowired
+ private UserDataBinder dataBinder;
+
+ @Autowired
+ private EntityFactory entityFactory;
+
+ @Override
+ protected void doExecute(final String executionId) {
+ UserTO userTO = engine.getRuntimeService().
+ getVariable(executionId, FlowableUserWorkflowAdapter.USER_TO, UserTO.class);
+ Boolean storePassword = engine.getRuntimeService().
+ getVariable(executionId, FlowableUserWorkflowAdapter.STORE_PASSWORD, Boolean.class);
+ // create and set workflow id
+ User user = entityFactory.newEntity(User.class);
+ dataBinder.create(user, userTO, storePassword == null ? true : storePassword);
+ user.setWorkflowId(executionId);
+
+ // report user as result
+ engine.getRuntimeService().setVariable(executionId, FlowableUserWorkflowAdapter.USER, user);
+ }
+}
http://git-wip-us.apache.org/repos/asf/syncope/blob/7098ca9f/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/Delete.java
----------------------------------------------------------------------
diff --git a/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/Delete.java b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/Delete.java
new file mode 100644
index 0000000..d4efe09
--- /dev/null
+++ b/core/workflow-flowable/src/main/java/org/apache/syncope/core/workflow/flowable/task/Delete.java
@@ -0,0 +1,41 @@
+/*
+ * 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.apache.syncope.core.workflow.flowable.task;
+
+import org.apache.syncope.core.persistence.api.entity.user.User;
+import org.apache.syncope.core.workflow.flowable.FlowableUserWorkflowAdapter;
+import org.springframework.stereotype.Component;
+
+@Component
+public class Delete extends AbstractFlowableServiceTask {
+
+ @Override
+ protected void doExecute(final String executionId) {
+ User user = engine.getRuntimeService().
+ getVariable(executionId, FlowableUserWorkflowAdapter.USER, User.class);
+
+ // Do something with user...
+ if (user != null) {
+ user.checkToken("");
+ }
+
+ // remove user variable
+ engine.getRuntimeService().removeVariable(executionId, FlowableUserWorkflowAdapter.USER);
+ }
+}