ngx-material-entity 15.3.0 → 16.0.0

package/esm2022/decorators/object/object-decorator.data.mjs

@@ -0,0 +1,22 @@
+import { PropertyDecoratorConfig } from '../base/property-decorator.data';
+/**
+ * Definition for the @object metadata.
+ */
+class ObjectDecoratorConfig extends PropertyDecoratorConfig {
+    /**
+     * The class of the object. Is used to call the constructor so that all metadata is initialized.
+     */
+    EntityClass;
+    /**
+     * How to display the object.
+     *
+     * The objects properties are added as input fields in an section of the entity.
+     * Useful if the object only contains a few properties (e.g. A address on a user).
+     */
+    displayStyle;
+    /**
+     * Some properties of the objects entity class that should be omitted.
+     */
+    omit;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/decorators/references-many/references-many-decorator-internal.data.mjs

@@ -0,0 +1,48 @@
+import { PropertyDecoratorConfigInternal } from '../base/property-decorator-internal.data';
+/**
+ * The internal DefaultNumberDecoratorConfig. Sets default values.
+ */
+export class ReferencesManyDecoratorConfigInternal extends PropertyDecoratorConfigInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getReferencedEntities;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getDropdownValues;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getEntityForId;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayColumns;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    addButtonLabel;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    removeButtonLabel;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    dropdownLabel;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    addAll;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    addAllButtonLabel;
+    constructor(data) {
+        super(data);
+        this.getReferencedEntities = data.getReferencedEntities;
+        this.getDropdownValues = data.getDropdownValues;
+        this.getEntityForId = data.getEntityForId ?? defaultGetEntityForId;
+        this.displayColumns = data.displayColumns;
+        this.addButtonLabel = data.addButtonLabel ?? 'Add';
+        this.removeButtonLabel = data.removeButtonLabel ?? 'Remove';
+        this.defaultWidths = data.defaultWidths ?? [12, 12, 12];
+        this.dropdownLabel = data.dropdownLabel ?? 'Select';
+        this.addAll = data.addAll ?? false;
+        this.addAllButtonLabel = data.addAllButtonLabel ?? 'Add all';
+    }
+}
+/**
+ * The default function to use when trying to get the referenced entity for the given id.
+ *
+ * @param entityId - The id of the referenced entity.
+ * @param allReferencedEntities - All referenced entities.
+ * @returns The entity that has the given id.
+ */
+export function defaultGetEntityForId(entityId, allReferencedEntities) {
+    return allReferencedEntities.find(e => e['id'] === entityId);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/decorators/references-one/references-one-decorator-internal.data.mjs

@@ -0,0 +1,24 @@
+import { PropertyDecoratorConfigInternal } from '../base/property-decorator-internal.data';
+import { defaultGetEntityForId } from '../references-many/references-many-decorator-internal.data';
+/**
+ * The internal DefaultNumberDecoratorConfig. Sets default values.
+ */
+export class ReferencesOneDecoratorConfigInternal extends PropertyDecoratorConfigInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getReferencedEntities;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getDropdownValues;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getEntityForId;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    EntityClass;
+    constructor(data) {
+        super(data);
+        this.getReferencedEntities = data.getReferencedEntities;
+        this.getDropdownValues = data.getDropdownValues;
+        this.getEntityForId = data.getEntityForId ?? defaultGetEntityForId;
+        this.EntityClass = data.EntityClass;
+        this.defaultWidths = data.defaultWidths ?? [12, 12, 12];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/decorators/string/string-decorator-internal.data.mjs

@@ -0,0 +1,114 @@
+import { PropertyDecoratorConfigInternal } from '../base/property-decorator-internal.data';
+/**
+ * The internal DropdownStringDecoratorConfig. Sets default values.
+ */
+export class DropdownStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayStyle;
+    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/no-explicit-any
+    dropdownValues;
+    constructor(data) {
+        super(data);
+        this.displayStyle = data.displayStyle;
+        this.dropdownValues = this.dropdownValuesToFunction(data.dropdownValues);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    dropdownValuesToFunction(dropdownValues) {
+        if (Array.isArray(dropdownValues)) {
+            return async () => dropdownValues;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return async (e) => await dropdownValues(e);
+    }
+}
+/**
+ * The internal DefaultStringDecoratorConfig. Sets default values.
+ */
+export class DefaultStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayStyle;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    minLength;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    maxLength;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    regex;
+    constructor(data) {
+        super(data);
+        this.displayStyle = data.displayStyle;
+        this.minLength = data.minLength;
+        this.maxLength = data.maxLength;
+        this.regex = data.regex;
+    }
+}
+/**
+ * The internal TextboxStringDecoratorConfig. Sets default values.
+ */
+export class TextboxStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayStyle;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    minLength;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    maxLength;
+    constructor(data) {
+        super(data);
+        this.displayStyle = data.displayStyle;
+        this.minLength = data.minLength;
+        this.maxLength = data.maxLength;
+    }
+}
+/**
+ * The internal AutocompleteStringDecoratorConfig. Sets default values.
+ */
+export class AutocompleteStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayStyle;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    autocompleteValues;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    minLength;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    maxLength;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    regex;
+    constructor(data) {
+        super(data);
+        this.displayStyle = data.displayStyle;
+        this.autocompleteValues = data.autocompleteValues;
+        this.minLength = data.minLength;
+        this.maxLength = data.maxLength;
+        this.regex = data.regex;
+    }
+}
+/**
+ * The internal PasswordStringDecoratorConfig. Sets default values.
+ */
+export class PasswordStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    displayStyle;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    minLength;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    maxLength;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    regex;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    needsConfirmation;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    confirmationDisplayName;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    passwordsDontMatchErrorMessage;
+    constructor(data) {
+        super(data);
+        this.displayStyle = data.displayStyle;
+        this.minLength = data.minLength;
+        this.maxLength = data.maxLength;
+        this.regex = data.regex;
+        this.needsConfirmation = data.needsConfirmation ?? true;
+        this.confirmationDisplayName = data.confirmationDisplayName ?? 'Confirm Password';
+        this.passwordsDontMatchErrorMessage = data.passwordsDontMatchErrorMessage ?? 'Passwords need to match!';
+        this.defaultWidths = data.defaultWidths ?? [12, 12, 12];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"string-decorator-internal.data.js","sourceRoot":"","sources":["../../../../../projects/ngx-material-entity/src/decorators/string/string-decorator-internal.data.ts"],"names":[],"mappings":"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","sourcesContent":["import { DropdownValue } from '../base/dropdown-value.interface';\nimport { PropertyDecoratorConfigInternal } from '../base/property-decorator-internal.data';\nimport { AutocompleteStringDecoratorConfig, DefaultStringDecoratorConfig, DropdownStringDecoratorConfig, PasswordStringDecoratorConfig, StringDropdownValues, TextboxStringDecoratorConfig } from './string-decorator.data';\n\n/**\n * The internal DropdownStringDecoratorConfig. Sets default values.\n */\nexport class DropdownStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal implements DropdownStringDecoratorConfig {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayStyle: 'dropdown';\n    // eslint-disable-next-line jsdoc/require-jsdoc, @typescript-eslint/no-explicit-any\n    dropdownValues: ((entity: any) => Promise<DropdownValue<string | undefined>[]>);\n\n    constructor(data: DropdownStringDecoratorConfig) {\n        super(data);\n        this.displayStyle = data.displayStyle;\n        this.dropdownValues = this.dropdownValuesToFunction(data.dropdownValues);\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    private dropdownValuesToFunction(dropdownValues: StringDropdownValues): (entity: any) => Promise<DropdownValue<string | undefined>[]> {\n        if (Array.isArray(dropdownValues)) {\n            return async () => dropdownValues;\n        }\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return async (e: any) => await dropdownValues(e);\n    }\n}\n\n/**\n * The internal DefaultStringDecoratorConfig. Sets default values.\n */\nexport class DefaultStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal implements DefaultStringDecoratorConfig {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayStyle: 'line';\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    minLength?: number;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    maxLength?: number;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    regex?: RegExp;\n\n    constructor(data: DefaultStringDecoratorConfig) {\n        super(data);\n        this.displayStyle = data.displayStyle;\n        this.minLength = data.minLength;\n        this.maxLength = data.maxLength;\n        this.regex = data.regex;\n    }\n}\n\n/**\n * The internal TextboxStringDecoratorConfig. Sets default values.\n */\nexport class TextboxStringDecoratorConfigInternal extends PropertyDecoratorConfigInternal implements TextboxStringDecoratorConfig {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayStyle: 'textbox';\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    minLength?: number;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    maxLength?: number;\n\n    constructor(data: TextboxStringDecoratorConfig) {\n        super(data);\n        this.displayStyle = data.displayStyle;\n        this.minLength = data.minLength;\n        this.maxLength = data.maxLength;\n    }\n}\n\n/**\n * The internal AutocompleteStringDecoratorConfig. Sets default values.\n */\nexport class AutocompleteStringDecoratorConfigInternal\n    extends PropertyDecoratorConfigInternal implements AutocompleteStringDecoratorConfig {\n\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayStyle: 'autocomplete';\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    autocompleteValues: string[];\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    minLength?: number;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    maxLength?: number;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    regex?: RegExp;\n\n    constructor(data: AutocompleteStringDecoratorConfig) {\n        super(data);\n        this.displayStyle = data.displayStyle;\n        this.autocompleteValues = data.autocompleteValues;\n        this.minLength = data.minLength;\n        this.maxLength = data.maxLength;\n        this.regex = data.regex;\n    }\n}\n\n/**\n * The internal PasswordStringDecoratorConfig. Sets default values.\n */\nexport class PasswordStringDecoratorConfigInternal\n    extends PropertyDecoratorConfigInternal implements PasswordStringDecoratorConfig {\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    displayStyle: 'password';\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    minLength?: number;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    maxLength?: number;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    regex?: RegExp;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    needsConfirmation: boolean;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    confirmationDisplayName: string;\n    // eslint-disable-next-line jsdoc/require-jsdoc\n    passwordsDontMatchErrorMessage: string;\n\n    constructor(data: PasswordStringDecoratorConfig) {\n        super(data);\n        this.displayStyle = data.displayStyle;\n        this.minLength = data.minLength;\n        this.maxLength = data.maxLength;\n        this.regex = data.regex;\n        this.needsConfirmation = data.needsConfirmation ?? true;\n        this.confirmationDisplayName = data.confirmationDisplayName ?? 'Confirm Password';\n        this.passwordsDontMatchErrorMessage = data.passwordsDontMatchErrorMessage ?? 'Passwords need to match!';\n        this.defaultWidths = data.defaultWidths ?? [12, 12, 12];\n    }\n}"]}

package/esm2022/decorators/string/string-decorator.data.mjs

@@ -0,0 +1,11 @@
+import { PropertyDecoratorConfig } from '../base/property-decorator.data';
+/**
+ * Definition for the @string metadata.
+ */
+class StringDecoratorConfig extends PropertyDecoratorConfig {
+    /**
+     * How to display the string.
+     */
+    displayStyle;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/encapsulation/uuid.utilities.mjs

@@ -0,0 +1,15 @@
+import * as uuid from 'uuid';
+/**
+ * Encapsulates functionality of the uuid package.
+ */
+export class UUIDUtilities {
+    /**
+     * Creates a new v4 uuid.
+     *
+     * @returns The created uuid.
+     */
+    static create() {
+        return uuid.v4();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXVpZC51dGlsaXRpZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtbWF0ZXJpYWwtZW50aXR5L3NyYy9lbmNhcHN1bGF0aW9uL3V1aWQudXRpbGl0aWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCOztHQUVHO0FBQ0gsTUFBTSxPQUFnQixhQUFhO0lBQy9COzs7O09BSUc7SUFDSCxNQUFNLENBQUMsTUFBTTtRQUNULE9BQU8sSUFBSSxDQUFDLEVBQUUsRUFBRSxDQUFDO0lBQ3JCLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHV1aWQgZnJvbSAndXVpZCc7XG5cbi8qKlxuICogRW5jYXBzdWxhdGVzIGZ1bmN0aW9uYWxpdHkgb2YgdGhlIHV1aWQgcGFja2FnZS5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFVVSURVdGlsaXRpZXMge1xuICAgIC8qKlxuICAgICAqIENyZWF0ZXMgYSBuZXcgdjQgdXVpZC5cbiAgICAgKlxuICAgICAqIEByZXR1cm5zIFRoZSBjcmVhdGVkIHV1aWQuXG4gICAgICovXG4gICAgc3RhdGljIGNyZWF0ZSgpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gdXVpZC52NCgpO1xuICAgIH1cbn0iXX0=

package/esm2022/services/entity.service.mjs

@@ -0,0 +1,276 @@
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { DecoratorTypes } from '../decorators/base/decorator-types.enum';
+import { LodashUtilities } from '../encapsulation/lodash.utilities';
+import { EntityUtilities } from '../utilities/entity.utilities';
+import { FileUtilities } from '../utilities/file.utilities';
+/**
+ * A generic EntityService class.
+ * Offers basic CRUD-functionality.
+ * You should create a service for every Entity you have.
+ * If you extend from this you need to make sure that the extended Service can be injected.
+ */
+export class EntityService {
+    http;
+    /**
+     * The route segment that comes before the id when editing an entity in a separate page.
+     */
+    editBaseRoute = 'entities';
+    /**
+     * The key which holds the id value.
+     *
+     * @default 'id'
+     */
+    idKey = 'id';
+    /**
+     * A subject of all the entity values.
+     * Can be subscribed to when you want to do a specific thing whenever the entities change.
+     */
+    entitiesSubject = new BehaviorSubject([]);
+    /**
+     * When frequently trying to find a single entity by an id (eg. When nesting relations)
+     * you might send a lot of unnecessary requests.
+     * Therefore the findById method tries to look in the already existing entities first,
+     * IF the entities have been requested in the last READ_EXPIRATION_IN_MS milliseconds.
+     *
+     * @default 900000 (5 minutes)
+     */
+    READ_EXPIRATION_IN_MS = 900000;
+    /**
+     * Gets the entities in an array from the internal entitiesSubject.
+     *
+     * @returns The current entities in form of an array.
+     */
+    get entities() {
+        return this.entitiesSubject.value;
+    }
+    lastRead;
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Creates a new Entity and pushes it to the entities array.
+     *
+     * @param entity - The data of the entity to create.
+     * All values that should be omitted will be removed from it inside this method.
+     * @param baseUrl - The base url to send the post request to.
+     * This can be used if you want to create an entity belonging to another, like "customers/{id}/invoices".
+     * @returns A Promise of the created entity.
+     */
+    async create(entity, baseUrl = this.baseUrl) {
+        const body = EntityUtilities.getWithoutOmitCreateValues(entity);
+        const filePropertyKeys = EntityUtilities.getFileProperties(entity);
+        if (!filePropertyKeys.length) {
+            return await this.createWithJson(body, baseUrl);
+        }
+        else {
+            return await this.createWithFormData(body, filePropertyKeys, entity, baseUrl);
+        }
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Imports everything from the provided json file.
+     *
+     * @param file - The json file to import from.
+     * @returns All entities that have been imported.
+     */
+    async import(file) {
+        const formData = new FormData();
+        formData.append('import', file);
+        const result = await firstValueFrom(this.http.post(`${this.baseUrl}/import`, formData));
+        this.entities.push(...result);
+        this.entitiesSubject.next(this.entities);
+        return result;
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Creates the entity with form data when the entity contains files in contrast to creating it with a normal json body.
+     * All file values are stored inside their respective property key and their name.
+     * Form data is able to handle setting multiple files to the same key.
+     *
+     * @param body - The body Of the request.
+     * @param filePropertyKeys - All property keys that are files and need to be added to the form data.
+     * @param entity - The entity to create. This is needed in addition to the body because the body doesn't contain any metadata.
+     * @param baseUrl - The base url to send the post request to.
+     * This can be used if you want to create an entity belonging to another, like "customers/{id}/invoices".
+     * @returns The created entity from the server.
+     */
+    async createWithFormData(body, filePropertyKeys, entity, baseUrl = this.baseUrl) {
+        const formData = new FormData();
+        formData.append('body', JSON.stringify(LodashUtilities.omit(body, filePropertyKeys)));
+        for (const key of filePropertyKeys) {
+            if (EntityUtilities.getPropertyMetadata(entity, key, DecoratorTypes.FILE_DEFAULT).multiple) {
+                const fileDataValues = body[key];
+                for (const value of fileDataValues) {
+                    formData.append(key, (await FileUtilities.getFileData(value, this.http)).file, value.name);
+                }
+            }
+            else {
+                const fileData = body[key];
+                formData.append(key, (await FileUtilities.getFileData(fileData, this.http)).file, fileData.name);
+            }
+        }
+        const e = await firstValueFrom(this.http.post(baseUrl, formData));
+        if (!e) {
+            throw new Error(`
+                The created entity was not returned in the response.
+                If you want to provide a logic that allows that
+                you need to override the create methods of this class.
+            `);
+        }
+        this.entities.push(e);
+        this.entitiesSubject.next(this.entities);
+        return e;
+    }
+    /**
+     * Creates the entity with a normal json body in contrast to creating it with form data when the entity contains files.
+     *
+     * @param body - The body Of the request.
+     * @param baseUrl - The base url to send the post request to.
+     * This can be used if you want to create an entity belonging to another, like "customers/{id}/invoices".
+     * @returns The created entity from the server.
+     */
+    async createWithJson(body, baseUrl = this.baseUrl) {
+        const e = await firstValueFrom(this.http.post(baseUrl, body));
+        if (!e) {
+            throw new Error(`
+                The created entity was not returned in the response.
+                If you want to provide a logic that allows that
+                you need to override the create methods of this class.
+            `);
+        }
+        this.entities.push(e);
+        this.entitiesSubject.next(this.entities);
+        return e;
+    }
+    /**
+     * Gets all existing entities and pushes them to the entities array.
+     *
+     * @param baseUrl - The base url for the request. Defaults to the baseUrl on the service.
+     * @returns A Promise of all received Entities.
+     */
+    async read(baseUrl = this.baseUrl) {
+        const e = await firstValueFrom(this.http.get(baseUrl));
+        this.entitiesSubject.next(e);
+        this.lastRead = new Date();
+        return e;
+    }
+    /**
+     * Tries to find an entity with the given id.
+     *
+     * @param id - The id of the entity to find.
+     * @returns The found entity.
+     */
+    async findById(id) {
+        if (this.lastRead == null
+            || (new Date().getTime() - this.lastRead.getTime()) > this.READ_EXPIRATION_IN_MS) {
+            return firstValueFrom(this.http.get(`${this.baseUrl}/${id}`));
+        }
+        return this.entities.find(e => e[this.idKey] === id) ?? firstValueFrom(this.http.get(`${this.baseUrl}/${id}`));
+    }
+    /**
+     * Updates a specific Entity.
+     *
+     * @param entity - The updated Entity
+     * All values that should be omitted will be removed from it inside this method.
+     * @param entityPriorChanges - The current Entity.
+     * It Is used to get changed values and only update them instead of sending the whole entity data.
+     */
+    async update(entity, entityPriorChanges) {
+        const filePropertyKeys = EntityUtilities.getFileProperties(entityPriorChanges);
+        const body = await this.entityToUpdateRequestBody(entity, entityPriorChanges);
+        if (!filePropertyKeys.length) {
+            await this.updateWithJson(body, entityPriorChanges[this.idKey]);
+        }
+        else {
+            await this.updateWithFormData(body, filePropertyKeys, entity, entityPriorChanges[this.idKey]);
+        }
+    }
+    /**
+     * Builds the update request body from the given entity before and after its changes.
+     *
+     * @param entity - The entity with changed values.
+     * @param entityPriorChanges - The entity before any changes.
+     * @returns A partial of only the changed values.
+     */
+    async entityToUpdateRequestBody(entity, entityPriorChanges) {
+        const body = await EntityUtilities.getWithoutOmitUpdateValues(entity, entityPriorChanges, this.http);
+        return LodashUtilities.omitBy(body, LodashUtilities.isNil);
+    }
+    // TODO: Find a way to use blobs with jest
+    /* istanbul ignore next */
+    /**
+     * Updates the entity with form data when the entity contains files in contrast to creating it with a normal json body.
+     * All file values are stored inside their respective property key and their name.
+     * Form data is able to handle setting multiple files to the same key.
+     *
+     * @param body - The request body. Already contains only properties that have changed.
+     * @param filePropertyKeys - The keys of all properties which are files and need to separately be appended to the form data.
+     * @param entity - The original entity. Is needed to get the metadata of all the files.
+     * @param id - The id of the entity to update.
+     */
+    async updateWithFormData(body, filePropertyKeys, entity, id) {
+        const formData = new FormData();
+        formData.append('body', JSON.stringify(body));
+        for (const key of filePropertyKeys) {
+            if (EntityUtilities.getPropertyMetadata(entity, key, DecoratorTypes.FILE_DEFAULT).multiple) {
+                const fileDataValues = body[key];
+                for (const value of fileDataValues) {
+                    formData.append(key, (await FileUtilities.getFileData(value, this.http)).file, value.name);
+                }
+            }
+            else {
+                const fileData = body[key];
+                formData.append(key, (await FileUtilities.getFileData(fileData, this.http)).file, fileData.name);
+            }
+        }
+        const updatedEntity = await firstValueFrom(this.http.patch(`${this.baseUrl}/${id}`, formData));
+        if (!updatedEntity) {
+            // eslint-disable-next-line no-console
+            console.warn('The updated entity was not returned in the response. Applying the changes from the request body.');
+            for (const key in body) {
+                this.entities[this.entities.findIndex(e => e[this.idKey] === id)][key]
+                    = body[key];
+            }
+            this.entitiesSubject.next(this.entities);
+            return;
+        }
+        this.entities[this.entities.findIndex(e => e[this.idKey] === id)] = updatedEntity;
+        this.entitiesSubject.next(this.entities);
+    }
+    /**
+     * Updates the entity with a normal json body in contrast to updating it with form data when the entity contains files.
+     *
+     * @param body - The body of the Request. Has already removed all unnecessary values.
+     * @param id - The id of the entity to update.
+     */
+    async updateWithJson(body, id) {
+        const updatedEntity = await firstValueFrom(this.http.patch(`${this.baseUrl}/${id}`, LodashUtilities.omitBy(body, LodashUtilities.isNil)));
+        if (!updatedEntity) {
+            // eslint-disable-next-line no-console
+            console.warn('The updated entity was not returned in the response. Applying the changes from the request body.');
+            const foundEntity = this.entities[this.entities.findIndex(e => e[this.idKey] === id)];
+            for (const key in body) {
+                foundEntity[key]
+                    = body[key];
+            }
+            this.entitiesSubject.next(this.entities);
+            return;
+        }
+        this.entities[this.entities.findIndex(e => e[this.idKey] === id)] = updatedEntity;
+        this.entitiesSubject.next(this.entities);
+    }
+    /**
+     * Deletes a specific Entity.
+     *
+     * @param entity - The entity to delete.
+     */
+    async delete(entity) {
+        await firstValueFrom(this.http.delete(`${this.baseUrl}/${entity[this.idKey]}`));
+        // the == comparison instead of === is to catch ids that are numbers.
+        this.entities.splice(this.entities.findIndex(e => e[this.idKey] === entity[this.idKey]), 1);
+        this.entitiesSubject.next(this.entities);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity.service.js","sourceRoot":"","sources":["../../../../projects/ngx-material-entity/src/services/entity.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAEvD,OAAO,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,OAAgB,aAAa;IAuDA;IAxC/B;;OAEG;IACM,aAAa,GAAW,UAAU,CAAC;IAE5C;;;;OAIG;IACM,KAAK,GAAqB,IAAwB,CAAC;IAE5D;;;OAGG;IACM,eAAe,GAAkC,IAAI,eAAe,CAAe,EAAE,CAAC,CAAC;IAGhG;;;;;;;OAOG;IACgB,qBAAqB,GAAW,MAAM,CAAC;IAE1D;;;;OAIG;IACH,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC;IACtC,CAAC;IAED,QAAQ,CAAQ;IAEhB,YAA+B,IAAgB;QAAhB,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAEnD;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,CAAC,MAAkB,EAAE,UAAkB,IAAI,CAAC,OAAO;QAC3D,MAAM,IAAI,GAAwB,eAAe,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC;QACrF,MAAM,gBAAgB,GAAyB,eAAe,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;QACzF,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE;YAC1B,OAAO,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;SACnD;aACI;YACD,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;SACjF;IACL,CAAC;IAED,0CAA0C;IAC1C,0BAA0B;IAC1B;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,IAAU;QACnB,MAAM,QAAQ,GAAa,IAAI,QAAQ,EAAE,CAAC;QAC1C,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAChC,MAAM,MAAM,GAAiB,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAe,GAAG,IAAI,CAAC,OAAO,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;QACpH,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;QAC9B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACzC,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,0CAA0C;IAC1C,0BAA0B;IAC1B;;;;;;;;;;;OAWG;IACO,KAAK,CAAC,kBAAkB,CAC9B,IAAyB,EACzB,gBAAsC,EACtC,MAAkB,EAClB,UAAkB,IAAI,CAAC,OAAO;QAE9B,MAAM,QAAQ,GAAa,IAAI,QAAQ,EAAE,CAAC;QAC1C,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;QACtF,KAAK,MAAM,GAAG,IAAI,gBAAgB,EAAE;YAChC,IAAI,eAAe,CAAC,mBAAmB,CAAC,MAAM,EAAE,GAAG,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE;gBACxF,MAAM,cAAc,GAAe,IAAI,CAAC,GAAG,CAAe,CAAC;gBAC3D,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE;oBAChC,QAAQ,CAAC,MAAM,CAAC,GAAa,EAAE,CAAC,MAAM,aAAa,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;iBACxG;aACJ;iBACI;gBACD,MAAM,QAAQ,GAAa,IAAI,CAAC,GAAG,CAAa,CAAC;gBACjD,QAAQ,CAAC,MAAM,CAAC,GAAa,EAAE,CAAC,MAAM,aAAa,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;aAC9G;SACJ;QACD,MAAM,CAAC,GAA2B,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAyB,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;QAClH,IAAI,CAAC,CAAC,EAAE;YACJ,MAAM,IAAI,KAAK,CAAC;;;;aAIf,CAAC,CAAC;SACN;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACzC,OAAO,CAAC,CAAC;IACb,CAAC;IAED;;;;;;;OAOG;IACO,KAAK,CAAC,cAAc,CAAC,IAAyB,EAAE,UAAkB,IAAI,CAAC,OAAO;QACpF,MAAM,CAAC,GAA2B,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAyB,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC;QAC9G,IAAI,CAAC,CAAC,EAAE;YACJ,MAAM,IAAI,KAAK,CAAC;;;;aAIf,CAAC,CAAC;SACN;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACzC,OAAO,CAAC,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO;QAC7B,MAAM,CAAC,GAAiB,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAe,OAAO,CAAC,CAAC,CAAC;QACnF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,IAAI,IAAI,EAAE,CAAC;QAC3B,OAAO,CAAC,CAAC;IACb,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAgC;QAC3C,IACI,IAAI,CAAC,QAAQ,IAAI,IAAI;eAClB,CAAC,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,qBAAqB,EAClF;YACE,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAa,GAAG,IAAI,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;SAC7E;QACD,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAa,GAAG,IAAI,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC;IAC/H,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,MAAM,CAAC,MAAkB,EAAE,kBAA8B;QAC3D,MAAM,gBAAgB,GAAyB,eAAe,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;QACrG,MAAM,IAAI,GAAwB,MAAM,IAAI,CAAC,yBAAyB,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;QACnG,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE;YAC1B,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SACnE;aACI;YACD,MAAM,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;SACjG;IACL,CAAC;IAED;;;;;;OAMG;IACO,KAAK,CAAC,yBAAyB,CAAC,MAAkB,EAAE,kBAA8B;QACxF,MAAM,IAAI,GAAwB,MAAM,eAAe,CAAC,0BAA0B,CAAC,MAAM,EAAE,kBAAkB,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1H,OAAO,eAAe,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAED,0CAA0C;IAC1C,0BAA0B;IAC1B;;;;;;;;;OASG;IACO,KAAK,CAAC,kBAAkB,CAC9B,IAAyB,EACzB,gBAAsC,EACtC,MAAkB,EAClB,EAAgC;QAEhC,MAAM,QAAQ,GAAa,IAAI,QAAQ,EAAE,CAAC;QAC1C,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9C,KAAK,MAAM,GAAG,IAAI,gBAAgB,EAAE;YAChC,IAAI,eAAe,CAAC,mBAAmB,CAAC,MAAM,EAAE,GAAG,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC,QAAQ,EAAE;gBACxF,MAAM,cAAc,GAAe,IAAI,CAAC,GAAG,CAAe,CAAC;gBAC3D,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE;oBAChC,QAAQ,CAAC,MAAM,CAAC,GAAa,EAAE,CAAC,MAAM,aAAa,CAAC,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;iBACxG;aACJ;iBACI;gBACD,MAAM,QAAQ,GAAa,IAAI,CAAC,GAAG,CAAa,CAAC;gBACjD,QAAQ,CAAC,MAAM,CAAC,GAAa,EAAE,CAAC,MAAM,aAAa,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;aAC9G;SACJ;QACD,MAAM,aAAa,GAA2B,MAAM,cAAc,CAC9D,IAAI,CAAC,IAAI,CAAC,KAAK,CAAyB,GAAG,IAAI,CAAC,OAAO,IAAI,EAAE,EAAE,EAAE,QAAQ,CAAC,CAC7E,CAAC;QACF,IAAI,CAAC,aAAa,EAAE;YAChB,sCAAsC;YACtC,OAAO,CAAC,IAAI,CAAC,kGAAkG,CAAC,CAAC;YACjH,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;gBACpB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;sBAChE,IAAI,CAAC,GAAG,CAAkD,CAAC;aACpE;YACD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACzC,OAAO;SACV;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC;QAClF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;OAKG;IACO,KAAK,CAAC,cAAc,CAAC,IAAyB,EAAE,EAAgC;QACtF,MAAM,aAAa,GAA2B,MAAM,cAAc,CAC9D,IAAI,CAAC,IAAI,CAAC,KAAK,CACX,GAAG,IAAI,CAAC,OAAO,IAAI,EAAE,EAAE,EACvB,eAAe,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,CACtD,CACJ,CAAC;QACF,IAAI,CAAC,aAAa,EAAE;YAChB,sCAAsC;YACtC,OAAO,CAAC,IAAI,CAAC,kGAAkG,CAAC,CAAC;YACjH,MAAM,WAAW,GAAe,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAClG,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;gBACpB,WAAW,CAAC,GAAG,CAAC;sBACV,IAAI,CAAC,GAAG,CAAkD,CAAC;aACpE;YACD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACzC,OAAO;SACV;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,GAAG,aAAa,CAAC;QAClF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,CAAC,MAAkB;QAC3B,MAAM,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAO,GAAG,IAAI,CAAC,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;QACtF,qEAAqE;QACrE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5F,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7C,CAAC;CACJ","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { BehaviorSubject, firstValueFrom } from 'rxjs';\nimport { BaseEntityType } from '../classes/entity.model';\nimport { DecoratorTypes } from '../decorators/base/decorator-types.enum';\nimport { FileData } from '../decorators/file/file-decorator.data';\nimport { LodashUtilities } from '../encapsulation/lodash.utilities';\nimport { EntityUtilities } from '../utilities/entity.utilities';\nimport { FileUtilities } from '../utilities/file.utilities';\n\n/**\n * A generic EntityService class.\n * Offers basic CRUD-functionality.\n * You should create a service for every Entity you have.\n * If you extend from this you need to make sure that the extended Service can be injected.\n */\nexport abstract class EntityService<EntityType extends BaseEntityType<EntityType>> {\n    /**\n     * The base url used for api requests. If u want to have more control over this,\n     * you can override the create, read, update and delete methods.\n     *\n     * Create Sends a POST-Request to baseUrl.\n     *\n     * Read Sends a GET-Request to baseUrl.\n     *\n     * Update Sends a PATCH-Request to baseUrl/{id}.\n     *\n     * Delete Sends a DEL-Request to baseUrl/{id}.\n     */\n    abstract readonly baseUrl: string;\n\n    /**\n     * The route segment that comes before the id when editing an entity in a separate page.\n     */\n    readonly editBaseRoute: string = 'entities';\n\n    /**\n     * The key which holds the id value.\n     *\n     * @default 'id'\n     */\n    readonly idKey: keyof EntityType = 'id' as keyof EntityType;\n\n    /**\n     * A subject of all the entity values.\n     * Can be subscribed to when you want to do a specific thing whenever the entities change.\n     */\n    readonly entitiesSubject: BehaviorSubject<EntityType[]> = new BehaviorSubject<EntityType[]>([]);\n\n\n    /**\n     * When frequently trying to find a single entity by an id (eg. When nesting relations)\n     * you might send a lot of unnecessary requests.\n     * Therefore the findById method tries to look in the already existing entities first,\n     * IF the entities have been requested in the last READ_EXPIRATION_IN_MS milliseconds.\n     *\n     * @default 900000 (5 minutes)\n     */\n    protected readonly READ_EXPIRATION_IN_MS: number = 900000;\n\n    /**\n     * Gets the entities in an array from the internal entitiesSubject.\n     *\n     * @returns The current entities in form of an array.\n     */\n    get entities(): EntityType[] {\n        return this.entitiesSubject.value;\n    }\n\n    lastRead?: Date;\n\n    constructor(protected readonly http: HttpClient) {}\n\n    /**\n     * Creates a new Entity and pushes it to the entities array.\n     *\n     * @param entity - The data of the entity to create.\n     * All values that should be omitted will be removed from it inside this method.\n     * @param baseUrl - The base url to send the post request to.\n     * This can be used if you want to create an entity belonging to another, like \"customers/{id}/invoices\".\n     * @returns A Promise of the created entity.\n     */\n    async create(entity: EntityType, baseUrl: string = this.baseUrl): Promise<EntityType> {\n        const body: Partial<EntityType> = EntityUtilities.getWithoutOmitCreateValues(entity);\n        const filePropertyKeys: (keyof EntityType)[] = EntityUtilities.getFileProperties(entity);\n        if (!filePropertyKeys.length) {\n            return await this.createWithJson(body, baseUrl);\n        }\n        else {\n            return await this.createWithFormData(body, filePropertyKeys, entity, baseUrl);\n        }\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Imports everything from the provided json file.\n     *\n     * @param file - The json file to import from.\n     * @returns All entities that have been imported.\n     */\n    async import(file: File): Promise<EntityType[]> {\n        const formData: FormData = new FormData();\n        formData.append('import', file);\n        const result: EntityType[] = await firstValueFrom(this.http.post<EntityType[]>(`${this.baseUrl}/import`, formData));\n        this.entities.push(...result);\n        this.entitiesSubject.next(this.entities);\n        return result;\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Creates the entity with form data when the entity contains files in contrast to creating it with a normal json body.\n     * All file values are stored inside their respective property key and their name.\n     * Form data is able to handle setting multiple files to the same key.\n     *\n     * @param body - The body Of the request.\n     * @param filePropertyKeys - All property keys that are files and need to be added to the form data.\n     * @param entity - The entity to create. This is needed in addition to the body because the body doesn't contain any metadata.\n     * @param baseUrl - The base url to send the post request to.\n     * This can be used if you want to create an entity belonging to another, like \"customers/{id}/invoices\".\n     * @returns The created entity from the server.\n     */\n    protected async createWithFormData(\n        body: Partial<EntityType>,\n        filePropertyKeys: (keyof EntityType)[],\n        entity: EntityType,\n        baseUrl: string = this.baseUrl\n    ): Promise<EntityType> {\n        const formData: FormData = new FormData();\n        formData.append('body', JSON.stringify(LodashUtilities.omit(body, filePropertyKeys)));\n        for (const key of filePropertyKeys) {\n            if (EntityUtilities.getPropertyMetadata(entity, key, DecoratorTypes.FILE_DEFAULT).multiple) {\n                const fileDataValues: FileData[] = body[key] as FileData[];\n                for (const value of fileDataValues) {\n                    formData.append(key as string, (await FileUtilities.getFileData(value, this.http)).file, value.name);\n                }\n            }\n            else {\n                const fileData: FileData = body[key] as FileData;\n                formData.append(key as string, (await FileUtilities.getFileData(fileData, this.http)).file, fileData.name);\n            }\n        }\n        const e: EntityType | undefined = await firstValueFrom(this.http.post<EntityType | undefined>(baseUrl, formData));\n        if (!e) {\n            throw new Error(`\n                The created entity was not returned in the response.\n                If you want to provide a logic that allows that\n                you need to override the create methods of this class.\n            `);\n        }\n        this.entities.push(e);\n        this.entitiesSubject.next(this.entities);\n        return e;\n    }\n\n    /**\n     * Creates the entity with a normal json body in contrast to creating it with form data when the entity contains files.\n     *\n     * @param body - The body Of the request.\n     * @param baseUrl - The base url to send the post request to.\n     * This can be used if you want to create an entity belonging to another, like \"customers/{id}/invoices\".\n     * @returns The created entity from the server.\n     */\n    protected async createWithJson(body: Partial<EntityType>, baseUrl: string = this.baseUrl): Promise<EntityType> {\n        const e: EntityType | undefined = await firstValueFrom(this.http.post<EntityType | undefined>(baseUrl, body));\n        if (!e) {\n            throw new Error(`\n                The created entity was not returned in the response.\n                If you want to provide a logic that allows that\n                you need to override the create methods of this class.\n            `);\n        }\n        this.entities.push(e);\n        this.entitiesSubject.next(this.entities);\n        return e;\n    }\n\n    /**\n     * Gets all existing entities and pushes them to the entities array.\n     *\n     * @param baseUrl - The base url for the request. Defaults to the baseUrl on the service.\n     * @returns A Promise of all received Entities.\n     */\n    async read(baseUrl = this.baseUrl): Promise<EntityType[]> {\n        const e: EntityType[] = await firstValueFrom(this.http.get<EntityType[]>(baseUrl));\n        this.entitiesSubject.next(e);\n        this.lastRead = new Date();\n        return e;\n    }\n\n    /**\n     * Tries to find an entity with the given id.\n     *\n     * @param id - The id of the entity to find.\n     * @returns The found entity.\n     */\n    async findById(id: EntityType[keyof EntityType]): Promise<EntityType> {\n        if (\n            this.lastRead == null\n            || (new Date().getTime() - this.lastRead.getTime()) > this.READ_EXPIRATION_IN_MS\n        ) {\n            return firstValueFrom(this.http.get<EntityType>(`${this.baseUrl}/${id}`));\n        }\n        return this.entities.find(e => e[this.idKey] === id) ?? firstValueFrom(this.http.get<EntityType>(`${this.baseUrl}/${id}`));\n    }\n\n    /**\n     * Updates a specific Entity.\n     *\n     * @param entity - The updated Entity\n     * All values that should be omitted will be removed from it inside this method.\n     * @param entityPriorChanges - The current Entity.\n     * It Is used to get changed values and only update them instead of sending the whole entity data.\n     */\n    async update(entity: EntityType, entityPriorChanges: EntityType): Promise<void> {\n        const filePropertyKeys: (keyof EntityType)[] = EntityUtilities.getFileProperties(entityPriorChanges);\n        const body: Partial<EntityType> = await this.entityToUpdateRequestBody(entity, entityPriorChanges);\n        if (!filePropertyKeys.length) {\n            await this.updateWithJson(body, entityPriorChanges[this.idKey]);\n        }\n        else {\n            await this.updateWithFormData(body, filePropertyKeys, entity, entityPriorChanges[this.idKey]);\n        }\n    }\n\n    /**\n     * Builds the update request body from the given entity before and after its changes.\n     *\n     * @param entity - The entity with changed values.\n     * @param entityPriorChanges - The entity before any changes.\n     * @returns A partial of only the changed values.\n     */\n    protected async entityToUpdateRequestBody(entity: EntityType, entityPriorChanges: EntityType): Promise<Partial<EntityType>> {\n        const body: Partial<EntityType> = await EntityUtilities.getWithoutOmitUpdateValues(entity, entityPriorChanges, this.http);\n        return LodashUtilities.omitBy(body, LodashUtilities.isNil);\n    }\n\n    // TODO: Find a way to use blobs with jest\n    /* istanbul ignore next */\n    /**\n     * Updates the entity with form data when the entity contains files in contrast to creating it with a normal json body.\n     * All file values are stored inside their respective property key and their name.\n     * Form data is able to handle setting multiple files to the same key.\n     *\n     * @param body - The request body. Already contains only properties that have changed.\n     * @param filePropertyKeys - The keys of all properties which are files and need to separately be appended to the form data.\n     * @param entity - The original entity. Is needed to get the metadata of all the files.\n     * @param id - The id of the entity to update.\n     */\n    protected async updateWithFormData(\n        body: Partial<EntityType>,\n        filePropertyKeys: (keyof EntityType)[],\n        entity: EntityType,\n        id: EntityType[keyof EntityType]\n    ): Promise<void> {\n        const formData: FormData = new FormData();\n        formData.append('body', JSON.stringify(body));\n        for (const key of filePropertyKeys) {\n            if (EntityUtilities.getPropertyMetadata(entity, key, DecoratorTypes.FILE_DEFAULT).multiple) {\n                const fileDataValues: FileData[] = body[key] as FileData[];\n                for (const value of fileDataValues) {\n                    formData.append(key as string, (await FileUtilities.getFileData(value, this.http)).file, value.name);\n                }\n            }\n            else {\n                const fileData: FileData = body[key] as FileData;\n                formData.append(key as string, (await FileUtilities.getFileData(fileData, this.http)).file, fileData.name);\n            }\n        }\n        const updatedEntity: EntityType | undefined = await firstValueFrom(\n            this.http.patch<EntityType | undefined>(`${this.baseUrl}/${id}`, formData)\n        );\n        if (!updatedEntity) {\n            // eslint-disable-next-line no-console\n            console.warn('The updated entity was not returned in the response. Applying the changes from the request body.');\n            for (const key in body) {\n                this.entities[this.entities.findIndex(e => e[this.idKey] === id)][key]\n                    = body[key] as EntityType[Extract<keyof EntityType, string>];\n            }\n            this.entitiesSubject.next(this.entities);\n            return;\n        }\n        this.entities[this.entities.findIndex(e => e[this.idKey] === id)] = updatedEntity;\n        this.entitiesSubject.next(this.entities);\n    }\n\n    /**\n     * Updates the entity with a normal json body in contrast to updating it with form data when the entity contains files.\n     *\n     * @param body - The body of the Request. Has already removed all unnecessary values.\n     * @param id - The id of the entity to update.\n     */\n    protected async updateWithJson(body: Partial<EntityType>, id: EntityType[keyof EntityType]): Promise<void> {\n        const updatedEntity: EntityType | undefined = await firstValueFrom(\n            this.http.patch<EntityType | undefined>(\n                `${this.baseUrl}/${id}`,\n                LodashUtilities.omitBy(body, LodashUtilities.isNil)\n            )\n        );\n        if (!updatedEntity) {\n            // eslint-disable-next-line no-console\n            console.warn('The updated entity was not returned in the response. Applying the changes from the request body.');\n            const foundEntity: EntityType = this.entities[this.entities.findIndex(e => e[this.idKey] === id)];\n            for (const key in body) {\n                foundEntity[key]\n                    = body[key] as EntityType[Extract<keyof EntityType, string>];\n            }\n            this.entitiesSubject.next(this.entities);\n            return;\n        }\n        this.entities[this.entities.findIndex(e => e[this.idKey] === id)] = updatedEntity;\n        this.entitiesSubject.next(this.entities);\n    }\n\n    /**\n     * Deletes a specific Entity.\n     *\n     * @param entity - The entity to delete.\n     */\n    async delete(entity: EntityType): Promise<void> {\n        await firstValueFrom(this.http.delete<void>(`${this.baseUrl}/${entity[this.idKey]}`));\n        // the == comparison instead of === is to catch ids that are numbers.\n        this.entities.splice(this.entities.findIndex(e => e[this.idKey] === entity[this.idKey]), 1);\n        this.entitiesSubject.next(this.entities);\n    }\n}"]}