protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
string formKey = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_FORM_FORMKEY);
StartEvent startEvent = null;
if (!string.IsNullOrWhiteSpace(formKey) && model.StartEventFormTypes != null && model.StartEventFormTypes.Contains(formKey))
{
startEvent = new AlfrescoStartEvent();
}
if (startEvent == null)
{
startEvent = new StartEvent();
}
BpmnXMLUtil.AddXMLLocation(startEvent, xtr);
startEvent.Initiator = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_EVENT_START_INITIATOR);
bool interrupting = true;
string interruptingAttribute = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_EVENT_START_INTERRUPTING);
if (BpmnXMLConstants.ATTRIBUTE_VALUE_FALSE.Equals(interruptingAttribute, StringComparison.OrdinalIgnoreCase))
{
interrupting = false;
}
startEvent.Interrupting = interrupting;
startEvent.FormKey = formKey;
ParseChildElements(XMLElementName, startEvent, model, xtr);
return(startEvent);
}
public static bool WriteFieldExtensions(IList <FieldExtension> fieldExtensionList, bool didWriteExtensionStartElement, XMLStreamWriter xtw)
{
foreach (FieldExtension fieldExtension in fieldExtensionList)
{
if (!string.IsNullOrWhiteSpace(fieldExtension.FieldName))
{
if (!string.IsNullOrWhiteSpace(fieldExtension.StringValue) || !string.IsNullOrWhiteSpace(fieldExtension.Expression))
{
if (!didWriteExtensionStartElement)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EXTENSIONS, BpmnXMLConstants.BPMN2_NAMESPACE);
didWriteExtensionStartElement = true;
}
xtw.WriteStartElement(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ELEMENT_FIELD, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_FIELD_NAME, fieldExtension.FieldName, xtw);
if (!string.IsNullOrWhiteSpace(fieldExtension.StringValue))
{
xtw.WriteStartElement(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ELEMENT_FIELD_STRING, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
xtw.WriteCharacters(fieldExtension.StringValue);
}
else
{
xtw.WriteStartElement(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ATTRIBUTE_FIELD_EXPRESSION, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
xtw.WriteCharacters(fieldExtension.Expression);
}
xtw.WriteEndElement();
xtw.WriteEndElement();
}
}
}
return(didWriteExtensionStartElement);
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
BoundaryEvent boundaryEvent = new BoundaryEvent();
BpmnXMLUtil.AddXMLLocation(boundaryEvent, xtr);
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_BOUNDARY_CANCELACTIVITY)))
{
string cancelActivity = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_BOUNDARY_CANCELACTIVITY);
if (BpmnXMLConstants.ATTRIBUTE_VALUE_FALSE.Equals(cancelActivity, StringComparison.CurrentCultureIgnoreCase))
{
boundaryEvent.CancelActivity = false;
}
}
boundaryEvent.AttachedToRefId = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_BOUNDARY_ATTACHEDTOREF);
ParseChildElements(XMLElementName, boundaryEvent, model, xtr);
// Explicitly set cancel activity to false for error boundary events
if (boundaryEvent.EventDefinitions.Count == 1)
{
EventDefinition eventDef = boundaryEvent.EventDefinitions[0];
if (eventDef is ErrorEventDefinition)
{
boundaryEvent.CancelActivity = false;
}
}
return(boundaryEvent);
}
public virtual void Parse(XMLStreamReader xtr, BpmnModel model)
{
model.TargetNamespace = xtr.GetAttributeValue(BpmnXMLConstants.TARGET_NAMESPACE_ATTRIBUTE);
for (int i = 0; i < xtr.NamespaceCount; i++)
{
string prefix = xtr.GetNamespacePrefix(i);
if (!string.IsNullOrWhiteSpace(prefix))
{
model.AddNamespace(prefix, xtr.GetNamespaceURI(i));
}
}
for (int i = 0; i < xtr.AttributeCount; i++)
{
var attr = xtr.element.Attributes().ElementAt(i);
ExtensionAttribute extensionAttribute = new ExtensionAttribute
{
Name = attr.Name.LocalName,
Value = attr.Value
};
if (!string.IsNullOrWhiteSpace(attr.Name.NamespaceName))
{
extensionAttribute.Namespace = attr.Name.NamespaceName;
}
if (!string.IsNullOrWhiteSpace(xtr.element.GetPrefixOfNamespace(attr.Name.Namespace)))
{
extensionAttribute.NamespacePrefix = xtr.element.GetPrefixOfNamespace(attr.Name.Namespace);
}
if (!BpmnXMLUtil.IsBlacklisted(extensionAttribute, defaultAttributes))
{
model.AddDefinitionsAttribute(extensionAttribute);
}
}
}
public static void WriteLanes(Process process, XMLStreamWriter xtw)
{
if (process.Lanes.Count > 0)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_LANESET, BpmnXMLConstants.BPMN2_NAMESPACE);
xtw.WriteAttribute(BpmnXMLConstants.ATTRIBUTE_ID, "laneSet_" + process.Id);
foreach (Lane lane in process.Lanes)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_LANE, BpmnXMLConstants.BPMN2_NAMESPACE);
xtw.WriteAttribute(BpmnXMLConstants.ATTRIBUTE_ID, lane.Id);
if (!string.IsNullOrWhiteSpace(lane.Name))
{
xtw.WriteAttribute(BpmnXMLConstants.ATTRIBUTE_NAME, lane.Name);
}
bool didWriteExtensionStartElement = BpmnXMLUtil.WriteExtensionElements(lane, false, xtw);
if (didWriteExtensionStartElement)
{
xtw.WriteEndElement();
}
foreach (string flowNodeRef in lane.FlowReferences)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_FLOWNODE_REF, BpmnXMLConstants.BPMN2_NAMESPACE);
xtw.WriteCharacters(flowNodeRef);
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
}
protected internal override void WriteAdditionalAttributes(BaseElement element, BpmnModel model, XMLStreamWriter xtw)
{
UserTask userTask = (UserTask)element;
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_ASSIGNEE, userTask.Assignee, xtw);
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_OWNER, userTask.Owner, xtw);
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_CANDIDATEUSERS, ConvertToDelimitedString(userTask.CandidateUsers), xtw);
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_CANDIDATEGROUPS, ConvertToDelimitedString(userTask.CandidateGroups), xtw);
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_DUEDATE, userTask.DueDate, xtw);
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_BUSINESS_CALENDAR_NAME, userTask.BusinessCalendarName, xtw);
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_CATEGORY, userTask.Category, xtw);
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_FORM_FORMKEY, userTask.FormKey, xtw);
if (userTask.Priority != null)
{
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_PRIORITY, userTask.Priority.ToString(), xtw);
}
if (!string.IsNullOrWhiteSpace(userTask.ExtensionId))
{
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_EXTENSIONID, userTask.ExtensionId, xtw);
}
if (userTask.SkipExpression != null)
{
WriteQualifiedAttribute(BpmnXMLConstants.ATTRIBUTE_TASK_USER_SKIP_EXPRESSION, userTask.SkipExpression, xtw);
}
// write custom attributes
BpmnXMLUtil.WriteCustomAttributes(userTask.Attributes.Values, xtw, defaultElementAttributes, defaultActivityAttributes, defaultUserTaskAttributes);
}
public virtual void Parse(XMLStreamReader xtr, BpmnModel model)
{
string resourceId = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ID);
string resourceName = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_NAME);
Resource resource;
if (model.ContainsResourceId(resourceId))
{
resource = model.GetResource(resourceId);
resource.Name = resourceName;
foreach (Process process in model.Processes)
{
foreach (FlowElement fe in process.FlowElements)
{
if (fe is UserTask && ((UserTask)fe).CandidateGroups.Contains(resourceId))
{
((UserTask)fe).CandidateGroups.Remove(resourceId);
((UserTask)fe).CandidateGroups.Add(resourceName);
}
}
}
}
else
{
resource = new Resource(resourceId, resourceName);
model.AddResource(resource);
}
BpmnXMLUtil.AddXMLLocation(resource, xtr);
}
public virtual void Parse(XMLStreamReader xtr, BpmnModel model)
{
string id = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ID);
if (!string.IsNullOrWhiteSpace(id))
{
DataStore dataStore = new DataStore();
dataStore.Id = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ID);
string name = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_NAME);
if (!string.IsNullOrWhiteSpace(name))
{
dataStore.Name = name;
}
string itemSubjectRef = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ITEM_SUBJECT_REF);
if (!string.IsNullOrWhiteSpace(itemSubjectRef))
{
dataStore.ItemSubjectRef = itemSubjectRef;
}
BpmnXMLUtil.AddXMLLocation(dataStore, xtr);
model.AddDataStore(dataStore.Id, dataStore);
BpmnXMLUtil.ParseChildElements(BpmnXMLConstants.ELEMENT_DATA_STORE, dataStore, xtr, model);
}
}
public virtual void Parse(XMLStreamReader xtr, BpmnModel model)
{
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ID)))
{
string itemDefinitionId = model.TargetNamespace + ":" + xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ID);
string structureRef = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_STRUCTURE_REF);
if (!string.IsNullOrWhiteSpace(structureRef))
{
ItemDefinition item = new ItemDefinition();
item.Id = itemDefinitionId;
BpmnXMLUtil.AddXMLLocation(item, xtr);
int indexOfP = structureRef.IndexOf(':');
if (indexOfP != -1)
{
string prefix = structureRef.Substring(0, indexOfP);
string resolvedNamespace = model.GetNamespace(prefix);
structureRef = resolvedNamespace + ":" + structureRef.Substring(indexOfP + 1);
}
else
{
structureRef = model.TargetNamespace + ":" + structureRef;
}
item.StructureRef = structureRef;
item.ItemKind = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ITEM_KIND);
BpmnXMLUtil.ParseChildElements(BpmnXMLConstants.ELEMENT_ITEM_DEFINITION, item, xtr, model);
model.AddItemDefinition(itemDefinitionId, item);
}
}
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
DataStoreReference dataStoreRef = new DataStoreReference();
BpmnXMLUtil.AddXMLLocation(dataStoreRef, xtr);
ParseChildElements(XMLElementName, dataStoreRef, model, xtr);
return(dataStoreRef);
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
EventGateway gateway = new EventGateway();
BpmnXMLUtil.AddXMLLocation(gateway, xtr);
ParseChildElements(XMLElementName, gateway, model, xtr);
return(gateway);
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
ReceiveTask receiveTask = new ReceiveTask();
BpmnXMLUtil.AddXMLLocation(receiveTask, xtr);
ParseChildElements(XMLElementName, receiveTask, model, xtr);
return(receiveTask);
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
EndEvent endEvent = new EndEvent();
BpmnXMLUtil.AddXMLLocation(endEvent, xtr);
ParseChildElements(XMLElementName, endEvent, model, xtr);
return(endEvent);
}
public virtual void Parse(XMLStreamReader xtr, BpmnModel model)
{
string id = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_DI_BPMNELEMENT);
IList <GraphicInfo> wayPointList = new List <GraphicInfo>();
while (xtr.HasNext())
{
//xtr.next();
if (xtr.IsStartElement() && BpmnXMLConstants.ELEMENT_DI_LABEL.Equals(xtr.LocalName, StringComparison.CurrentCultureIgnoreCase))
{
while (xtr.HasNext())
{
//xtr.next();
if (xtr.IsStartElement() && BpmnXMLConstants.ELEMENT_DI_BOUNDS.Equals(xtr.LocalName, StringComparison.CurrentCultureIgnoreCase))
{
GraphicInfo graphicInfo = new GraphicInfo();
BpmnXMLUtil.AddXMLLocation(graphicInfo, xtr);
graphicInfo.X = Convert.ToDouble(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_DI_X));
graphicInfo.Y = Convert.ToDouble(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_DI_Y));
graphicInfo.Width = Convert.ToDouble(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_DI_WIDTH));
graphicInfo.Height = Convert.ToDouble(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_DI_HEIGHT));
model.AddLabelGraphicInfo(id, graphicInfo);
break;
}
else if (xtr.EndElement && BpmnXMLConstants.ELEMENT_DI_LABEL.Equals(xtr.LocalName, StringComparison.CurrentCultureIgnoreCase))
{
break;
}
if (xtr.IsEmptyElement && BpmnXMLConstants.ELEMENT_DI_LABEL.Equals(xtr.LocalName, StringComparison.CurrentCultureIgnoreCase))
{
break;
}
}
}
else if (xtr.IsStartElement() && BpmnXMLConstants.ELEMENT_DI_WAYPOINT.Equals(xtr.LocalName, StringComparison.CurrentCultureIgnoreCase))
{
GraphicInfo graphicInfo = new GraphicInfo();
BpmnXMLUtil.AddXMLLocation(graphicInfo, xtr);
graphicInfo.X = Convert.ToDouble(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_DI_X));
graphicInfo.Y = Convert.ToDouble(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_DI_Y));
wayPointList.Add(graphicInfo);
}
else if (xtr.EndElement && BpmnXMLConstants.ELEMENT_DI_EDGE.Equals(xtr.LocalName, StringComparison.CurrentCultureIgnoreCase))
{
break;
}
if (xtr.IsEmptyElement && BpmnXMLConstants.ELEMENT_DI_EDGE.Equals(xtr.LocalName, StringComparison.CurrentCultureIgnoreCase))
{
break;
}
}
model.AddFlowGraphicInfoList(id, wayPointList);
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
TextAnnotation textAnnotation = new TextAnnotation();
BpmnXMLUtil.AddXMLLocation(textAnnotation, xtr);
textAnnotation.TextFormat = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_TEXTFORMAT);
ParseChildElements(XMLElementName, textAnnotation, childParserMap, model, xtr);
return(textAnnotation);
}
public virtual void Parse(XMLStreamReader xtr, BpmnModel model)
{
Import importObject = new Import();
BpmnXMLUtil.AddXMLLocation(importObject, xtr);
importObject.ImportType = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_IMPORT_TYPE);
importObject.Namespace = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_NAMESPACE);
importObject.Location = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LOCATION);
model.Imports.Add(importObject);
}
protected internal virtual void ParseChildElements(string elementName, BaseElement parentElement, IDictionary <string, BaseChildElementParser> additionalParsers, BpmnModel model, XMLStreamReader xtr)
{
IDictionary <string, BaseChildElementParser> childParsers = new Dictionary <string, BaseChildElementParser>();
if (additionalParsers != null)
{
childParsers.PutAll(additionalParsers);
}
BpmnXMLUtil.ParseChildElements(elementName, parentElement, xtr, childParsers, model);
}
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
{
if (!(parentElement is Event))
{
return;
}
CancelEventDefinition eventDefinition = new CancelEventDefinition();
BpmnXMLUtil.AddXMLLocation(eventDefinition, xtr);
((Event)parentElement).EventDefinitions.Add(eventDefinition);
}
protected internal virtual void WriteCancelDefinition(Event parentEvent, CancelEventDefinition cancelEventDefinition, XMLStreamWriter xtw)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EVENT_CANCELDEFINITION, BpmnXMLConstants.BPMN2_NAMESPACE);
bool didWriteExtensionStartElement = BpmnXMLUtil.WriteExtensionElements(cancelEventDefinition, false, xtw);
if (didWriteExtensionStartElement)
{
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
public virtual void Parse(XMLStreamReader xtr, Process activeProcess, BpmnModel model)
{
Lane lane = new Lane();
BpmnXMLUtil.AddXMLLocation(lane, xtr);
lane.Id = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ID);
lane.Name = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_NAME);
lane.ParentProcess = activeProcess;
activeProcess.Lanes.Add(lane);
BpmnXMLUtil.ParseChildElements(BpmnXMLConstants.ELEMENT_LANE, lane, xtr, model);
}
private static bool WriteListeners(string xmlElementName, IList <ActivitiListener> listenerList, bool didWriteExtensionStartElement, XMLStreamWriter xtw)
{
if (listenerList != null)
{
foreach (ActivitiListener listener in listenerList)
{
if (!string.IsNullOrWhiteSpace(listener.Event))
{
if (!didWriteExtensionStartElement)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EXTENSIONS, BpmnXMLConstants.BPMN2_NAMESPACE);
didWriteExtensionStartElement = true;
}
xtw.WriteStartElement(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, xmlElementName, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_EVENT, listener.Event, xtw);
if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.Equals(listener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_CLASS, listener.Implementation, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.Equals(listener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_EXPRESSION, listener.Implementation, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.Equals(listener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_DELEGATEEXPRESSION, listener.Implementation, xtw);
}
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_ON_TRANSACTION, listener.OnTransaction, xtw);
if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.Equals(listener.CustomPropertiesResolverImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_CUSTOM_PROPERTIES_RESOLVER_CLASS, listener.CustomPropertiesResolverImplementation, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.Equals(listener.CustomPropertiesResolverImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_CUSTOM_PROPERTIES_RESOLVER_EXPRESSION, listener.CustomPropertiesResolverImplementation, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.Equals(listener.CustomPropertiesResolverImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_CUSTOM_PROPERTIES_RESOLVER_DELEGATEEXPRESSION, listener.CustomPropertiesResolverImplementation, xtw);
}
FieldExtensionExport.WriteFieldExtensions(listener.FieldExtensions, true, xtw);
xtw.WriteEndElement();
}
}
}
return(didWriteExtensionStartElement);
}
protected internal virtual void WriteErrorDefinition(Event parentEvent, ErrorEventDefinition errorDefinition, XMLStreamWriter xtw)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EVENT_ERRORDEFINITION, BpmnXMLConstants.BPMN2_NAMESPACE);
WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_ERROR_REF, errorDefinition.ErrorCode, xtw);
bool didWriteExtensionStartElement = BpmnXMLUtil.WriteExtensionElements(errorDefinition, false, xtw);
if (didWriteExtensionStartElement)
{
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
protected internal virtual void WriteCompensateDefinition(Event parentEvent, CompensateEventDefinition compensateEventDefinition, XMLStreamWriter xtw)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EVENT_COMPENSATEDEFINITION, BpmnXMLConstants.BPMN2_NAMESPACE);
WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_COMPENSATE_ACTIVITYREF, compensateEventDefinition.ActivityRef, xtw);
bool didWriteExtensionStartElement = BpmnXMLUtil.WriteExtensionElements(compensateEventDefinition, false, xtw);
if (didWriteExtensionStartElement)
{
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
CallActivity callActivity = new CallActivity();
BpmnXMLUtil.AddXMLLocation(callActivity, xtr);
callActivity.CalledElement = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_CALL_ACTIVITY_CALLEDELEMENT);
callActivity.BusinessKey = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_CALL_ACTIVITY_BUSINESS_KEY);
bool.TryParse(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_CALL_ACTIVITY_INHERIT_BUSINESS_KEY), out callActivity.inheritBusinessKey);
bool.TryParse(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_CALL_ACTIVITY_INHERITVARIABLES), out callActivity.inheritVariables);
ParseChildElements(XMLElementName, callActivity, childParserMap, model, xtr);
return(callActivity);
}
public virtual void Parse(XMLStreamReader xtr, BpmnModel model)
{
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ID)))
{
string messageId = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ID);
string messageName = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_NAME);
string itemRef = ParseItemRef(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_ITEM_REF), model);
Message message = new Message(messageId, messageName, itemRef);
BpmnXMLUtil.AddXMLLocation(message, xtr);
BpmnXMLUtil.ParseChildElements(BpmnXMLConstants.ELEMENT_MESSAGE, message, xtr, model);
model.AddMessage(message);
}
}
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
{
if (!(parentElement is Activity))
{
return;
}
DataAssociation dataAssociation = new DataAssociation();
BpmnXMLUtil.AddXMLLocation(dataAssociation, xtr);
DataAssociationParser.parseDataAssociation(dataAssociation, ElementName, xtr);
((Activity)parentElement).DataInputAssociations.Add(dataAssociation);
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
string formKey = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_FORM_FORMKEY);
UserTask userTask = null;
if (!string.IsNullOrWhiteSpace(formKey))
{
if (model.UserTaskFormTypes != null && model.UserTaskFormTypes.Contains(formKey))
{
userTask = new AlfrescoUserTask();
}
}
if (userTask == null)
{
userTask = new UserTask();
}
BpmnXMLUtil.AddXMLLocation(userTask, xtr);
userTask.DueDate = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_DUEDATE);
userTask.BusinessCalendarName = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_BUSINESS_CALENDAR_NAME);
userTask.Category = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_CATEGORY);
userTask.FormKey = formKey;
userTask.Assignee = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_ASSIGNEE);
userTask.Owner = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_OWNER);
userTask.Priority = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_PRIORITY);
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_CANDIDATEUSERS)))
{
string expression = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_CANDIDATEUSERS);
(userTask.CandidateUsers as List <string>).AddRange(ParseDelimitedList(expression));
}
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_CANDIDATEGROUPS)))
{
string expression = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_CANDIDATEGROUPS);
(userTask.CandidateGroups as List <string>).AddRange(ParseDelimitedList(expression));
}
userTask.ExtensionId = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_SERVICE_EXTENSIONID);
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_SKIP_EXPRESSION)))
{
string expression = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_TASK_USER_SKIP_EXPRESSION);
userTask.SkipExpression = expression;
}
BpmnXMLUtil.AddCustomAttributes(xtr, userTask, defaultElementAttributes, defaultActivityAttributes, defaultUserTaskAttributes);
ParseChildElements(XMLElementName, userTask, childParserMap, model, xtr);
return(userTask);
}
protected internal static bool WriteEventListeners(IList <EventListener> eventListeners, bool didWriteExtensionStartElement, XMLStreamWriter xtw)
{
if (eventListeners != null && eventListeners.Count > 0)
{
foreach (EventListener eventListener in eventListeners)
{
if (!didWriteExtensionStartElement)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EXTENSIONS, BpmnXMLConstants.BPMN2_NAMESPACE);
didWriteExtensionStartElement = true;
}
xtw.WriteStartElement(BpmnXMLConstants.ACTIVITI_EXTENSIONS_PREFIX, BpmnXMLConstants.ELEMENT_EVENT_LISTENER, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE);
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_EVENTS, eventListener.Events, xtw);
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_ENTITY_TYPE, eventListener.EntityType, xtw);
if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.Equals(eventListener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_CLASS, eventListener.Implementation, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.Equals(eventListener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_DELEGATEEXPRESSION, eventListener.Implementation, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_SIGNAL_EVENT.Equals(eventListener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_SIGNAL_EVENT_NAME, eventListener.Implementation, xtw);
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE, BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE_SIGNAL, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_GLOBAL_SIGNAL_EVENT.Equals(eventListener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_SIGNAL_EVENT_NAME, eventListener.Implementation, xtw);
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE, BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE_GLOBAL_SIGNAL, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_MESSAGE_EVENT.Equals(eventListener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_MESSAGE_EVENT_NAME, eventListener.Implementation, xtw);
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE, BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE_MESSAGE, xtw);
}
else if (ImplementationType.IMPLEMENTATION_TYPE_THROW_ERROR_EVENT.Equals(eventListener.ImplementationType))
{
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_ERROR_EVENT_CODE, eventListener.Implementation, xtw);
BpmnXMLUtil.WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE, BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE_ERROR, xtw);
}
xtw.WriteEndElement();
}
}
return(didWriteExtensionStartElement);
}
protected internal override BaseElement ConvertXMLToElement(XMLStreamReader xtr, BpmnModel model)
{
SequenceFlow sequenceFlow = new SequenceFlow();
BpmnXMLUtil.AddXMLLocation(sequenceFlow, xtr);
sequenceFlow.SourceRef = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_FLOW_SOURCE_REF);
sequenceFlow.TargetRef = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_FLOW_TARGET_REF);
sequenceFlow.Name = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_NAME);
sequenceFlow.SkipExpression = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_FLOW_SKIP_EXPRESSION);
ParseChildElements(XMLElementName, sequenceFlow, model, xtr);
return(sequenceFlow);
}
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
{
EventListener listener = new EventListener();
BpmnXMLUtil.AddXMLLocation(listener, xtr);
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_CLASS)))
{
listener.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_CLASS);
listener.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_CLASS;
}
else if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_DELEGATEEXPRESSION)))
{
listener.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_DELEGATEEXPRESSION);
listener.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION;
}
else if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE)))
{
string eventType = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE);
if (BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE_SIGNAL.Equals(eventType))
{
listener.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_THROW_SIGNAL_EVENT;
listener.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_SIGNAL_EVENT_NAME);
}
else if (BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE_GLOBAL_SIGNAL.Equals(eventType))
{
listener.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_THROW_GLOBAL_SIGNAL_EVENT;
listener.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_SIGNAL_EVENT_NAME);
}
else if (BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE_MESSAGE.Equals(eventType))
{
listener.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_THROW_MESSAGE_EVENT;
listener.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_MESSAGE_EVENT_NAME);
}
else if (BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_EVENT_TYPE_ERROR.Equals(eventType))
{
listener.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_THROW_ERROR_EVENT;
listener.Implementation = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_THROW_ERROR_EVENT_CODE);
}
else
{
listener.ImplementationType = ImplementationType.IMPLEMENTATION_TYPE_INVALID_THROW_EVENT;
}
}
listener.Events = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_EVENTS);
listener.EntityType = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_LISTENER_ENTITY_TYPE);
Process parentProcess = (Process)parentElement;
parentProcess.EventListeners.Add(listener);
}
