ngx-material-entity 16.0.1 → 16.0.3

package/esm2022/utilities/validation.utilities.mjs

@@ -0,0 +1,455 @@
+import { DecoratorTypes } from '../decorators/base/decorator-types.enum';
+import { LodashUtilities } from '../encapsulation/lodash.utilities';
+import { ReflectUtilities } from '../encapsulation/reflect.utilities';
+import { DateUtilities } from './date.utilities';
+import { EntityUtilities } from './entity.utilities';
+import { FileUtilities } from './file.utilities';
+/**
+ * Contains HelperMethods around handling Validation of entities and properties.
+ */
+export class ValidationUtilities {
+    /**
+     * Checks if the values on an entity are valid.
+     * Also checks all the validators given by the metadata ("required", "maxLength" etc.).
+     *
+     * @param entity - The entity to validate.
+     * @param omit - Whether to check for creating or editing validity.
+     * @returns Whether or not the entity is valid.
+     */
+    static isEntityValid(entity, omit) {
+        return this.getEntityValidationErrors(entity, omit).length === 0;
+    }
+    /**
+     * Gets all validation errors on the given entity.
+     *
+     * @param entity - The entity to validate.
+     * @param omit - What keys not to check. An empty value means no keys are omitted.
+     * @returns An array of validation errors on the provided entity.
+     */
+    static getEntityValidationErrors(entity, omit) {
+        const res = [];
+        for (const key in entity) {
+            const err = this.getPropertyValidationError(entity, key, omit);
+            if (err) {
+                res.push(err);
+            }
+        }
+        return res;
+    }
+    // /**
+    //  * Checks if a single property value is valid.
+    //  *
+    //  * @param entity - The entity where the property is from.
+    //  * @param key - The name of the property.
+    //  * @param omit - Whether to check if the given entity is valid for creation or updating.
+    //  * @returns Whether or not the property value is valid.
+    //  * @throws Throws when it extracts an unknown metadata type.
+    //  */
+    // static isPropertyValid<EntityType extends BaseEntityType<EntityType>>(
+    //     entity: EntityType,
+    //     key: keyof EntityType,
+    //     omit?: 'create' | 'update'
+    // ): boolean {
+    //     return this.getPropertyValidationError(entity, key, omit) == null;
+    // }
+    /**
+     * Validates the property on the given entity with the given key.
+     *
+     * @param entity - The entity on which the property to check is.
+     * @param key - The key of the property to validate.
+     * @param omit - What keys not to check. An empty value means no keys are omitted.
+     * @returns A validation error when the property is not valid, undefined otherwise.
+     * @throws When the type of the property is not known.
+     */
+    static getPropertyValidationError(entity, key, omit) {
+        const type = EntityUtilities.getPropertyType(entity, key);
+        const metadata = EntityUtilities.getPropertyMetadata(entity, key, type);
+        if (metadata.omitForCreate && omit === 'create') {
+            return undefined;
+        }
+        if (metadata.omitForUpdate && omit === 'update') {
+            return undefined;
+        }
+        if (metadata.required(entity) && type !== DecoratorTypes.HAS_MANY) {
+            if (entity[key] == null || entity[key] === '') {
+                return {
+                    property: metadata.displayName,
+                    message: 'required'
+                };
+            }
+        }
+        if (!metadata.required(entity)) {
+            if (entity[key] == null || entity[key] === '') {
+                return undefined;
+            }
+        }
+        switch (type) {
+            case DecoratorTypes.BOOLEAN_DROPDOWN:
+                break;
+            case DecoratorTypes.BOOLEAN_CHECKBOX:
+            case DecoratorTypes.BOOLEAN_TOGGLE:
+                const entityBoolean = entity[key];
+                const booleanMetadata = metadata;
+                return this.getBooleanValidationError(entity, entityBoolean, booleanMetadata);
+            case DecoratorTypes.STRING_DROPDOWN:
+                break;
+            case DecoratorTypes.STRING:
+            case DecoratorTypes.STRING_AUTOCOMPLETE:
+                const entityString = entity[key];
+                const stringMetadata = metadata;
+                return this.getStringValidationError(entityString, stringMetadata);
+            case DecoratorTypes.STRING_TEXTBOX:
+                const entityTextbox = entity[key];
+                const textboxMetadata = metadata;
+                return this.getTextboxValidationError(entityTextbox, textboxMetadata);
+            case DecoratorTypes.STRING_PASSWORD:
+                const entityPassword = entity[key];
+                const passwordMetadata = metadata;
+                const confirmPassword = ReflectUtilities.getMetadata(EntityUtilities.CONFIRM_PASSWORD_KEY, entity, key);
+                return this.getPasswordValidationError(entityPassword, passwordMetadata, confirmPassword);
+            case DecoratorTypes.NUMBER_DROPDOWN:
+                // Because only valid values can be selected, this is always true when it has a value
+                return undefined;
+            case DecoratorTypes.NUMBER:
+            case DecoratorTypes.NUMBER_SLIDER:
+                const entityNumber = entity[key];
+                const numberMetadata = metadata;
+                return this.getNumberValidationError(entityNumber, numberMetadata);
+            case DecoratorTypes.OBJECT:
+                const entityObject = entity[key];
+                for (const parameterKey in entityObject) {
+                    const value = entityObject[parameterKey];
+                    if (!metadata.omit.includes(parameterKey)
+                        && !(!metadata.required(entity) && (value == null || value == ''))) {
+                        const err = this.getPropertyValidationError(entityObject, parameterKey, omit);
+                        if (err) {
+                            return {
+                                property: metadata.displayName,
+                                message: `${err.property} is invalid: ${err.message}`
+                            };
+                        }
+                    }
+                }
+                break;
+            case DecoratorTypes.ARRAY_STRING_CHIPS:
+            case DecoratorTypes.ARRAY_STRING_AUTOCOMPLETE_CHIPS:
+            case DecoratorTypes.ARRAY_DATE:
+            case DecoratorTypes.ARRAY_DATE_TIME:
+            case DecoratorTypes.ARRAY_DATE_RANGE:
+            case DecoratorTypes.ARRAY:
+                const entityArray = entity[key];
+                // eslint-disable-next-line max-len
+                const arrayMetadata = metadata;
+                if (arrayMetadata.required(entity) && !entityArray.length) {
+                    return {
+                        property: metadata.displayName,
+                        message: 'no items in array'
+                    };
+                }
+                break;
+            case DecoratorTypes.DATE:
+                const entityDate = new Date(entity[key]);
+                const dateMetadata = metadata;
+                return this.getDateValidationError(entityDate, dateMetadata);
+            case DecoratorTypes.DATE_RANGE:
+                const entityDateRange = LodashUtilities.cloneDeep(entity[key]);
+                const dateRangeMetadata = metadata;
+                return this.getDateRangeValidationError(entity, entityDateRange, dateRangeMetadata);
+            case DecoratorTypes.DATE_TIME:
+                const entityDateTime = new Date(entity[key]);
+                const dateTimeMetadata = metadata;
+                const hasTime = ReflectUtilities.hasMetadata(EntityUtilities.TIME_KEY, entity, key);
+                return this.getDateTimeValidationError(entityDateTime, dateTimeMetadata, hasTime);
+            case DecoratorTypes.FILE_DEFAULT:
+            case DecoratorTypes.FILE_IMAGE:
+                const entityFile = entity[key];
+                const entityFileMetadata = metadata;
+                return this.getFileDataValidationError(entityFile, entityFileMetadata);
+            case DecoratorTypes.REFERENCES_MANY:
+            case DecoratorTypes.REFERENCES_ONE:
+            case DecoratorTypes.HAS_MANY:
+                break;
+            case DecoratorTypes.CUSTOM:
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, max-len
+                const customMetadata = metadata;
+                if (!customMetadata.isValid(entity[key], omit)) {
+                    return {
+                        property: metadata.displayName,
+                        message: 'invalid'
+                    };
+                }
+                break;
+            default:
+                throw new Error(`Could not validate the input because the DecoratorType ${type} is not known`);
+        }
+        return undefined;
+    }
+    static getBooleanValidationError(entity, value, metadata) {
+        if (metadata.required(entity) && !value) {
+            return {
+                property: metadata.displayName,
+                message: 'not selected'
+            };
+        }
+        return undefined;
+    }
+    static getStringValidationError(value, metadata) {
+        if (metadata.maxLength && value.length > metadata.maxLength) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be smaller than ${metadata.maxLength} characters`
+            };
+        }
+        if (metadata.minLength && value.length < metadata.minLength) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be bigger than ${metadata.minLength} characters`
+            };
+        }
+        if (metadata.regex && !value.match(metadata.regex)) {
+            return {
+                property: metadata.displayName,
+                message: 'invalid'
+            };
+        }
+        return undefined;
+    }
+    static getTextboxValidationError(value, metadata) {
+        if (metadata.maxLength && value.length > metadata.maxLength) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be smaller than ${metadata.maxLength} characters`
+            };
+        }
+        if (metadata.minLength && value.length < metadata.minLength) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be bigger than ${metadata.minLength} characters`
+            };
+        }
+        return undefined;
+    }
+    static getPasswordValidationError(value, metadata, confirmPassword) {
+        if (value !== confirmPassword) {
+            return {
+                property: metadata.displayName,
+                message: 'passwords need to match'
+            };
+        }
+        if (metadata.maxLength && value.length > metadata.maxLength) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be smaller than ${metadata.maxLength} characters`
+            };
+        }
+        if (metadata.minLength && value.length < metadata.minLength) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be bigger than ${metadata.minLength} characters`
+            };
+        }
+        if (metadata.regex && !value.match(metadata.regex)) {
+            return {
+                property: metadata.displayName,
+                message: 'invalid'
+            };
+        }
+        return undefined;
+    }
+    static getNumberValidationError(value, metadata) {
+        if (metadata.max && value > metadata.max) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be smaller than ${metadata.max}`
+            };
+        }
+        if (metadata.min && value < metadata.min) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be bigger than ${metadata.min}`
+            };
+        }
+        return undefined;
+    }
+    static getDateValidationError(value, metadata) {
+        if (metadata.min && value.getTime() < metadata.min(value).getTime()) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be after ${formatDate(metadata.min(value))}`
+            };
+        }
+        if (metadata.max && value.getTime() > metadata.max(value).getTime()) {
+            return {
+                property: metadata.displayName,
+                message: `needs to be before ${formatDate(metadata.max(value))}`
+            };
+        }
+        if (metadata.filter && !metadata.filter(value)) {
+            return {
+                property: metadata.displayName,
+                message: 'invalid'
+            };
+        }
+        return undefined;
+    }
+    static getDateRangeValidationError(entity, value, metadata) {
+        if (metadata.required(entity)) {
+            if (value.start == null || value.end == null || value.values == null) {
+                return {
+                    property: metadata.displayName,
+                    message: 'required'
+                };
+            }
+        }
+        value.start = new Date(value.start);
+        value.end = new Date(value.end);
+        if (metadata.minStart && value.start.getTime() < metadata.minStart(value.start).getTime()) {
+            return {
+                property: metadata.displayName,
+                message: `start date needs to be after ${formatDate(metadata.minStart(value.start))}`
+            };
+        }
+        if (metadata.maxStart && value.start.getTime() > metadata.maxStart(value.start).getTime()) {
+            return {
+                property: metadata.displayName,
+                message: `start date needs to be before ${formatDate(metadata.maxStart(value.start))}`
+            };
+        }
+        if (metadata.minEnd && value.end.getTime() < metadata.minEnd(value.end).getTime()) {
+            return {
+                property: metadata.displayName,
+                message: `end date needs to be after ${formatDate(metadata.minEnd(value.end))}`
+            };
+        }
+        if (metadata.maxEnd && value.end.getTime() > metadata.maxEnd(value.end).getTime()) {
+            return {
+                property: metadata.displayName,
+                message: `end date needs to be before ${formatDate(metadata.maxEnd(value.end))}`
+            };
+        }
+        if (metadata.filter) {
+            if (!metadata.filter(value.start)) {
+                return {
+                    property: metadata.displayName,
+                    message: 'start date invalid'
+                };
+            }
+            if (!metadata.filter(value.end)) {
+                return {
+                    property: metadata.displayName,
+                    message: 'end date invalid'
+                };
+            }
+            for (const date of value.values) {
+                if (!metadata.filter(date)) {
+                    return {
+                        property: metadata.displayName,
+                        message: `value ${formatDate(date)} invalid`
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+    static getDateTimeValidationError(value, metadata, hasTime) {
+        if (!hasTime) {
+            return {
+                property: metadata.displayName,
+                message: 'no time'
+            };
+        }
+        if (metadata.minDate && value.getTime() < metadata.minDate(value).getTime()) {
+            return {
+                property: metadata.displayName,
+                message: `date needs to be after ${formatDate(metadata.minDate(value))}`
+            };
+        }
+        if (metadata.maxDate && value.getTime() > metadata.maxDate(value).getTime()) {
+            return {
+                property: metadata.displayName,
+                message: `date needs to be before ${formatDate(metadata.maxDate(value))}`
+            };
+        }
+        if (metadata.filterDate && !metadata.filterDate(value)) {
+            return {
+                property: metadata.displayName,
+                message: 'invalid date'
+            };
+        }
+        const time = DateUtilities.getTimeFromDate(value);
+        if (metadata.minTime) {
+            const minTime = metadata.minTime(value);
+            if (!(time.hours > minTime.hours
+                || (time.hours === minTime.hours
+                    && time.minutes >= minTime.minutes))) {
+                return {
+                    property: metadata.displayName,
+                    message: `time needs to be after ${minTime.hours}:${minTime.minutes}`
+                };
+            }
+        }
+        if (metadata.maxTime) {
+            const maxTime = metadata.maxTime(value);
+            if (!(time.hours < maxTime.hours
+                || (time.hours === maxTime.hours
+                    && time.minutes <= maxTime.minutes))) {
+                return {
+                    property: metadata.displayName,
+                    message: `time needs to be before ${maxTime.hours}:${maxTime.minutes}`
+                };
+            }
+        }
+        if (metadata.filterTime && !metadata.filterTime(time)) {
+            return {
+                property: metadata.displayName,
+                message: 'invalid time'
+            };
+        }
+        return undefined;
+    }
+    static getFileDataValidationError(value, metadata) {
+        const files = metadata.multiple ? value : [value];
+        let fileSizeTotal = 0;
+        for (const file of files) {
+            if (!file.name || !file.file && !file.url) {
+                return {
+                    property: metadata.displayName,
+                    message: 'invalid'
+                };
+            }
+            if (!FileUtilities.isMimeTypeValid(file.type, metadata.allowedMimeTypes)) {
+                return {
+                    property: metadata.displayName,
+                    message: `mimetype needs to be one of ${metadata.allowedMimeTypes}`
+                };
+            }
+            if (FileUtilities.transformToMegaBytes(file.size, 'B') > metadata.maxSize) {
+                return {
+                    property: metadata.displayName,
+                    message: `file needs to be smaller than ${metadata.maxSize} MB`
+                };
+            }
+            fileSizeTotal += file.size;
+            if (FileUtilities.transformToMegaBytes(fileSizeTotal, 'B') > metadata.maxSizeTotal) {
+                return {
+                    property: metadata.displayName,
+                    message: `The size of all files combined needs to be smaller than ${metadata.maxSizeTotal}`
+                };
+            }
+        }
+        return undefined;
+    }
+}
+// eslint-disable-next-line jsdoc/require-jsdoc
+function padTo2Digits(num) {
+    return num.toString().padStart(2, '0');
+}
+// eslint-disable-next-line jsdoc/require-jsdoc
+function formatDate(date) {
+    return [
+        padTo2Digits(date.getDate()),
+        padTo2Digits(date.getMonth() + 1),
+        date.getFullYear()
+    ].join('/');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validation.utilities.js","sourceRoot":"","sources":["../../../../projects/ngx-material-entity/src/utilities/validation.utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import { Time } from '@angular/common';\nimport { BaseEntityType } from '../classes/entity.model';\nimport { EntityArrayDecoratorConfigInternal } from '../decorators/array/array-decorator-internal.data';\nimport { DecoratorTypes } from '../decorators/base/decorator-types.enum';\nimport { PropertyDecoratorConfigInternal } from '../decorators/base/property-decorator-internal.data';\nimport { ToggleBooleanDecoratorConfigInternal } from '../decorators/boolean/boolean-decorator-internal.data';\nimport { CustomDecoratorConfigInternal } from '../decorators/custom/custom-decorator-internal.data';\nimport { DateRangeDateDecoratorConfigInternal, DateTimeDateDecoratorConfigInternal, DefaultDateDecoratorConfigInternal } from '../decorators/date/date-decorator-internal.data';\nimport { DateRange } from '../decorators/date/date-decorator.data';\nimport { DefaultFileDecoratorConfigInternal } from '../decorators/file/file-decorator-internal.data';\nimport { FileData } from '../decorators/file/file-decorator.data';\nimport { DefaultNumberDecoratorConfigInternal } from '../decorators/number/number-decorator-internal.data';\nimport { DefaultObjectDecoratorConfigInternal } from '../decorators/object/object-decorator-internal.data';\nimport { DefaultStringDecoratorConfigInternal, PasswordStringDecoratorConfigInternal, TextboxStringDecoratorConfigInternal } from '../decorators/string/string-decorator-internal.data';\nimport { LodashUtilities } from '../encapsulation/lodash.utilities';\nimport { ReflectUtilities } from '../encapsulation/reflect.utilities';\nimport { DateUtilities } from './date.utilities';\nimport { EntityUtilities } from './entity.utilities';\nimport { FileUtilities } from './file.utilities';\n\n/**\n * A validation error reported by the validation utilities.\n * Consists of the property name where the error originated from and a message.\n */\nexport interface ValidationError {\n    /**\n     * The property name on which the error occurred. This is the displayName value.\n     */\n    property: string,\n    /**\n     * The validation error message.\n     */\n    message: string\n}\n\n/**\n * Contains HelperMethods around handling Validation of entities and properties.\n */\nexport abstract class ValidationUtilities {\n    /**\n     * Checks if the values on an entity are valid.\n     * Also checks all the validators given by the metadata (\"required\", \"maxLength\" etc.).\n     *\n     * @param entity - The entity to validate.\n     * @param omit - Whether to check for creating or editing validity.\n     * @returns Whether or not the entity is valid.\n     */\n    static isEntityValid<EntityType extends BaseEntityType<EntityType>>(entity: EntityType, omit?: 'create' | 'update'): boolean {\n        return this.getEntityValidationErrors(entity, omit).length === 0;\n    }\n\n    /**\n     * Gets all validation errors on the given entity.\n     *\n     * @param entity - The entity to validate.\n     * @param omit - What keys not to check. An empty value means no keys are omitted.\n     * @returns An array of validation errors on the provided entity.\n     */\n    static getEntityValidationErrors<EntityType extends BaseEntityType<EntityType>>(\n        entity: EntityType,\n        omit?: 'create' | 'update'\n    ): ValidationError[] {\n        const res: ValidationError[] = [];\n        for (const key in entity) {\n            const err: ValidationError | undefined = this.getPropertyValidationError(entity, key, omit);\n            if (err) {\n                res.push(err);\n            }\n        }\n        return res;\n    }\n\n    // /**\n    //  * Checks if a single property value is valid.\n    //  *\n    //  * @param entity - The entity where the property is from.\n    //  * @param key - The name of the property.\n    //  * @param omit - Whether to check if the given entity is valid for creation or updating.\n    //  * @returns Whether or not the property value is valid.\n    //  * @throws Throws when it extracts an unknown metadata type.\n    //  */\n    // static isPropertyValid<EntityType extends BaseEntityType<EntityType>>(\n    //     entity: EntityType,\n    //     key: keyof EntityType,\n    //     omit?: 'create' | 'update'\n    // ): boolean {\n    //     return this.getPropertyValidationError(entity, key, omit) == null;\n    // }\n\n    /**\n     * Validates the property on the given entity with the given key.\n     *\n     * @param entity - The entity on which the property to check is.\n     * @param key - The key of the property to validate.\n     * @param omit - What keys not to check. An empty value means no keys are omitted.\n     * @returns A validation error when the property is not valid, undefined otherwise.\n     * @throws When the type of the property is not known.\n     */\n    static getPropertyValidationError<EntityType extends BaseEntityType<EntityType>>(\n        entity: EntityType,\n        key: keyof EntityType,\n        omit?: 'create' | 'update'\n    ): ValidationError | undefined {\n        const type: DecoratorTypes = EntityUtilities.getPropertyType(entity, key);\n        const metadata: PropertyDecoratorConfigInternal<unknown> = EntityUtilities.getPropertyMetadata(entity, key, type);\n\n        if (metadata.omitForCreate && omit === 'create') {\n            return undefined;\n        }\n        if (metadata.omitForUpdate && omit === 'update') {\n            return undefined;\n        }\n        if (metadata.required(entity) && type !== DecoratorTypes.HAS_MANY) {\n            if (entity[key] == null || entity[key] === '') {\n                return {\n                    property: metadata.displayName,\n                    message: 'required'\n                };\n            }\n        }\n        if (!metadata.required(entity)) {\n            if (entity[key] == null || entity[key] === '') {\n                return undefined;\n            }\n        }\n        switch (type) {\n            case DecoratorTypes.BOOLEAN_DROPDOWN:\n                break;\n            case DecoratorTypes.BOOLEAN_CHECKBOX:\n            case DecoratorTypes.BOOLEAN_TOGGLE:\n                const entityBoolean: boolean = entity[key] as boolean;\n                const booleanMetadata: ToggleBooleanDecoratorConfigInternal = metadata as ToggleBooleanDecoratorConfigInternal;\n                return this.getBooleanValidationError(entity, entityBoolean, booleanMetadata);\n            case DecoratorTypes.STRING_DROPDOWN:\n                break;\n            case DecoratorTypes.STRING:\n            case DecoratorTypes.STRING_AUTOCOMPLETE:\n                const entityString: string = entity[key] as string;\n                const stringMetadata: DefaultStringDecoratorConfigInternal = metadata as DefaultStringDecoratorConfigInternal;\n                return this.getStringValidationError(entityString, stringMetadata);\n            case DecoratorTypes.STRING_TEXTBOX:\n                const entityTextbox: string = entity[key] as string;\n                const textboxMetadata: TextboxStringDecoratorConfigInternal = metadata as TextboxStringDecoratorConfigInternal;\n                return this.getTextboxValidationError(entityTextbox, textboxMetadata);\n            case DecoratorTypes.STRING_PASSWORD:\n                const entityPassword: string = entity[key] as string;\n                const passwordMetadata: PasswordStringDecoratorConfigInternal = metadata as PasswordStringDecoratorConfigInternal;\n                const confirmPassword: string = ReflectUtilities.getMetadata(EntityUtilities.CONFIRM_PASSWORD_KEY, entity, key) as string;\n                return this.getPasswordValidationError(entityPassword, passwordMetadata, confirmPassword);\n            case DecoratorTypes.NUMBER_DROPDOWN:\n                // Because only valid values can be selected, this is always true when it has a value\n                return undefined;\n            case DecoratorTypes.NUMBER:\n            case DecoratorTypes.NUMBER_SLIDER:\n                const entityNumber: number = entity[key] as number;\n                const numberMetadata: DefaultNumberDecoratorConfigInternal = metadata as DefaultNumberDecoratorConfigInternal;\n                return this.getNumberValidationError(entityNumber, numberMetadata);\n            case DecoratorTypes.OBJECT:\n                const entityObject: EntityType = entity[key] as EntityType;\n                for (const parameterKey in entityObject) {\n                    const value: unknown = entityObject[parameterKey];\n                    if (\n                        !(metadata as DefaultObjectDecoratorConfigInternal<EntityType>).omit.includes(parameterKey)\n                        && !(!metadata.required(entity) && (value == null || value == ''))\n                    ) {\n                        const err: ValidationError | undefined = this.getPropertyValidationError(entityObject, parameterKey, omit);\n                        if (err) {\n                            return {\n                                property: metadata.displayName,\n                                message: `${err.property} is invalid: ${err.message}`\n                            };\n                        }\n                    }\n                }\n                break;\n            case DecoratorTypes.ARRAY_STRING_CHIPS:\n            case DecoratorTypes.ARRAY_STRING_AUTOCOMPLETE_CHIPS:\n            case DecoratorTypes.ARRAY_DATE:\n            case DecoratorTypes.ARRAY_DATE_TIME:\n            case DecoratorTypes.ARRAY_DATE_RANGE:\n            case DecoratorTypes.ARRAY:\n                const entityArray: unknown[] = entity[key] as unknown[];\n                // eslint-disable-next-line max-len\n                const arrayMetadata: EntityArrayDecoratorConfigInternal<EntityType> = metadata as EntityArrayDecoratorConfigInternal<EntityType>;\n                if (arrayMetadata.required(entity) && !entityArray.length) {\n                    return {\n                        property: metadata.displayName,\n                        message: 'no items in array'\n                    };\n                }\n                break;\n            case DecoratorTypes.DATE:\n                const entityDate: Date = new Date(entity[key] as Date);\n                const dateMetadata: DefaultDateDecoratorConfigInternal = metadata as DefaultDateDecoratorConfigInternal;\n                return this.getDateValidationError(entityDate, dateMetadata);\n            case DecoratorTypes.DATE_RANGE:\n                const entityDateRange: DateRange = LodashUtilities.cloneDeep(entity[key] as DateRange);\n                const dateRangeMetadata: DateRangeDateDecoratorConfigInternal = metadata as DateRangeDateDecoratorConfigInternal;\n                return this.getDateRangeValidationError(entity, entityDateRange, dateRangeMetadata);\n            case DecoratorTypes.DATE_TIME:\n                const entityDateTime: Date = new Date(entity[key] as Date);\n                const dateTimeMetadata: DateTimeDateDecoratorConfigInternal = metadata as DateTimeDateDecoratorConfigInternal;\n                const hasTime: boolean = ReflectUtilities.hasMetadata(EntityUtilities.TIME_KEY, entity, key);\n                return this.getDateTimeValidationError(entityDateTime, dateTimeMetadata, hasTime);\n            case DecoratorTypes.FILE_DEFAULT:\n            case DecoratorTypes.FILE_IMAGE:\n                const entityFile: FileData | FileData[] = entity[key] as FileData | FileData[];\n                const entityFileMetadata: DefaultFileDecoratorConfigInternal = metadata as DefaultFileDecoratorConfigInternal;\n                return this.getFileDataValidationError(entityFile, entityFileMetadata);\n            case DecoratorTypes.REFERENCES_MANY:\n            case DecoratorTypes.REFERENCES_ONE:\n            case DecoratorTypes.HAS_MANY:\n                break;\n            case DecoratorTypes.CUSTOM:\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any, max-len\n                const customMetadata: CustomDecoratorConfigInternal<EntityType, any, any, any> = metadata as CustomDecoratorConfigInternal<EntityType, any, any, any>;\n                if (!customMetadata.isValid(entity[key], omit)) {\n                    return {\n                        property: metadata.displayName,\n                        message: 'invalid'\n                    };\n                }\n                break;\n            default:\n                throw new Error(`Could not validate the input because the DecoratorType ${type} is not known`);\n        }\n        return undefined;\n    }\n\n    private static getBooleanValidationError<EntityType extends BaseEntityType<EntityType>>(\n        entity: EntityType,\n        value: boolean,\n        metadata: ToggleBooleanDecoratorConfigInternal\n    ): ValidationError | undefined {\n        if (metadata.required(entity) && !value) {\n            return {\n                property: metadata.displayName,\n                message: 'not selected'\n            };\n        }\n        return undefined;\n    }\n\n    private static getStringValidationError(value: string, metadata: DefaultStringDecoratorConfigInternal): ValidationError | undefined {\n        if (metadata.maxLength && value.length > metadata.maxLength) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be smaller than ${metadata.maxLength} characters`\n            };\n        }\n        if (metadata.minLength && value.length < metadata.minLength) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be bigger than ${metadata.minLength} characters`\n            };\n        }\n        if (metadata.regex && !value.match(metadata.regex)) {\n            return {\n                property: metadata.displayName,\n                message: 'invalid'\n            };\n        }\n        return undefined;\n    }\n\n    private static getTextboxValidationError(value: string, metadata: TextboxStringDecoratorConfigInternal): ValidationError | undefined {\n        if (metadata.maxLength && value.length > metadata.maxLength) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be smaller than ${metadata.maxLength} characters`\n            };\n        }\n        if (metadata.minLength && value.length < metadata.minLength) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be bigger than ${metadata.minLength} characters`\n            };\n        }\n        return undefined;\n    }\n\n    private static getPasswordValidationError(\n        value: string,\n        metadata: PasswordStringDecoratorConfigInternal,\n        confirmPassword: string\n    ): ValidationError | undefined {\n        if (value !== confirmPassword) {\n            return {\n                property: metadata.displayName,\n                message: 'passwords need to match'\n            };\n        }\n        if (metadata.maxLength && value.length > metadata.maxLength) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be smaller than ${metadata.maxLength} characters`\n            };\n        }\n        if (metadata.minLength && value.length < metadata.minLength) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be bigger than ${metadata.minLength} characters`\n            };\n        }\n        if (metadata.regex && !value.match(metadata.regex)) {\n            return {\n                property: metadata.displayName,\n                message: 'invalid'\n            };\n        }\n        return undefined;\n    }\n\n    private static getNumberValidationError(value: number, metadata: DefaultNumberDecoratorConfigInternal): ValidationError | undefined {\n        if (metadata.max && value > metadata.max) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be smaller than ${metadata.max}`\n            };\n        }\n        if (metadata.min && value < metadata.min) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be bigger than ${metadata.min}`\n            };\n        }\n        return undefined;\n    }\n\n    private static getDateValidationError(value: Date, metadata: DefaultDateDecoratorConfigInternal): ValidationError | undefined {\n        if (metadata.min && value.getTime() < metadata.min(value).getTime()) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be after ${formatDate(metadata.min(value))}`\n            };\n        }\n        if (metadata.max && value.getTime() > metadata.max(value).getTime()) {\n            return {\n                property: metadata.displayName,\n                message: `needs to be before ${formatDate(metadata.max(value))}`\n            };\n        }\n        if (metadata.filter && !metadata.filter(value)) {\n            return {\n                property: metadata.displayName,\n                message: 'invalid'\n            };\n        }\n        return undefined;\n    }\n\n    private static getDateRangeValidationError<EntityType extends BaseEntityType<EntityType>>(\n        entity: EntityType,\n        value: DateRange,\n        metadata: DateRangeDateDecoratorConfigInternal\n    ): ValidationError | undefined {\n        if (metadata.required(entity)) {\n            if (value.start == null || value.end == null || value.values == null) {\n                return {\n                    property: metadata.displayName,\n                    message: 'required'\n                };\n            }\n        }\n        value.start = new Date(value.start);\n        value.end = new Date(value.end);\n        if (metadata.minStart && value.start.getTime() < metadata.minStart(value.start).getTime()) {\n            return {\n                property: metadata.displayName,\n                message: `start date needs to be after ${formatDate(metadata.minStart(value.start))}`\n            };\n        }\n        if (metadata.maxStart && value.start.getTime() > metadata.maxStart(value.start).getTime()) {\n            return {\n                property: metadata.displayName,\n                message: `start date needs to be before ${formatDate(metadata.maxStart(value.start))}`\n            };\n        }\n        if (metadata.minEnd && value.end.getTime() < metadata.minEnd(value.end).getTime()) {\n            return {\n                property: metadata.displayName,\n                message: `end date needs to be after ${formatDate(metadata.minEnd(value.end))}`\n            };\n        }\n        if (metadata.maxEnd && value.end.getTime() > metadata.maxEnd(value.end).getTime()) {\n            return {\n                property: metadata.displayName,\n                message: `end date needs to be before ${formatDate(metadata.maxEnd(value.end))}`\n            };\n        }\n        if (metadata.filter) {\n            if (!metadata.filter(value.start)) {\n                return {\n                    property: metadata.displayName,\n                    message: 'start date invalid'\n                };\n            }\n            if (!metadata.filter(value.end)) {\n                return {\n                    property: metadata.displayName,\n                    message: 'end date invalid'\n                };\n            }\n            for (const date of value.values) {\n                if (!metadata.filter(date)) {\n                    return {\n                        property: metadata.displayName,\n                        message: `value ${formatDate(date)} invalid`\n                    };\n                }\n            }\n        }\n        return undefined;\n    }\n\n    private static getDateTimeValidationError(\n        value: Date,\n        metadata: DateTimeDateDecoratorConfigInternal,\n        hasTime: boolean\n    ): ValidationError | undefined {\n        if (!hasTime) {\n            return {\n                property: metadata.displayName,\n                message: 'no time'\n            };\n        }\n        if (metadata.minDate && value.getTime() < metadata.minDate(value).getTime()) {\n            return {\n                property: metadata.displayName,\n                message: `date needs to be after ${formatDate(metadata.minDate(value))}`\n            };\n        }\n        if (metadata.maxDate && value.getTime() > metadata.maxDate(value).getTime()) {\n            return {\n                property: metadata.displayName,\n                message: `date needs to be before ${formatDate(metadata.maxDate(value))}`\n            };\n        }\n        if (metadata.filterDate && !metadata.filterDate(value)) {\n            return {\n                property: metadata.displayName,\n                message: 'invalid date'\n            };\n        }\n        const time: Time = DateUtilities.getTimeFromDate(value) as Time;\n        if (metadata.minTime) {\n            const minTime: Time = metadata.minTime(value);\n            if (\n                !(\n                    time.hours > minTime.hours\n                    || (\n                        time.hours === minTime.hours\n                        && time.minutes >= minTime.minutes\n                    )\n                )\n            ) {\n                return {\n                    property: metadata.displayName,\n                    message: `time needs to be after ${minTime.hours}:${minTime.minutes}`\n                };\n            }\n        }\n        if (metadata.maxTime) {\n            const maxTime: Time = metadata.maxTime(value);\n            if (\n                !(\n                    time.hours < maxTime.hours\n                    || (\n                        time.hours === maxTime.hours\n                        && time.minutes <= maxTime.minutes\n                    )\n                )\n            ) {\n                return {\n                    property: metadata.displayName,\n                    message: `time needs to be before ${maxTime.hours}:${maxTime.minutes}`\n                };\n            }\n        }\n        if (metadata.filterTime && !metadata.filterTime(time)) {\n            return {\n                property: metadata.displayName,\n                message: 'invalid time'\n            };\n        }\n        return undefined;\n    }\n\n    private static getFileDataValidationError(\n        value: FileData | FileData[],\n        metadata: DefaultFileDecoratorConfigInternal\n    ): ValidationError | undefined {\n        const files: FileData[] = metadata.multiple ? value as FileData[] : [value as FileData];\n        let fileSizeTotal: number = 0;\n        for (const file of files) {\n            if (!file.name || !file.file && !file.url) {\n                return {\n                    property: metadata.displayName,\n                    message: 'invalid'\n                };\n            }\n            if (!FileUtilities.isMimeTypeValid(file.type, metadata.allowedMimeTypes)) {\n                return {\n                    property: metadata.displayName,\n                    message: `mimetype needs to be one of ${metadata.allowedMimeTypes}`\n                };\n            }\n            if (FileUtilities.transformToMegaBytes(file.size, 'B') > metadata.maxSize) {\n                return {\n                    property: metadata.displayName,\n                    message: `file needs to be smaller than ${metadata.maxSize} MB`\n                };\n            }\n            fileSizeTotal += file.size;\n            if (FileUtilities.transformToMegaBytes(fileSizeTotal, 'B') > metadata.maxSizeTotal) {\n                return {\n                    property: metadata.displayName,\n                    message: `The size of all files combined needs to be smaller than ${metadata.maxSizeTotal}`\n                };\n            }\n        }\n        return undefined;\n    }\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction padTo2Digits(num: number): string {\n    return num.toString().padStart(2, '0');\n}\n\n// eslint-disable-next-line jsdoc/require-jsdoc\nfunction formatDate(date: Date): string {\n    return [\n        padTo2Digits(date.getDate()),\n        padTo2Digits(date.getMonth() + 1),\n        date.getFullYear()\n    ].join('/');\n}"]}