@blnlpa/asf-tools/tools.validator.ts

import {response, IResponse} from './tools';

export interface IAddress {
    address1?: string;
    address2?: string;
    city?: string;
    state?: string;
    country?: string;
    zip?: string;
}

interface IValidatorItem {
    key: string;
    format: string;
    value: any;
}

export class Validator {
    private validator:any;

    constructor() {
        this.validator = require('validator');
    }

    private createResponse(value: any, type: string): IResponse {
        if(value === true) {
            return response(true, null, true);
        } else {
            return response(false, `is not a valid "${type}"`, value);
        }
    }

    validateArray(items: Array<IValidatorItem>): IResponse {
        try {
            let success = true;
            const answer = {};

            for (let i = 0; i < items.length; i++) {
                const item:IValidatorItem = items[i];

                // if there is "pipe |" as parameter
                if(item.format.indexOf('|') > 0) {
                    const ex = item.format.split('|');

                    // if it's an array so 'value' has to be an array as well
                    if(ex[0].toLowerCase() === 'array') {
                        if (Array.isArray(item.value)) {
                            for (let k=0; k<item.value.length; k++) {
                                const formats = JSON.parse(ex[1]);
                                if ((typeof formats) === 'object') {
                                    const keys = Object.keys(formats);
                                    for (let j=0; j<keys.length; j++) {
                                        const fName = 'is' + formats[keys[j]].charAt(0).toUpperCase() + formats[keys[j]].substr(1, formats[keys[j]].length);
                                        const res = this[fName](item.value[k][keys[j]]);

                                        if (!res.success) {
                                            success = false;
                                            const _key = `${item.key}[${j}].${keys[j]}`;
                                            answer[_key] = response(false, `${_key} does not match expected format "${_key}: ${formats[keys[j]]}"`);
                                        }
                                    }
                                } else {
                                    success = false;
                                    answer[item.key] = response(false, `${item.key} does not match expected format "Array[${formats}]"`);
                                }
                            }
                        } else {
                            success = false;
                            answer[item.key] = response(false, `${item.key} does not match expected format "${item.format}"`);
                        }

                    } else {
                        const formats = JSON.parse(ex[1]);
                        if ((typeof formats) === 'object') {
                            const keys = Object.keys(formats);
                            for (let j=0; j<keys.length; j++) {
                                const fName = 'is' + formats[keys[j]].charAt(0).toUpperCase() + formats[keys[j]].substr(1, formats[keys[j]].length);
                                const res = this[fName](item.value[keys[j]]);

                                if (!res.success) {
                                    success = false;
                                    const _key = `${item.key}.${keys[j]}`;
                                    answer[_key] = response(false, `${_key} does not match expected format "${_key}:${formats[keys[j]]}"`);
                                }
                            }
                        } else {
                            success = false;
                            answer[item.key] = response(false, `${item.key} does not match expected format "${formats}"`);
                        }
                    }
                } else {
                    const fName = 'is' + item.format.charAt(0).toUpperCase() + item.format.substr(1, item.format.length);
                    if (!this[fName]) {
                        return response(false, `${fName} is not a known validator.`);
                    }

                    const res = this[fName](item.value);

                    if (!res.success) {
                        success = false;
                        answer[item.key] = response(false, `${item.key} does not match expected format "${item.format}"`);
                    }
                }

            }
            if (success) {
                return response(true, null, true);
            }
            return response(false, 'one or more fields do not match expected formats', answer);
        } catch (error) {
            console.log('107 tools.validation.validateArray()', error);
            return response(false, error);
        }
    }

    // TODO implement for a third party API to check address
    private _verifyAddress(address: IAddress): IResponse {
        const validator = this;

        try {
            const err = [];

            if (!address.address1) {
                err.push('address1');
            }
            if (!address.zip || !validator.isNumber(address.zip.toString()).success) {
                err.push('zip code');
            }
            if (!address.city) {
                err.push('city');
            }
            if (!address.state) {
                err.push('state');
            }

            if(err.length < 1) {
                return response(true, null, true);
            }

            return response(false, `is not a valid 'address', field is not a correct format`, err);
        } catch(error) {
            console.log(error);
            return response(false, error);
        }
    }

    isArray(value: any): IResponse {
        return this.createResponse(Array.isArray(value), 'array');
    }

    isAddress(address: IAddress): IResponse {
        return this._verifyAddress(address);
    }

    isEmail(value: any): IResponse {
        return this.createResponse(this.validator.isEmail(value.toString()), 'email');
    }

    isString(value: any): IResponse {
        return this.createResponse(!!(typeof value ==='string'), 'string');
    }

    // 123-456-7890
    isSSN(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString(), /^[0-9]{3}\-?[0-9]{2}\-?[0-9]{4}$/), 'SSN');
    }

    isLast4Digits(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString(), /^\d{4}$/), 'last4Digits');
    }

    isIDnumber(value: any, state: string): IResponse {
        const regExSt = {
            'NY': /^\d{9}$/,
            'NJ': /^[A-Z]{1}\d{14}$/,
            'FL': /^[A-Z]{1}\d{13}$/
        };

        if (Object.keys(regExSt).indexOf(state.toUpperCase()) < 0) {
            return response(false, `"${state}"" verify rule not found`);
        }

        return this.createResponse(this.validator.matches(value.toString(), regExSt[state.toUpperCase()]), 'IDnumber');
    }

    // 49985
    isNumber(value: any): IResponse {
        return this.createResponse(this.validator.isNumeric(value.toString()), 'number');
    }

    // 3.14155986
    isFloat(value: any): IResponse {
        return this.createResponse(this.validator.isFloat(value.toString()), 'float');
    }

    // 20,55
    isCurrency(value: any): IResponse {
        return this.createResponse(this.validator.isCurrency(value.toString()), 'currency');
    }

    // 12/31/1980 or 12-31-1980
    isBirthDate(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString(), /^(0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])[\/\-]\d{4}$/gm), 'birthDate');
    }

    isISODate(value: any): IResponse {
        return this.createResponse(this.validator.isISO8601(value.toString()), 'ISO date');
    }

    // 2018-12-31
    isDate(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString(), /^\d{4}[\-](0?[1-9]|1[012])[\-](0?[1-9]|[12][0-9]|3[01])$/), 'date');
    }

    // 2018-12-31T13:15:00.233Z
    isDateTime(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString(), /^\d{4}[\-](0?[1-9]|1[012])[\-](0?[1-9]|[12][0-9]|3[01])T(\d{1,2}):(\d{2})(?::(\d{2}))?\.(\d{3})Z$/), 'dateTime');
    }

    //13:15
    isTime(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString(), /^(\d{1,2}):(\d{2})$/), 'Time');
    }

    // 1:04PM
    is12HourTime(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString().toUpperCase(), /^(\d{1,2}):(\d{2})?(AM|PM)$/), 'Time');
    }

    // 13:15:00.233Z
    isISOTime(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString(), /^(\d{1,2}):(\d{2})(?::(\d{2}))?\.(\d{3})Z$/), 'ISO time');
    }

    isUUID(value: any): IResponse {
        return this.createResponse(this.validator.isUUID(value.toString()), 'UUID');
    }

    isPhoneNumber(value: any): IResponse {
        return this.createResponse(this.validator.matches(value.toString(), /^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/i), 'PhoneNumber');
    }

}