added more flexible way to use message functions

Umed Khudoiberdiev · Umed Khudoiberdiev · commit aa91e0144563 · 2016-06-29T10:52:40.000+05:00
diff --git a/sample/sample5-schemas/post.json b/sample/sample5-schemas/post.json
@@ -1,66 +1,52 @@
 {
   "name": "post",
   "properties": {
-    "title": [
-      {
-        "type": "min_length",
-        "value1": 10
-      },
-      {
-        "type": "max_length",
-        "value1": 20
-      }
-    ],
-    "text": [
-      {
-        "type": "contains",
-        "value1": "hello"
-      }
-    ],
-    "rating": [
-      {
-        "type": "is_int"
-      }
-    ],
-    "email": [
-      {
-        "type": "is_email"
-      }
-    ],
-    "site": [
-      {
-        "type": "is_fqdn"
-      }
-    ],
-    "createDate": [
-      {
-        "type": "is_date"
-      }
-    ],
-    "tags": [
-      {
-        "type": "array_not_empty"
-      },
-      {
-        "type": "array_min_size",
-        "value1": 2
-      },
-      {
-        "type": "array_max_size",
-        "value1": 5
-      },
-      {
-        "type": "min_length",
-        "each": true,
-        "value1": 3,
-        "message": "Tag is too short. Minimal length is $value characters"
-      },
-      {
-        "type": "max_length",
-        "each": true,
-        "value1": 50,
-        "message": "Tag is too long. Maximal length is $value characters"
-      }
-    ]
+    "title": [{
+      "type": "min_length",
+      "constraints": [10]
+    },
+    {
+      "type": "max_length",
+      "constraints": [20]
+    }],
+    "text": [{
+      "type": "contains",
+      "value1": "hello"
+    }],
+    "rating": [{
+      "type": "is_int"
+    }],
+    "email": [{
+      "type": "is_email"
+    }],
+    "site": [{
+      "type": "is_fqdn"
+    }],
+    "createDate": [{
+      "type": "is_date"
+    }],
+    "tags": [{
+      "type": "array_not_empty"
+    },
+    {
+      "type": "array_min_size",
+      "constraints": [2]
+    },
+    {
+      "type": "array_max_size",
+      "constraints": [5]
+    },
+    {
+      "type": "min_length",
+      "each": true,
+      "constraints": [3],
+      "message": "Tag is too short. Minimal length is $value characters"
+    },
+    {
+      "type": "max_length",
+      "each": true,
+      "constraints": [50],
+      "message": "Tag is too long. Maximal length is $value characters"
+    }]
   }
 }
diff --git a/src/metadata/ValidationMetadata.ts b/src/metadata/ValidationMetadata.ts
@@ -1,4 +1,5 @@
 import {ValidationMetadataArgs} from "./ValidationMetadataArgs";
+import {MessageArguments} from "../validation/MessageArguments";
 
 /**
  * This metadata contains validation rules.
@@ -37,7 +38,7 @@ export class ValidationMetadata {
     /**
      * Validation message to be shown in the case of error.
      */
-    message: string|((value?: any, constraints?: any[]) => string);
+    message: string|((args: MessageArguments) => string);
 
     /**
      * Validation groups used for this validation.
diff --git a/src/validation/MessageArguments.ts b/src/validation/MessageArguments.ts
@@ -0,0 +1,32 @@
+/**
+ * Arguments being sent to message builders - user can create message either by simply returning a string,
+ * either by returning a function that accepts MessageArguments and returns a message string built based on these arguments.
+ */
+export interface MessageArguments {
+
+    /**
+     * Validating value.
+     */
+    value: any;
+
+    /**
+     * Constraints set by this validation type.
+     */
+    constraints: any[];
+
+    /**
+     * Name of the target that is being validated.
+     */
+    targetName: string;
+
+    /**
+     * Object that is being validated.
+     */
+    object: Object;
+
+    /**
+     * Name of the object's property being validated.
+     */
+    property: string;
+    
+}
diff --git a/src/validation/ValidationExecutor.ts b/src/validation/ValidationExecutor.ts
@@ -7,6 +7,7 @@ import {ValidatorOptions} from "./ValidatorOptions";
 import {ValidationTypes} from "./ValidationTypes";
 import {ValidatorConstraintInterface} from "./ValidatorConstraintInterface";
 import {ConstraintMetadata} from "../metadata/ConstraintMetadata";
+import {MessageArguments} from "./MessageArguments";
 
 /**
  * Executes validation over given object.
@@ -146,14 +147,23 @@ export class ValidationExecutor {
 
         let messageString: string;
         if (message instanceof Function) {
-            messageString = (message as ((value?: any, constraints?: any[]) => string))(value, metadata.constraints);
+            const messageArgs: MessageArguments = {
+                targetName: targetName,
+                property: metadata.propertyName,
+                object: target,
+                value: value,
+                constraints: metadata.constraints
+            };
+            messageString = (message as (args: MessageArguments) => string)(messageArgs);
 
         } else if (typeof message === "string") {
             messageString = message as string;
         }
         
         if (messageString && metadata.constraints instanceof Array)
-            metadata.constraints.forEach((constraint, index) => messageString.replace(new RegExp(`\$constraint${index}`, "g"), constraint));
+            metadata.constraints.forEach((constraint, index) => {
+                messageString = messageString.replace(new RegExp(`\\$constraint${index + 1}`, "g"), constraint);
+            });
         if (messageString && value !== undefined && value !== null)
             messageString = messageString.replace(/\$value/g, value);
         if (messageString)
diff --git a/src/validation/ValidationTypes.ts b/src/validation/ValidationTypes.ts
@@ -1,3 +1,4 @@
+import {MessageArguments} from "./MessageArguments";
 /**
  * Validation types.
  */
@@ -94,14 +95,14 @@ export class ValidationTypes {
     /**
      * Gets default validation error message for the given validation type.
      */
-    static getMessage(type: string): string|((value?: any, constraints?: any[]) => string) {
+    static getMessage(type: string): string|((args: MessageArguments) => string) {
         switch (type) {
 
             /* common checkers */
             case this.EQUALS:
-                return "given value ($value) of $property is not equal to $constraint1";
+                return "$property must be equal to $constraint1";
             case this.NOT_EQUALS:
-                return "given value ($value) of $property should not be equal to $constraint1";
+                return "$property should not be equal to $constraint1";
             case this.EMPTY:
                 return "$property must be empty";
             case this.NOT_EMPTY:
@@ -130,6 +131,8 @@ export class ValidationTypes {
                 return "$property must be divisible by $constraint1";
             case this.IS_POSITIVE:
                 return "$property must be a positive number";
+            case this.IS_NEGATIVE:
+                return "$property must be a negative number";
             case this.GREATER_THEN:
                 return "$property must be greater then $constraint1";
             case this.LESS_THEN:
@@ -147,7 +150,7 @@ export class ValidationTypes {
             case this.IS_DATE_STRING:
                 return "$property must be a date string";
             case this.IS_NUMBER_STRING:
-                return "$property must be a number";
+                return "$property must be a number string";
 
             /* string checkers */
             case this.CONTAINS:
@@ -209,15 +212,22 @@ export class ValidationTypes {
             case this.IS_UPPERCASE:
                 return "$property must be uppercase";
             case this.LENGTH:
-                return () => { // todo
+                return (args: MessageArguments) => { // todo more complex object must come here (with target and propertyName)
+                    const isMinLength = args.constraints[0] !== null && args.constraints[0] !== undefined;
+                    const isMaxLength = args.constraints[1] !== null && args.constraints[1] !== undefined;
+                    if (isMinLength && (!args.value || args.value.length < args.constraints[0])) {
+                        return "$property must be longer then $constraint1";
+                    } else if (isMaxLength && (args.value.length > args.constraints[1])) {
+                        return "$property must be shorter then $constraint2";
+                    }
                     return "$property must be longer then $constraint1 and shorter then $constraint2";
                 };
             case this.MIN_LENGTH:
                 return "$property must be longer then $constraint1";
             case this.MAX_LENGTH:
                 return "$property must be shorter then $constraint2";
             case this.MATCHES:
-                return "$property must much a given regular expression $constraint1";
+                return "$property must match $constraint1 regular expression";
 
             /* array checkers */
             case this.ARRAY_CONTAINS:
@@ -227,11 +237,11 @@ export class ValidationTypes {
             case this.ARRAY_NOT_EMPTY:
                 return "$property should not be empty";
             case this.ARRAY_MIN_SIZE:
-                return "$property's must contain at least $constraint1 elements";
+                return "$property must contain at least $constraint1 elements";
             case this.ARRAY_MAX_SIZE:
-                return "$property's must contain not more then $constraint1 elements";
+                return "$property must contain not more then $constraint1 elements";
             case this.ARRAY_UNIQUE:
-                return "all $property's elements must be unqiue";
+                return "All $property's elements must be unique";
         }
     }
     
