/** * Creates and inserts a subscription entity depending on the message type of this declaration. */ public EventSubscriptionEntity createSubscriptionForExecution(ExecutionEntity execution) { EventSubscriptionEntity eventSubscriptionEntity = new EventSubscriptionEntity(execution, eventType); String eventName = resolveExpressionOfEventName(execution); eventSubscriptionEntity.setEventName(eventName); if (activityId != null) { ActivityImpl activity = execution.getProcessDefinition().findActivity(activityId); eventSubscriptionEntity.setActivity(activity); } eventSubscriptionEntity.insert(); LegacyBehavior.removeLegacySubscriptionOnParent(execution, eventSubscriptionEntity); return eventSubscriptionEntity; }
/** * Checks if the parameters are the same apart from the execution id */ protected static boolean areEqualEventSubscriptions(EventSubscriptionEntity subscription1, EventSubscriptionEntity subscription2) { return valuesEqual(subscription1.getEventType(), subscription2.getEventType()) && valuesEqual(subscription1.getEventName(), subscription2.getEventName()) && valuesEqual(subscription1.getActivityId(), subscription2.getActivityId()); }
protected void removeEventSubscriptionsExceptCompensation() { // remove event subscriptions which are not compensate event subscriptions List<EventSubscriptionEntity> eventSubscriptions = getEventSubscriptions(); for (EventSubscriptionEntity eventSubscriptionEntity : eventSubscriptions) { if (!EventType.COMPENSATE.name().equals(eventSubscriptionEntity.getEventType())) { eventSubscriptionEntity.delete(); } } }
public static EventSubscriptionEntity createAndInsert(ExecutionEntity executionEntity, EventType eventType, ActivityImpl activity, String configuration) { EventSubscriptionEntity eventSubscription = new EventSubscriptionEntity(executionEntity, eventType); eventSubscription.setActivity(activity); eventSubscription.setTenantId(executionEntity.getTenantId()); eventSubscription.setConfiguration(configuration); eventSubscription.insert(); return eventSubscription; }
public void updateSubscription(EventSubscriptionEntity eventSubscription) { String eventName = resolveExpressionOfEventName(eventSubscription.getExecution()); eventSubscription.setEventName(eventName); eventSubscription.setActivityId(activityId); }
public Void execute(CommandContext commandContext) { Calendar calendar = new GregorianCalendar(); EventSubscriptionEntity messageEventSubscriptionEntity1 = new EventSubscriptionEntity(EventType.MESSAGE); messageEventSubscriptionEntity1.setEventName("messageName"); messageEventSubscriptionEntity1.setActivityId("someActivity"); calendar.set(2001, 1, 1); messageEventSubscriptionEntity1.setCreated(calendar.getTime()); messageEventSubscriptionEntity1.insert(); EventSubscriptionEntity messageEventSubscriptionEntity2 = new EventSubscriptionEntity(EventType.MESSAGE); messageEventSubscriptionEntity2.setEventName("messageName"); messageEventSubscriptionEntity2.setActivityId("someActivity"); calendar.set(2000, 1, 1); messageEventSubscriptionEntity2.setCreated(calendar.getTime()); messageEventSubscriptionEntity2.insert(); EventSubscriptionEntity signalEventSubscriptionEntity3 = new EventSubscriptionEntity(EventType.SIGNAL); signalEventSubscriptionEntity3.setEventName("messageName2"); signalEventSubscriptionEntity3.setActivityId("someOtherActivity"); calendar.set(2002, 1, 1); signalEventSubscriptionEntity3.setCreated(calendar.getTime()); signalEventSubscriptionEntity3.insert(); return null; } });
public EventSubscriptionEntity createSubscriptionForStartEvent(ProcessDefinitionEntity processDefinition) { EventSubscriptionEntity eventSubscriptionEntity = new EventSubscriptionEntity(eventType); VariableScope scopeForExpression = StartProcessVariableScope.getSharedInstance(); String eventName = resolveExpressionOfEventName(scopeForExpression); eventSubscriptionEntity.setEventName(eventName); eventSubscriptionEntity.setActivityId(activityId); eventSubscriptionEntity.setConfiguration(processDefinition.getId()); eventSubscriptionEntity.setTenantId(processDefinition.getTenantId()); return eventSubscriptionEntity; }
@Test @Deployment(resources = SINGLE_CONDITIONAL_START_EVENT_XML) public void testDeploymentCreatesSubscriptions() { // given a deployed process String processDefinitionId = repositoryService.createProcessDefinitionQuery().processDefinitionKey(CONDITIONAL_EVENT_PROCESS).singleResult().getId(); // when List<EventSubscription> eventSubscriptions = runtimeService.createEventSubscriptionQuery().list(); // then assertEquals(1, eventSubscriptions.size()); EventSubscriptionEntity conditionalEventSubscription = (EventSubscriptionEntity) eventSubscriptions.get(0); assertEquals(EventType.CONDITONAL.name(), conditionalEventSubscription.getEventType()); assertEquals(processDefinitionId, conditionalEventSubscription.getConfiguration()); assertNull(conditionalEventSubscription.getEventName()); assertNull(conditionalEventSubscription.getExecutionId()); assertNull(conditionalEventSubscription.getProcessInstanceId()); }
protected void addConditionalStartEventSubscription(EventSubscriptionDeclaration conditionalEventDefinition, ProcessDefinitionEntity processDefinition) { EventSubscriptionEntity newSubscription = conditionalEventDefinition.createSubscriptionForStartEvent(processDefinition); newSubscription.insert(); }
@Override public void leaveOnSatisfiedCondition(final EventSubscriptionEntity eventSubscription, final VariableEvent variableEvent) { final PvmExecutionImpl execution = eventSubscription.getExecution(); if (execution != null && !execution.isEnded() && execution.isScope() && conditionalEvent.tryEvaluate(variableEvent, execution)) { execution.executeEventHandlerActivity(eventSubscription.getActivity()); } } }
/** * Assumes that an activity has at most one declaration of a certain eventType. */ public static EventSubscriptionJobDeclaration findDeclarationForSubscription(EventSubscriptionEntity eventSubscription) { List<EventSubscriptionJobDeclaration> declarations = getDeclarationsForActivity(eventSubscription.getActivity()); for (EventSubscriptionJobDeclaration declaration : declarations) { if (declaration.getEventType().equals(eventSubscription.getEventType())) { return declaration; } } return null; }
protected boolean matchesSubscription(EventSubscriptionEntity subscription, String type, String eventName) { EnsureUtil.ensureNotNull("event type", type); String subscriptionEventName = subscription.getEventName(); return type.equals(subscription.getEventType()) && ((eventName == null && subscriptionEventName == null) || (eventName != null && eventName.equals(subscriptionEventName))); }
protected void handleStartEvent(EventSubscriptionEntity eventSubscription, Map<String, Object> payload, String businessKey, CommandContext commandContext) { String processDefinitionId = eventSubscription.getConfiguration(); ensureNotNull("Configuration of signal start event subscription '" + eventSubscription.getId() + "' contains no process definition id.", processDefinitionId); DeploymentCache deploymentCache = Context.getProcessEngineConfiguration().getDeploymentCache(); ProcessDefinitionEntity processDefinition = deploymentCache.findDeployedProcessDefinitionById(processDefinitionId); if (processDefinition == null || processDefinition.isSuspended()) { // ignore event subscription LOG.debugIgnoringEventSubscription(eventSubscription, processDefinitionId); } else { ActivityImpl signalStartEvent = processDefinition.findActivity(eventSubscription.getActivityId()); PvmProcessInstance processInstance = processDefinition.createProcessInstance(businessKey, signalStartEvent); processInstance.start(payload); } }
@SuppressWarnings("unchecked") public List<EventSubscriptionEntity> findSignalEventSubscriptionsByNameAndExecution(String name, String executionId) { final String query = "selectSignalEventSubscriptionsByNameAndExecution"; Map<String,String> params = new HashMap<String, String>(); params.put("executionId", executionId); params.put("eventName", name); Set<EventSubscriptionEntity> selectList = new HashSet<EventSubscriptionEntity>( getDbEntityManager().selectList(query, params)); // add events created in this command (not visible yet in query) for (EventSubscriptionEntity entity : createdSignalSubscriptions) { if(executionId.equals(entity.getExecutionId()) && name.equals(entity.getEventName())) { selectList.add(entity); } } return new ArrayList<EventSubscriptionEntity>(selectList); }
public void handleIntermediateEvent(EventSubscriptionEntity eventSubscription, Object payload, Object localPayload, CommandContext commandContext) { PvmExecutionImpl execution = eventSubscription.getExecution(); ActivityImpl activity = eventSubscription.getActivity(); ensureNotNull("Error while sending signal for event subscription '" + eventSubscription.getId() + "': " + "no activity associated with event subscription", "activity", activity); if (payload instanceof Map) { execution.setVariables((Map<String, Object>)payload); } if (localPayload instanceof Map) { execution.setVariablesLocal((Map<String, Object>) localPayload); } if(activity.equals(execution.getActivity())) { execution.signal("signal", null); } else { // hack around the fact that the start event is referenced by event subscriptions for event subprocesses // and not the subprocess itself if (activity.getActivityBehavior() instanceof EventSubProcessStartEventActivityBehavior) { activity = (ActivityImpl) activity.getFlowScope(); } execution.executeEventHandlerActivity(activity); } }
public void eventReceived(Object payload, boolean processASync) { eventReceived(payload, null, null, processASync); }
public void remove() { eventSubscriptionEntity.delete(); } }
@Override public void migrateState() { eventSubscription.setActivity((ActivityImpl) targetScope); currentScope = targetScope; }
/** * Find all signal event subscriptions with the given event name and tenant. */ @SuppressWarnings("unchecked") public List<EventSubscriptionEntity> findSignalEventSubscriptionsByEventNameAndTenantId(String eventName, String tenantId) { final String query = "selectSignalEventSubscriptionsByEventNameAndTenantId"; Map<String, Object> parameter = new HashMap<String, Object>(); parameter.put("eventName", eventName); parameter.put("tenantId", tenantId); Set<EventSubscriptionEntity> eventSubscriptions = new HashSet<EventSubscriptionEntity>( getDbEntityManager().selectList(query, parameter)); // add events created in this command (not visible yet in query) for (EventSubscriptionEntity entity : createdSignalSubscriptions) { if(eventName.equals(entity.getEventName()) && hasTenantId(entity, tenantId)) { eventSubscriptions.add(entity); } } return new ArrayList<EventSubscriptionEntity>(eventSubscriptions); }
public EventSubscriptionEntity(ExecutionEntity executionEntity, EventType eventType) { this(eventType); setExecution(executionEntity); setActivity(execution.getActivity()); this.processInstanceId = executionEntity.getProcessInstanceId(); this.tenantId = executionEntity.getTenantId(); }