I have started using jbpm suite and would like to ask, is there a way I can link or refer my business rule task or decision task directly to DMN file ? (or decision tree) rather going through facts, rules or action (Drools). If yes, pls provide any example or reference url
Yes it is possible to link DMN in the BPMN editor for the Business Rule Task, you can select "DMN" instead of DRL.
Then in the Data I/O as input you need to supply namespace+name of the DMN model you want to evaluate, along with the required Input Data, and mapping of the required Decision which are meant to be used as output.
Example:
model namespace
model name
required Input Data
required Decision result to be used as output.
The following presentation contains a comprehensive demo of BPMN and DMN integration, if that might be of help: https://youtu.be/C0u3ZDiH3ek?t=15m2s
Related
I tried to reduce my problem to the following simple example. If the profit is low and the customer is not a regular one then the order should become canceled. In all other cases (low/regular, high/*) the order is to be executed. How should I model the disconnected part in the middle?
Wheter or not the client corresponding to order is a regular client follows from the data model:
I assume you are looking for the formally correct way to model this. Here it is:
If less formality is sufficient, you could skip the decision input flows and simply assume that the guards have access to any objects in the scope of the activity. Then one decision node is sufficient with a guard [profit=low AND not order.customer.regular Customer].
Is there any other way to pass on variables between tasks beside using
process.var_name= value
process.save()
activation.done()
and then accessing it like,
activation.process.var_name
limitation with this approach is I have to declare a var_name member in model. I want to escape from declaring new members in model.
So any approach for passing variables between tasks without using models.
Viewflow is a thin workflow layer on top of django. So your question could be reformulated as "how to pass an object b/w views in django"
Except if your case is about one task executed immediately after another during single HTTP request processing. In that case, you should use just python functions and pass an object as a parameter as usual. On the viewflow layer - it would be a single task. So no inter-task communication would happen.
One of the goals of BPMN workflow automation is to provide an ability to build performance reports based on the workflow data. So, to report friendly saving workflow data in a process mode is mandatory.
In a very few cases, you can consider use redis or memcached to keep workflow data in it. But it's highly unrecommended.
Another rare case is to combine View and Gateway task in a single custom task node. So you can take a view data and pass it to activation.done to make a branching decision without data saving.
I know that AndroMDA generate code from UML model,
my question is:
it is possible to generate code from BPMN model (Business Process Model and Notation) with androMDA (i.e create a new cartridge which support BPMN)?
Common practice is not to generate code for BPMN model, but interpret it, Take a look on jBPM cartrige for AndroMDA.
What is the role of ontologies in natural language processing when using GATE?
As I understand it, at a high level, an ontology allows for the modelling of a domain consisting of classes, their instances, properties of these instances and relationships between classes in the domain.
However is there an advantage to creating a custom ontology when working with GATE?
Or can processing be as effective using the only the built in processing resources provided by ANNIE?
You can check this tutorial on ontologies in GATE.
As stated in the pdf:
Link annotations to concepts in a knowledge base.
The annotated text is a “Mention” of a concept in the KB
We can use the knowledge associated with Mentions in our IE pipeline: e.g. Persons have JobTitles, Cities have zip codes
We can use the knowledge associated with Mentions for “Semantic Search”
We can use semantically annotated documents to add new facts to our knowledge base
In the process of annotation, ontology data (instances, classes, relations, etc.) can be used by JAPE for smarter matching, i.e. matching a mention with class "engineer", knowing that "engineer" is a subclass of a "person". Also there are ontology-aware gazetteers which can create annotations based on instances and put the right class and uri for the created annotations.
The last two questions are too generic but I'll try...
After following the tutorial, you'll know exactly how to use ontologies for annotation, hence you'll know if you need to create a custom ontology for your task.
ANNIE is an example of a pipeline and a good place to start studying GATE and writing your own application.
I designed a data model which is represented by an XSD scheme.
The data model also provides the types that are being used as web service parameters in a WSDL descriptor.
I would like to send the XSD scheme around and ask the people involved to peer review the data model.
What tool or presentation method would you suggest to be used as a basis for peer reviews? The data model should be readable for non-skilled people, at least when it comes to the semantic meanings of the parameters
Edit:
To be more specific: Of course, syntactically, the scheme validates. Actually I'm already working on code which is based on JAXB generated classes. My goal is
to freeze the data model and thus
the input parameters
to make sure
nothing got lost or forgotten from a
semantic (in the meaning of
business-relevant) point of view.
Edit 2
I've been thinking about how it probably would be best to spread a datamodel around. I'm thinking of something like a JavaDoc for XSD schemas. Anyone knows if something like that exists? Basically it would be done with a set of XSLTs, right?
I know the following tools that generate documentation from XML Schema files (XSD):
xs3p
XSLT stylesheet that generates single XHTML from XSD
xsddoc
free / LGPL
mainly XSLT based
JavaDoc like output
see xsddoc examples
xnsdoc
improved commercial version of xsddoc
free for personal/educational use
JavaDoc like output
XSDdoc 2.0
commercial
JavaDoc like output
For small a XML schema, I would probably suggest using the xs3p XSLT stylesheet. For more a complex schema, I suggest using xsddoc.
I recommend using the XSD for something. Specifically, show some actual applications, with examples as real code.
Actual applications are what make a schema interesting. The examples don't have to be big, sophisticated or completely realistic. They just have to compile. Other people will want to copy and paste the code samples.
These examples are the "hello world" of the schema. And they act as a kind of unit test for the schema.
The closest thing to Javadoc for an XML schema that I've seen is running the Javadoc tool on source generated from the schema. This requires two things: 1) That your schema has internal annotation elements documenting it, and that 2) your source generator uses those annotations as Javadoc elements.
The very useful Oxygen XML developer also supports generating documentation, see
http://www.oxygenxml.com/xml_schema_documentation.html
(commercial, but there's a fully functional 30 day trial available)
I'll try it out now, need a simple way to generate a document with all types and available xsd:documentation description as a simple interface description...
** Disclosure : I work for Innovasys, the producer of the documentation tool mentioned below *
You could take a look at Innovasys Document! X. As well as automatically generating a structured and linked page for every element, simple type, complex type, group and attribute group it will also generate linked XSD diagrams (including sequences/choice etc.) and structure tables that include the annotations from your XSDs and make sense of the relationships between the elements in your schemas. The output is template based so you can adapt it to your preferred style and structure. It will build output to web ready html or compiled help files.
Uniquely it also includes a WYSIWYG editor that allows you author additional content to supplement the stuff that's automatically generated and the annotations from the XSD source - so you can provide additional contextual information for your peer review. There is also a Community Extensions feature that allows people viewing the generated output to record comments and feedback and that can be viewed and actioned directly from within Document! X.