//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sentryTransformWithSameVariableOnPartTwice()
public virtual void sentryTransformWithSameVariableOnPartTwice()
{
// given
ExtensionElements extensionElements = createElement(sentry, "extensionElements", typeof(ExtensionElements));
CamundaVariableOnPart variableOnPart = createElement(extensionElements, null, typeof(CamundaVariableOnPart));
createElement(variableOnPart, null, typeof(CamundaVariableTransitionEvent));
variableOnPart.VariableEvent = VariableTransition.create;
variableOnPart.VariableName = "aVariable";
CamundaVariableOnPart additionalVariableOnPart = createElement(extensionElements, null, typeof(CamundaVariableOnPart));
createElement(additionalVariableOnPart, null, typeof(CamundaVariableTransitionEvent));
additionalVariableOnPart.VariableEvent = VariableTransition.create;
additionalVariableOnPart.VariableName = "aVariable";
CmmnSentryDeclaration sentryDeclaration = sentryHandler.handleElement(sentry, context);
// then
assertNotNull(sentryDeclaration);
IList <CmmnVariableOnPartDeclaration> variableOnParts = sentryDeclaration.VariableOnParts;
assertNotNull(variableOnParts);
assertFalse(variableOnParts.Count == 0);
assertEquals(1, variableOnParts.Count);
}
/// <summary>takes the updated entry returned and sets the properties to this object</summary>
/// <param name="updatedEntry"> </param>
protected void CopyEntry(AtomEntry updatedEntry)
{
Tracing.Assert(updatedEntry != null, "updatedEntry should not be null");
if (updatedEntry == null)
{
throw new ArgumentNullException("updatedEntry");
}
_title = updatedEntry.Title;
_authors = updatedEntry.Authors;
_id = updatedEntry.Id;
_links = updatedEntry.Links;
_lastUpdateDate = updatedEntry.Updated;
_publicationDate = updatedEntry.Published;
_authors = updatedEntry.Authors;
_rights = updatedEntry.Rights;
_categories = updatedEntry.Categories;
_summary = updatedEntry.Summary;
_content = updatedEntry.Content;
_source = updatedEntry.Source;
ExtensionElements.Clear();
foreach (IExtensionElementFactory extension in updatedEntry.ExtensionElements)
{
ExtensionElements.Add(extension);
}
}
protected internal virtual T getCreateSingleExtensionElement <T>(Type typeClass) where T : BpmnModelElementInstance
{
typeClass = typeof(T);
ExtensionElements extensionElements = getCreateSingleChild(typeof(ExtensionElements));
return(getCreateSingleChild(extensionElements, typeClass));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sentryTransformWithMultipleVariableEvent()
public virtual void sentryTransformWithMultipleVariableEvent()
{
// given
ExtensionElements extensionElements = createElement(sentry, "extensionElements", typeof(ExtensionElements));
CamundaVariableOnPart variableOnPart = createElement(extensionElements, null, typeof(CamundaVariableOnPart));
CamundaVariableTransitionEvent transitionEvent = createElement(variableOnPart, null, typeof(CamundaVariableTransitionEvent));
transitionEvent.TextContent = "create";
CamundaVariableTransitionEvent additionalTransitionEvent = createElement(variableOnPart, null, typeof(CamundaVariableTransitionEvent));
additionalTransitionEvent.TextContent = "delete";
variableOnPart.VariableName = "aVariable";
CmmnSentryDeclaration sentryDeclaration = sentryHandler.handleElement(sentry, context);
// then
assertNotNull(sentryDeclaration);
IList <CmmnVariableOnPartDeclaration> variableOnParts = sentryDeclaration.VariableOnParts;
assertNotNull(variableOnParts);
assertFalse(variableOnParts.Count == 0);
assertEquals(1, variableOnParts.Count);
CmmnVariableOnPartDeclaration transformedVariableOnPart = variableOnParts[0];
assertEquals("aVariable", transformedVariableOnPart.VariableName);
// when there are multiple variable events then, only first variable event is considered.
assertEquals(VariableTransition.create.name(), transformedVariableOnPart.VariableEvent);
}
/// <summary>
/// Add an extension element to the element.
/// </summary>
/// <param name="extensionElement"> the extension element to add </param>
/// <returns> the builder object </returns>
public virtual B addExtensionElement(BpmnModelElementInstance extensionElement)
{
ExtensionElements extensionElements = getCreateSingleChild(typeof(ExtensionElements));
extensionElements.addChildElement(extensionElement);
return(myself);
}
///////////////////////////////////////////////////////////////////////
/// <summary>Adds element from the gm: namespace</summary>
///////////////////////////////////////////////////////////////////////
internal bool AddFromMetaNamespace(XmlNode node)
{
if (String.Compare(node.NamespaceURI,
GBaseNameTable.NSGBaseMeta, true) == 0)
{
switch (node.LocalName)
{
case "item_type":
ExtensionElements.Add(MetadataItemType.Parse(node));
break;
case "attributes":
ExtensionElements.Add(ItemTypeAttributes.Parse(node));
break;
case "attribute":
ExtensionElements.Add(AttributeHistogram.Parse(node));
break;
case "stats":
ExtensionElements.Add(Stats.Parse(node));
break;
default:
return(false);
}
return(true);
}
return(false);
}
/// <summary>
/// used to copy the unknown childnodes for later saving
/// </summary>
/// <param name="node">the node to process</param>
/// <param name="parser">the feed parser to pass down if need be</param>
public override void ProcessChildNodes(XmlNode node, AtomFeedParser parser)
{
if (node != null && node.HasChildNodes)
{
XmlNode childNode = node.FirstChild;
while (childNode != null)
{
bool fProcessed = false;
if (childNode is XmlElement)
{
foreach (IExtensionElementFactory f in this.ExtensionFactories)
{
if (String.Compare(childNode.NamespaceURI, f.XmlNameSpace) == 0)
{
if (String.Compare(childNode.LocalName, f.XmlName) == 0)
{
//Tracing.TraceMsg("Added extension to SimpleContainer for: " + f.XmlName);
ExtensionElements.Add(f.CreateInstance(childNode, parser));
fProcessed = true;
break;
}
}
}
}
if (fProcessed == false)
{
this.ChildNodes.Add(childNode);
}
childNode = childNode.NextSibling;
}
}
}
/// <summary>
/// finds our position element, if we don't have one
/// creates a new one depending on the fCreate parameter
/// </summary>
/// <param name="create">creates the subelements on true</param>
/// <returns>GeoKmlPosition</returns>
protected GeoKmlPosition GetPosition(bool create)
{
GeoKmlPoint point = FindExtension(
GeoNametable.GeoKmlPointElement,
GeoNametable.NSGeoKml) as GeoKmlPoint;
GeoKmlPosition position = null;
if (point == null && create)
{
point = new GeoKmlPoint();
ExtensionElements.Add(point);
}
if (point != null)
{
position = point.FindExtension(
GeoNametable.GeoKmlPositionElement,
GeoNametable.NSGeoKml) as GeoKmlPosition;
if (position == null && create)
{
position = new GeoKmlPosition("0 0");
point.ExtensionElements.Add(position);
}
}
return(position);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testClassDelegateHandling()
public virtual void testClassDelegateHandling()
{
ExtensionElements extensionElements = SpecUtil.createElement(modelInstance, caseTask, null, typeof(ExtensionElements));
CamundaVariableListener variableListener = SpecUtil.createElement(modelInstance, extensionElements, null, typeof(CamundaVariableListener));
CamundaField field = SpecUtil.createElement(modelInstance, variableListener, null, typeof(CamundaField));
field.CamundaName = "fieldName";
field.CamundaStringValue = "a string value";
variableListener.CamundaClass = "a.class.Name";
// when
CmmnActivity activity = handler.handleElement(planItem, context);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<org.camunda.bpm.engine.delegate.VariableListener<?>> listeners = activity.getVariableListenersLocal(org.camunda.bpm.engine.delegate.CaseVariableListener_Fields.CREATE);
IList <VariableListener <object> > listeners = activity.getVariableListenersLocal([email protected]_Fields.CREATE);
Assert.assertEquals(1, listeners.Count);
ClassDelegateCaseVariableListener listener = (ClassDelegateCaseVariableListener)listeners[0];
Assert.assertEquals("a.class.Name", listener.ClassName);
Assert.assertEquals(1, listener.FieldDeclarations.Count);
Assert.assertEquals("fieldName", listener.FieldDeclarations[0].Name);
object fieldValue = listener.FieldDeclarations[0].Value;
assertTrue(fieldValue is Expression);
Expression expressionValue = (Expression)fieldValue;
assertEquals("a string value", expressionValue.ExpressionText);
Assert.assertEquals(listener, activity.getVariableListenersLocal([email protected]_Fields.UPDATE)[0]);
Assert.assertEquals(listener, activity.getVariableListenersLocal([email protected]_Fields.DELETE)[0]);
}
private void addExecutionListener(BaseElement element, string eventName)
{
ExtensionElements extensionElements = element.ModelInstance.newInstance(typeof(ExtensionElements));
ModelElementInstance executionListener = extensionElements.addExtensionElement(CAMUNDA_NS, "executionListener");
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
executionListener.setAttributeValueNs(CAMUNDA_NS, "class", typeof(ModelExecutionContextExecutionListener).FullName);
executionListener.setAttributeValueNs(CAMUNDA_NS, "event", eventName);
element.ExtensionElements = extensionElements;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAddParentChildElementInCorrectOrder()
public virtual void shouldAddParentChildElementInCorrectOrder()
{
// create empty model
BpmnModelInstance bpmnModelInstance = Bpmn.createEmptyModel();
// add definitions to model
Definitions definitions = bpmnModelInstance.newInstance(typeof(Definitions));
definitions.TargetNamespace = "Examples";
bpmnModelInstance.Definitions = definitions;
// add process
Process process = bpmnModelInstance.newInstance(typeof(Process));
process.Id = "messageEventDefinition";
definitions.RootElements.Add(process);
// add start event
StartEvent startEvent = bpmnModelInstance.newInstance(typeof(StartEvent));
startEvent.Id = "theStart";
process.FlowElements.Add(startEvent);
// create and add message
Message message = bpmnModelInstance.newInstance(typeof(Message));
message.Id = "start-message-id";
definitions.RootElements.Add(message);
// add message event definition to start event
MessageEventDefinition startEventMessageEventDefinition = bpmnModelInstance.newInstance(typeof(MessageEventDefinition));
startEventMessageEventDefinition.Message = message;
startEvent.EventDefinitions.Add(startEventMessageEventDefinition);
// add property after message event definition
Property property = bpmnModelInstance.newInstance(typeof(Property));
startEvent.Properties.Add(property);
// finally add an extensions element
ExtensionElements extensionElements = bpmnModelInstance.newInstance(typeof(ExtensionElements));
process.ExtensionElements = extensionElements;
// validate model
try
{
Bpmn.validateModel(bpmnModelInstance);
}
catch (ModelValidationException)
{
Assert.fail();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void sentryTransformShouldFailWithMissingVariableEvent()
public virtual void sentryTransformShouldFailWithMissingVariableEvent()
{
// given
ExtensionElements extensionElements = createElement(sentry, "extensionElements", typeof(ExtensionElements));
CamundaVariableOnPart variableOnPart = createElement(extensionElements, null, typeof(CamundaVariableOnPart));
variableOnPart.VariableName = "aVariable";
thrown.expect(typeof(CmmnTransformException));
thrown.expectMessage("The variableOnPart of the sentry with id 'aSentry' must have one valid variable event.");
sentryHandler.handleElement(sentry, context);
}
protected internal virtual IList <V> queryExtensionElementsByClass <V>(CmmnElement element, Type cls) where V : org.camunda.bpm.model.xml.instance.ModelElementInstance
{
cls = typeof(V);
ExtensionElements extensionElements = element.ExtensionElements;
if (extensionElements != null)
{
Query <ModelElementInstance> query = extensionElements.ElementsQuery;
return(query.filterByType(cls).list());
}
else
{
return(new List <V>());
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void modifyingElementWithActivitiNsKeepsIt()
public virtual void modifyingElementWithActivitiNsKeepsIt()
{
BpmnModelInstance modelInstance = Bpmn.readModelFromStream(typeof(CamundaExtensionsTest).getResourceAsStream("CamundaExtensionsCompatabilityTest.xml"));
ProcessImpl process = modelInstance.getModelElementById(PROCESS_ID);
ExtensionElements extensionElements = process.ExtensionElements;
ICollection <CamundaExecutionListener> listeners = extensionElements.getChildElementsByType(typeof(CamundaExecutionListener));
string listenerClass = "org.foo.Bar";
foreach (CamundaExecutionListener listener in listeners)
{
listener.CamundaClass = listenerClass;
}
foreach (CamundaExecutionListener listener in listeners)
{
assertThat(listener.getAttributeValueNs(BpmnModelConstants.ACTIVITI_NS, "class"), @is(listenerClass));
}
}
public virtual void addListenerToElement(CmmnModelInstance modelInstance, CmmnModelElementInstance modelElement)
{
ExtensionElements extensionElements = SpecUtil.createElement(modelInstance, modelElement, null, typeof(ExtensionElements));
CamundaCaseExecutionListener caseExecutionListener = SpecUtil.createElement(modelInstance, extensionElements, null, typeof(CamundaCaseExecutionListener));
if (!ANY_EVENT.Equals(eventNameToRegisterOn))
{
caseExecutionListener.CamundaEvent = eventNameToRegisterOn;
}
configureCaseExecutionListener(modelInstance, caseExecutionListener);
foreach (FieldSpec fieldSpec in fieldSpecs)
{
fieldSpec.addFieldToListenerElement(modelInstance, caseExecutionListener);
}
}
private void deployProcess(string eventName)
{
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess(PROCESS_ID).startEvent().userTask(USER_TASK_ID).endEvent().done();
ExtensionElements extensionElements = modelInstance.newInstance(typeof(ExtensionElements));
ModelElementInstance taskListener = extensionElements.addExtensionElement(CAMUNDA_NS, "taskListener");
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
taskListener.setAttributeValueNs(CAMUNDA_NS, "class", typeof(ModelExecutionContextTaskListener).FullName);
taskListener.setAttributeValueNs(CAMUNDA_NS, "event", eventName);
UserTask userTask = modelInstance.getModelElementById(USER_TASK_ID);
userTask.ExtensionElements = extensionElements;
deploymentId = repositoryService.createDeployment().addModelInstance("process.bpmn", modelInstance).deploy().Id;
}
public bool IsStartValid(ProcessVariablesContainer variables, IsProcessStartValid isProcessStartValid)
{
if (ExtensionElement != null)
{
ExtensionElements ee = (ExtensionElements)ExtensionElement;
if (ee.Children != null)
{
foreach (IElement ie in ee.Children)
{
if (ie is ConditionSet)
{
if (!((ConditionSet)ie).Evaluate(variables))
{
return(false);
}
}
}
}
}
return(isProcessStartValid(this, variables));
}
internal void ProcessTask(ref ProcessVariablesContainer variables, ProcessScriptTask processScriptTask)
{
if (ExtensionElement != null)
{
ExtensionElements ee = (ExtensionElements)ExtensionElement;
if (ee.Children != null)
{
foreach (IElement ie in ee.Children)
{
if (ie is AScript)
{
variables = (ProcessVariablesContainer)((AScript)ie).Invoke(variables);
break;
}
}
}
}
if (processScriptTask != null)
{
processScriptTask(this, ref variables);
}
}
/// <summary>
/// we have one string based setter
/// usage is: entry.setExtensionValue("tagname", "ns", "value") to set the element
/// this will create the extension if it's not there
/// note, you can ofcourse, just get an existing one and work with that
/// object:
/// </summary>
/// <param name="extension">the name of the extension to look for</param>
/// <param name="ns">the namespace of the extension to look for</param>
/// <param name="newValue">the new value for this extension element</param>
/// <returns>SimpleElement, either a brand new one, or the one
/// returned by the service</returns>
public SimpleElement SetExtensionValue(string extension, string ns, string newValue)
{
if (extension == null)
{
throw new System.ArgumentNullException("extension");
}
SimpleElement ele = FindExtension(extension, ns) as SimpleElement;
if (ele == null)
{
ele = CreateExtension(extension, ns) as SimpleElement;
if (ele == null)
{
throw new System.ArgumentException("The namespace or tagname was invalid");
}
ExtensionElements.Add(ele);
}
ele.Value = newValue;
return(ele);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testExpressionDelegateHandling()
public virtual void testExpressionDelegateHandling()
{
ExtensionElements extensionElements = SpecUtil.createElement(modelInstance, caseTask, null, typeof(ExtensionElements));
CamundaVariableListener variableListener = SpecUtil.createElement(modelInstance, extensionElements, null, typeof(CamundaVariableListener));
variableListener.CamundaExpression = "${expression}";
variableListener.CamundaEvent = [email protected]_Fields.CREATE;
// when
CmmnActivity activity = handler.handleElement(planItem, context);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<org.camunda.bpm.engine.delegate.VariableListener<?>> listeners = activity.getVariableListenersLocal(org.camunda.bpm.engine.delegate.CaseVariableListener_Fields.CREATE);
IList <VariableListener <object> > listeners = activity.getVariableListenersLocal([email protected]_Fields.CREATE);
Assert.assertEquals(1, listeners.Count);
ExpressionCaseVariableListener listener = (ExpressionCaseVariableListener)listeners[0];
Assert.assertEquals("${expression}", listener.ExpressionText);
Assert.assertEquals(0, activity.getVariableListenersLocal([email protected]_Fields.UPDATE).Count);
Assert.assertEquals(0, activity.getVariableListenersLocal([email protected]_Fields.DELETE).Count);
}
/// <summary>
/// Parses the inner state of the element
/// </summary>
/// <param name="e">The extension element that should be added to this entry</param>
/// <param name="parser">The AtomFeedParser that called this</param>
public virtual void Parse(ExtensionElementEventArgs e, AtomFeedParser parser)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
Tracing.TraceMsg("Entering Parse on AbstractEntry");
XmlNode node = e.ExtensionElement;
if (ExtensionFactories != null && ExtensionFactories.Count > 0)
{
Tracing.TraceMsg("Entring default Parsing for AbstractEntry");
IExtensionElementFactory f = FindExtensionFactory(
node.LocalName,
node.NamespaceURI);
if (f != null)
{
ExtensionElements.Add(f.CreateInstance(node, parser));
e.DiscardEntry = true;
}
}
}
