Whenite | repository contains a solution to a Rule Engine | Rule Engine library

In CLIPSDOS, you can use the command (system cls) to clear the screen. This will simply call out to DOS to execute a cls command.

The IDEs use standard text editing classes for the CLIPS command prompt window. Tabs appear to work correctly on the macOS IDE, but not the Windows or Java Swing IDEs, so that will need to be corrected.

While you can directly enter constructs at the command prompt, it's better to edit them in a file with your preferred text editor and then use the load command from the command prompt to load the contents of that file. The IDE supports a command history so you can use the up/down arrow keys to cycle through prior commands to avoid retyping.

You asked

Is it possible to tell it which order to run the rules files in, or which files to skip for each use case?

The answer is yes. The method to do this is called salience. The linked article is a good source to learn about this. This is important because salience can make it possible to change the order of execution of rules.

Hypothetically, let say that you have a program that process transactions based on categories. So, if category == deposit, you want to add to current balance. You have another rule that if category == withdrawal you want to subtract from current balance. BUT, you want to process deposits over withdrawals. Using salience you can guarantee that the deposits rule will fire before the withdrawal rule regardless of order of transaction.

Dependency is kind of related, but not the same. In drools, this is know as Forward or Backward Chaining depending on the order. This is all composed based on a series of facts. For example, if I was to ask a system "is my house on planet Earth?" the conclusion is reached if the following facts exist:

1. My house is in Fort Worth
2. Fort Worth is a city in Texas
3. Texas is a state in the United States
4. United States is a country on Earth

A direct fact linking the house location to this planet is asserted based on the rules that verify the enumerated facts above. This is done using chaining. Forward or backwards is just how these are processed (top-down or bottom-up). This is in a nutshell to the best of my recollection.

You could try like this:

Congratulation, you found drools bug DROOLS-6542 - fixed in 7.60.0.Final
There is a workaround - remove mvel dialect for the rule "Invalidate visa application with invalid passport".

BTW, I'd like to propose you drools testing library which may save you great amount of time to mind complicated rules and simplify writing test scenarios. Here is how test may look like.

You're kind of going about this in a funny way. Part of the reason your rules don't work is because you're trying to put consequences into the conditional section.

We can break down your problem into the following.

Given:

• a Student, who has a status and marks.

Rule 1:

• When status = active and marks > 65, a student is eligible for Award65.

Rule 2:

• When status = active and marks > 75, a student is eligible for Award75.

This is pretty straight forward.

So far, our rules will look like this:

Developer of Karate here, I really like your question because it validates what I personally believe, that Karate just makes it easy to work with JSON.

Why I won't recommend this for production use is because Karate embeds a JS engine that can be targeted using a "script injection" attack. Karate is designed for users running "locally" and has no safeguards built-in to prevent any malicious attacks coming in via JSON payloads.

The other question is performance, personally I am quite confident, because Karate is being used in conjunction with Gatling and some work has gone into improving performance over the years. But at the end of the day, Karate does use a JS engine in interpreted mode. So you need to run a performance test or load test yourself to validate if Karate can handle the volume you expect.

Maybe you can contribute to Karate to address both the above concerns !

The expectation for the RulesEngine(string[], ILogger, ReSettings) constructor is that each element of the string array is a complete JSON object. In your case, you've provided just a single line per array element.

Given that your text file already contains a collection of rules, you should deserialize it yourself, and pass the deserialized collection into the constructor accepting a WorkflowRules[]:

Because your events expire only in 24h, older ones do participate in the rule logic.
Usually this can be fixed with sliding length window

According to the documentation

Only a single policy per environment may be active at any given time.

You don't really remove it, you just overwrite it. You can create a new draft, lock it, and deploy it on top of the existing one.

Also note that you can't have an empty policy.