public override BaseElement Clone() { TimerEventDefinition clone = new TimerEventDefinition { Values = this }; return(clone); }
protected internal virtual void HandleTimerEventDefinition(Process process, Event @event, EventDefinition eventDefinition, IList <ValidationError> errors) { TimerEventDefinition timerEventDefinition = (TimerEventDefinition)eventDefinition; if (string.IsNullOrWhiteSpace(timerEventDefinition.TimeDate) && string.IsNullOrWhiteSpace(timerEventDefinition.TimeCycle) && string.IsNullOrWhiteSpace(timerEventDefinition.TimeDuration)) { // neither date, cycle or duration configured AddError(errors, ProblemsConstants.EVENT_TIMER_MISSING_CONFIGURATION, process, @event, ProcessValidatorResource.EVENT_TIMER_MISSING_CONFIGURATION); } }
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model) { if (!(parentElement is TimerEventDefinition)) { return; } TimerEventDefinition eventDefinition = (TimerEventDefinition)parentElement; eventDefinition.TimeDate = xtr.ElementText; }
public override object Clone() { var result = new TimerEventDefinition { TimeCycle = TimeCycle, TimeDate = TimeDate, TimeDuration = TimeDuration }; FeedElt(result); return(result); }
/// <summary> /// Sets an event definition for the timer with a time date. /// </summary> /// <param name="timerDate"> the time date of the timer </param> /// <returns> the builder object </returns> public virtual B timerWithDate(string timerDate) { TimeDate timeDate = createInstance(typeof(TimeDate)); timeDate.TextContent = timerDate; TimerEventDefinition timerEventDefinition = createInstance(typeof(TimerEventDefinition)); timerEventDefinition.TimeDate = timeDate; element.EventDefinitions.add(timerEventDefinition); return(myself); }
protected virtual ScheduledJob CreateTimerJob(ProcessDefinition processDefinition, StartEvent startEvent, TimerEventDefinition timerEvent) { ScheduledJob job = new ScheduledJob(); job.ActivityId = startEvent.Id; job.Key = Guid.NewGuid().ToString("n"); job.ProcessDefinition = processDefinition; job.TenantId = this.tenantId; job.Handler = "timerStartEvent"; return(job); }
/// <summary> /// Sets an event definition for the timer with a time duration. /// </summary> /// <param name="timerDuration"> the time duration of the timer </param> /// <returns> the builder object </returns> public virtual B timerWithDuration(string timerDuration) { TimeDuration timeDuration = createInstance(typeof(TimeDuration)); timeDuration.TextContent = timerDuration; TimerEventDefinition timerEventDefinition = createInstance(typeof(TimerEventDefinition)); timerEventDefinition.TimeDuration = timeDuration; element.EventDefinitions.add(timerEventDefinition); return(myself); }
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model) { if (!(parentElement is TimerEventDefinition)) { return; } TimerEventDefinition eventDefinition = (TimerEventDefinition)parentElement; if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_END_DATE))) { eventDefinition.EndDate = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_END_DATE); } eventDefinition.TimeCycle = xtr.ElementText; }
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model) { if (!(parentElement is Event)) { return; } TimerEventDefinition eventDefinition = new TimerEventDefinition(); string calendarName = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_CALENDAR_NAME); if (!string.IsNullOrWhiteSpace(calendarName)) { eventDefinition.CalendarName = calendarName; } BpmnXMLUtil.AddXMLLocation(eventDefinition, xtr); BpmnXMLUtil.ParseChildElements(BpmnXMLConstants.ELEMENT_EVENT_TIMERDEFINITION, eventDefinition, xtr, model); ((Event)parentElement).EventDefinitions.Add(eventDefinition); }
protected internal virtual void restoreTimerStartEvent(IProcessDefinition previousProcessDefinition, StartEvent startEvent, EventDefinition eventDefinition) { TimerEventDefinition timerEventDefinition = (TimerEventDefinition)eventDefinition; ITimerJobEntity timer = TimerUtil.CreateTimerEntityForTimerEventDefinition((TimerEventDefinition)eventDefinition, false, null, TimerStartEventJobHandler.TYPE, TimerEventHandler.CreateConfiguration(startEvent.Id, timerEventDefinition.EndDate, timerEventDefinition.CalendarName)); if (timer != null) { ITimerJobEntity timerJob = JobManager.CreateTimerJob((TimerEventDefinition)eventDefinition, false, null, TimerStartEventJobHandler.TYPE, TimerEventHandler.CreateConfiguration(startEvent.Id, timerEventDefinition.EndDate, timerEventDefinition.CalendarName)); timerJob.ProcessDefinitionId = previousProcessDefinition.Id; if (!ReferenceEquals(previousProcessDefinition.TenantId, null)) { timerJob.TenantId = previousProcessDefinition.TenantId; } JobManager.ScheduleTimerJob(timerJob); } }
protected internal virtual void WriteTimerDefinition(Event parentEvent, TimerEventDefinition timerDefinition, XMLStreamWriter xtw) { xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EVENT_TIMERDEFINITION, BpmnXMLConstants.BPMN2_NAMESPACE); if (!string.IsNullOrWhiteSpace(timerDefinition.CalendarName)) { WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_CALENDAR_NAME, timerDefinition.CalendarName, xtw); } bool didWriteExtensionStartElement = BpmnXMLUtil.WriteExtensionElements(timerDefinition, false, xtw); if (didWriteExtensionStartElement) { xtw.WriteEndElement(); } if (!string.IsNullOrWhiteSpace(timerDefinition.TimeDate)) { xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ATTRIBUTE_TIMER_DATE, BpmnXMLConstants.BPMN2_NAMESPACE); xtw.WriteCharacters(timerDefinition.TimeDate); xtw.WriteEndElement(); } else if (!string.IsNullOrWhiteSpace(timerDefinition.TimeCycle)) { xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ATTRIBUTE_TIMER_CYCLE, BpmnXMLConstants.BPMN2_NAMESPACE); if (!string.IsNullOrWhiteSpace(timerDefinition.EndDate)) { xtw.WriteAttribute(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_END_DATE, timerDefinition.EndDate); } xtw.WriteCharacters(timerDefinition.TimeCycle); xtw.WriteEndElement(); } else if (!string.IsNullOrWhiteSpace(timerDefinition.TimeDuration)) { xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ATTRIBUTE_TIMER_DURATION, BpmnXMLConstants.BPMN2_NAMESPACE); xtw.WriteCharacters(timerDefinition.TimeDuration); xtw.WriteEndElement(); } xtw.WriteEndElement(); }
/// <summary> /// /// </summary> /// <param name="timerEventDefinition"></param> /// <param name="interrupting"></param> /// <param name="execution"></param> /// <param name="timerEventType"></param> /// <param name="jobHandlerConfiguration"></param> /// <returns></returns> public virtual ITimerJobEntity CreateTimerJob(TimerEventDefinition timerEventDefinition, bool interrupting, IExecutionEntity execution, string timerEventType, string jobHandlerConfiguration) { ITimerJobEntity timerEntity = TimerUtil.CreateTimerEntityForTimerEventDefinition(timerEventDefinition, interrupting, execution, timerEventType, jobHandlerConfiguration); return(timerEntity); }
public BoundaryTimerEventActivityBehavior(TimerEventDefinition timerEventDefinition, bool interrupting) : base(interrupting) { this.timerEventDefinition = timerEventDefinition; }
public virtual BoundaryTimerEventActivityBehavior CreateBoundaryTimerEventActivityBehavior(BoundaryEvent boundaryEvent, TimerEventDefinition timerEventDefinition, bool interrupting) { return(new BoundaryTimerEventActivityBehavior(timerEventDefinition, interrupting)); }
public virtual IntermediateCatchTimerEventActivityBehavior CreateIntermediateCatchTimerEventActivityBehavior(IntermediateCatchEvent intermediateCatchEvent, TimerEventDefinition timerEventDefinition) { return(new IntermediateCatchTimerEventActivityBehavior(timerEventDefinition)); }
public IntermediateCatchTimerEventActivityBehavior(TimerEventDefinition timerEventDefinition) { this.timerEventDefinition = timerEventDefinition; }
/// <summary> /// The event definition on which the timer is based. /// /// Takes in an optional execution, if missing the <seealso cref="NoExecutionVariableScope"/> will be used (eg Timer start event) /// </summary> public static ITimerJobEntity CreateTimerEntityForTimerEventDefinition(TimerEventDefinition timerEventDefinition, bool isInterruptingTimer, IExecutionEntity executionEntity, string jobHandlerType, string jobHandlerConfig) { ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration; string businessCalendarRef = null; IExpression expression = null; ExpressionManager expressionManager = processEngineConfiguration.ExpressionManager; // ACT-1415: timer-declaration on start-event may contain expressions NOT // evaluating variables but other context, evaluating should happen nevertheless IVariableScope scopeForExpression = executionEntity; if (scopeForExpression == null) { //scopeForExpression = NoExecutionVariableScope.SharedInstance; } if (!string.IsNullOrWhiteSpace(timerEventDefinition.TimeDate)) { businessCalendarRef = DueDateBusinessCalendar.NAME; expression = expressionManager.CreateExpression(timerEventDefinition.TimeDate); } else if (!string.IsNullOrWhiteSpace(timerEventDefinition.TimeCycle)) { businessCalendarRef = CycleBusinessCalendar.NAME; expression = expressionManager.CreateExpression(timerEventDefinition.TimeCycle); } else if (!string.IsNullOrWhiteSpace(timerEventDefinition.TimeDuration)) { businessCalendarRef = DurationBusinessCalendar.NAME; expression = expressionManager.CreateExpression(timerEventDefinition.TimeDuration); } if (!string.IsNullOrWhiteSpace(timerEventDefinition.CalendarName)) { businessCalendarRef = timerEventDefinition.CalendarName; IExpression businessCalendarExpression = expressionManager.CreateExpression(businessCalendarRef); businessCalendarRef = businessCalendarExpression.GetValue(scopeForExpression).ToString(); } if (expression == null) { throw new ActivitiException("Timer needs configuration (either timeDate, timeCycle or timeDuration is needed) (" + timerEventDefinition.Id + ")"); } IBusinessCalendar businessCalendar = processEngineConfiguration.BusinessCalendarManager.GetBusinessCalendar(businessCalendarRef); string dueDateString = null; DateTime?duedate = null; object dueDateValue = expression.GetValue(scopeForExpression); if (dueDateValue is string) { dueDateString = (string)dueDateValue; } else if (dueDateValue is DateTime) { duedate = (DateTime)dueDateValue; } else if (dueDateValue is Nullable <DateTime> ) { //JodaTime support duedate = (DateTime?)dueDateValue; } else if (dueDateValue != null) { throw new ActivitiException("Timer '" + executionEntity.ActivityId + "' was not configured with a valid duration/time, either hand in a java.util.Date or a String in format 'yyyy-MM-dd'T'hh:mm:ss'"); } if (duedate == null && !string.IsNullOrWhiteSpace(dueDateString)) { duedate = businessCalendar.ResolveDuedate(dueDateString); } ITimerJobEntity timer = null; if (duedate != null) { timer = Context.CommandContext.TimerJobEntityManager.Create(); timer.JobType = JobFields.JOB_TYPE_TIMER; timer.Revision = 1; timer.JobHandlerType = jobHandlerType; timer.JobHandlerConfiguration = jobHandlerConfig; timer.Exclusive = true; timer.Retries = processEngineConfiguration.AsyncExecutorNumberOfRetries; timer.Duedate = duedate; if (executionEntity != null) { timer.Execution = executionEntity; timer.ProcessDefinitionId = executionEntity.ProcessDefinitionId; timer.ProcessInstanceId = executionEntity.ProcessInstanceId; // Inherit tenant identifier (if applicable) if (!string.IsNullOrWhiteSpace(executionEntity.TenantId)) { timer.TenantId = executionEntity.TenantId; } } } if (!string.IsNullOrWhiteSpace(timerEventDefinition.TimeCycle)) { // See ACT-1427: A boundary timer with a cancelActivity='true', doesn't need to repeat itself bool repeat = !isInterruptingTimer; // ACT-1951: intermediate catching timer events shouldn't repeat according to spec if (executionEntity != null) { FlowElement currentElement = executionEntity.CurrentFlowElement; if (currentElement is IntermediateCatchEvent) { repeat = false; } } if (repeat) { string prepared = PrepareRepeat(dueDateString); timer.Repeat = prepared; } } if (timer != null && executionEntity != null) { timer.Execution = executionEntity; timer.ProcessDefinitionId = executionEntity.ProcessDefinitionId; // Inherit tenant identifier (if applicable) if (!string.IsNullOrWhiteSpace(executionEntity.TenantId)) { timer.TenantId = executionEntity.TenantId; } } return(timer); }
public override object Create(object parent, IParseContext context, XElement element) { EventDefinition eventDefinition = null; var localName = Helper.GetRealLocalName(element); switch (localName) { case "cancelEventDefinition": eventDefinition = new CancelEventDefinition(); break; case "errorEventDefinition": var errorEventDefinition = new ErrorEventDefinition(); eventDefinition = errorEventDefinition; var errorRef = element.GetAttribute("errorRef"); if (errorRef != null) { context.AddReferenceRequest <Error>(errorRef, x => errorEventDefinition.ErrorRef = x); } break; case "timerEventDefinition": eventDefinition = new TimerEventDefinition(); break; case "terminateEventDefinition": eventDefinition = new TerminateEventDefinition(); break; case "messageEventDefinition": var messageEventDefinition = new MessageEventDefinition(); eventDefinition = messageEventDefinition; var operationRef = element.GetAttribute("operationRef"); if (operationRef != null) { context.AddReferenceRequest <Operation>(operationRef, x => messageEventDefinition.OperationRef = x); } var messageRef = element.GetAttribute("messageRef"); if (messageRef != null) { context.AddReferenceRequest <Message>(messageRef, x => messageEventDefinition.MessageRef = x); } break; case "conditionalEventDefinition": eventDefinition = new ConditionalEventDefinition(); break; case "compensateEventDefinition": var compensateEventDefinition = new CompensateEventDefinition(); eventDefinition = compensateEventDefinition; compensateEventDefinition.WaitForCompletion = element.GetBoolean("waitForCompletion"); var activityRef = element.GetAttribute("activityRef"); if (activityRef != null) { context.AddReferenceRequest <Activity>(activityRef, x => compensateEventDefinition.ActivityRef = x); } break; case "signalEventDefinition": var signalEventDefinition = new SignalEventDefinition(); eventDefinition = signalEventDefinition; var signalRef = element.GetAttribute("signalRef"); if (signalRef != null) { context.AddReferenceRequest <Signal>(signalRef, x => signalEventDefinition.SignalRef = x); } break; case "escalationEventDefinition": eventDefinition = new EscalationEventDefinition() { EscalationRef = element.GetAttribute("escalationRef") }; break; case "linkEventDefinition": eventDefinition = new LinkEventDefinition() { Name = element.GetAttribute("name"), Target = element.GetAttribute("target") }; break; } if (this.callback != null) { this.callback(parent, context, element, eventDefinition); } base.Init(eventDefinition, context, element); context.Push(eventDefinition); return(eventDefinition); }