Re: GWT and Client-side rules engine

Thanks for your mail. I am very (very) intrigued by this project - I am currently reading through the materials on the dark-matter-project wiki to see if i can use it. Nevertheless, it is very exciting to say the least - evidently. you have done a lot of work on this.

Just so we are on the same page - let me re-iterate what I am trying to do  - with an example
Example -> I see you have mentioned eclipse modeling framework in the dark-matter-project wiki. I don't know whether you have worked with the eclipse Graphical Modeling framework (GMF) - in GMF you can launch a cheat-sheet called GMF Dashboard which guides you through the process
Here is a video - http://www.youtube.com/watch?v=JbnqEA0dLTk - appears in the bottom part of the editor around 2:17 mins. As you can see, the GMF Dashboard is basically a visual representation of a workflow+rules+state-engine pattern with defined user-action and app-action at each state. The user can go through the workflow working on any state - the state machine pattern of the gine. However, there are certain rules applied - like a certain dependent state can only be activated when all the previous state has been completed - the workflow part of the engine. At each state, when the user provides certain inputs, the input ( in this case - domain model etc) is validated and the app takes a pre-defined action based on the rules (like generating code etc)- hence the rules part of engine

My case -> Very similar to the above ( only i am thinking of implementing the graphical part as a 2nd step). As of now, the design is as follows
The whole process is a logic/algorithm working on user provided data. Which part of the algorithm is triggered depends on what data the user provides.
 
1> The user triggers any of the defined workflow
2>. The work flow has a specific defined path / states and the user can not go a dependent state without completing previous states
3>. The user can go back to any state which he has executed and edit it again.
4>. At each state as the user enter the data, the rules engine validates it - it might also alter the defined path depending on the data.

A point which I am still trying to figure out in the dark-matter-project - it looks to be more of a compile time creation of class - and I am still trying to figure out how to achieve #2 above with it.



On Saturday, August 24, 2013 8:56:39 PM UTC-4, Sleeveen wrote:

I have something very similar to what you're describing, but it depends on a complete infrastructure of generated code; the dark-matter-data project (in Google Code).

Classes and attributes are modelled and the generated (fully GWT compliant) classes lend themselves to being sanity checked, and or having business rules applied to them.

The rules themselves are modelled and allow for parameterizing instances of the rules.

For instance, let's say you have a class X with a numeric attribute myValue that you want limited to a range of values. You would specify (as part of the schema that defines your classes):

NumericRangeRuleData

ruleName Limit myValue to 1-15

nrrMinimum       1

nrrMaximum      15

applyToAttribute myValue

applyToClass     X

At runtime, you tell a RuleManager to load the rules from the schema of the classes you're dealing with.

You call on the RuleManager to apply the attribute level validation rules on your object and it determines which set of rules to apply, based on the applyToClass and applyToAttribute in the rule.

Different categories of rules are supported, since rules applied in different contexts require different interfaces to trigger them. Attribute level rules apply to a single object. Rules that involve consistency between objects require handles to the objects involved (or to a collection objects) etc.

The nice thing about this framework is that you can implement any type of rule or business logic you need because the implementation is just Java. 

I've been working on dark-matter for about 4 years and it forms the basis of the network management system my group is working on; my employer was kind enough to allow to me continue working on it (since I had started it before joining the company).

The only problem is that I haven't had the time to put in on the documentation (my employer wants me focussed on my day job ;-)

Anyway, if any of this intrigues you, I could work up an example and you might be able to create your own mechanisms based on the concepts. 

The dark-matter stuff allows us to generate about 80% of our code for both server and client, so the infrastructure on which the rules stuff depends is fairly extensive (just so you know).

Cheers!

On Friday, August 9, 2013 9:38:21 AM UTC-4, asif...@gmail.com wrote:

Hi,

The architecture and requirement is as follows

1>. The application has an extensive domain model and significant amount of business logic
2>. At runtime, the user populates data in the domain model.
3>. "The rules engine" evaluates the data and takes various actions including
          a>. Change subsequent data entry forms and data entry process flows
          b>. Pops up ui errors.

Since, I don't want to undergo the cost of server roundtrip for each evaluation, I am looking for a good architecture or pre-built client side rules engine.

In the threads, I came across
1>. Jess
2>. MVEL
3>. Tohu
4>. Metawidget

A brief browse, and I have a feeling that MVEL would be the way to go. Tohu is kind of ruled out for the same reason that I steered clear of Drools/jBPM.

Any expert ideas? Anybody else has attempted anything similar - would love to get their view.

Regards

--
You received this message because you are subscribed to the Google Groups "Google Web Toolkit" group.
To unsubscribe from this group and stop receiving emails from it, send an email to google-web-toolkit+unsubscribe@googlegroups.com.
To post to this group, send email to google-web-toolkit@googlegroups.com.
Visit this group at http://groups.google.com/group/google-web-toolkit.
For more options, visit https://groups.google.com/groups/opt_out.