@63pokupki/nodejs-common
Version:
common nodejs functionality
595 lines • 24.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
// Библиотеки
const _ = require("lodash");
const utf8 = require('utf8');
/**
* Системный сервис валидации данных для моделей
*/
class ModelValidatorSys {
constructor(req) {
this.errorSys = req.sys.errorSys;
}
/**
* Валидирует и экранирует строковое значени
*
* @param string sKey - ключ в базе данных
* @param string sTpl - регулярное выражение по которому проверять
* @return boolean
*/
fValidString(sKey, sTpl) {
let bSuccess = false;
let s = String(this.data[sKey]).trim();
if (s || s === '') {
s = utf8.encode(s);
if (sTpl instanceof RegExp) { // Проверка на регулярное выражение
if (sTpl.exec(s)) {
this.aResult[sKey] = s;
bSuccess = true;
}
}
else {
this.aResult[sKey] = s;
bSuccess = true;
}
}
return bSuccess;
}
/**
* Экранирует текст
*
* @param string sKey
* @return boolean
*/
fValidText(sKey) {
let bSuccess = false;
let s = String(this.data[sKey]).trim();
if (s || s === '') {
this.aResult[sKey] = s;
bSuccess = true;
}
return bSuccess;
}
/**
* Валидирует булевую переменную
*
* @param string sKey
* @param string sTpl
* @return boolean
*/
fValidBool(sKey) {
let bSuccess = false;
let i = Number(this.data[sKey]);
if (!isNaN(i)) {
if (i == 0 || i == 1) {
this.aResult[sKey] = i;
bSuccess = true;
}
else {
bSuccess = false;
}
}
return bSuccess;
}
/**
* Проверяет числовые значения
*
* @param string sKey
* @param string sTpl
* @return boolean
*/
fValidInt(sKey) {
let bSuccess = false;
let i = Math.round(Number(this.data[sKey]));
if (!isNaN(i)) {
this.aResult[sKey] = i;
bSuccess = true;
}
return bSuccess;
}
/**
* Проверяет числовые значения - 2.22
*
* @param string sKey
* @return boolean
*/
fValidDecimal(sKey) {
let bSuccess = false;
let i = parseFloat(Number(this.data[sKey]).toFixed(2));
if (!isNaN(i)) {
this.aResult[sKey] = i;
bSuccess = true;
}
return bSuccess;
}
/**
* Проверяет массив чисел
*
* @param string sKey
* @return boolean
*/
fValidArrayNumbers(sKey) {
let bSuccess = false;
let checkArray = true;
let array = this.data[sKey];
if (_.isArray(array)) {
for (let i = 0; i < array.length; i++) {
if (checkArray) {
array[i] = Number(array[i]);
if (!array[i]) {
checkArray = false;
}
}
}
}
else {
checkArray = false;
}
if (checkArray) {
this.aResult[sKey] = array;
bSuccess = true;
}
return bSuccess;
}
/**
* Проверка Enum параметров
*
* @param sKey - ключ значения
* @param aEnumList - Список возможных значений
*/
fValidEnum(sKey, aEnumList) {
let bSuccess = false;
let v = this.data[sKey];
if (_.indexOf(aEnumList, v) >= 0) {
let index = _.indexOf(aEnumList, this.data[sKey]);
this.aResult[sKey] = aEnumList[index];
bSuccess = true;
}
return bSuccess;
}
/**
* Экранирует JSON и проверяет
* Если это массив конвертирует в JSON
*
* @param string sKey
* @return boolean
*/
fValidJson(sKey) {
let vJsonValue = this.data[sKey];
let sJsonValue = '';
let bSuccess = false;
if (vJsonValue) {
// Проверка на массив
if (_.isObject(vJsonValue)) {
sJsonValue = JSON.stringify(vJsonValue);
}
else {
sJsonValue = vJsonValue;
}
// Проверка строки на корректный JSON
try {
let obj = null;
obj = JSON.parse(sJsonValue);
if (obj) {
this.aResult[sKey] = sJsonValue;
bSuccess = true;
}
}
catch (e) {
this.errorSys.errorEx(e, sKey + '_json_parse', sKey + ' - неверный формат json поля');
}
}
return bSuccess;
}
/**
* Проверяет объект ли это
*
* @param string sKey
* @return boolean
*/
fValidObject(sKey) {
let bSuccess = false;
if (_.isObject(this.data[sKey])) {
this.aResult[sKey] = this.data[sKey];
bSuccess = true;
}
return bSuccess;
}
/**
* Проверяет массив ли это
*
* @param string sKey
* @return boolean
*/
fValidArray(sKey) {
let bSuccess = false;
if (_.isArray(this.data[sKey])) {
this.aResult[sKey] = this.data[sKey];
bSuccess = true;
}
return bSuccess;
}
// ================================================================
// Логические проверки
// ================================================================
/**
* Проверяет на больше
*
* @param string sKey
* @param string sTpl
* @return boolean
*/
fValidMore(sKey, iVal) {
let bSuccess = false;
let i = Number(this.aResult[sKey]);
if (!_.isNaN(i)) {
if (i > iVal) { // Если значение больше - все хорошо
this.aResult[sKey] = i;
bSuccess = true;
}
}
return bSuccess;
}
/**
* Проверяет на больше или равно
*
* @param string sKey
* @param string sTpl
* @return boolean
*/
fValidMoreOrEqual(sKey, iVal) {
let bSuccess = false;
let i = Number(this.aResult[sKey]);
if (!isNaN(i)) {
if (i >= iVal) { // Если значение больше - все хорошо
this.aResult[sKey] = i;
bSuccess = true;
}
}
return bSuccess;
}
/**
* Проверяет на меньше
*
* @param string sKey
* @param string sTpl
* @return boolean
*/
fValidLess(sKey, iVal) {
let bSuccess = false;
let i = Number(this.aResult[sKey]);
if (!_.isNaN(i)) {
if (i < iVal) { // Если значение меньше - все хорошо
this.aResult[sKey] = i;
bSuccess = true;
}
}
return bSuccess;
}
/**
* Проверяет на меньше или равно
*
* @param string sKey
* @param string sTpl
* @return boolean
*/
fValidLessOrEqual(sKey, iVal) {
let bSuccess = false;
let i = Number(this.aResult[sKey]);
if (!isNaN(i)) {
if (i <= iVal) { // Если значение меньше - все хорошо
this.aResult[sKey] = i;
bSuccess = true;
}
}
return bSuccess;
}
/**
* Проверяет на макс количесво символов
*
* @param string sKey
* @param string sTpl
* @return boolean
*/
fValidMaxLen(sKey, iLen) {
let bSuccess = false;
if (this.aResult[sKey] || this.aResult[sKey] == '') {
let s = String(this.aResult[sKey]);
if (s.length <= iLen) { // Если значение меньше - все хорошо
this.aResult[sKey] = s;
bSuccess = true;
}
}
if (bSuccess) {
return true;
}
else {
return false;
}
}
/**
* Проверяет минимальное количество символов
*
* @param string stringKey
* @param number checkValue
* @return boolean
*/
fValidMinLen(stringKey, checkValue) {
if (this.aResult[stringKey]) {
const preparedInputString = String(this.aResult[stringKey]);
if (preparedInputString.length >= checkValue) {
this.aResult[stringKey] = preparedInputString;
return true;
}
}
return false;
}
/**
* Проверить существование значения
* @param val - Значение
*/
checkExist(val) {
let resp = true;
if (val == undefined) {
resp = false;
}
if (val == null) {
resp = false;
}
return resp;
}
// ================================================================
/**
* Получить проверенные отфильтрованные данные в качестве массива
*
* @return array|null
*/
getResult() {
return this.aResult;
}
getStatus() {
return this.okResult;
}
getMsg() {
return this.aMsg;
}
//ФОРМАТ ПРАВИЛА [
// key_field :[0:type, 1:condition, 2:required, 3:depend, 4:msg_error]
//]
fValid(aRules, data) {
this.data = data;
this.okResult = true; // [true/false] - Успешно или нет прошла валидация
this.abValidOK = {};
this.aResult = {};
this.aMsg = [];
_.forEach(aRules, (v, k) => {
this.abValidOK[k] = true;
//Подстановка значений по умолчанию, если значения нет
if (this.okResult && v['def'] && !this.data[k]) {
this.data[k] = v['def'];
}
if ('error_key' in v) { // Если указываем ключ ошибки декларируем ее
let errorKey = {};
errorKey[v['error_key']['key']] = v['error_key']['msg'];
this.errorSys.declareEx(errorKey);
}
//Проверка существования данных
let bExist = this.checkExist(this.data[k]);
//Проверка зависимостей
let bDpend = true;
if (v['depend']) {
this.errorSys.decl('valid_' + k + '_depend', k + ' - поле не прошло проверку зависимостей');
_.forEach(v['depend'], (vDepend, kDepend) => {
if (this.okResult && this.abValidOK[kDepend]) {
if (this.abValidOK[kDepend] && this.data[kDepend]) {
if (!(this.data[kDepend] == vDepend || vDepend == '*')) {
bDpend = false;
this.errorSys.error('valid_' + k + '_depend', k + ' - поле не прошло проверку зависимостей');
}
}
} //if
}); //foreach
} //if
//Проверка - обязательного поля
if (v['require']) {
this.errorSys.decl('valid_' + k + '_require', k + ' - поле обязательно для заполнения');
if (!this.checkExist(this.data[k])) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_require', k + ' - поле обязательно для заполнения');
}
}
// Обработка [string] значений
if (bExist && bDpend && v['type'] == 'str') {
this.errorSys.decl('valid_' + k + '_str', v['error'] + ' Ошибка string = ' + this.data[k]);
if (!this.fValidString(k, v['if'])) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_str', v['error'] + ' Ошибка string = ' + this.data[k]);
}
}
// Обработка [boolean] значений
if (bExist && bDpend && v['type'] == 'boolean') {
this.errorSys.decl('valid_' + k + '_bool', v['error'] + ' Ошибка boolean = ' + this.data[k]);
if (!this.fValidBool(k)) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_bool', v['error'] + ' Ошибка boolean = ' + this.data[k]);
}
}
// Обработка [integer] значений
if (bExist && bDpend && v['type'] == 'int') {
this.errorSys.decl('valid_' + k + '_int', v['error'] + ' Ошибка int = ' + this.data[k]);
if (!this.fValidInt(k)) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_int', v['error'] + ' Ошибка int = ' + this.data[k]);
}
}
// Обработка [enum] значений
if (bExist && bDpend && v['type'] == 'enum') {
this.errorSys.decl('valid_' + k + '_enum', v['error'] + ' Ошибка enum = ' + this.data[k]);
if (!this.fValidEnum(k, v['if'])) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_enum', v['error'] + ' Ошибка enum = ' + this.data[k]);
}
}
// Обработка [text] значений
if (bExist && bDpend && v['type'] == 'text') {
this.errorSys.decl('valid_' + k + '_text', v['error'] + ' Ошибка text = ' + this.data[k]);
if (!this.fValidText(k)) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_text', v['error'] + ' Ошибка text = ' + this.data[k]);
}
}
// Обработка [json] значений
if (bExist && bDpend && v['type'] == 'json') {
this.errorSys.decl('valid_' + k + '_json', v['error'] + ' Ошибка json = ' + this.data[k]);
if (!this.fValidJson(k)) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_json', v['error'] + ' Ошибка json = ' + this.data[k]);
}
}
// Обработка [decimal] значений
if (bExist && bDpend && v['type'] == 'decimal') {
this.errorSys.decl('valid_' + k + '_decimal', v['error'] + ' Ошибка decimal = ' + this.data[k]);
if (!this.fValidDecimal(k)) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_decimal', v['error'] + ' Ошибка decimal = ' + this.data[k]);
}
}
// Обработка [arrayNumbers] значений
if (bExist && bDpend && v['type'] === 'arrayNumbers') {
this.errorSys.decl('valid_' + k + '_arrayNumbers', v['error'] + ' Ошибка arrayNumbers = ' + this.data[k]);
if (!this.fValidArrayNumbers(k)) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_arrayNumbers', v['error'] + ' Ошибка arrayNumbers = ' + this.data[k]);
}
}
// Обработка [object] значений
if (bExist && bDpend && v['type'] == 'object') {
this.errorSys.decl('valid_' + k + '_object', v['error'] + ' Ошибка object = ' + this.data[k]);
if (!this.fValidObject(k)) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_object', v['error'] + ' Ошибка object = ' + this.data[k]);
}
}
// Обработка [array] значений
if (bExist && bDpend && v['type'] == 'array') {
this.errorSys.decl('valid_' + k + '_array', v['error'] + ' Ошибка array = ' + this.data[k]);
if (!this.fValidArray(k)) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_array', v['error'] + ' Ошибка array = ' + this.data[k]);
}
}
// =================================================
// Логические проверки
// =================================================
// Обработка [more] значений - Проверка на больше
if (bExist && 'more' in v) {
this.errorSys.decl('valid_' + k + '_more', v['error'] + ' Число слишком маленькое = ' + this.data[k]);
if (v['type'] == 'int' || v['type'] == 'decimal') {
if (!this.fValidMore(k, v['more'])) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_more', v['error'] + ' Число слишком маленькое = ' + this.data[k]);
}
}
else {
this.errorSys.error('valid_' + k + '_more_no_number', v['error'] + ' Поле не является числом');
}
}
// Обработка [more_or_equal] значений - Проверка на больше или равно
if (bExist && 'more_or_equal' in v) {
this.errorSys.decl('valid_' + k + '_more_or_equal', 'errorValidate');
if (v['type'] == 'int' || v['type'] == 'decimal') {
if (!this.fValidMoreOrEqual(k, v['more_or_equal'])) {
this.abValidOK[k] = false;
this.okResult = false;
this.errorSys.error('valid_' + k + '_more_or_equal', v['error'] + ' Число слишком маленькое = ' + this.data[k]);
}
}
else {
this.errorSys.error('valid_' + k + '_more_or_equal_no_number', v['error'] + ' Поле не является числом');
}
}
// Обработка [less] значений - Проверка на меньше
if (bExist && 'less' in v) {
this.errorSys.decl('valid_' + k + '_less');
if (v['type'] == 'int' || v['type'] == 'decimal') {
if (!this.fValidLess(k, v['less'])) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_less', v['error'] + ' Число слишком большое = ' + this.data[k]);
}
}
else {
this.errorSys.error('valid_' + k + '_less_no_number', v['error'] + ' Поле не является числом');
}
}
// Обработка [less_or_equal] значений - Проверка на меньше или равно
if (bExist && 'less_or_equal' in v) {
this.errorSys.decl('valid_' + k + '_less_or_equal', 'errorValidate');
if (v['type'] == 'int' || v['type'] == 'decimal') {
if (!this.fValidLessOrEqual(k, v['less_or_equal'])) {
this.abValidOK[k] = false;
this.okResult = false;
this.errorSys.error('valid_' + k + '_less_or_equal', v['error'] + ' Число слишком большое = ' + this.data[k]);
}
}
else {
this.errorSys.error('valid_' + k + '_less_or_equal_no_number', v['error'] + ' Поле не является числом');
}
}
// Обработка [max_len] значений - Проверка на большее
if (bExist && 'max_len' in v) {
this.errorSys.decl('valid_' + k + '_max_len');
this.errorSys.decl('valid_' + k + '_max_len_no_string');
// Проверка является ли поле текстовым
if (v['type'] == 'text' || v['type'] == 'str') {
if (!this.fValidMaxLen(k, v['max_len'])) {
this.okResult = false;
this.abValidOK[k] = false;
this.errorSys.error('valid_' + k + '_max_len', v['error'] + ' Превышено количество символов = ' + this.data[k]);
}
}
else {
this.errorSys.error('valid_' + k + '_max_len_no_string', 'Поле не является строкой');
}
}
// Обработка [min_len] значений - Проверка на меньшее
if (bExist && 'min_len' in v) {
this.errorSys.decl(`valid_${k}_min_len`);
this.errorSys.decl(`valid_${k}_min_len_no_string`);
// Проверка является ли поле текстовым
if (v.type === 'text' || v.type === 'str') {
if (this.fValidMinLen(k, v.min_len)) {
this.abValidOK[k] = true;
}
else {
this.okResult = false;
this.errorSys.error(`valid_'${k}_min_len`, `${v.error} Количество символов меньше минимального значения = ${this.data[k]}`);
}
}
else {
this.errorSys.error(`valid_${k}_min_len_no_string`, 'Поле не является строкой');
}
}
// ============================================
// Кастомная ошибка на поле [error_key]
if (!this.abValidOK[k] && 'error_key' in v) { // Вызываем кастомную ошибку, если она произошла и была указана
this.errorSys.error(v['error_key']['key'], v['error_key']['msg']);
}
}); // foreach
return this.okResult;
}
}
exports.ModelValidatorSys = ModelValidatorSys;
//# sourceMappingURL=ModelValidatorSys.js.map