taxtank 0.1.0

package/projects/tt-core/src/lib/validators/address-corelogic.validator.ts

@@ -0,0 +1,24 @@
+import { FormControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { AddressForm } from '../forms';
+
+/**
+ * @TODO not used temporary, waiting for corelogic support response why it can't find some suburbs (like Hamilton Island)
+ * Validator for address, check if corelogic suggestion selected correctly
+ */
+export function addressCorelogicValidator(): ValidatorFn {
+  return (form: AddressForm): ValidationErrors => {
+    // we are interested in corelogic ids only for Australian addresses
+    if (!form.isAustraliaSelected()) {
+      return null;
+    }
+
+    // we need at least corelogic locality id to get growth percent
+    const locIdControl: FormControl = form.get('corelogicLocId') as FormControl;
+
+    if (locIdControl.enabled && locIdControl.hasError('required')) {
+      return { address: 'City, state or postal code not specified' };
+    }
+
+    return null;
+  };
+}

package/projects/tt-core/src/lib/validators/at-least-one-enabled.validator.ts

@@ -0,0 +1,10 @@
+import { AbstractControl, UntypedFormArray, UntypedFormGroup, ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validator check if at least one control in formArray is enabled
+ */
+export function atLeastOneEnabledValidator(arrayName: string): ValidatorFn {
+  return (formGroup: UntypedFormGroup): ValidationErrors => (formGroup.get(arrayName) as UntypedFormArray).controls.find((control: AbstractControl) => control.enabled)
+    ? null
+    : {arrayControlsDisabled: true}
+}

package/projects/tt-core/src/lib/validators/at-least-one.validator.ts

@@ -0,0 +1,10 @@
+import { UntypedFormControl, UntypedFormGroup, ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Check if at least one form field is true, otherwise form is invalid.
+ * Use with groups of boolean form controls (checkbox, toggle, etc.)
+ */
+export function atLeastOneCheckedValidator(): ValidatorFn {
+  return (formGroup: UntypedFormGroup): ValidationErrors => Object.values(formGroup.controls)
+    .find((control: UntypedFormControl): boolean => control.value) ? null : {nothingChecked: true}
+}

package/projects/tt-core/src/lib/validators/autocomplete.validator.ts

@@ -0,0 +1,9 @@
+import { UntypedFormControl, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validation function for autocomplete fields. Checks that the user should select a value from a list rather than type in input field
+ * @TODO Alex: create class AppValidators with static methods and move there all custom validators (line Angular Validators)
+ */
+export function autocompleteValidator(): ValidatorFn {
+  return (control: UntypedFormControl) => (!control.value || (typeof control.value === 'object')) ? null : {notFromList: true};
+}

package/projects/tt-core/src/lib/validators/conditional.validator.ts

@@ -0,0 +1,35 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { distinctUntilChanged } from 'rxjs/operators';
+
+export function conditionalValidator(
+  condition: (control: AbstractControl) => boolean,
+  validator: (control: AbstractControl) => object | null): ValidatorFn {
+  return function (control: AbstractControl): ValidationErrors {
+    revalidateOnChanges(control);
+
+    if (control && control.parent) {
+      if (condition(control.parent)) {
+        return validator(control);
+      }
+    }
+
+    return null;
+  };
+}
+
+/**
+ * Conditional validator depends on other fields and should be updated on each form value change
+ */
+function revalidateOnChanges(control: AbstractControl): void {
+  if (control && control.parent && !control['_revalidateOnChanges']) {
+    control['_revalidateOnChanges'] = true;
+    control.parent.valueChanges.pipe(
+      distinctUntilChanged((a: object, b: object) => JSON.stringify(a) === JSON.stringify(b))
+    )
+      .subscribe(() => {
+        control.updateValueAndValidity({ emitEvent: false });
+      });
+  }
+
+  return;
+}

package/projects/tt-core/src/lib/validators/current-fin-year.validator.ts

@@ -0,0 +1,18 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { FinancialYear } from '../models';
+
+/**
+ * Validation function, that checks If provided date is within a current financial year
+ */
+export function currentFinYearValidator(): ValidatorFn {
+  const currentFinYear: FinancialYear = new FinancialYear();
+
+  return (control: AbstractControl): ValidationErrors => {
+    const date = new Date(control.value);
+    if (!control.value || date >= currentFinYear.startDate && date <= currentFinYear.endDate) {
+      return null;
+    }
+
+    return { notCurrentFinYear: true };
+  };
+}

package/projects/tt-core/src/lib/validators/date/max-date.validator.ts

@@ -0,0 +1,23 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { DatePipe } from '@angular/common';
+
+/**
+ * Validation function, that checks If date form value is more than provided date
+ */
+export function maxDateValidator(
+  date: Date,
+  message: string = `The date should not be after ${new DatePipe('en-US').transform(date)}`
+): ValidatorFn {
+  return (control: AbstractControl): ValidationErrors => {
+    if (!control.value) {
+      return null;
+    }
+
+    // form control value can be as a Moment object - we wrap it in "new Date()" to work with it like with JS Date
+    if (new Date(control.value) <= new Date(date)) {
+      return null;
+    }
+
+    return { minDate: message };
+  };
+}

package/projects/tt-core/src/lib/validators/date/min-date.validator.ts

@@ -0,0 +1,23 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+import { DatePipe } from '@angular/common';
+
+/**
+ * Validation function, that checks If date form value is more than provided date
+ */
+export function minDateValidator(
+  date: Date,
+  message: string = `The date should not be before ${new DatePipe('en-US').transform(date)}`
+): ValidatorFn {
+  return (control: AbstractControl): ValidationErrors => {
+    if (!control.value) {
+      return null;
+    }
+
+    // form control value can be as a Moment object - we wrap it in "new Date()" to work with it like with JS Date
+    if (new Date(control.value) >= new Date(date)) {
+      return null;
+    }
+
+    return { minDate: message };
+  };
+}

package/projects/tt-core/src/lib/validators/date-range.validator.ts

@@ -0,0 +1,27 @@
+import { UntypedFormControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validate date value. Date value should be in passed dateRange
+ */
+export function dateRangeValidator(dateStart: Date, dateEnd: Date): ValidatorFn {
+  // Avoid timezone hours problem when converts to UTC
+  // dateStart.setHours(0, 0, 0, 0);
+  // dateEnd.setHours(0, 0, 0, 0);
+
+  return (control: UntypedFormControl): ValidationErrors => {
+    // Skip empty value
+    if (!control.value) {
+      return null;
+    }
+
+    if (control.value < dateStart) {
+      return { dateRangeStart: dateStart };
+    }
+
+    if (control.value > dateEnd) {
+      return { dateRangeEnd: dateEnd };
+    }
+
+    return null;
+  };
+}

package/projects/tt-core/src/lib/validators/fields-sum.validator.ts

@@ -0,0 +1,27 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validator that check if sum amount of provided fields is greater than provided sum
+ * @param field to check in each formArray element
+ * @param summary to compare with fields sum
+ * @param fieldAlias to show it in error message
+ */
+export function fieldsSumValidator(field: string, summary = 100, fieldAlias?: string): ValidatorFn {
+  return (formArray: AbstractControl): ValidationErrors => {
+    // calculate sum of desired fields in formArray control
+    const fieldsSum: number = formArray['controls']
+      .reduce((acc: number, group: AbstractControl) => acc += group.get(field).value, 0);
+
+    if (fieldsSum <= summary) {
+      return null;
+    }
+    return {
+      fieldsSum: {
+        name: field,
+        alias: fieldAlias,
+        summary
+      }
+    };
+
+  };
+}

package/projects/tt-core/src/lib/validators/file.validator.ts

@@ -0,0 +1,46 @@
+import { UntypedFormControl, ValidatorFn } from '@angular/forms';
+import { DOCUMENT_FILE_TYPES } from '../models/document/document-file-types.const';
+import { AbstractModel } from '../db/Models';
+
+const MAX_SIZE = 4194304;
+
+export class FileValidator {
+  // File max size check
+  static fileMaxSize(maxSize: number = MAX_SIZE): ValidatorFn {
+    const validatorFn: any = (file: File): object => {
+
+      // We don`t need to validate saved files, because when saving the form, the file was valid
+      if (file instanceof AbstractModel) {
+        return null;
+      }
+
+      return file.size > maxSize ? { fileMaxSize: {maxSize} } : null;
+    };
+    return FileValidator.fileValidation(validatorFn);
+  }
+
+  // File extension check
+  static fileExtensions(allowedExtensions: string[] = DOCUMENT_FILE_TYPES.all): ValidatorFn {
+    const validatorFn: any = (file: File): object => {
+
+      // We don`t need to validate saved files, because when saving the form, the file was valid
+      if (file instanceof AbstractModel) {
+        return null;
+      }
+
+      return allowedExtensions.includes(file.type) ? null : { fileExtension: {allowedExtensions: allowedExtensions.join()} };
+    };
+
+    return FileValidator.fileValidation(validatorFn);
+  }
+
+  private static fileValidation(validatorFn: (File: File) => null | object): ValidatorFn {
+    return (formControl: UntypedFormControl) => {
+      if (!formControl.value) {
+        return null;
+      }
+
+      return validatorFn(formControl.value);
+    };
+  }
+}

package/projects/tt-core/src/lib/validators/greater-than-control.validator.ts

@@ -0,0 +1,17 @@
+import { AbstractControl,  ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validator that enforces the current control's value to be >= another control's value.
+ */
+export function greaterThanControlValidator(controlName: string, alias: string): ValidatorFn {
+  return (control: AbstractControl): ValidationErrors => {
+    // skip validation until control is attached to a parent FormGroup
+    if (!control?.parent) {
+      return null;
+    }
+    const group = control.parent;
+    const fieldToCompare = group.get(controlName);
+    const isLessThan = Number(fieldToCompare.value) > Number(control.value);
+    return isLessThan ? { greaterThanControl: `The value should be greater than ${alias}` } : null;
+  }
+}

package/projects/tt-core/src/lib/validators/greater-than.validator.ts

@@ -0,0 +1,14 @@
+import { FormControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validator is checking if field value is greater than passed value
+ */
+export function greaterThanValidator(value: number): ValidatorFn {
+  return (control: FormControl): ValidationErrors => {
+    if (!control.value && (control.value !== 0)) {
+      return null;
+    }
+
+    return control.value > value ? null : { greaterThan: `The value should be greater than ${value}` };
+  }
+}

package/projects/tt-core/src/lib/validators/group.validator.ts

@@ -0,0 +1,13 @@
+import { FormGroup, ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Custom validator that applies another validator to all controls in a FormGroup
+ */
+export function groupValidator(validatorFn: ValidatorFn): ValidatorFn {
+  return (control: FormGroup): ValidationErrors | null => {
+    const keys = Object.keys(control.controls);
+    const errors = keys.map(key => validatorFn(control.get(key))).filter(Boolean);
+
+    return errors.length === keys.length ? errors[0] : null;
+  }
+}

package/projects/tt-core/src/lib/validators/index.ts

@@ -0,0 +1,15 @@
+export * from './at-least-one.validator';
+export * from './autocomplete.validator';
+export * from './conditional.validator';
+export * from './password.validator';
+export * from './password-match.validator';
+export * from './date/min-date.validator';
+export * from './date/max-date.validator';
+export * from './fields-sum.validator';
+export * from './current-fin-year.validator';
+export * from './file.validator';
+export * from './greater-than.validator';
+export * from './greater-than-control.validator';
+export * from './unique-email.validator';
+export * from './string/name.validator';
+export * from './match-sum.validator';

package/projects/tt-core/src/lib/validators/less-than-control.validator.ts

@@ -0,0 +1,18 @@
+import { AbstractControl,  ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validator that enforces the current control's value to be >= another control's value.
+ */
+export function lessThanControlValidator(controlName: string, alias: string): ValidatorFn {
+  return (control: AbstractControl): ValidationErrors => {
+    // skip validation until control is attached to a parent FormGroup
+    if (!control?.parent) {
+      return null;
+    }
+
+    const group = control.parent;
+    const fieldToCompare = group.get(controlName);
+    const isLessThan = Number(fieldToCompare.value) > Number(control.value);
+    return isLessThan ? null : { lessThanControl: `The value should be less than ${alias}` };
+  }
+}

package/projects/tt-core/src/lib/validators/match-sum.validator.ts

@@ -0,0 +1,18 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * @param controlsFn function to get controls from target parent
+ * it's easier to pass controls instead of function, but it won't work with dynamic fields
+ */
+export function matchSumValidator(controlsFn: () => AbstractControl[], error: string): ValidatorFn {
+  return (targetControl: AbstractControl): ValidationErrors | null => {
+    const controls: AbstractControl[] = controlsFn.bind(targetControl.parent)();
+    if (controls.find(control => control.value === null) || targetControl.value === null) {
+      return null;
+    }
+    const sum = controls.reduce((acc, control) => acc + control.value, 0);
+    const targetValue = targetControl.value;
+
+    return sum.toFixed(2) === targetValue.toFixed(2) ? null : { matchSum: error };
+  };
+}

package/projects/tt-core/src/lib/validators/not-greater-than-control.validator.ts

@@ -0,0 +1,17 @@
+import { AbstractControl,  ValidationErrors, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validator that enforces the current control's value to be <= another control's value.
+ */
+export function notGreaterThanControlValidator(controlName: string, alias: string): ValidatorFn {
+  return (control: AbstractControl): ValidationErrors => {
+    // skip validation until control is attached to a parent FormGroup
+    if (!control?.parent) {
+      return null;
+    }
+    const group = control.parent;
+    const fieldToCompare = group.get(controlName);
+    const isNotGreaterThan = Number(control.value) <= Number(fieldToCompare.value);
+    return isNotGreaterThan ? null : { notGreaterThanControl: `The value should be not greater than ${alias}` };
+  }
+}

package/projects/tt-core/src/lib/validators/password-match.validator.ts

@@ -0,0 +1,20 @@
+import { AbstractControl, UntypedFormGroup, ValidatorFn } from '@angular/forms';
+
+export function passwordMatchValidator(newPassControlName: string, confirmPassControlName: string): ValidatorFn {
+  return (group: UntypedFormGroup) => {
+    const passwordControl: AbstractControl = group.get(newPassControlName);
+    const confirmControl: AbstractControl = group.get(confirmPassControlName);
+
+    if (confirmControl.errors && !confirmControl.hasError('passwordMismatch')) {
+      // return if another validator has already found an error on the confirmControl
+      return this;
+    }
+
+    if (passwordControl.value !== confirmControl.value) {
+      confirmControl.setErrors({ passwordMismatch: true });
+    } else {
+      confirmControl.setErrors(null);
+    }
+
+  };
+}

package/projects/tt-core/src/lib/validators/password.validator.ts

@@ -0,0 +1,24 @@
+import { UntypedFormControl, ValidatorFn } from '@angular/forms';
+
+/**
+ * Regular expressions that are used to check password strength and valid values
+ */
+export const PASSWORD_REGEXPS: { [key: string]: RegExp } = {
+  medium: /(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9])))(?=.{6,})/,
+  strong: /(((?=.*[a-z])(?=.*[A-Z])(?=.*[!@#$%^&*]))|((?=.*[a-z])(?=.*[0-9])(?=.*[!@#$%^&*]))|((?=.*[A-Z])(?=.*[0-9]))(?=.*[!@#$%^&*]))(?=.{8,})/,
+  format: /^[0-9a-zA-Z!@$!%*?&#]*$/
+};
+
+export function passwordValidator(): ValidatorFn {
+  return (control: UntypedFormControl) => {
+    if (!PASSWORD_REGEXPS.format.test(control.value)) {
+      return { passwordInvalid: true }
+    }
+
+    if (!PASSWORD_REGEXPS.medium.test(control.value)) {
+      return { passwordWeak: true }
+    }
+
+    return null;
+  };
+}

package/projects/tt-core/src/lib/validators/phone-number.validator.ts

@@ -0,0 +1,11 @@
+import { UntypedFormControl, ValidatorFn } from '@angular/forms';
+
+const phonePattern = /^(((\s*)?([- ()]?\d[- ()]?){0,30}(\s*)?)|)$/;
+
+/**
+ * Validator for phone number
+ * Allowed special symbols"-", "(", ")"
+ */
+export function phoneNumberValidator(): ValidatorFn {
+  return (control: UntypedFormControl) => phonePattern.test(control.value) ? null : { phoneInvalid: true };
+}

package/projects/tt-core/src/lib/validators/required-length.validator.ts

@@ -0,0 +1,14 @@
+import { UntypedFormControl, ValidatorFn } from '@angular/forms';
+
+/**
+ * Validator check if entered strong length is equal to passed length parameter
+ */
+export function requiredLengthValidator(length: number): ValidatorFn {
+  return (control: UntypedFormControl) => {
+    if (control.value && control.value.length !== length) {
+      return { requiredLength: length }
+    }
+
+    return null;
+  };
+}

package/projects/tt-core/src/lib/validators/string/name.validator.ts

@@ -0,0 +1,9 @@
+import { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';
+
+const NAME_PATTERN = /^[A-Za-z0-9' -]+$/;
+
+export function nameValidator(): ValidatorFn {
+  return (control: AbstractControl): ValidationErrors | null => {
+    return NAME_PATTERN.test(control.value) ? null : { name: true };
+  };
+}

package/projects/tt-core/src/lib/validators/unique-email.validator.ts

@@ -0,0 +1,19 @@
+import {
+  AbstractControl, AsyncValidator,
+  ValidationErrors,
+} from '@angular/forms';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { UserService } from '../services';
+import { Injectable } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class UniqueEmailValidator implements AsyncValidator {
+  constructor(private userService: UserService) {}
+
+  validate(control: AbstractControl): Observable<ValidationErrors | null> {
+    return this.userService.search(control.value).pipe(
+      map(user => user ? { emailIsUsed: true } : null)
+    );
+  }
+}

package/projects/tt-core/tsconfig.lib.json

@@ -0,0 +1,15 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/projects/tt-core/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,46 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    /**
+    * @TODO Vik this config not check all types, but need refactoring and set this property true more about this flag https://www.typescriptlang.org/tsconfig#useDefineForClassFields
+    * models/employee/employee-invite.ts  Property 'employee' will overwrite the base property in 'EmployeeInvite'. If this is intentional, add an initializer. Otherwise, add a 'declare' modifier or remove the redundant declaration.
+    */
+    "useDefineForClassFields": false,
+    "baseUrl": "./",
+    "outDir": "./dist/out-tsc",
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "strict": false,
+    "noImplicitOverride": false,
+    "noPropertyAccessFromIndexSignature": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "sourceMap": true,
+    "declaration": false,
+    "experimentalDecorators": true,
+    "moduleResolution": "bundler",
+    "importHelpers": true,
+    "target": "ES2022",
+    "module": "es2020",
+    "lib": [
+      "es2019",
+      "dom"
+    ],
+    "paths": {
+      "tt-core": [
+        "dist/tt-core"
+      ],
+      "tt-core/*": [
+        "dist/tt-core/*"
+      ]
+    },
+    "resolveJsonModule": true
+  },
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "strictTemplates": true
+  }
+}