/* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.activiti.engine.impl.bpmn.parser.factory;
import java.util.HashMap;
import java.util.Map;
import org.activiti.bpmn.model.ActivitiListener;
import org.activiti.bpmn.model.EventListener;
import org.activiti.bpmn.model.ImplementationType;
import org.activiti.engine.ActivitiIllegalArgumentException;
import org.activiti.engine.delegate.ExecutionListener;
import org.activiti.engine.delegate.TaskListener;
import org.activiti.engine.delegate.event.ActivitiEventListener;
import org.activiti.engine.impl.bpmn.helper.BaseDelegateEventListener;
import org.activiti.engine.impl.bpmn.helper.ClassDelegate;
import org.activiti.engine.impl.bpmn.helper.DelegateActivitiEventListener;
import org.activiti.engine.impl.bpmn.helper.DelegateExpressionActivitiEventListener;
import org.activiti.engine.impl.bpmn.helper.ErrorThrowingEventListener;
import org.activiti.engine.impl.bpmn.helper.MessageThrowingEventListener;
import org.activiti.engine.impl.bpmn.helper.SignalThrowingEventListener;
import org.activiti.engine.impl.bpmn.listener.DelegateExpressionExecutionListener;
import org.activiti.engine.impl.bpmn.listener.DelegateExpressionTaskListener;
import org.activiti.engine.impl.bpmn.listener.ExpressionExecutionListener;
import org.activiti.engine.impl.bpmn.listener.ExpressionTaskListener;
import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.Execution;
import org.activiti.engine.runtime.Job;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Attachment;
import org.activiti.engine.task.Comment;
import org.activiti.engine.task.IdentityLink;
import org.activiti.engine.task.Task;
/**
* Default implementation of the {@link ListenerFactory}.
* Used when no custom {@link ListenerFactory} is injected on
* the {@link ProcessEngineConfigurationImpl}.
*
* @author Joram Barrez
*/
public class DefaultListenerFactory extends AbstractBehaviorFactory implements ListenerFactory {
public static final Map<String, Class<?>> ENTITY_MAPPING = new HashMap<String, Class<?>>();
static {
ENTITY_MAPPING.put("attachment", Attachment.class);
ENTITY_MAPPING.put("comment", Comment.class);
ENTITY_MAPPING.put("execution", Execution.class);
ENTITY_MAPPING.put("identity-link", IdentityLink.class);
ENTITY_MAPPING.put("job", Job.class);
ENTITY_MAPPING.put("process-definition", ProcessDefinition.class);
ENTITY_MAPPING.put("process-instance", ProcessInstance.class);
ENTITY_MAPPING.put("task", Task.class);
}
public TaskListener createClassDelegateTaskListener(ActivitiListener activitiListener) {
return new ClassDelegate(activitiListener.getImplementation(), createFieldDeclarations(activitiListener.getFieldExtensions()));
}
public TaskListener createExpressionTaskListener(ActivitiListener activitiListener) {
return new ExpressionTaskListener(expressionManager.createExpression(activitiListener.getImplementation()));
}
public TaskListener createDelegateExpressionTaskListener(ActivitiListener activitiListener) {
return new DelegateExpressionTaskListener(expressionManager.createExpression(activitiListener.getImplementation()),
createFieldDeclarations(activitiListener.getFieldExtensions()));
}
public ExecutionListener createClassDelegateExecutionListener(ActivitiListener activitiListener) {
return new ClassDelegate(activitiListener.getImplementation(), createFieldDeclarations(activitiListener.getFieldExtensions()));
}
public ExecutionListener createExpressionExecutionListener(ActivitiListener activitiListener) {
return new ExpressionExecutionListener(expressionManager.createExpression(activitiListener.getImplementation()));
}
public ExecutionListener createDelegateExpressionExecutionListener(ActivitiListener activitiListener) {
return new DelegateExpressionExecutionListener(expressionManager.createExpression(activitiListener.getImplementation()),
createFieldDeclarations(activitiListener.getFieldExtensions()));
}
@Override
public ActivitiEventListener createClassDelegateEventListener(EventListener eventListener) {
return new DelegateActivitiEventListener(eventListener.getImplementation(), getEntityType(eventListener.getEntityType()));
}
@Override
public ActivitiEventListener createDelegateExpressionEventListener(EventListener eventListener) {
return new DelegateExpressionActivitiEventListener(expressionManager.createExpression(
eventListener.getImplementation()), getEntityType(eventListener.getEntityType()));
}
@Override
public ActivitiEventListener createEventThrowingEventListener(EventListener eventListener) {
BaseDelegateEventListener result = null;
if (ImplementationType.IMPLEMENTATION_TYPE_THROW_SIGNAL_EVENT.equals(eventListener.getImplementationType())) {
result = new SignalThrowingEventListener();
((SignalThrowingEventListener) result).setSignalName(eventListener.getImplementation());
((SignalThrowingEventListener) result).setProcessInstanceScope(true);
} else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_GLOBAL_SIGNAL_EVENT.equals(eventListener.getImplementationType())) {
result = new SignalThrowingEventListener();
((SignalThrowingEventListener) result).setSignalName(eventListener.getImplementation());
((SignalThrowingEventListener) result).setProcessInstanceScope(false);
} else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_MESSAGE_EVENT.equals(eventListener.getImplementationType())) {
result = new MessageThrowingEventListener();
((MessageThrowingEventListener) result).setMessageName(eventListener.getImplementation());
} else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_ERROR_EVENT.equals(eventListener.getImplementationType())) {
result = new ErrorThrowingEventListener();
((ErrorThrowingEventListener) result).setErrorCode(eventListener.getImplementation());
}
if (result == null) {
throw new ActivitiIllegalArgumentException("Cannot create an event-throwing event-listener, unknown implementation type: "
+ eventListener.getImplementationType());
}
result.setEntityClass(getEntityType(eventListener.getEntityType()));
return result;
}
/**
* @param entityType the name of the entity
* @return
* @throws ActivitiIllegalArgumentException when the given entity name
*/
protected Class<?> getEntityType(String entityType) {
if(entityType != null) {
Class<?> entityClass = ENTITY_MAPPING.get(entityType.trim());
if(entityClass == null) {
throw new ActivitiIllegalArgumentException("Unsupported entity-type for an ActivitiEventListener: " + entityType);
}
return entityClass;
}
return null;
}
}