1 files changed, 390 insertions, 183 deletions

diff --git a/catalog-ui/src/app/ng2/pages/properties-assignment/constraints/constraints.component.ts b/catalog-ui/src/app/ng2/pages/properties-assignment/constraints/constraints.component.ts
index 2fb8b64e54..31dbeadd4e 100644
--- a/catalog-ui/src/app/ng2/pages/properties-assignment/constraints/constraints.component.ts
+++ b/catalog-ui/src/app/ng2/pages/properties-assignment/constraints/constraints.component.ts
@@ -18,7 +18,15 @@
  */
 
 import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';
-import { PROPERTY_DATA, PROPERTY_TYPES } from "app/utils/constants"
+import {
+  AbstractControl, FormArray,
+  FormBuilder,
+  FormControl,
+  FormGroup, ValidationErrors,
+  ValidatorFn,
+  Validators
+} from '@angular/forms';
+import { PROPERTY_DATA, PROPERTY_TYPES } from 'app/utils/constants';
 
 @Component({
   selector: 'app-constraints',
@@ -32,88 +40,358 @@ export class ConstraintsComponent implements OnInit {
   @Input() isViewOnly: boolean = false;
   @Output() onConstraintChange: EventEmitter<any> = new EventEmitter<any>();
 
-  constraints: Constraint[] = new Array();
   constraintTypes: string[];
   ConstraintTypesMapping = ConstraintTypesMapping;
-  valid: boolean = true;
+  valid: boolean = false;
+  constraintForm: FormGroup;
+  validationMessages;
+  init: boolean = true;
+
+  constructor(private formBuilder: FormBuilder) {}
+
+  get constraintsArray() {
+    return this.constraintForm.get('constraint') as FormArray;
+  }
+
+  get constraintValidators(): ValidatorFn {
+    switch (this.propertyType) {
+      case PROPERTY_TYPES.INTEGER:
+        console.warn('Add int validator');
+        return Validators.compose([
+          Validators.required,
+          intValidator()
+        ]);
+      case PROPERTY_TYPES.FLOAT:
+        console.warn('Add float validator');
+        return Validators.compose([
+          Validators.required,
+          floatValidator()
+        ]);
+      default:
+        console.warn('Only required validator');
+        return Validators.compose([
+          Validators.required
+        ]);
+    }
+}
+
+  public constraintValuesArray(index: number): FormArray {
+    return this.constraintsArray.at(index).get('value') as FormArray;
+  }
 
   ngOnInit() {
-    this.constraintTypes = Object.keys(ConstraintTypes).map(key => ConstraintTypes[key]);
+    console.groupEnd();
+    this.constraintTypes = Object.keys(ConstraintTypes).map((key) => ConstraintTypes[key]);
+
+    // This is only used by the spec test
+    if (!this.constraintForm) {
+      this.constraintForm = this.formBuilder.group({
+        constraint: this.formBuilder.array([])
+      });
+    }
+
+    this.validationMessages = {
+      constraint: [
+        { type: 'required', message: 'Constraint value is required'},
+        { type: 'invalidInt', message: 'Constraint value is not a valid integer'},
+        { type: 'invalidFloat', message: 'Constraint value is not a valid floating point value'}
+      ],
+      type : [
+        { type: 'required', message: 'Constraint type is required'}
+      ]
+    };
+
+    this.init = false;
   }
 
   ngOnChanges(changes): void {
+    console.groupEnd();
+
+    // Changes fires before init so form has to be initialised here
+    if (this.init) {
+      this.constraintForm = this.formBuilder.group({
+        constraint: this.formBuilder.array([])
+      });
+
+      if (changes.propertyConstraints && changes.propertyConstraints.currentValue) {
+        changes.propertyConstraints.currentValue.forEach((constraint: any) => {
+          const prop = this.getConstraintFromPropertyBEModel(constraint);
+          console.log('constraint from BE model', prop);
+          this.constraintsArray.push(prop);
+        });
+      }
+    }
+
     if (changes.propertyType) {
+      if (!this.init) {
+        // Reset constraints on property type change
+        console.warn('Property type changed. Resetting constraints');
+        this.constraintForm = this.formBuilder.group({
+          constraint: this.formBuilder.array([])
+        });
+      }
+
       if (!this.propertyType || changes.propertyType.currentValue == this.propertyType) {
         this.propertyType = changes.propertyType.currentValue;
       } else {
-        this.constraints = new Array();
         this.propertyType = changes.propertyType;
         this.emitOnConstraintChange();
       }
+
+      this.constraintsArray.controls.forEach((control: AbstractControl) => {
+        control.get('value').setValidators(this.constraintValidators);
+      });
     }
-    this.constraints = new Array();
-    if(changes.propertyConstraints) {
-      if (changes.propertyConstraints.currentValue) {
-        changes.propertyConstraints.currentValue.forEach((constraint: any) => {
-            this.constraints.push(this.getConstraintFromPropertyBEModel(constraint));
-        });
-      }
+
+    console.log('constraints', this.constraintsArray);
+  }
+
+  removeFromList(constraintIndex: number, valueIndex: number) {
+    this.constraintsArray.at(constraintIndex).get('value').value.splice(valueIndex, 1);
+    this.emitOnConstraintChange();
+  }
+
+  addToList(constraintIndex: number) {
+    const newConstraint = new FormControl('', this.constraintValidators);
+
+    this.constraintValuesArray(constraintIndex).push(newConstraint);
+    console.log('constraintsArray', this.constraintsArray);
+    console.log('constraintValuesArray', this.constraintValuesArray(constraintIndex));
+    this.emitOnConstraintChange();
+  }
+
+  onChangeConstraintType(constraintIndex: number, newType: ConstraintTypes) {
+    if ((newType == ConstraintTypes.valid_values)) {
+      const newConstraint = this.formBuilder.group({
+        type: new FormControl({
+          value: newType,
+          disabled: this.isViewOnly
+        }, Validators.required),
+        value: this.formBuilder.array([])});
+
+      this.constraintsArray.removeAt(constraintIndex);
+      this.constraintsArray.push(newConstraint);
+    } else if (newType == ConstraintTypes.in_range) {
+      const newConstraint = this.formBuilder.group({
+        type: new FormControl({
+          value: newType,
+          disabled: this.isViewOnly
+        }, Validators.required),
+        value: this.formBuilder.array([])});
+
+      const valRef = newConstraint.get('value') as FormArray;
+      valRef.push(new FormControl('', this.constraintValidators));
+      valRef.push(new FormControl('', this.constraintValidators));
+
+      this.constraintsArray.removeAt(constraintIndex);
+      this.constraintsArray.push(newConstraint);
+    } else {
+      this.constraintsArray.at(constraintIndex).value.type = newType;
     }
+    this.emitOnConstraintChange();
+  }
+
+  onChangeConstraintValue(constraintIndex: number, newValue: any) {
+    this.constraintsArray.at(constraintIndex).get('value').setValue(newValue);
+    this.emitOnConstraintChange();
+  }
+
+  onChangeConstrainValueIndex(constraintIndex: number, newValue: any, valueIndex: number) {
+    this.constraintValuesArray(constraintIndex).controls[valueIndex].setValue(newValue);
+    this.emitOnConstraintChange();
   }
 
-  private getConstraintFromPropertyBEModel(constraint: any):Constraint {
+  removeConstraint(constraintIndex: number) {
+    this.constraintsArray.removeAt(constraintIndex);
+    this.emitOnConstraintChange();
+}
+
+  addConstraint() {
+    const newConstraint = this.formBuilder.group({
+      type: new FormControl({
+        value: ConstraintTypes.null,
+        disabled: this.isViewOnly
+      }, Validators.required),
+      value: new FormControl({
+        value: '',
+        disabled: this.isViewOnly
+      }, this.constraintValidators)
+    });
+    this.constraintsArray.push(newConstraint);
+    this.valid = false;
+    this.emitOnConstraintChange();
+  }
+
+  getInRangeValue(constraintIndex: number, valueIndex: number): string {
+    const value = this.constraintsArray.at(constraintIndex).get('value').value;
+
+    if (!value || !value[valueIndex]) {
+      return '';
+    }
+
+    return value[valueIndex];
+  }
+
+  disableConstraint(optionConstraintType: ConstraintTypes): boolean {
+    const invalid = this.notAllowedConstraint(optionConstraintType);
+    return invalid ? invalid : this.getConstraintTypeIfPresent(optionConstraintType) ? true : false;
+  }
+
+  notAllowedConstraint(optionConstraintType: ConstraintTypes): boolean {
+    switch (optionConstraintType) {
+      case ConstraintTypes.less_or_equal:
+      case ConstraintTypes.less_than:
+      case ConstraintTypes.greater_or_equal:
+      case ConstraintTypes.greater_than:
+      case ConstraintTypes.in_range:
+        if (this.isComparable(this.propertyType)) {
+          return false;
+        }
+        break;
+      case ConstraintTypes.length:
+      case ConstraintTypes.max_length:
+      case ConstraintTypes.min_length:
+        if (this.propertyType == PROPERTY_TYPES.STRING || this.propertyType == PROPERTY_TYPES.MAP || this.propertyType == PROPERTY_TYPES.LIST) {
+          return false;
+        }
+        break;
+      case ConstraintTypes.pattern:
+        if (this.propertyType == PROPERTY_TYPES.STRING) {
+          return false;
+        }
+        break;
+      case ConstraintTypes.valid_values:
+      case ConstraintTypes.equal:
+        return false;
+    }
+    return true;
+  }
+
+  getConstraintTypeIfPresent(constraintType: ConstraintTypes): AbstractControl {
+    return this.constraintsArray.controls.find((control: AbstractControl) => {
+      const type = control.get('type').value;
+      return type == constraintType;
+    });
+  }
+
+  trackByFn(index) {
+    return index;
+  }
+
+  isComparable(propType: string): boolean {
+    if (PROPERTY_DATA.COMPARABLE_TYPES.indexOf(propType) >= 0) {
+      return true;
+    }
+    return false;
+  }
+
+  private getConstraintFromPropertyBEModel(constraint: any): AbstractControl {
+    console.log('be model constraints', constraint);
     let constraintType: ConstraintTypes;
     let constraintValue: any;
     if (!constraint) {
       constraintType = ConstraintTypes.null;
-      constraintValue = "";
-    } else if(constraint.hasOwnProperty(ConstraintTypes.valid_values)){
+      constraintValue = '';
+    } else if (constraint.hasOwnProperty(ConstraintTypes.valid_values)) {
       constraintType = ConstraintTypes.valid_values;
-      constraintValue = constraint.validValues;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.equal)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.equal)) {
       constraintType = ConstraintTypes.equal;
       constraintValue = constraint.equal;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.greater_than)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.greater_than)) {
       constraintType = ConstraintTypes.greater_than;
       constraintValue = constraint.greaterThan;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.greater_or_equal)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.greater_or_equal)) {
       constraintType = ConstraintTypes.greater_or_equal;
       constraintValue = constraint.greaterOrEqual;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.less_than)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.less_than)) {
       constraintType = ConstraintTypes.less_than;
       constraintValue = constraint.lessThan;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.less_or_equal)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.less_or_equal)) {
       constraintType = ConstraintTypes.less_or_equal;
       constraintValue = constraint.lessOrEqual;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.in_range)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.in_range)) {
       constraintType = ConstraintTypes.in_range;
       constraintValue = new Array(constraint.inRange[0], constraint.inRange[1]);
-    } else if(constraint.rangeMaxValue || constraint.rangeMinValue) {
+    } else if (constraint.rangeMaxValue || constraint.rangeMinValue) {
       constraintType = ConstraintTypes.in_range;
       constraintValue = new Array(constraint.rangeMinValue, constraint.rangeMaxValue);
-    } else if(constraint.hasOwnProperty(ConstraintTypes.length)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.length)) {
       constraintType = ConstraintTypes.length;
       constraintValue = constraint.length;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.min_length)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.min_length)) {
       constraintType = ConstraintTypes.min_length;
       constraintValue = constraint.minLength;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.max_length)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.max_length)) {
       constraintType = ConstraintTypes.max_length;
       constraintValue = constraint.maxLength;
-    } else if(constraint.hasOwnProperty(ConstraintTypes.pattern)) {
+    } else if (constraint.hasOwnProperty(ConstraintTypes.pattern)) {
       constraintType = ConstraintTypes.pattern;
       constraintValue = constraint.pattern;
     }
-    return {
-      type:constraintType,
-      value:constraintValue
+
+    if (!constraint.hasOwnProperty(ConstraintTypes.valid_values) && !constraint.hasOwnProperty(ConstraintTypes.in_range)) {
+      return this.formBuilder.group({
+        type: new FormControl({
+          value: constraintType,
+          disabled: this.isViewOnly
+        }, Validators.required),
+        value: new FormControl({
+          value: constraintValue,
+          disabled: this.isViewOnly
+        }, this.constraintValidators)
+      });
+    } else {
+      const newForm = this.formBuilder.group({
+        type: new FormControl({
+          value: constraintType,
+          disabled: this.isViewOnly
+        }, Validators.required),
+        value: this.formBuilder.array([])
+      });
+
+      const valRef = newForm.get('value') as FormArray;
+
+      if (constraint.hasOwnProperty(ConstraintTypes.valid_values)) {
+        constraint.validValues.forEach((val) => {
+          valRef.push(new FormControl(val, this.constraintValidators));
+        });
+      } else {
+        constraint.inRange.forEach((val) => {
+          valRef.push(new FormControl(val, this.constraintValidators));
+        });
+      }
+
+      console.log('new form', newForm);
+      return newForm;
     }
   }
 
   private getConstraintsFormat(): any[] {
-    let constraintArray = new Array();
-    this.constraints.forEach((constraint: Constraint) => {
-      constraintArray.push(this.getConstraintFormat(constraint))
+    const constraintArray = new Array();
+    this.constraintsArray.controls.forEach((control: AbstractControl) => {
+      const type = control.get('type').value;
+      let constraint: Constraint;
+
+      if (type != ConstraintTypes.valid_values && type != ConstraintTypes.in_range) {
+        constraint = {
+          type,
+          value: control.get('value').value
+        };
+      } else {
+        const valArray = [];
+
+        control.get('value').value.forEach((val) => {
+          valArray.push(val);
+        });
+
+        constraint = {
+          type,
+          value: valArray
+        };
+      }
+
+      console.log('New constraint object', constraint);
+      constraintArray.push(this.getConstraintFormat(constraint));
     });
     return constraintArray;
   }
@@ -123,224 +401,153 @@ export class ConstraintsComponent implements OnInit {
       case ConstraintTypes.equal:
         return {
           [ConstraintTypes.equal]: constraint.value
-        }
+        };
       case ConstraintTypes.less_or_equal:
         return {
           [ConstraintTypes.less_or_equal]: constraint.value
-        }
+        };
       case ConstraintTypes.less_than:
         return {
           [ConstraintTypes.less_than]: constraint.value
-        }
+        };
       case ConstraintTypes.greater_or_equal:
         return {
           [ConstraintTypes.greater_or_equal]: constraint.value
-        }
+        };
       case ConstraintTypes.greater_than:
         return {
           [ConstraintTypes.greater_than]: constraint.value
-        }
+        };
       case ConstraintTypes.in_range:
         return {
           [ConstraintTypes.in_range]: constraint.value
-        }
+        };
       case ConstraintTypes.length:
         return {
           [ConstraintTypes.length]: constraint.value
-        }
+        };
       case ConstraintTypes.max_length:
         return {
           [ConstraintTypes.max_length]: constraint.value
-        }
+        };
       case ConstraintTypes.min_length:
         return {
           [ConstraintTypes.min_length]: constraint.value
-        }
+        };
       case ConstraintTypes.pattern:
         return {
           [ConstraintTypes.pattern]: constraint.value
-        }
+        };
       case ConstraintTypes.valid_values:
         return {
           [ConstraintTypes.valid_values]: constraint.value
-        }
+        };
       default:
         return;
     }
   }
 
   private validateConstraints(): void {
-    this.valid = this.constraints.every((constraint: Constraint) => {
-      if (Array.isArray(constraint.value)) {
-        return !(constraint.value.length == 0 || this.doesArrayContaintEmptyValues(constraint.value));
+    this.valid = this.constraintsArray.controls.every((control: AbstractControl) => {
+      const value = control.get('value').value;
+      const type = control.get('type').value;
+      control.updateValueAndValidity();
+
+      if (Array.isArray(value)) {
+        return !(value.length == 0 || this.doesArrayContaintEmptyValues(value));
       }
-      if (constraint.type == ConstraintTypes.pattern) {
+      if (type == ConstraintTypes.pattern) {
         try {
-          new RegExp(constraint.value);
+          new RegExp(value);
           this.valid = true;
-        } catch(e) {
+        } catch (e) {
           this.valid = false;
         }
+      } else {
+        this.valid = this.constraintForm.valid;
       }
-      return constraint.value && constraint.type != ConstraintTypes.null
+
+      return value && type != ConstraintTypes.null;
     });
   }
 
   private doesArrayContaintEmptyValues(arr) {
-    for(const element of arr) {
-      if(element === "") return true;
+    for (const element of arr) {
+      if (element === '') { return true; }
     }
     return false;
   }
 
   private emitOnConstraintChange(): void {
+    console.log('constraints', this.constraintsArray);
+
     this.validateConstraints();
     const newConstraints = this.getConstraintsFormat();
+
+    this.valid = this.constraintForm.valid;
+    console.log('emitOnConstraintChange.valid', this.valid);
+
     this.onConstraintChange.emit({
       constraints: newConstraints,
       valid: this.valid
     });
   }
 
-  removeFromList(constraintIndex: number, valueIndex: number){
-    this.constraints[constraintIndex].value.splice(valueIndex, 1);
-    this.emitOnConstraintChange()
-  }
-
-  addToList(constraintIndex: number){
-    if (!this.constraints[constraintIndex].value) {
-      this.constraints[constraintIndex].value = new Array();
-    }
-    this.constraints[constraintIndex].value.push("");
-    this.emitOnConstraintChange()
-  }
-
-  onChangeConstraintType(constraintIndex: number, newType: ConstraintTypes) {
-    this.constraints[constraintIndex].type = newType;
-    if ((newType == ConstraintTypes.in_range || newType == ConstraintTypes.valid_values) && !Array.isArray(this.constraints[constraintIndex].value)) {
-      this.constraints[constraintIndex].value = new Array()
-    }
-    this.emitOnConstraintChange();
-  }
-
-  onChangeConstraintValue(constraintIndex: number, newValue: any) {
-    this.constraints[constraintIndex].value = newValue;
-    this.emitOnConstraintChange();
-  }
-
-  onChangeConstrainValueIndex(constraintIndex: number, newValue: any, valueIndex: number) {
-    if(!this.constraints[constraintIndex].value) {
-      this.constraints[constraintIndex].value = new Array();
-    }
-    this.constraints[constraintIndex].value[valueIndex] = newValue;
-    this.emitOnConstraintChange();
-  }
-
-  removeConstraint(constraintIndex: number) {
-    this.constraints.splice(constraintIndex, 1);
-    this.emitOnConstraintChange();
 }
 
-  addConstraint() {
-    let newConstraint: Constraint = {
-      type: ConstraintTypes.null,
-      value: ""
-    }
-    this.constraints.push(newConstraint);
-    this.emitOnConstraintChange();
-  }
-
-  getInRangeValue(constraintIndex: number, valueIndex: number): string {
-    if(!this.constraints[constraintIndex].value || !this.constraints[constraintIndex].value[valueIndex]) {
-      return "";
-    }
-    return this.constraints[constraintIndex].value[valueIndex];
-  }
-
-  disableConstraint(optionConstraintType: ConstraintTypes): boolean {
-    const invalid = this.notAllowedConstraint(optionConstraintType);
-    return invalid ? invalid : this.getConstraintTypeIfPresent(optionConstraintType) ? true : false;
-  }
-
-  notAllowedConstraint(optionConstraintType: ConstraintTypes): boolean {
-    switch (optionConstraintType) {
-      case ConstraintTypes.less_or_equal:
-      case ConstraintTypes.less_than:
-      case ConstraintTypes.greater_or_equal:
-      case ConstraintTypes.greater_than:
-      case ConstraintTypes.in_range:
-        if (this.isComparable(this.propertyType)){
-          return false;
-        }
-        break;
-      case ConstraintTypes.length:
-      case ConstraintTypes.max_length:
-      case ConstraintTypes.min_length:
-        if (this.propertyType == PROPERTY_TYPES.STRING || this.propertyType == PROPERTY_TYPES.MAP || this.propertyType == PROPERTY_TYPES.LIST){
-          return false;
-        }
-        break;
-      case ConstraintTypes.pattern:
-        if (this.propertyType == PROPERTY_TYPES.STRING){
-          return false;
-        }
-        break;
-      case ConstraintTypes.valid_values:
-      case ConstraintTypes.equal:
-        return false;
-    }
-    return true;
-  }
+export enum ConstraintTypes {
+  null = '',
+  equal= 'equal',
+  greater_than = 'greaterThan',
+  greater_or_equal = 'greaterOrEqual',
+  less_than = 'lessThan',
+  less_or_equal = 'lessOrEqual',
+  in_range = 'inRange',
+  valid_values = 'validValues',
+  length = 'length',
+  min_length = 'minLength',
+  max_length = 'maxLength',
+  pattern = 'pattern'
+}
 
-  getConstraintTypeIfPresent(constraintType: ConstraintTypes): Constraint {
-    return this.constraints.find((constraint) => {
-      return constraint.type == constraintType ? true : false;
-    })
-  }
+export const ConstraintTypesMapping = {
+  [ConstraintTypes.equal]: 'equal',
+  [ConstraintTypes.greater_than]: 'greater_than',
+  [ConstraintTypes.greater_or_equal]: 'greater_or_equal',
+  [ConstraintTypes.less_than]: 'less_than',
+  [ConstraintTypes.less_or_equal]: 'less_or_equal',
+  [ConstraintTypes.in_range]: 'in_range',
+  [ConstraintTypes.valid_values]: 'valid_values',
+  [ConstraintTypes.length]: 'length',
+  [ConstraintTypes.min_length]: 'min_length',
+  [ConstraintTypes.max_length]: 'max_length',
+  [ConstraintTypes.pattern]: 'pattern'
+};
 
-  trackByFn(index) {
-    return index;
-  }
+export interface Constraint {
+  type: ConstraintTypes;
+  value: any;
+}
 
-  isComparable(propType: string): boolean {
-    if (PROPERTY_DATA.COMPARABLE_TYPES.indexOf(propType) >= 0) {
-      return true;
+export function intValidator(): ValidatorFn {
+  const intRegex = /^[-+]?\d+$/;
+  return (control: AbstractControl): ValidationErrors | null => {
+    if (control.value && !intRegex.test(control.value)) {
+      return {invalidInt: true};
     }
-    return false;
-  }
 
+    return null;
+  };
 }
 
-export enum ConstraintTypes {
-  null = "",
-  equal= "equal",
-  greater_than = "greaterThan",
-  greater_or_equal = "greaterOrEqual",
-  less_than = "lessThan",
-  less_or_equal = "lessOrEqual",
-  in_range = "inRange",
-  valid_values = "validValues",
-  length = "length",
-  min_length = "minLength",
-  max_length = "maxLength",
-  pattern = "pattern"
-}
+export function floatValidator(): ValidatorFn {
+  const floatRegex = /^[-+]?\d+(\.\d+)?$/;
 
-export const ConstraintTypesMapping = {
-  [ConstraintTypes.equal]: "equal",
-  [ConstraintTypes.greater_than]: "greater_than",
-  [ConstraintTypes.greater_or_equal]: "greater_or_equal",
-  [ConstraintTypes.less_than]: "less_than",
-  [ConstraintTypes.less_or_equal]: "less_or_equal",
-  [ConstraintTypes.in_range]: "in_range",
-  [ConstraintTypes.valid_values]: "valid_values",
-  [ConstraintTypes.length]: "length",
-  [ConstraintTypes.min_length]: "min_length",
-  [ConstraintTypes.max_length]: "max_length",
-  [ConstraintTypes.pattern]: "pattern"
-};
+  return (control: AbstractControl): ValidationErrors | null => {
+    if (control.value && !floatRegex.test(control.value)) {
+      return {invalidFloat: true};
+    }
 
-export interface Constraint {
-  type:ConstraintTypes,
-  value:any
+    return null;
+  };
 }