feat(universal): add min and max Date validators

Author: Nightapes

src/components/universal/universal-validators.spec.ts

@@ -237,4 +237,76 @@ describe("Universal validators service", () => {
       expect(validated).toEqual({ max: { required: 2, actual: "3" } });
     });
   });
+
+  describe("maxDate", () => {
+    it("should work for empty control", () => {
+      const control: FormControl = new FormControl("");
+      const validated = UniversalValidators.maxDate(new Date())(control);
+      expect(validated).toBeUndefined();
+    });
+
+    it("should work for valid maxDate", () => {
+      const control: FormControl = new FormControl("2012-12-24");
+      const validated = UniversalValidators.maxDate(new Date())(control);
+      expect(validated).toBeUndefined();
+    });
+
+    it("should work for valid maxDate", () => {
+      const date = new Date();
+      const control: FormControl = new FormControl(date.getTime());
+      const validated = UniversalValidators.maxDate(date)(control);
+      expect(validated).toBeUndefined();
+    });
+
+    it("should work for invalid date", () => {
+      const date = new Date();
+      const control: FormControl = new FormControl("broken");
+      const validated = UniversalValidators.maxDate(date)(control);
+      expect(validated).toEqual({ dateRequired: true });
+    });
+
+    it("should work for invalid maxDate", () => {
+      const currentDate = new Date();
+      const requiredDate = new Date("2012-12-24");
+      const control: FormControl = new FormControl(currentDate);
+      const validated = UniversalValidators.maxDate(requiredDate)(control);
+      expect(validated).toEqual({ maxDate: { required: requiredDate, actual: currentDate } });
+    });
+  });
+
+  describe("minDate", () => {
+    it("should work for empty control", () => {
+      const control: FormControl = new FormControl("");
+      const validated = UniversalValidators.minDate(new Date())(control);
+      expect(validated).toBeUndefined();
+    });
+
+    it("should work for valid minDate", () => {
+      const control: FormControl = new FormControl("2020-12-24");
+      const validated = UniversalValidators.minDate(new Date("2012-12-24"))(control);
+      expect(validated).toBeUndefined();
+    });
+
+    it("should work for valid minDate", () => {
+      const date = new Date();
+      const control: FormControl = new FormControl(date.getTime());
+      const validated = UniversalValidators.minDate(date)(control);
+      expect(validated).toBeUndefined();
+    });
+
+    it("should work for invalid date", () => {
+      const date = new Date();
+      const control: FormControl = new FormControl("broken");
+      const validated = UniversalValidators.minDate(date)(control);
+      expect(validated).toEqual({ dateRequired: true });
+    });
+
+    it("should work for invalid minDate", () => {
+      const currentDate = new Date("2012-12-24");
+      const requiredDate = new Date();
+      const control: FormControl = new FormControl(currentDate);
+      const validated = UniversalValidators.minDate(requiredDate)(control);
+      expect(validated).toEqual({ minDate: { required: requiredDate, actual: currentDate } });
+    });
+  });
 });

src/components/universal/universal-validators.ts

@@ -115,4 +115,34 @@ export class UniversalValidators {
     };
     return validator;
   }
+
+  public static minDate(minDate: Date) {
+    const validator = (control: AbstractControl): ValidationErrors => {
+      if (AbstractControlUtil.isNotPresent(control)) return undefined;
+      const date: Date = new Date(control.value);
+      if (isNaN(date.getTime())) {
+        return { dateRequired: true };
+      }
+      if (date.getTime() >= minDate.getTime()) {
+        return undefined;
+      }
+      return { minDate: { required: minDate, actual: date } };
+    };
+    return validator;
+  }
+
+  public static maxDate(minDate: Date) {
+    const validator = (control: AbstractControl): ValidationErrors => {
+      if (AbstractControlUtil.isNotPresent(control)) return undefined;
+      const date: Date = new Date(control.value);
+      if (isNaN(date.getTime())) {
+        return { dateRequired: true };
+      }
+      if (date.getTime() <= minDate.getTime()) {
+        return undefined;
+      }
+      return { maxDate: { required: minDate, actual: date } };
+    };
+    return validator;
+  }
 }

src/components/universal/universal.directive.ts

@@ -197,3 +197,77 @@ export class MinValidatorDirective implements Validator, OnInit, OnChanges {
     this.onChange = fn;
   }
 }
+
+@Directive({
+  selector: "input[type=text][minDate][formControlName],input[type=text][minDate][formControl],input[type=text][minDate][ngModel]",
+  providers: [
+    {
+      provide: NG_VALIDATORS,
+      // tslint:disable-next-line:no-forward-ref
+      useExisting: forwardRef(() => MinDateValidatorDirective),
+      multi: true,
+    },
+  ],
+})
+export class MinDateValidatorDirective implements Validator, OnInit, OnChanges {
+  @Input() minDate: string;
+
+  private validator: ValidatorFn;
+  private onChange: () => void;
+
+  ngOnInit() {
+    this.validator = UniversalValidators.minDate(new Date(this.minDate));
+  }
+
+  ngOnChanges(changes: SimpleChanges): void {
+    if (changes.minDate && !changes.minDate.isFirstChange()) {
+      this.validator = UniversalValidators.minDate(changes.min.currentValue);
+      this.onChange();
+    }
+  }
+
+  validate(c: AbstractControl): ValidationErrors {
+    return this.validator(c);
+  }
+
+  registerOnValidatorChange(fn: () => void): void {
+    this.onChange = fn;
+  }
+}
+
+@Directive({
+  selector: "input[type=text][maxDate][formControlName],input[type=text][maxDate][formControl],input[type=text][maxDate][ngModel]",
+  providers: [
+    {
+      provide: NG_VALIDATORS,
+      // tslint:disable-next-line:no-forward-ref
+      useExisting: forwardRef(() => MaxDateValidatorDirective),
+      multi: true,
+    },
+  ],
+})
+export class MaxDateValidatorDirective implements Validator, OnInit, OnChanges {
+  @Input() maxDate: string;
+
+  private validator: ValidatorFn;
+  private onChange: () => void;
+
+  ngOnInit() {
+    this.validator = UniversalValidators.maxDate(new Date(this.maxDate));
+  }
+
+  ngOnChanges(changes: SimpleChanges): void {
+    if (changes.maxDate && !changes.maxDate.isFirstChange()) {
+      this.validator = UniversalValidators.maxDate(changes.min.currentValue);
+      this.onChange();
+    }
+  }
+
+  validate(c: AbstractControl): ValidationErrors {
+    return this.validator(c);
+  }
+
+  registerOnValidatorChange(fn: () => void): void {
+    this.onChange = fn;
+  }
+}