@fincity/kirun-js 2.3.1 → 2.3.2

package/src/engine/function/system/date/GetCurrentTimeStamp.ts

@@ -0,0 +1,36 @@
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Event } from '../../../model/Event';
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { AbstractFunction } from "../../AbstractFunction";
+import { Schema } from "../../../json/schema/Schema";
+import { EventResult } from "../../../model/EventResult";
+
+
+const OUTPUT = 'date';
+
+const SIGNATURE: FunctionSignature = new FunctionSignature("GetCurrentTimeStamp")
+                                        .setNamespace(Namespaces.DATE)
+                                        .setParameters(new Map([]))
+                                        .setEvents(new Map([
+                                            Event.outputEventMapEntry(
+                                                new Map([[OUTPUT, Schema.ofRef(`${Namespaces.DATE}.timeStamp`)]]),
+                                            ),
+                                        ]));
+
+export class GetCurrentTimeStamp extends AbstractFunction{
+
+    public getSignature(): FunctionSignature {
+
+        return SIGNATURE;        
+    }
+    
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        
+        const date : string = new Date(Date.now()).toISOString();
+        
+        return new FunctionOutput([EventResult.of(OUTPUT, new Map([ [OUTPUT, date]]))]);
+    }
+}

package/src/engine/function/system/date/GetTimeAsArray.ts

@@ -0,0 +1,48 @@
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { ArraySchemaType } from "../../../json/schema/array/ArraySchemaType";
+import { Schema } from "../../../json/schema/Schema";
+import { Event } from '../../../model/Event';
+import { EventResult } from "../../../model/EventResult";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { MapUtil } from "../../../util/MapUtil";
+import { isNullValue } from "../../../util/NullCheck";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+import { AbstractFunction } from "../../AbstractFunction";
+
+
+const VALUE:string = "isoDate";
+
+const OUTPUT:string = "result";
+
+const SIGNATURE = new FunctionSignature('GetTimeAsArray')
+    .setNamespace(Namespaces.DATE)
+    .setParameters(MapUtil.of(VALUE, Parameter.of(VALUE, Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
+    .setEvents(new Map([Event.outputEventMapEntry(new Map([[OUTPUT , Schema.ofArray(OUTPUT).setItems(ArraySchemaType.of(Schema.ofNumber("number")))]]))]))
+
+
+export class GetTimeAsArray extends AbstractFunction{
+    
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+    
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+         
+        var inputDate = context.getArguments()?.get(VALUE);
+
+        if(isNullValue(inputDate) || !ValidDateTimeUtil.validate(inputDate))
+            throw new KIRuntimeException("Please provide a valid date object");
+
+        const date = new Date(inputDate);
+
+        const outputArray = [ date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate()
+            , date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds()];
+        
+        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT , outputArray]]))]);
+    }
+
+}

package/src/engine/function/system/date/GetTimeAsObject.ts

@@ -0,0 +1,66 @@
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { ArraySchemaType } from "../../../json/schema/array/ArraySchemaType";
+import { Schema } from "../../../json/schema/Schema";
+import { Event } from '../../../model/Event';
+import { EventResult } from "../../../model/EventResult";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { MapUtil } from "../../../util/MapUtil";
+import { isNullValue } from "../../../util/NullCheck";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+import { AbstractFunction } from "../../AbstractFunction";
+
+
+const VALUE:string = "isoDate";
+
+const OUTPUT:string = "result";
+
+const SIGNATURE = new FunctionSignature('GetTimeAsObject')
+    .setNamespace(Namespaces.DATE)
+    .setParameters(MapUtil.of(VALUE, Parameter.of(VALUE, Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
+    .setEvents(new Map([Event.outputEventMapEntry(new Map([[OUTPUT , 
+        Schema.ofObject(OUTPUT).setProperties(new Map(
+            [
+                ["year", Schema.ofNumber("year")],
+                ["month", Schema.ofNumber("month")],
+                ["day", Schema.ofNumber("day")],
+                ["hours", Schema.ofNumber("hours")],
+                ["minutes", Schema.ofNumber("minutes")],
+                ["seconds", Schema.ofNumber("seconds")],
+                ["milliseconds", Schema.ofNumber("milliseconds")]
+            ]
+        ))]]))])); 
+
+
+export class GetTimeAsObject extends AbstractFunction{
+    
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+    
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+         
+        var inputDate = context.getArguments()?.get(VALUE);
+
+        if(isNullValue(inputDate) || !ValidDateTimeUtil.validate(inputDate))
+            throw new KIRuntimeException("Please provide a valid date object");
+
+        const date = new Date(inputDate);
+
+        const outputObject = {
+            year: date.getUTCFullYear(),
+            month: date.getUTCMonth() + 1,
+            day: date.getUTCDate(),
+            hours: date.getUTCHours(),
+            minutes: date.getUTCMinutes(),
+            seconds: date.getUTCSeconds(),
+            milliseconds: date.getUTCMilliseconds()
+        };
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT , outputObject]]))]);
+    }
+
+}

package/src/engine/function/system/date/IsValidISODate.ts

@@ -0,0 +1,43 @@
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { Schema } from "../../../json/schema/Schema";
+import { Event } from '../../../model/Event';
+import { EventResult } from "../../../model/EventResult";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { MapUtil } from "../../../util/MapUtil";
+import { isNullValue } from "../../../util/NullCheck";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+import { AbstractFunction } from "../../AbstractFunction";
+
+
+const VALUE : string = "isoDate";
+
+const OUTPUT : string = "output";
+
+const SIGNATURE = new FunctionSignature('IsValidISODate')
+.setNamespace(Namespaces.DATE)
+.setParameters(MapUtil.of(VALUE, Parameter.of(VALUE, Schema.ofRef(Namespaces.DATE + ".timeStamp"))))
+.setEvents(MapUtil.of(OUTPUT , new Event(OUTPUT , MapUtil.of(OUTPUT, Schema.ofBoolean(OUTPUT)))));
+
+export class IsValidISODate extends AbstractFunction{
+
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        
+        var date = context.getArguments()?.get(VALUE);
+
+        if(isNullValue(date))
+            throw new KIRuntimeException("Please provide a valid date object");
+
+        return new FunctionOutput([ EventResult.of(OUTPUT , MapUtil.of( OUTPUT , ValidDateTimeUtil.validate(date)))]);
+        
+    }
+    
+
+}

package/src/engine/function/system/date/MaximumTimestamp.ts

@@ -0,0 +1,73 @@
+import { Schema } from "../../../json/schema/Schema";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { AbstractFunction } from "../../AbstractFunction";
+import { Event } from "../../../model/Event";
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+import { EventResult } from "../../../model/EventResult";
+
+const VALUE = "isoDates";
+
+const OUTPUT = "result";
+
+const ERROR_MESSAGE = "Please provide a valid date";
+
+
+
+const SIGNATURE : FunctionSignature = new FunctionSignature('MaximumTimestamp')
+    .setNamespace(Namespaces.DATE)
+    .setParameters(new Map([[VALUE, Parameter.of(VALUE, Schema.ofString(VALUE).setRef(Namespaces.DATE + ".timeStamp")).setVariableArgument(true)]]))
+    .setEvents(new Map([[OUTPUT, new Event(OUTPUT, new Map([[OUTPUT, Schema.ofString(OUTPUT).setRef(Namespaces.DATE + ".timeStamp")]]))]]));
+
+export class MaximumTimestamp extends AbstractFunction {
+
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        
+        const dates = context?.getArguments()?.get(VALUE);
+
+        const size = dates.length;
+
+        if(size === 0){
+            throw new KIRuntimeException(ERROR_MESSAGE)
+        }
+
+        else if (size == 1) {
+
+            const firstDate: string = dates[0];
+
+            if (!ValidDateTimeUtil.validate(firstDate))
+
+                throw new KIRuntimeException(ERROR_MESSAGE);
+
+            return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, firstDate]]))]);
+        }
+
+        let maxIndex: number = 0;
+        let max : number = new Date(dates[0]).getTime();
+
+        for(let i=1;i<size;i++){
+
+            const date: string = dates[i];
+
+            if(!ValidDateTimeUtil.validate(date))
+                throw new KIRuntimeException(ERROR_MESSAGE);
+            
+            const current: number = new Date(date).getTime();
+
+            if(current > max){
+                max = current;
+                maxIndex = i;
+            }
+        }
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, dates[maxIndex]]]))]);
+    }
+}

package/src/engine/function/system/date/MinimumTimestamp.ts

@@ -0,0 +1,74 @@
+import { KIRuntimeException } from "../../../exception/KIRuntimeException";
+import { Schema } from "../../../json/schema/Schema";
+import { FunctionOutput } from "../../../model/FunctionOutput";
+import { FunctionSignature } from "../../../model/FunctionSignature";
+import { Parameter } from "../../../model/Parameter";
+import { Namespaces } from "../../../namespaces/Namespaces";
+import { FunctionExecutionParameters } from "../../../runtime/FunctionExecutionParameters";
+import { ValidDateTimeUtil } from "../../../util/ValidDateTimeUtil";
+import { AbstractFunction } from "../../AbstractFunction";
+import { EventResult } from "../../../model/EventResult";
+import { Event } from "../../../model/Event";
+
+
+
+const VALUE: string = "isoDates";
+
+const OUTPUT: string = "result";
+
+const ERROR_MESSAGE: string = "Please provide a valid date";
+
+const SIGNATURE : FunctionSignature = new FunctionSignature('MinimumTimestamp')
+        .setNamespace(Namespaces.DATE)
+        .setParameters(new Map([[VALUE, Parameter.of(VALUE, Schema.ofString(VALUE).setRef(Namespaces.DATE + ".timeStamp")).setVariableArgument(true)]]))
+        .setEvents(new Map([[OUTPUT , new Event(OUTPUT, new Map([[OUTPUT, Schema.ofString(OUTPUT).setRef(Namespaces.DATE + ".timeStamp")]]))]]));
+
+export class MinimumTimestamp extends AbstractFunction{
+
+    public getSignature(): FunctionSignature {
+        return SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+           
+        const dates = context?.getArguments()?.get(VALUE);
+
+        const size = dates.length;
+
+        if(size === 0){
+            throw new KIRuntimeException(ERROR_MESSAGE)
+        }
+
+        else if (size == 1) {
+
+            const firstDate: string = dates[0];
+
+            if (!ValidDateTimeUtil.validate(firstDate))
+
+                throw new KIRuntimeException(ERROR_MESSAGE);
+
+            return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, firstDate]]))]);
+        }
+
+        let minIndex: number = 0;
+        let min : number = new Date(dates[0]).getTime();
+
+        for(let i=1;i<size;i++){
+
+            const date: string = dates[i];
+
+            if(!ValidDateTimeUtil.validate(date))
+                throw new KIRuntimeException(ERROR_MESSAGE);
+            
+            const current: number = new Date(date).getTime();
+
+            if(current < min){
+                min = current;
+                minIndex = i;
+            }
+        }
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[OUTPUT, dates[minIndex]]]))]);
+    }
+
+}

package/src/engine/namespaces/Namespaces.ts

@@ -7,6 +7,7 @@ export class Namespaces {
 
     public static readonly MATH: string = 'System.Math';
     public static readonly STRING: string = 'System.String';
+    public static readonly DATE: string = 'System.Date';
 
     private constructor() {}
 }

package/src/engine/repository/KIRunFunctionRepository.ts

@@ -1,5 +1,6 @@
 import { Function } from '../function/Function';
 import { ArrayFunctionRepository } from '../function/system/array/ArrayFunctionRepository';
+import { Join } from '../function/system/array/Join';
 import { Create } from '../function/system/context/Create';
 import { Get } from '../function/system/context/Get';
 import { SetFunction } from '../function/system/context/SetFunction';
@@ -13,6 +14,7 @@ import { MathFunctionRepository } from '../function/system/math/MathFunctionRepo
 import { ObjectFunctionRepository } from '../function/system/object/ObjectFunctionRepository';
 import { Print } from '../function/system/Print';
 import { StringFunctionRepository } from '../function/system/string/StringFunctionRepository';
+import { DateFunctionRepository } from '../function/system/date/DateFunctionRepository';
 import { Wait } from '../function/system/Wait';
 import { HybridRepository } from '../HybridRepository';
 import { Namespaces } from '../namespaces/Namespaces';
@@ -39,6 +41,7 @@ const map: Map<string, Map<string, Function>> = new Map([
             mapEntry(new GenerateEvent()),
             mapEntry(new Print()),
             mapEntry(new Wait()),
+            mapEntry(new Join()),
         ]),
     ],
 ]);
@@ -65,6 +68,7 @@ export class KIRunFunctionRepository extends HybridRepository<Function> {
             new StringFunctionRepository(),
             new ArrayFunctionRepository(),
             new ObjectFunctionRepository(),
+            new DateFunctionRepository(),
         );
     }
 }

package/src/engine/repository/KIRunSchemaRepository.ts

@@ -12,6 +12,7 @@ const map: Map<string, Schema> = new Map([
     ['long', Schema.ofLong('long').setNamespace(Namespaces.SYSTEM)],
     ['number', Schema.ofNumber('number').setNamespace(Namespaces.SYSTEM)],
     ['string', Schema.ofString('string').setNamespace(Namespaces.SYSTEM)],
+    ['Date.timeStamp', Schema.ofString('timeStamp').setNamespace(Namespaces.DATE)],
     [Parameter.EXPRESSION.getName()!, Parameter.EXPRESSION],
     [Schema.NULL.getName()!, Schema.NULL],
     [Schema.SCHEMA.getName()!, Schema.SCHEMA],

package/src/engine/runtime/expression/ExpressionEvaluator.ts

@@ -96,7 +96,7 @@ export class ExpressionEvaluator {
 
     public constructor(exp: Expression | string) {
         if (exp instanceof Expression) {
-            this.exp = exp as Expression;
+            this.exp = exp;
             this.expression = this.exp.getExpression();
         } else {
             this.expression = exp;
@@ -163,7 +163,7 @@ export class ExpressionEvaluator {
     ): string {
         let newExpression = expression;
 
-        for (var tuple of tuples.toArray()) {
+        for (let tuple of tuples.toArray()) {
             if (tuple.getT2() == -1)
                 throw new ExpressionEvaluationException(
                     expression,
@@ -212,14 +212,14 @@ export class ExpressionEvaluator {
             } else if (operator == Operation.CONDITIONAL_TERNARY_OPERATOR) {
                 const token2: ExpressionToken = tokens.pop();
                 const token3: ExpressionToken = tokens.pop();
-                var v1 = this.getValueFromToken(valuesMap, token3);
-                var v2 = this.getValueFromToken(valuesMap, token2);
-                var v3 = this.getValueFromToken(valuesMap, token);
+                let v1 = this.getValueFromToken(valuesMap, token3);
+                let v2 = this.getValueFromToken(valuesMap, token2);
+                let v3 = this.getValueFromToken(valuesMap, token);
                 tokens.push(this.applyTernaryOperation(operator, v1, v2, v3));
             } else {
                 const token2: ExpressionToken = tokens.pop();
-                var v1 = this.getValueFromToken(valuesMap, token2);
-                var v2 = this.getValueFromToken(valuesMap, token);
+                let v1 = this.getValueFromToken(valuesMap, token2);
+                let v2 = this.getValueFromToken(valuesMap, token);
                 tokens.push(this.applyBinaryOperation(operator, v1, v2));
             }
         }
@@ -235,8 +235,7 @@ export class ExpressionEvaluator {
             );
 
         const token: ExpressionToken = tokens.get(0);
-        if (token instanceof ExpressionTokenValue)
-            return (token as ExpressionTokenValue).getElement();
+        if (token instanceof ExpressionTokenValue) return token.getElement();
         else if (!(token instanceof Expression)) return this.getValueFromToken(valuesMap, token);
 
         throw new ExecutionException(
@@ -262,7 +261,7 @@ export class ExpressionEvaluator {
                 objTokens.push(
                     new ExpressionTokenValue(
                         token.toString(),
-                        this.evaluateExpression(token as Expression, valuesMap),
+                        this.evaluateExpression(token, valuesMap),
                     ),
                 );
             else if (token) objTokens.push(token);
@@ -275,7 +274,7 @@ export class ExpressionEvaluator {
                 objTokens.push(
                     new ExpressionTokenValue(
                         token.toString(),
-                        this.evaluateExpression(token as Expression, valuesMap),
+                        this.evaluateExpression(token, valuesMap),
                     ),
                 );
             else objTokens.push(token);
@@ -296,7 +295,7 @@ export class ExpressionEvaluator {
 
         let sb: StringBuilder = new StringBuilder(
             objToken instanceof ExpressionTokenValue
-                ? (objToken as ExpressionTokenValue).getTokenValue()
+                ? objToken.getTokenValue()
                 : objToken.toString(),
         );
 
@@ -305,7 +304,7 @@ export class ExpressionEvaluator {
             operator = objOperations.pop();
             sb.append(operator.getOperator()).append(
                 objToken instanceof ExpressionTokenValue
-                    ? (objToken as ExpressionTokenValue).getTokenValue()
+                    ? objToken.getTokenValue()
                     : objToken.toString(),
             );
             if (operator == Operation.ARRAY_OPERATOR) sb.append(']');
@@ -414,9 +413,9 @@ export class ExpressionEvaluator {
         token: ExpressionToken,
     ): any {
         if (token instanceof Expression) {
-            return this.evaluateExpression(token as Expression, valuesMap);
+            return this.evaluateExpression(token, valuesMap);
         } else if (token instanceof ExpressionTokenValue) {
-            return (token as ExpressionTokenValue).getElement();
+            return token.getElement();
         }
         return this.getValue(token.getExpression(), valuesMap);
     }

package/src/engine/util/ValidDateTimeUtil.ts

@@ -0,0 +1,119 @@
+
+export class ValidDateTimeUtil{
+
+   private constructor(){
+
+   }
+   public static  isLeapYear( year : number) : boolean{
+		return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
+	}
+
+    public static  validYearRange( year : number) :boolean {
+		return year < 275761 && year > -271821;
+	}
+
+	public static validMonthRange( month: number) : boolean{
+		return month <= 12 && month > 0;
+	}
+
+    public static  validDate( year : number,  month: number,  date: number) : boolean{
+
+		if (date <= 0 || month <= 0)
+			return false;
+
+		switch (month) {
+		case 2:
+			return ValidDateTimeUtil.validYearRange(year) && ValidDateTimeUtil.validMonthRange(month) && (ValidDateTimeUtil.isLeapYear(year) && date < 30)
+			        || (!ValidDateTimeUtil.isLeapYear(year) && date < 29);
+
+		case 4:
+        case 6:
+        case 9:
+        case 11:
+			return ValidDateTimeUtil.validYearRange(year) && ValidDateTimeUtil.validMonthRange(month) && date <= 30;
+
+		default:
+			return ValidDateTimeUtil.validYearRange(year) && ValidDateTimeUtil.validMonthRange(month) && date <= 31;
+		}
+
+	}
+
+
+    public static  validHourRange( hour: number) : boolean{
+		return hour < 24 && hour >= 0;
+	}
+
+	public static  validMinuteSecondRange( minute : number) : boolean{
+		return minute < 60 && minute >= 0;
+	}
+
+	public static validMilliSecondRange( millis: number) : boolean {
+		return millis < 1000 && millis >= 0;
+	}
+
+    public static validateWithOptionalMillis( portion: string): boolean {
+
+		return ValidDateTimeUtil.validMilliSecondRange(ValidDateTimeUtil.convertToInt(portion.substring(1, 4))) && ValidDateTimeUtil.validateLocalTime(portion.substring(4));
+	}
+
+    public  getYear( date: string) : number{
+
+		const first: string = date.charAt(0);
+		if (first == '+' || first == '-') {
+			const year : number = ValidDateTimeUtil.convertToInt(date.substring(1, 7));
+			return first == '-' ? year * -1 : year;
+		}
+
+		return ValidDateTimeUtil.convertToInt(date.substring(0, 4));
+	}
+
+	public static  validateLocalTime( offset: string )  : boolean{
+
+		if (offset.charAt(0) == 'Z')
+			return true;
+
+		if (offset.length != 6)
+			return false;
+
+		return (offset.charAt(0) == '+' || offset.charAt(0) == '-')
+		        && (ValidDateTimeUtil.validHourRange(ValidDateTimeUtil.convertToInt(offset.substring(1, 3))) && offset.charAt(3) == ':'
+		                && ValidDateTimeUtil.validMinuteSecondRange(ValidDateTimeUtil.convertToInt(offset.substring(4, offset.length - 1))));
+	}
+
+   public static validate( date: string) : boolean {
+
+    if (date.length < 20 || date.length > 32)
+        return false; // as date time should have minimum of 20 characters and maximum of 32 characters
+
+    const first: string = date.charAt(0); // checking first index whether '+' or '-' or any digit
+
+    if (first == '+' || first == '-') {
+
+       const  a : boolean = date.charAt(7) == '-' && date.charAt(10) == '-' && date.charAt(13) == 'T'
+                && date.charAt(16) == ':' && date.charAt(19) == ':' && date.charAt(22) == '.';
+
+        return a && ValidDateTimeUtil.validDate(ValidDateTimeUtil.convertToInt(date.substring(1, 7)), ValidDateTimeUtil.convertToInt(date.substring(8, 10)),
+                ValidDateTimeUtil.convertToInt(date.substring(11, 13))) && ValidDateTimeUtil.validHourRange(ValidDateTimeUtil.convertToInt(date.substring(14, 16)))
+                && ValidDateTimeUtil.validMinuteSecondRange(ValidDateTimeUtil.convertToInt(date.substring(17, 19)))
+                && ValidDateTimeUtil.validMinuteSecondRange(ValidDateTimeUtil.convertToInt(date.substring(20, 22)))
+                && ValidDateTimeUtil.validateWithOptionalMillis(date.substring(22));
+    } else {
+
+        const  a : boolean = date.charAt(4) == '-' && date.charAt(7) == '-' && date.charAt(10) == 'T'
+                && date.charAt(13) == ':' && date.charAt(16) == ':' && date.charAt(19) == '.';
+
+        return a && ValidDateTimeUtil.validDate(ValidDateTimeUtil.convertToInt(date.substring(0, 4)), ValidDateTimeUtil.convertToInt(date.substring(5, 7)),
+                ValidDateTimeUtil.convertToInt(date.substring(8, 10))) && ValidDateTimeUtil.validHourRange(ValidDateTimeUtil.convertToInt(date.substring(11, 13)))
+                && ValidDateTimeUtil.validMinuteSecondRange(ValidDateTimeUtil.convertToInt(date.substring(14, 16)))
+                && ValidDateTimeUtil.validMinuteSecondRange(ValidDateTimeUtil.convertToInt(date.substring(17, 19)))
+                && ValidDateTimeUtil.validateWithOptionalMillis(date.substring(19));
+    }
+
+    }
+
+    private static  convertToInt( num : string )  : number{ // adding exception
+		var parsed = parseInt(num);		
+		return isNaN(parsed) ? Number.MIN_VALUE : parsed;
+	}
+}
+