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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tools_1 = require("./tools");
class Validator {
    constructor() {
        this.validator = require('validator');
    }
    createResponse(value, type) {
        if (value === true) {
            return tools_1.response(true, null, true);
        }
        else {
            return tools_1.response(false, `is not a valid "${type}"`, value);
        }
    }
    validateArray(items) {
        try {
            let success = true;
            const answer = {};
            for (let i = 0; i < items.length; i++) {
                const item = items[i];
                if (item.format.indexOf('|') > 0) {
                    const ex = item.format.split('|');
                    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] = tools_1.response(false, `${_key} does not match expected format "${_key}: ${formats[keys[j]]}"`);
                                        }
                                    }
                                }
                                else {
                                    success = false;
                                    answer[item.key] = tools_1.response(false, `${item.key} does not match expected format "Array[${formats}]"`);
                                }
                            }
                        }
                        else {
                            success = false;
                            answer[item.key] = tools_1.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] = tools_1.response(false, `${_key} does not match expected format "${_key}:${formats[keys[j]]}"`);
                                }
                            }
                        }
                        else {
                            success = false;
                            answer[item.key] = tools_1.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 tools_1.response(false, `${fName} is not a known validator.`);
                    }
                    const res = this[fName](item.value);
                    if (!res.success) {
                        success = false;
                        answer[item.key] = tools_1.response(false, `${item.key} does not match expected format "${item.format}"`);
                    }
                }
            }
            if (success) {
                return tools_1.response(true, null, true);
            }
            return tools_1.response(false, 'one or more fields do not match expected formats', answer);
        }
        catch (error) {
            console.log('107 tools.validation.validateArray()', error);
            return tools_1.response(false, error);
        }
    }
    _verifyAddress(address) {
        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 tools_1.response(true, null, true);
            }
            return tools_1.response(false, `is not a valid 'address', field is not a correct format`, err);
        }
        catch (error) {
            console.log(error);
            return tools_1.response(false, error);
        }
    }
    isArray(value) {
        return this.createResponse(Array.isArray(value), 'array');
    }
    isAddress(address) {
        return this._verifyAddress(address);
    }
    isEmail(value) {
        return this.createResponse(this.validator.isEmail(value.toString()), 'email');
    }
    isString(value) {
        return this.createResponse(!!(typeof value === 'string'), 'string');
    }
    isSSN(value) {
        return this.createResponse(this.validator.matches(value.toString(), /^[0-9]{3}\-?[0-9]{2}\-?[0-9]{4}$/), 'SSN');
    }
    isLast4Digits(value) {
        return this.createResponse(this.validator.matches(value.toString(), /^\d{4}$/), 'last4Digits');
    }
    isIDnumber(value, state) {
        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 tools_1.response(false, `"${state}"" verify rule not found`);
        }
        return this.createResponse(this.validator.matches(value.toString(), regExSt[state.toUpperCase()]), 'IDnumber');
    }
    isNumber(value) {
        return this.createResponse(this.validator.isNumeric(value.toString()), 'number');
    }
    isFloat(value) {
        return this.createResponse(this.validator.isFloat(value.toString()), 'float');
    }
    isCurrency(value) {
        return this.createResponse(this.validator.isCurrency(value.toString()), 'currency');
    }
    isBirthDate(value) {
        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) {
        return this.createResponse(this.validator.isISO8601(value.toString()), 'ISO date');
    }
    isDate(value) {
        return this.createResponse(this.validator.matches(value.toString(), /^\d{4}[\-](0?[1-9]|1[012])[\-](0?[1-9]|[12][0-9]|3[01])$/), 'date');
    }
    isDateTime(value) {
        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');
    }
    isTime(value) {
        return this.createResponse(this.validator.matches(value.toString(), /^(\d{1,2}):(\d{2})$/), 'Time');
    }
    is12HourTime(value) {
        return this.createResponse(this.validator.matches(value.toString().toUpperCase(), /^(\d{1,2}):(\d{2})?(AM|PM)$/), 'Time');
    }
    isISOTime(value) {
        return this.createResponse(this.validator.matches(value.toString(), /^(\d{1,2}):(\d{2})(?::(\d{2}))?\.(\d{3})Z$/), 'ISO time');
    }
    isUUID(value) {
        return this.createResponse(this.validator.isUUID(value.toString()), 'UUID');
    }
    isPhoneNumber(value) {
        return this.createResponse(this.validator.matches(value.toString(), /^[\+]?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/i), 'PhoneNumber');
    }
}
exports.Validator = Validator;
//# sourceMappingURL=tools.validator.js.map