1037 lines
27 KiB
TypeScript
1037 lines
27 KiB
TypeScript
import {
|
|
ISO_DATE_FORMAT,
|
|
VALIDATION_TYPES,
|
|
ValidationResponse,
|
|
Validator,
|
|
} from "../constants/WidgetValidation";
|
|
import { DataTree } from "../entities/DataTree/dataTreeFactory";
|
|
import _, {
|
|
every,
|
|
indexOf,
|
|
isBoolean,
|
|
isNil,
|
|
isNumber,
|
|
isObject,
|
|
isPlainObject,
|
|
isString,
|
|
isUndefined,
|
|
toNumber,
|
|
toString,
|
|
} from "lodash";
|
|
import { WidgetProps } from "../widgets/BaseWidget";
|
|
import {
|
|
CUSTOM_CHART_TYPES,
|
|
CUSTOM_CHART_DEFAULT_PARSED,
|
|
} from "../constants/CustomChartConstants";
|
|
import moment from "moment";
|
|
|
|
export function validateDateString(
|
|
dateString: string,
|
|
dateFormat: string,
|
|
version: number,
|
|
) {
|
|
let isValid = true;
|
|
if (version === 2) {
|
|
try {
|
|
const d = moment(dateString);
|
|
isValid =
|
|
d.toISOString(true) === dateString || d.toISOString() === dateString;
|
|
if (!isValid) {
|
|
const parsedDate = moment(dateString);
|
|
isValid = parsedDate.isValid();
|
|
}
|
|
} catch (e) {
|
|
isValid = false;
|
|
}
|
|
} else {
|
|
const parsedDate = moment(dateString, dateFormat);
|
|
isValid = parsedDate.isValid();
|
|
}
|
|
return isValid;
|
|
}
|
|
|
|
const WIDGET_TYPE_VALIDATION_ERROR = "This value does not evaluate to type"; // TODO: Lot's of changes in validations.ts file
|
|
|
|
export const VALIDATORS: Record<VALIDATION_TYPES, Validator> = {
|
|
[VALIDATION_TYPES.TEXT]: (value: any): ValidationResponse => {
|
|
let parsed = value;
|
|
if (isUndefined(value) || value === null) {
|
|
return {
|
|
isValid: true,
|
|
parsed: value,
|
|
message: "",
|
|
};
|
|
}
|
|
if (isObject(value)) {
|
|
return {
|
|
isValid: false,
|
|
parsed: JSON.stringify(value, null, 2),
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "text"`,
|
|
};
|
|
}
|
|
let isValid = isString(value);
|
|
if (!isValid) {
|
|
try {
|
|
parsed = toString(value);
|
|
isValid = true;
|
|
} catch (e) {
|
|
console.error(`Error when parsing ${value} to string`);
|
|
console.error(e);
|
|
return {
|
|
isValid: false,
|
|
parsed: "",
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "text"`,
|
|
};
|
|
}
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
[VALIDATION_TYPES.REGEX]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
const { isValid, message, parsed } = VALIDATORS[VALIDATION_TYPES.TEXT](
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
|
|
if (isValid) {
|
|
try {
|
|
new RegExp(parsed);
|
|
} catch (e) {
|
|
return {
|
|
isValid: false,
|
|
parsed: parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "regex"`,
|
|
};
|
|
}
|
|
}
|
|
|
|
return { isValid, parsed, message };
|
|
},
|
|
[VALIDATION_TYPES.NUMBER]: (value: any): ValidationResponse => {
|
|
let parsed = value;
|
|
if (isUndefined(value)) {
|
|
return {
|
|
isValid: false,
|
|
parsed: 0,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "number"`,
|
|
};
|
|
}
|
|
let isValid = isNumber(value);
|
|
if (!isValid) {
|
|
try {
|
|
parsed = toNumber(value);
|
|
if (isNaN(parsed)) {
|
|
return {
|
|
isValid: false,
|
|
parsed: 0,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "number"`,
|
|
};
|
|
}
|
|
isValid = true;
|
|
} catch (e) {
|
|
console.error(`Error when parsing ${value} to number`);
|
|
console.error(e);
|
|
return {
|
|
isValid: false,
|
|
parsed: 0,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "number"`,
|
|
};
|
|
}
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
[VALIDATION_TYPES.BOOLEAN]: (value: any): ValidationResponse => {
|
|
let parsed = value;
|
|
if (isUndefined(value)) {
|
|
return {
|
|
isValid: false,
|
|
parsed: false,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "boolean"`,
|
|
};
|
|
}
|
|
const isABoolean = isBoolean(value);
|
|
const isStringTrueFalse = value === "true" || value === "false";
|
|
const isValid = isABoolean || isStringTrueFalse;
|
|
if (isStringTrueFalse) parsed = value !== "false";
|
|
if (!isValid) {
|
|
return {
|
|
isValid: isValid,
|
|
parsed: !!parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "boolean"`,
|
|
};
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
[VALIDATION_TYPES.OBJECT]: (value: any): ValidationResponse => {
|
|
let parsed = value;
|
|
if (isUndefined(value)) {
|
|
return {
|
|
isValid: false,
|
|
parsed: {},
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR}: Object`,
|
|
};
|
|
}
|
|
let isValid = isObject(value);
|
|
if (!isValid) {
|
|
try {
|
|
parsed = JSON.parse(value);
|
|
isValid = true;
|
|
} catch (e) {
|
|
console.error(`Error when parsing ${value} to object`);
|
|
console.error(e);
|
|
return {
|
|
isValid: false,
|
|
parsed: {},
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR}: Object`,
|
|
};
|
|
}
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
[VALIDATION_TYPES.ARRAY]: (value: any): ValidationResponse => {
|
|
let parsed = value;
|
|
try {
|
|
if (isUndefined(value)) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
transformed: undefined,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array"`,
|
|
};
|
|
}
|
|
if (isString(value)) {
|
|
parsed = JSON.parse(parsed as string);
|
|
}
|
|
|
|
if (!Array.isArray(parsed)) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
transformed: parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array"`,
|
|
};
|
|
}
|
|
|
|
return { isValid: true, parsed, transformed: parsed };
|
|
} catch (e) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
transformed: parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array"`,
|
|
};
|
|
}
|
|
},
|
|
[VALIDATION_TYPES.TABS_DATA]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
const { isValid, parsed } = VALIDATORS[VALIDATION_TYPES.ARRAY](
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
if (!isValid) {
|
|
return {
|
|
isValid,
|
|
parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array<{ label: string, id: string(unique), widgetId: string(unique) }>"`,
|
|
};
|
|
} else if (
|
|
!every(
|
|
parsed,
|
|
(datum: {
|
|
id: string;
|
|
label: string;
|
|
widgetId: string;
|
|
isVisible?: boolean;
|
|
}) =>
|
|
isObject(datum) &&
|
|
!isUndefined(datum.id) &&
|
|
!isUndefined(datum.label) &&
|
|
!isUndefined(datum.widgetId),
|
|
)
|
|
) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array<{ label: string, id: string(unique), widgetId: string(unique) }>"`,
|
|
};
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
[VALIDATION_TYPES.LIST_DATA]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
const { isValid, parsed, transformed } = VALIDATORS.ARRAY(
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
|
|
if (!isValid) {
|
|
return {
|
|
isValid,
|
|
parsed: [],
|
|
transformed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR}: "Array<Object>"`,
|
|
};
|
|
}
|
|
|
|
const isValidListData = every(parsed, (datum) => {
|
|
return (
|
|
isObject(datum) &&
|
|
Object.keys(datum).filter((key) => isString(key) && key.length === 0)
|
|
.length === 0
|
|
);
|
|
});
|
|
|
|
if (!isValidListData) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
transformed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR}: "Array<Object>"`,
|
|
};
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
[VALIDATION_TYPES.TABLE_DATA]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
const { isValid, parsed, transformed } = VALIDATORS.ARRAY(
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
if (!isValid) {
|
|
return {
|
|
isValid,
|
|
parsed: [],
|
|
transformed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array<Object>"`,
|
|
};
|
|
}
|
|
const isValidTableData = every(parsed, (datum) => {
|
|
return (
|
|
isPlainObject(datum) &&
|
|
Object.keys(datum).filter((key) => isString(key) && key.length === 0)
|
|
.length === 0
|
|
);
|
|
});
|
|
if (!isValidTableData) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
transformed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array<Object>"`,
|
|
};
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
[VALIDATION_TYPES.CHART_SERIES_DATA]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
let parsed = [];
|
|
let transformed = [];
|
|
let isValid = false;
|
|
let validationMessage = "";
|
|
|
|
try {
|
|
const validatedResponse: ValidationResponse = VALIDATORS[
|
|
VALIDATION_TYPES.ARRAY
|
|
](value, props, dataTree);
|
|
|
|
if (validatedResponse.isValid) {
|
|
isValid = every(
|
|
validatedResponse.parsed,
|
|
(chartPoint: { x: string; y: any }) => {
|
|
return (
|
|
isObject(chartPoint) &&
|
|
isString(chartPoint.x) &&
|
|
!isUndefined(chartPoint.y)
|
|
);
|
|
},
|
|
);
|
|
}
|
|
|
|
if (!isValid) {
|
|
parsed = [];
|
|
transformed = validatedResponse.transformed;
|
|
validationMessage = `${WIDGET_TYPE_VALIDATION_ERROR}: "Array<x:string, y:number>"`;
|
|
} else {
|
|
parsed = validatedResponse.parsed;
|
|
transformed = validatedResponse.parsed;
|
|
}
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
|
|
if (!isValid) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
transformed: transformed,
|
|
message: validationMessage,
|
|
};
|
|
}
|
|
|
|
return { isValid, parsed, transformed };
|
|
},
|
|
[VALIDATION_TYPES.CUSTOM_FUSION_CHARTS_DATA]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
const { isValid, parsed } = VALIDATORS[VALIDATION_TYPES.OBJECT](
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
if (props.chartName && parsed.dataSource && parsed.dataSource.chart) {
|
|
parsed.dataSource.chart.caption = props.chartName;
|
|
}
|
|
|
|
if (!isValid) {
|
|
return {
|
|
isValid,
|
|
parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "{type: string, dataSource: { chart: object, data: Array<{label: string, value: number}>}}"`,
|
|
};
|
|
}
|
|
if (parsed.renderAt) {
|
|
delete parsed.renderAt;
|
|
}
|
|
if (!parsed.dataSource || !parsed.type) {
|
|
return {
|
|
isValid: false,
|
|
parsed: parsed,
|
|
transformed: parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "{type: string, dataSource: { chart: object, data: Array<{label: string, value: number}>}}"`,
|
|
};
|
|
}
|
|
// check custom chart exist or not
|
|
const typeExist = indexOf(CUSTOM_CHART_TYPES, parsed.type) !== -1;
|
|
if (!typeExist) {
|
|
return {
|
|
isValid: false,
|
|
parsed: { ...CUSTOM_CHART_DEFAULT_PARSED },
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "{type: string, dataSource: { chart: object, data: Array<{label: string, value: number}>}}"`,
|
|
};
|
|
}
|
|
return { isValid, parsed, transformed: parsed };
|
|
},
|
|
[VALIDATION_TYPES.MARKERS]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
const { isValid, parsed } = VALIDATORS[VALIDATION_TYPES.ARRAY](
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
if (!isValid) {
|
|
return {
|
|
isValid,
|
|
parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array<{ lat: number, long: number }>"`,
|
|
};
|
|
} else if (
|
|
!every(
|
|
parsed,
|
|
(datum) => VALIDATORS[VALIDATION_TYPES.LAT_LONG](datum, props).isValid,
|
|
)
|
|
) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array<{ lat: number, long: number }>"`,
|
|
};
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
[VALIDATION_TYPES.OPTIONS_DATA]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
const { isValid, parsed } = VALIDATORS[VALIDATION_TYPES.ARRAY](
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
if (!isValid) {
|
|
return {
|
|
isValid,
|
|
parsed,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array<{ label: string, value: string }>"`,
|
|
};
|
|
}
|
|
try {
|
|
const isValidOption = (option: { label: any; value: any }) =>
|
|
_.isObject(option) &&
|
|
_.isString(option.label) &&
|
|
!_.isEmpty(option.label);
|
|
|
|
const hasOptions = every(parsed, isValidOption);
|
|
const validOptions = parsed.filter(isValidOption);
|
|
const uniqValidOptions = _.uniqBy(validOptions, "value");
|
|
|
|
if (!hasOptions || uniqValidOptions.length !== validOptions.length) {
|
|
return {
|
|
isValid: false,
|
|
parsed: uniqValidOptions,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "Array<{ label: string, value: string }>"`,
|
|
};
|
|
}
|
|
return { isValid, parsed };
|
|
} catch (e) {
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
transformed: parsed,
|
|
};
|
|
}
|
|
},
|
|
[VALIDATION_TYPES.DATE_ISO_STRING]: (
|
|
dateString: string,
|
|
props: WidgetProps,
|
|
): ValidationResponse => {
|
|
const dateFormat =
|
|
props.version === 2
|
|
? ISO_DATE_FORMAT
|
|
: props.dateFormat || ISO_DATE_FORMAT;
|
|
if (dateString === null) {
|
|
return {
|
|
isValid: true,
|
|
parsed: "",
|
|
message: "",
|
|
};
|
|
}
|
|
if (dateString === undefined) {
|
|
return {
|
|
isValid: false,
|
|
parsed: "",
|
|
message:
|
|
`${WIDGET_TYPE_VALIDATION_ERROR}: Date String ` +
|
|
(props.dateFormat ? props.dateFormat : ""),
|
|
};
|
|
}
|
|
const isValid = validateDateString(dateString, dateFormat, props.version);
|
|
let parsedDate = dateString;
|
|
|
|
try {
|
|
if (isValid && props.version === 2) {
|
|
parsedDate = moment(dateString).toISOString(true);
|
|
}
|
|
} catch (e) {
|
|
console.error("Could not parse date", parsedDate, e);
|
|
}
|
|
|
|
if (!isValid) {
|
|
return {
|
|
isValid: isValid,
|
|
parsed: "",
|
|
message: `Value does not match ISO 8601 standard date string`,
|
|
};
|
|
}
|
|
return {
|
|
isValid,
|
|
parsed: parsedDate,
|
|
message: isValid
|
|
? ""
|
|
: `Value does not match ISO 8601 standard date string`,
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.DEFAULT_DATE]: (
|
|
dateString: string,
|
|
props: WidgetProps,
|
|
): ValidationResponse => {
|
|
const dateFormat =
|
|
props.version === 2
|
|
? ISO_DATE_FORMAT
|
|
: props.dateFormat || ISO_DATE_FORMAT;
|
|
if (dateString === null) {
|
|
return {
|
|
isValid: true,
|
|
parsed: "",
|
|
message: "",
|
|
};
|
|
}
|
|
if (dateString === undefined) {
|
|
return {
|
|
isValid: false,
|
|
parsed: "",
|
|
message:
|
|
`${WIDGET_TYPE_VALIDATION_ERROR}: Date String ` +
|
|
(dateFormat ? dateFormat : ""),
|
|
};
|
|
}
|
|
|
|
const isValid = validateDateString(dateString, dateFormat, props.version);
|
|
let parsedDate = dateString;
|
|
|
|
try {
|
|
if (isValid && props.version === 2) {
|
|
parsedDate = moment(dateString).toISOString(true);
|
|
}
|
|
} catch (e) {
|
|
console.error("Could not parse date", parsedDate, e);
|
|
}
|
|
if (!isValid) {
|
|
return {
|
|
isValid: isValid,
|
|
parsed: "",
|
|
message: `Value does not match ISO 8601 standard date string`,
|
|
};
|
|
}
|
|
return {
|
|
isValid: isValid,
|
|
parsed: parsedDate,
|
|
message: "",
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.MIN_DATE]: (
|
|
dateString: string,
|
|
props: WidgetProps,
|
|
): ValidationResponse => {
|
|
const dateFormat =
|
|
props.version === 2
|
|
? ISO_DATE_FORMAT
|
|
: props.dateFormat || ISO_DATE_FORMAT;
|
|
if (dateString === undefined) {
|
|
return {
|
|
isValid: false,
|
|
parsed: "",
|
|
message:
|
|
`${WIDGET_TYPE_VALIDATION_ERROR}: Date String ` +
|
|
(dateFormat ? dateFormat : ""),
|
|
};
|
|
}
|
|
const parsedMinDate = moment(dateString, dateFormat);
|
|
let isValid = validateDateString(dateString, dateFormat, props.version);
|
|
if (!props.defaultDate) {
|
|
return {
|
|
isValid: isValid,
|
|
parsed: dateString,
|
|
message: "",
|
|
};
|
|
}
|
|
const parsedDefaultDate = moment(props.defaultDate, dateFormat);
|
|
|
|
if (
|
|
isValid &&
|
|
parsedDefaultDate.isValid() &&
|
|
parsedDefaultDate.isBefore(parsedMinDate)
|
|
) {
|
|
isValid = false;
|
|
}
|
|
if (!isValid) {
|
|
return {
|
|
isValid: isValid,
|
|
parsed: "",
|
|
message:
|
|
`${WIDGET_TYPE_VALIDATION_ERROR}: Date String ` +
|
|
(dateFormat ? dateFormat : ""),
|
|
};
|
|
}
|
|
return {
|
|
isValid: isValid,
|
|
parsed: dateString,
|
|
message: "",
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.MAX_DATE]: (
|
|
dateString: string,
|
|
props: WidgetProps,
|
|
): ValidationResponse => {
|
|
const dateFormat =
|
|
props.version === 2
|
|
? ISO_DATE_FORMAT
|
|
: props.dateFormat || ISO_DATE_FORMAT;
|
|
if (dateString === undefined) {
|
|
return {
|
|
isValid: false,
|
|
parsed: "",
|
|
message:
|
|
`${WIDGET_TYPE_VALIDATION_ERROR}: Date String ` +
|
|
(dateFormat ? dateFormat : ""),
|
|
};
|
|
}
|
|
const parsedMaxDate = moment(dateString, dateFormat);
|
|
let isValid = validateDateString(dateString, dateFormat, props.version);
|
|
if (!props.defaultDate) {
|
|
return {
|
|
isValid: isValid,
|
|
parsed: dateString,
|
|
message: "",
|
|
};
|
|
}
|
|
const parsedDefaultDate = moment(props.defaultDate, dateFormat);
|
|
|
|
if (
|
|
isValid &&
|
|
parsedDefaultDate.isValid() &&
|
|
parsedDefaultDate.isAfter(parsedMaxDate)
|
|
) {
|
|
isValid = false;
|
|
}
|
|
if (!isValid) {
|
|
return {
|
|
isValid: isValid,
|
|
parsed: "",
|
|
message:
|
|
`${WIDGET_TYPE_VALIDATION_ERROR}: Date String ` +
|
|
(dateFormat ? dateFormat : ""),
|
|
};
|
|
}
|
|
return {
|
|
isValid: isValid,
|
|
parsed: dateString,
|
|
message: "",
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.ACTION_SELECTOR]: (value: any): ValidationResponse => {
|
|
if (Array.isArray(value) && value.length) {
|
|
return {
|
|
isValid: true,
|
|
parsed: undefined,
|
|
transformed: "Function Call",
|
|
};
|
|
}
|
|
return {
|
|
isValid: false,
|
|
parsed: undefined,
|
|
transformed: "undefined",
|
|
message: "Not a function call",
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.ARRAY_ACTION_SELECTOR]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
): ValidationResponse => {
|
|
const { isValid, message, parsed } = VALIDATORS[VALIDATION_TYPES.ARRAY](
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
let isValidFinal = isValid;
|
|
let finalParsed = parsed.slice();
|
|
if (isValid) {
|
|
finalParsed = parsed.map((value: any) => {
|
|
const { isValid, message } = VALIDATORS[
|
|
VALIDATION_TYPES.ACTION_SELECTOR
|
|
](value.dynamicTrigger, props, dataTree);
|
|
|
|
isValidFinal = isValidFinal && isValid;
|
|
return {
|
|
...value,
|
|
message: message,
|
|
isValid: isValid,
|
|
};
|
|
});
|
|
}
|
|
|
|
return {
|
|
isValid: isValidFinal,
|
|
parsed: finalParsed,
|
|
message: message,
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.SELECTED_TAB]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
): ValidationResponse => {
|
|
const tabs: any = props.tabsObj
|
|
? Object.values(props.tabsObj)
|
|
: props.tabs || [];
|
|
const tabNames = tabs.map((i: { label: string; id: string }) => i.label);
|
|
const isValidTabName = tabNames.includes(value);
|
|
return {
|
|
isValid: isValidTabName,
|
|
parsed: isValidTabName ? value : "",
|
|
message: isValidTabName ? "" : `Tab name provided does not exist.`,
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.DEFAULT_OPTION_VALUE]: (
|
|
value: string | string[],
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
) => {
|
|
let values = value;
|
|
|
|
if (props) {
|
|
if (props.selectionType === "SINGLE_SELECT") {
|
|
const defaultValue = value && _.isString(value) ? value.trim() : value;
|
|
return VALIDATORS[VALIDATION_TYPES.TEXT](defaultValue, props, dataTree);
|
|
} else if (props.selectionType === "MULTI_SELECT") {
|
|
if (typeof value === "string") {
|
|
try {
|
|
values = JSON.parse(value);
|
|
if (!Array.isArray(values)) {
|
|
throw new Error();
|
|
}
|
|
} catch {
|
|
values = value.length ? value.split(",") : [];
|
|
if (values.length > 0) {
|
|
values = values.map((value) => value.trim());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(values)) {
|
|
values = _.uniq(values);
|
|
}
|
|
|
|
return {
|
|
isValid: true,
|
|
parsed: values,
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.DEFAULT_SELECTED_ROW]: (
|
|
value: string | string[],
|
|
props: WidgetProps,
|
|
) => {
|
|
if (props) {
|
|
if (props.multiRowSelection) {
|
|
return VALIDATORS[VALIDATION_TYPES.ROW_INDICES](value, props);
|
|
} else {
|
|
try {
|
|
const _value: string = value as string;
|
|
if (
|
|
Number.isInteger(parseInt(_value, 10)) &&
|
|
parseInt(_value, 10) > -1
|
|
)
|
|
return { isValid: true, parsed: parseInt(_value, 10) };
|
|
|
|
return {
|
|
isValid: true,
|
|
parsed: -1,
|
|
};
|
|
} catch (e) {
|
|
return {
|
|
isValid: true,
|
|
parsed: -1,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
isValid: true,
|
|
parsed: value,
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.COLUMN_PROPERTIES_ARRAY]: (
|
|
value: any,
|
|
props: WidgetProps,
|
|
dataTree?: DataTree,
|
|
) => {
|
|
const { isValid, parsed } = VALIDATORS[VALIDATION_TYPES.ARRAY](
|
|
value,
|
|
props,
|
|
dataTree,
|
|
);
|
|
if (!isValid) {
|
|
return {
|
|
isValid,
|
|
parsed,
|
|
transformed: parsed,
|
|
message: "",
|
|
};
|
|
}
|
|
const isValidProperty = (data: any) =>
|
|
isString(data) || isNumber(data) || isBoolean(data);
|
|
const isValidColumns = every(parsed, (datum: any) => {
|
|
const validatedResponse: {
|
|
isValid: boolean;
|
|
parsed: Record<string, unknown>;
|
|
message?: string;
|
|
} = VALIDATORS[VALIDATION_TYPES.OBJECT](datum, props, dataTree);
|
|
const isValidColumn = validatedResponse.isValid;
|
|
if (isValidColumn) {
|
|
for (const key in validatedResponse.parsed) {
|
|
const columnProperty = validatedResponse.parsed[key];
|
|
let isValidColumnProperty = true;
|
|
if (Array.isArray(columnProperty)) {
|
|
isValidColumnProperty = every(columnProperty, (data: any) => {
|
|
return isValidProperty(data);
|
|
});
|
|
} else if (!isObject(columnProperty)) {
|
|
isValidColumnProperty = isValidProperty(columnProperty);
|
|
}
|
|
if (!isValidColumnProperty) {
|
|
validatedResponse.parsed[key] = "";
|
|
}
|
|
}
|
|
}
|
|
return isValidColumn;
|
|
});
|
|
if (!isValidColumns) {
|
|
return {
|
|
isValid: isValidColumns,
|
|
parsed: [],
|
|
transformed: parsed,
|
|
message: "",
|
|
};
|
|
}
|
|
return { isValid, parsed, transformed: parsed };
|
|
},
|
|
[VALIDATION_TYPES.LAT_LONG]: (unparsedValue: {
|
|
lat?: number;
|
|
long?: number;
|
|
[x: string]: any;
|
|
}): ValidationResponse => {
|
|
let value = unparsedValue;
|
|
const invalidResponse = {
|
|
isValid: false,
|
|
parsed: undefined,
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR} "{ lat: number, long: number }"`,
|
|
};
|
|
|
|
if (isString(unparsedValue)) {
|
|
try {
|
|
value = JSON.parse(unparsedValue);
|
|
} catch (e) {
|
|
console.error(`Error when parsing string as object`);
|
|
}
|
|
}
|
|
|
|
const { lat, long } = value || {};
|
|
const validLat = typeof lat === "number" && lat <= 90 && lat >= -90;
|
|
const validLong = typeof long === "number" && long <= 180 && long >= -180;
|
|
|
|
if (!validLat || !validLong) {
|
|
return invalidResponse;
|
|
}
|
|
|
|
return {
|
|
isValid: true,
|
|
parsed: value,
|
|
};
|
|
},
|
|
[VALIDATION_TYPES.IMAGE]: (value: any): ValidationResponse => {
|
|
let parsed = value;
|
|
const base64ImageRegex = /^data:image\/.*;base64/;
|
|
const imageUrlRegex = /(http(s?):)([/|.|\w|\s|-])*\.(?:jpeg|jpg|gif|png)??(?:&?[^=&]*=[^=&]*)*/;
|
|
if (isUndefined(value) || value === null) {
|
|
return {
|
|
isValid: true,
|
|
parsed: value,
|
|
message: "",
|
|
};
|
|
}
|
|
if (isObject(value)) {
|
|
return {
|
|
isValid: false,
|
|
parsed: JSON.stringify(value, null, 2),
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR}: text`,
|
|
};
|
|
}
|
|
if (imageUrlRegex.test(value)) {
|
|
return {
|
|
isValid: true,
|
|
parsed: value,
|
|
message: "",
|
|
};
|
|
}
|
|
let isValid = base64ImageRegex.test(value);
|
|
if (!isValid) {
|
|
try {
|
|
parsed =
|
|
btoa(atob(value)) === value
|
|
? "data:image/png;base64," + value
|
|
: value;
|
|
isValid = true;
|
|
} catch (err) {
|
|
console.error(`Error when parsing ${value} to string`);
|
|
console.error(err);
|
|
return {
|
|
isValid: false,
|
|
parsed: "",
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR}: text`,
|
|
};
|
|
}
|
|
}
|
|
return { isValid, parsed };
|
|
},
|
|
// If we keep adding these here there will be a huge unmaintainable list
|
|
// TODO(abhinav: WIDGET DEV API):
|
|
// - Compile validators from the widgets during widget registration
|
|
// - Use the compiled list in the web worker startup
|
|
// - Remove widget specific validations from this file
|
|
// - Design consideration: If widgets can be dynamically imported, how will this work?
|
|
[VALIDATION_TYPES.TABLE_PAGE_NO]: (value: any): ValidationResponse => {
|
|
if (!value || !Number.isInteger(value) || value < 0)
|
|
return { isValid: false, parsed: 1, message: "" };
|
|
return { isValid: true, parsed: value };
|
|
},
|
|
[VALIDATION_TYPES.ROW_INDICES]: (
|
|
value: any,
|
|
props: any,
|
|
): ValidationResponse => {
|
|
if (props && !props.multiRowSelection)
|
|
return { isValid: true, parsed: undefined };
|
|
|
|
if (isString(value)) {
|
|
const trimmed = value.trim();
|
|
try {
|
|
const parsedArray = JSON.parse(trimmed);
|
|
if (Array.isArray(parsedArray)) {
|
|
const sanitized = parsedArray.filter((entry) => {
|
|
return (
|
|
Number.isInteger(parseInt(entry, 10)) && parseInt(entry, 10) > -1
|
|
);
|
|
});
|
|
return { isValid: true, parsed: sanitized };
|
|
} else {
|
|
throw Error("Not a stringified array");
|
|
}
|
|
} catch (e) {
|
|
// If cannot be parsed as an array
|
|
const arrayEntries = trimmed.split(",");
|
|
const result: number[] = [];
|
|
arrayEntries.forEach((entry) => {
|
|
if (
|
|
Number.isInteger(parseInt(entry, 10)) &&
|
|
parseInt(entry, 10) > -1
|
|
) {
|
|
if (!isNil(entry)) result.push(parseInt(entry, 10));
|
|
}
|
|
});
|
|
return { isValid: true, parsed: result };
|
|
}
|
|
}
|
|
if (Array.isArray(value)) {
|
|
const sanitized = value.filter((entry) => {
|
|
return (
|
|
Number.isInteger(parseInt(entry, 10)) && parseInt(entry, 10) > -1
|
|
);
|
|
});
|
|
return { isValid: true, parsed: sanitized };
|
|
}
|
|
if (Number.isInteger(value) && value > -1) {
|
|
return { isValid: true, parsed: [value] };
|
|
}
|
|
return {
|
|
isValid: false,
|
|
parsed: [],
|
|
message: `${WIDGET_TYPE_VALIDATION_ERROR}: number[]`,
|
|
};
|
|
},
|
|
};
|