Ready to go in 3 min.

Prerequisites
You need Java version 8 or higher. Here you can download the corresponding JRE 1.8.
1. Installation
You need openvalidation.jar to generate code. openvalidation.jar is a simple Java command line interface. You can download the openvalidation.jar here:
​​
​ 
Windows
Unix
Best you create a new directory under your personal Temp folder and download the openvalidation.jar into this folder:
1
cd %temp%
2
mkdir openvalidation
3
cd openvalidation
4
curl http://download.openvalidation.io/openvalidation.jar
Copied!
Best you create a new directory under your personal Temp folder and download the openvalidation.jar into this folder:
1
cd /tmp/
2
mkdir openvalidation
3
cd openvalidation
4
curl http://central.maven.org/maven2/openvalidation.jar
Copied!
2. Create a rule
Ok, now you are ready to start and can program your first validation rule in openVALIDATION. Create a file called rules.ov and add the following content:
rules.ov
1
  IF the message IS Hello
2
THEN hello openVALIDATION!
Copied!
This rule is formatted so that it best illustrates the keywords and syntax of the openVALIDATION language. You could also just write If the message is Hello then hello openVALIDATION! and it would work just the same.
In addition to the actual rule, you also need a schema. The schema defines the data structure of the data set to be validated. You can use a simple JSON object from which a JSON schema is automatically derived. Our schema consists only of a text field called "Message".
YAML
JSON
1
Message : Text
Copied!
1
{
2
    Message : "Text"
3
}
Copied!
3. Generate code
Since our validation rule and the corresponding schema are already fixed, we can now generate the corresponding code. 
1
​
2
java -jar openvalidation.jar /
3
     -r rules.ov /
4
     -s "{Message : \"Text\"}" /
5
     -l javascript /
6
     -o myRules.js /
7
     -c en /
8
     -f
9
​
Copied!
Parameter       
Description
-r
The Rule parameter is used to pass the actual validation rule either directly or as a file reference. In our case, we pass the file rules.ov
-s
The schema specifies the data structure for openVALIDATION.
-l
The programming language to be translated 
-c
The culture code of natural language (de for German/ en for English)
-o
Output Parameter defines the code file. Alternatively you can specify a directory where the code files will be stored after the generation process. Without specifying the output parameter, the generated code will only be output in the console
-f
This parameter (--single-file) ensures that the generated code is generated in a file. Normally there are two files: the base framework and the implementation of the rules
Congratulations! You have just created your first validation rule in JavaScript. This can be found in the file myRules.js. This is the result:
1
...
2
​
3
huml.appendRule("",
4
     ["Message"],
5
     "Hello openVALIDATION!",
6
     function(model) { return  huml.EQUALS(model.Message, "Hello");},
7
     false
8
);
9
​
10
...
Copied!
​
4. Rules integration
Now we'd like to see if our rule works. We create a file called test.html and add the following code:
test.html
1
<html>
2
  <body>
3
​
4
    <input id="message" />
5
    <div id="error"></div>
6
​
7
    <script src="myRules.js"></script>
8
    <script type="text/javascript">
9
​
10
      window.addEventListener('load', (event) => {
11
​
12
        var validator = new HUMLValidator();
13
​
14
        document.getElementById('message').onkeyup = function(e){
15
            var result = validator.validate({Message:e.target.value});
16
​
17
            if (result.hasErrors)
18
              document.getElementById('error').textContent = result.errors[0].error;
19
            else
20
              document.getElementById('error').textContent = "";
21
        };
22
      });
23
​
24
    </script>
25
  </body>
26
</html>
Copied!
We call the test.html in the browser and type "Hello" into the input field:
As expected, when entering the value "Hello", our error message appears.
​
5. No-Code Development
You can now extend the rules by filling the file rules.ov with additional rules and then doing the generation process again using openVALIDATION CLI. Just follow steps 2 to 4.
The nice thing about it is that the file rules.ov can now be edited by a domain expert without having to be familiar with the technology! As soon as he has changed the rules, openVALIDATION can automatically generate program code from them. This is what we call No-Code Development.
If you would like to try out another detailed implementation example, then have a look at the Integration section.
Who we are
Grammar
Last modified 2yr ago
Copy link
Contents
5. No-Code Development