//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; } } }