//Generate the Notifications collection (of N) based on an existing Template
public static List<Event> Create(XmlDocument xmlTemplateDoc, bool IsManagedItem)
{
List<Event> notifications = new List<Event>();
XmlNodeList nodeNotifications = xmlTemplateDoc.SelectNodes(Utility.XMLHelper.GetXPath(true, XMLNames._E_TemplateDef, XMLNames._E_Events, XMLNames._E_Event));
if (nodeNotifications != null)
{
foreach (XmlNode nodeNotification in nodeNotifications)
{
Event notification = new Event(nodeNotification, IsManagedItem);
notifications.Add(notification);
}
}
return notifications;
}
protected void btnAddNotification_OnCommand(object sender, CommandEventArgs e)
{
Business.Event notification = new Kindred.Knect.ITAT.Business.Event(Kindred.Knect.ITAT.Business.EventType.Custom, _template.IsManagedItem);
notification.Name = "New Notification";
notification.BaseDateTermID = Guid.Empty;
notification.BaseDateOffset = "";
Business.Message message = new Kindred.Knect.ITAT.Business.Message();
message.NotificationStatuses.Clear();
message.NotificationStatuses.Add(Business.XMLNames._M_AllStatuses);
message.Subject = string.Empty;
message.Text = Helper.DefaultEditorHtml(this.edt);
notification.Messages.Add(message);
_template.Events.Add(notification);
LoadDateTermsAndNotifications();
int nIndex = 0;
foreach (ListItem item in lstNotifications.Items)
{
if (item.Text == "New Notification")
{
lstNotifications.SelectedIndex = nIndex;
btnDeleteNotification.Enabled = true;
string[] segments = lstNotifications.SelectedValue.Split('|');
//segments[0] indicates NotificationType
//on workflow notifications, segments[1] = state name, segments[2] = action TargetState
Business.EventType notificationType = Business.EventTypeHelper.GetNotificationType(segments[0]);
SetPropertyValues(notificationType, lstNotifications.SelectedItem.Text, segments);
break;
}
nIndex++;
}
IsChanged = true;
}
private int GetBaseOffsetDays(Event eachEvent)
{
int baseOffsetDays = 0;
Term offsetTerm = FindTerm(eachEvent.OffsetTermID, eachEvent.OffsetTermName);
if (offsetTerm != null)
{
try { baseOffsetDays += int.Parse(offsetTerm.DisplayValue("")); }
catch { baseOffsetDays += eachEvent.OffsetDefaultValue; }
}
else
{
baseOffsetDays += eachEvent.OffsetDefaultValue;
}
return baseOffsetDays;
}
private List<ProcessScheduledEvent> CustomScheduledEvents(Event eachEvent, ScheduledEvent.ExecutedCalculationType executedCalculationType, DateTime cutoffDate)
{
List<ProcessScheduledEvent> processScheduledEvents = new List<ProcessScheduledEvent>();
Term term = FindTerm(eachEvent.BaseDateTermID, eachEvent.BaseDateTermName);
int baseOffsetDays = GetBaseOffsetDays(eachEvent);
if (term != null)
{
switch (term.TermType)
{
case TermType.Date:
DateTerm dateTerm = term as DateTerm;
if (dateTerm == null)
throw new Exception(string.Format("Term '{0}' is not a Date Term.", term.Name));
if (dateTerm.Value.HasValue)
{
foreach (ScheduledEvent scheduledEvent in eachEvent.ScheduledEvents)
{
DateTime eventDate = ScheduledEvent.GetEventDate(dateTerm.Value.Value.AddDays(-1 * baseOffsetDays), scheduledEvent.DateOffset);
ProcessScheduledEvent existingPSE = ProcessScheduledEvents.Find(pse => pse.ScheduledEventId == scheduledEvent.ID);
processScheduledEvents.Add(new ProcessScheduledEvent(scheduledEvent.ID, scheduledEvent.EventId, eventDate, ShouldBeMarkedExecuted(existingPSE, executedCalculationType, eventDate, cutoffDate)));
}
}
break;
case TermType.Renewal:
RenewalTerm renewalTerm = term as RenewalTerm;
if (renewalTerm == null)
throw new Exception(string.Format("Term '{0}' is not a Renewal Term.", term.Name));
DateTime? dtBaseDate = null;
switch (eachEvent.BaseDateTermPart)
{
case XMLNames._TPS_EffectiveDate:
if (renewalTerm.EffectiveDate.HasValue)
dtBaseDate = renewalTerm.EffectiveDate.Value;
break;
case XMLNames._TPS_ExpirationDate:
case "":
case null:
default:
if (renewalTerm.ExpirationDate.HasValue)
dtBaseDate = renewalTerm.ExpirationDate.Value;
break;
}
if (dtBaseDate.HasValue)
{
foreach (ScheduledEvent scheduledEvent in eachEvent.ScheduledEvents)
{
DateTime eventDate = ScheduledEvent.GetEventDate(dtBaseDate.Value.AddDays(-1 * baseOffsetDays), scheduledEvent.DateOffset);
ProcessScheduledEvent existingPSE = ProcessScheduledEvents.Find(pse => pse.ScheduledEventId == scheduledEvent.ID);
processScheduledEvents.Add(new ProcessScheduledEvent(scheduledEvent.ID, scheduledEvent.EventId, eventDate, ShouldBeMarkedExecuted(existingPSE, executedCalculationType, eventDate, cutoffDate)));
}
}
break;
default:
throw new Exception(string.Format("Tried to assign basic term '{0}' of type {1} to Custom Event '{2}'", term.Name, term.TermType.ToString(), eachEvent.Name));
}
}
return processScheduledEvents;
}
private List<ProcessScheduledEvent> RenewalScheduledEvents(Event eachEvent, ScheduledEvent.ExecutedCalculationType executedCalculationType, DateTime cutoffDate)
{
List<ProcessScheduledEvent> processScheduledEvents = new List<ProcessScheduledEvent>();
RenewalTerm renewalTerm = FindBasicTerm(TermType.Renewal) as RenewalTerm;
if (renewalTerm != null)
{
if (renewalTerm.SendNotification ?? true)
{
if (renewalTerm.RenewalEvent != null && renewalTerm.RenewalEvent.ScheduledEvents != null)
{
if (renewalTerm.ExpirationDate.HasValue)
{
int baseOffsetDays = GetBaseOffsetDays(eachEvent, renewalTerm);
foreach (ScheduledEvent scheduledEvent in eachEvent.ScheduledEvents)
{
DateTime eventDate = ScheduledEvent.GetEventDate(renewalTerm.ExpirationDate.Value.AddDays(-1 * baseOffsetDays), scheduledEvent.DateOffset);
ProcessScheduledEvent existingPSE = ProcessScheduledEvents.Find(pse => pse.ScheduledEventId == scheduledEvent.ID);
processScheduledEvents.Add(new ProcessScheduledEvent(scheduledEvent.ID, scheduledEvent.EventId, eventDate, ShouldBeMarkedExecuted(existingPSE, executedCalculationType, eventDate, cutoffDate)));
}
}
}
}
}
return processScheduledEvents;
}
private List<ProcessScheduledEvent> WorkflowRevertToDraftScheduledEvents(Event eachEvent, ScheduledEvent.ExecutedCalculationType executedCalculationType, DateTime cutoffDate)
{
List<ProcessScheduledEvent> scheduledEvents = new List<ProcessScheduledEvent>();
DateTime renewalTermEffectiveDate = DateTime.MinValue;
RenewalTerm renewalTerm = FindBasicTerm(TermType.Renewal) as RenewalTerm;
if (renewalTerm != null)
if (renewalTerm.EffectiveDate.HasValue)
renewalTermEffectiveDate = renewalTerm.EffectiveDate.Value;
DateTime dtRevertEvent;
//Currently, WorkflowRevertToDraft event forces State to be the 'IsBase' state.
//TODO - Just added this logic to inhibit the creation of the RevertToBaseStateEvent if the current State is an Exit state.
if (Workflow.GetRevertToBaseStateEventDate(renewalTermEffectiveDate, out dtRevertEvent))
if (!State.IsExit ?? false)
foreach (ScheduledEvent scheduledEvent in Workflow.RevertEvent.ScheduledEvents)
scheduledEvents.Add(new ProcessScheduledEvent(scheduledEvent.ID, eachEvent.ID, dtRevertEvent, false));
return scheduledEvents;
}
public Event Copy(bool IsManagedItem)
{
Event newEvent = new Event(EventType, IsManagedItem);
newEvent.IsRef = IsRef;
newEvent.Name = Name;
newEvent.Description = Description;
newEvent.BaseDateTermID = BaseDateTermID;
newEvent.OffsetTermID = OffsetTermID;
newEvent.BaseDateTermPart = BaseDateTermPart;
newEvent.OffsetDefaultValue = OffsetDefaultValue;
newEvent.Messages.Clear();
foreach (Message message in Messages)
{
newEvent.Messages.Add(message);
}
newEvent.ScheduledEvents.Clear();
foreach (ScheduledEvent scheduledEvent in ScheduledEvents)
{
ScheduledEvent newScheduledEvent = new ScheduledEvent(scheduledEvent.DateOffset, newEvent.ID, IsManagedItem);
newEvent.ScheduledEvents.Add(newScheduledEvent);
}
return newEvent;
}
public Workflow(XmlNode nodeWorkflow, bool IsManagedItem, Template template)
{
_isManagedItem = IsManagedItem;
_name = Utility.XMLHelper.GetAttributeString(nodeWorkflow, XMLNames._A_Name);
if (string.IsNullOrEmpty(_name))
_name = "New Workflow";
_id = Guid.Empty;
string id = Utility.XMLHelper.GetAttributeString(nodeWorkflow, XMLNames._A_ID);
if (!string.IsNullOrEmpty(id))
{
try
{
_id = new Guid(id);
}
catch
{
}
}
//If an ID was not assigned before, assign it now....
if (_id == Guid.Empty)
_id = Guid.NewGuid();
_useFunction = Utility.XMLHelper.GetAttributeBool(nodeWorkflow, XMLNames._A_UseFunction);
_daysAfterWorkflowEntry = Utility.XMLHelper.GetAttributeInt(nodeWorkflow, XMLNames._A_DaysAfterWorkflowEntry);
//DateExitedBaseState
XmlNode nodeDateExitedBaseState = nodeWorkflow.SelectSingleNode(XMLNames._E_DateExitedBaseState);
if (nodeDateExitedBaseState != null)
{
_dateExitedBaseState = Utility.XMLHelper.GetValueDate(nodeDateExitedBaseState);
}
XmlNodeList listStates = nodeWorkflow.SelectNodes(Utility.XMLHelper.GetXPath(false, XMLNames._E_States, XMLNames._E_State));
if (listStates != null)
{
_states = new List<State>(listStates.Count);
foreach (XmlNode nodeState in listStates)
{
State state = new State(nodeState, template, this);
_states.Add(state);
}
foreach (State state in _states)
{
foreach (Action action in state.Actions)
{
if (!action.TargetStateIDDefined)
{
State targetState = FindState(action.TargetState);
if (targetState == null)
throw new Exception(string.Format("Target State not found for action {0} of Workflow {1}, State {2}", action.ButtonText, _name, state.Name));
action.TargetStateID = targetState.ID;
}
}
}
}
//RR - 12/10/2007 - added code (revertToDraftEventSet) to prevent loading of multiple RevertToDraft events for a workflow
_events = new List<Event>();
bool revertToDraftEventSet = false;
XmlNodeList nodeNotifications = nodeWorkflow.SelectNodes(Utility.XMLHelper.GetXPath(false, XMLNames._E_Events, XMLNames._E_Event));
if (nodeNotifications != null)
{
foreach (XmlNode nodeNotification in nodeNotifications)
{
Event notification = new Event(nodeNotification, IsManagedItem);
if (notification.EventType == EventType.WorkflowRevertToDraft)
{
if (!revertToDraftEventSet)
{
_events.Add(notification);
revertToDraftEventSet = true;
}
}
else
_events.Add(notification);
}
}
}
private Event GetEvent(EventType messageEventType)
{
if (Events.Count != 0)
{
foreach (Event eachEvent in Events)
{
if (eachEvent.EventType == messageEventType)
return eachEvent;
}
}
Business.Event newEvent = new Event(messageEventType, this is ManagedItem);
newEvent.Name = messageEventType.ToString();
Events.Add(newEvent);
return newEvent;
}
