ngx-material-entity 0.1.3 → 0.1.4

package/esm2020/classes/date.utilities.mjs

@@ -0,0 +1,138 @@
+import { cloneDeep } from 'lodash';
+const DAY_IN_MS = 1000 * 60 * 60 * 24;
+/**
+ * Contains Helper Functions for handling date properties.
+ */
+export class DateUtilities {
+    /**
+     * Gets the given value as a date value.
+     *
+     * @param value - The value to get as a date.
+     * @returns The given value as a date.
+     */
+    static asDate(value) {
+        return value;
+    }
+    /**
+     * Gets the default times used by the DateTime picker when nothing is specified by the user.
+     *
+     * @param format - The time format. Defaults to 24.
+     * @param minuteSteps - The steps from one time value to the next. Defaults to 30.
+     * @returns Times in the 24 hour format from 0:00 until 23:30 in 30 minute steps.
+     */
+    static getDefaultTimes(format = 24, minuteSteps = 30) {
+        const res = [{ displayName: '-', value: undefined }];
+        for (let hour = 0; hour < 24; hour++) {
+            for (let minute = 0; minute < 60; minute += minuteSteps) {
+                res.push(this.getTimeDropdownValue(format, hour, minute));
+            }
+        }
+        return res;
+    }
+    static getTimeDropdownValue(format, hour, minute) {
+        const displayHour = this.getFormattedHour(format, cloneDeep(hour));
+        const displayMinute = this.getFormattedMinute(format, hour, minute);
+        return {
+            displayName: `${displayHour}:${displayMinute}`,
+            value: {
+                hours: hour,
+                minutes: minute
+            }
+        };
+    }
+    static getFormattedHour(format, hour) {
+        if (format === 12 && hour > 12) {
+            hour -= 12;
+        }
+        return hour;
+    }
+    static getFormattedMinute(format, hour, minute) {
+        let res = `${minute}`;
+        if (format === 12) {
+            if (hour > 12) {
+                res = `${minute} PM`;
+            }
+            else {
+                res = `${minute} AM`;
+            }
+        }
+        if (minute.toString().length === 1) {
+            res = '0'.concat(res);
+        }
+        return res;
+    }
+    /**
+     * Gets the Time object from the given date.
+     *
+     * @param value - The date to get the time object from.
+     * @returns The Time object build from the date value.
+     */
+    static getTimeFromDate(value) {
+        if (!value) {
+            return {
+                hours: undefined,
+                minutes: undefined
+            };
+        }
+        else {
+            return {
+                hours: new Date(value).getHours(),
+                minutes: new Date(value).getMinutes()
+            };
+        }
+    }
+    /**
+     * Gets the dates between the two given gates. Does additional filtering based on the provided DateRange metadata.
+     *
+     * @param startDate - The start date.
+     * @param endDate - The end date.
+     * @param metadataDateRangeDate - The metadata.
+     * @returns All dates between the two provided dates. Includes start and end date.
+     */
+    static getDatesBetween(startDate, endDate, metadataDateRangeDate) {
+        const res = [];
+        while (startDate.getFullYear() < endDate.getFullYear()
+            || startDate.getMonth() < endDate.getMonth()
+            || startDate.getDate() <= endDate.getDate()) {
+            res.push(new Date(startDate));
+            startDate.setTime(startDate.getTime() + DAY_IN_MS);
+        }
+        if (metadataDateRangeDate.filter) {
+            return res.filter(d => metadataDateRangeDate.filter?.(d));
+        }
+        else {
+            return res;
+        }
+    }
+    /**
+     * Get all valid times for the dropdown of a datetime property.
+     *
+     * @param date - The date of the datetime.
+     * @param times - All given times to filter.
+     * @param min - The function that defines the minimum time.
+     * @param max - The function that defines the maximum time.
+     * @param filter - A filter function to do more specific time filtering. This could be e.g. The removal of lunch breaks.
+     * @returns All valid dropdown values for the datetime property.
+     */
+    static getValidTimesForDropdown(date, times, min, max, filter) {
+        if (min) {
+            const minTime = min(date);
+            times = times.filter(t => !t.value
+                || t.value.hours > minTime.hours
+                || (t.value.hours === minTime.hours
+                    && t.value.minutes >= minTime.minutes));
+        }
+        if (max) {
+            const maxTime = max(date);
+            times = times.filter(t => !t.value
+                || t.value.hours < maxTime.hours
+                || (t.value.hours === maxTime.hours
+                    && t.value.minutes <= maxTime.minutes));
+        }
+        if (filter) {
+            times = times.filter(t => !t.value || filter(t.value));
+        }
+        return times;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date.utilities.js","sourceRoot":"","sources":["../../../../projects/ngx-material-entity/src/classes/date.utilities.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAInC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAOtC;;GAEG;AACH,MAAM,OAAgB,aAAa;IAE/B;;;;;OAKG;IACH,MAAM,CAAC,MAAM,CAAC,KAAc;QACxB,OAAO,KAAa,CAAC;IACzB,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,SAAkB,EAAE,EAAE,cAA2B,EAAE;QACtE,MAAM,GAAG,GAA0B,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,SAA4B,EAAC,CAAC,CAAC;QAC9F,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,EAAE,EAAE,IAAI,EAAE,EAAE;YAClC,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,EAAE,EAAE,MAAM,IAAI,WAAW,EAAE;gBACrD,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;aAC7D;SACJ;QACD,OAAO,GAAG,CAAC;IACf,CAAC;IAEO,MAAM,CAAC,oBAAoB,CAAC,MAAe,EAAE,IAAY,EAAE,MAAc;QAC7E,MAAM,WAAW,GAAW,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QAC3E,MAAM,aAAa,GAAW,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QAC5E,OAAO;YACH,WAAW,EAAE,GAAG,WAAW,IAAI,aAAa,EAAE;YAC9C,KAAK,EAAE;gBACH,KAAK,EAAE,IAAI;gBACX,OAAO,EAAE,MAAM;aAClB;SACJ,CAAA;IACL,CAAC;IAEO,MAAM,CAAC,gBAAgB,CAAC,MAAe,EAAE,IAAY;QACzD,IAAI,MAAM,KAAK,EAAE,IAAI,IAAI,GAAG,EAAE,EAAE;YAC5B,IAAI,IAAI,EAAE,CAAC;SACd;QACD,OAAO,IAAI,CAAC;IAChB,CAAC;IAEO,MAAM,CAAC,kBAAkB,CAAC,MAAe,EAAE,IAAY,EAAE,MAAc;QAC3E,IAAI,GAAG,GAAG,GAAG,MAAM,EAAE,CAAC;QACtB,IAAI,MAAM,KAAK,EAAE,EAAE;YACf,IAAI,IAAI,GAAG,EAAE,EAAE;gBACX,GAAG,GAAG,GAAG,MAAM,KAAK,CAAC;aACxB;iBACI;gBACD,GAAG,GAAG,GAAG,MAAM,KAAK,CAAC;aACxB;SACJ;QACD,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;YAChC,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SACzB;QACD,OAAO,GAAG,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,KAAW;QAC9B,IAAI,CAAC,KAAK,EAAE;YACR,OAAO;gBACH,KAAK,EAAE,SAAS;gBAChB,OAAO,EAAE,SAAS;aACF,CAAC;SACxB;aACI;YACD,OAAO;gBACH,KAAK,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE;gBACjC,OAAO,EAAE,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,EAAE;aACxC,CAAC;SACL;IACL,CAAC;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,eAAe,CAClB,SAAe,EACf,OAAa,EACb,qBAA2D;QAE3D,MAAM,GAAG,GAAW,EAAE,CAAC;QACvB,OACI,SAAS,CAAC,WAAW,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE;eAC5C,SAAS,CAAC,QAAQ,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE;eACzC,SAAS,CAAC,OAAO,EAAE,IAAI,OAAO,CAAC,OAAO,EAAE,EAC7C;YACE,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;YAC9B,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,EAAE,GAAG,SAAS,CAAC,CAAC;SACtD;QACD,IAAI,qBAAqB,CAAC,MAAM,EAAE;YAC9B,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,qBAAqB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;SAC7D;aACI;YACD,OAAO,GAAG,CAAC;SACd;IACL,CAAC;IAED;;;;;;;;;OASG;IACH,MAAM,CAAC,wBAAwB,CAC3B,IAAU,EACV,KAA4B,EAC5B,GAA2B,EAC3B,GAA2B,EAC3B,MAAoD;QAEpD,IAAI,GAAG,EAAE;YACL,MAAM,OAAO,GAAS,GAAG,CAAC,IAAI,CAAC,CAAC;YAChC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CACrB,CAAC,CAAC,CAAC,KAAK;mBACL,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK;mBAC7B,CACC,CAAC,CAAC,KAAK,CAAC,KAAK,KAAK,OAAO,CAAC,KAAK;uBAC5B,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,OAAO,CAAC,OAAO,CACxC,CACJ,CAAC;SACL;QACD,IAAI,GAAG,EAAE;YACL,MAAM,OAAO,GAAS,GAAG,CAAC,IAAI,CAAC,CAAC;YAChC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CACrB,CAAC,CAAC,CAAC,KAAK;mBACL,CAAC,CAAC,KAAK,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK;mBAC7B,CACC,CAAC,CAAC,KAAK,CAAC,KAAK,KAAK,OAAO,CAAC,KAAK;uBAC5B,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,OAAO,CAAC,OAAO,CACxC,CACJ,CAAC;SACL;QACD,IAAI,MAAM,EAAE;YACR,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAA;SACzD;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ","sourcesContent":["import { Time } from '@angular/common';\nimport { cloneDeep } from 'lodash';\nimport { DropdownValue } from '../decorators/base/dropdown-value.interface';\nimport { DateRangeDateDecoratorConfigInternal } from '../decorators/date/date-decorator-internal.data';\n\nconst DAY_IN_MS = 1000 * 60 * 60 * 24;\n\n/**\n * Valid steps from one time value to the next. Needs to be able to divide 60 minutes without remainder.\n */\ntype MinuteSteps = 1 | 2 | 3 | 4 | 5 | 6 | 10 | 12 | 15 | 20 | 30 | 60;\n\n/**\n * Contains Helper Functions for handling date properties.\n */\nexport abstract class DateUtilities {\n\n    /**\n     * Gets the given value as a date value.\n     *\n     * @param value - The value to get as a date.\n     * @returns The given value as a date.\n     */\n    static asDate(value: unknown): Date {\n        return value as Date;\n    }\n\n    /**\n     * Gets the default times used by the DateTime picker when nothing is specified by the user.\n     *\n     * @param format - The time format. Defaults to 24.\n     * @param minuteSteps - The steps from one time value to the next. Defaults to 30.\n     * @returns Times in the 24 hour format from 0:00 until 23:30 in 30 minute steps.\n     */\n    static getDefaultTimes(format: 12 | 24 = 24, minuteSteps: MinuteSteps = 30): DropdownValue<Time>[] {\n        const res: DropdownValue<Time>[] = [{ displayName: '-', value: undefined as unknown as Time}];\n        for (let hour = 0; hour < 24; hour++) {\n            for (let minute = 0; minute < 60; minute += minuteSteps) {\n                res.push(this.getTimeDropdownValue(format, hour, minute));\n            }\n        }\n        return res;\n    }\n\n    private static getTimeDropdownValue(format: 12 | 24, hour: number, minute: number): DropdownValue<Time> {\n        const displayHour: number = this.getFormattedHour(format, cloneDeep(hour));\n        const displayMinute: string = this.getFormattedMinute(format, hour, minute);\n        return {\n            displayName: `${displayHour}:${displayMinute}`,\n            value: {\n                hours: hour,\n                minutes: minute\n            }\n        }\n    }\n\n    private static getFormattedHour(format: 12 | 24, hour: number): number {\n        if (format === 12 && hour > 12) {\n            hour -= 12;\n        }\n        return hour;\n    }\n\n    private static getFormattedMinute(format: 12 | 24, hour: number, minute: number): string {\n        let res = `${minute}`;\n        if (format === 12) {\n            if (hour > 12) {\n                res = `${minute} PM`;\n            }\n            else {\n                res = `${minute} AM`;\n            }\n        }\n        if (minute.toString().length === 1) {\n            res = '0'.concat(res);\n        }\n        return res;\n    }\n\n    /**\n     * Gets the Time object from the given date.\n     *\n     * @param value - The date to get the time object from.\n     * @returns The Time object build from the date value.\n     */\n    static getTimeFromDate(value: Date): Time {\n        if (!value) {\n            return {\n                hours: undefined,\n                minutes: undefined\n            } as unknown as Time;\n        }\n        else {\n            return {\n                hours: new Date(value).getHours(),\n                minutes: new Date(value).getMinutes()\n            };\n        }\n    }\n\n    /**\n     * Gets the dates between the two given gates. Does additional filtering based on the provided DateRange metadata.\n     *\n     * @param startDate - The start date.\n     * @param endDate - The end date.\n     * @param metadataDateRangeDate - The metadata.\n     * @returns All dates between the two provided dates. Includes start and end date.\n     */\n    static getDatesBetween(\n        startDate: Date,\n        endDate: Date,\n        metadataDateRangeDate: DateRangeDateDecoratorConfigInternal\n    ): Date[] {\n        const res: Date[] = [];\n        while (\n            startDate.getFullYear() < endDate.getFullYear()\n            || startDate.getMonth() < endDate.getMonth()\n            || startDate.getDate() <= endDate.getDate()\n        ) {\n            res.push(new Date(startDate));\n            startDate.setTime(startDate.getTime() + DAY_IN_MS);\n        }\n        if (metadataDateRangeDate.filter) {\n            return res.filter(d => metadataDateRangeDate.filter?.(d));\n        }\n        else {\n            return res;\n        }\n    }\n\n    /**\n     * Get all valid times for the dropdown of a datetime property.\n     *\n     * @param date - The date of the datetime.\n     * @param times - All given times to filter.\n     * @param min - The function that defines the minimum time.\n     * @param max - The function that defines the maximum time.\n     * @param filter - A filter function to do more specific time filtering. This could be e.g. The removal of lunch breaks.\n     * @returns All valid dropdown values for the datetime property.\n     */\n    static getValidTimesForDropdown(\n        date: Date,\n        times: DropdownValue<Time>[],\n        min?: (date?: Date) => Time,\n        max?: (date?: Date) => Time,\n        filter?: ((time: Time) => boolean) | (() => boolean)\n    ): DropdownValue<Time>[] {\n        if (min) {\n            const minTime: Time = min(date);\n            times = times.filter(t =>\n                !t.value\n                || t.value.hours > minTime.hours\n                || (\n                    t.value.hours === minTime.hours\n                    && t.value.minutes >= minTime.minutes\n                )\n            );\n        }\n        if (max) {\n            const maxTime: Time = max(date);\n            times = times.filter(t =>\n                !t.value\n                || t.value.hours < maxTime.hours\n                || (\n                    t.value.hours === maxTime.hours\n                    && t.value.minutes <= maxTime.minutes\n                )\n            );\n        }\n        if (filter) {\n            times = times.filter(t => !t.value || filter(t.value))\n        }\n\n        return times;\n    }\n}"]}

package/esm2020/classes/entity.model.mjs

@@ -0,0 +1,19 @@
+import { __decorate, __metadata } from "tslib";
+import { string } from '../decorators/string/string.decorator';
+/**
+ * A base Entity class with a builtin id.
+ */
+export class Entity {
+}
+__decorate([
+    string({
+        omitForCreate: true,
+        omitForUpdate: true,
+        display: false,
+        displayStyle: 'line',
+        displayName: 'ID',
+        required: true
+    }),
+    __metadata("design:type", String)
+], Entity.prototype, "id", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW50aXR5Lm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LW1hdGVyaWFsLWVudGl0eS9zcmMvY2xhc3Nlcy9lbnRpdHkubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQztBQU8vRDs7R0FFRztBQUNILE1BQU0sT0FBZ0IsTUFBTTtDQWEzQjtBQURHO0lBUkMsTUFBTSxDQUFDO1FBQ0osYUFBYSxFQUFFLElBQUk7UUFDbkIsYUFBYSxFQUFFLElBQUk7UUFDbkIsT0FBTyxFQUFFLEtBQUs7UUFDZCxZQUFZLEVBQUUsTUFBTTtRQUNwQixXQUFXLEVBQUUsSUFBSTtRQUNqQixRQUFRLEVBQUUsSUFBSTtLQUNqQixDQUFDOztrQ0FDVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IHN0cmluZyB9IGZyb20gJy4uL2RlY29yYXRvcnMvc3RyaW5nL3N0cmluZy5kZWNvcmF0b3InO1xuXG4vKipcbiAqIFRoZSBuZXdhYmxlIHR5cGUgdXNlZCB3aGVuZXZlciBhbiBlbnRpdHkgY2xhc3MgaXMgcGFzc2VkIHRvIGNyZWF0ZSBhbiBlbnRpdHkgYW5kIGluaXRpYWxpemUgaXRzIG1ldGFkYXRhLlxuICovXG5leHBvcnQgdHlwZSBFbnRpdHlDbGFzc05ld2FibGU8RW50aXR5VHlwZSBleHRlbmRzIG9iamVjdD4gPSBuZXcoZGF0YT86IEVudGl0eVR5cGUpID0+IEVudGl0eVR5cGU7XG5cbi8qKlxuICogQSBiYXNlIEVudGl0eSBjbGFzcyB3aXRoIGEgYnVpbHRpbiBpZC5cbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIEVudGl0eSB7XG4gICAgLyoqXG4gICAgICogQSB1bmlxdWUgaWRlbnRpZmllciBmb3IgdGhlIEVudGl0eS5cbiAgICAgKi9cbiAgICBAc3RyaW5nKHtcbiAgICAgICAgb21pdEZvckNyZWF0ZTogdHJ1ZSxcbiAgICAgICAgb21pdEZvclVwZGF0ZTogdHJ1ZSxcbiAgICAgICAgZGlzcGxheTogZmFsc2UsXG4gICAgICAgIGRpc3BsYXlTdHlsZTogJ2xpbmUnLFxuICAgICAgICBkaXNwbGF5TmFtZTogJ0lEJyxcbiAgICAgICAgcmVxdWlyZWQ6IHRydWVcbiAgICB9KVxuICAgIGlkITogc3RyaW5nO1xufSJdfQ==

package/esm2020/classes/entity.service.mjs

@@ -0,0 +1,83 @@
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { isNil, omit, omitBy } from 'lodash';
+import { EntityUtilities } from './entity.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 {
+    constructor(http) {
+        this.http = http;
+        /**
+         * The key which holds the id value.
+         *
+         * @default 'id'
+         */
+        this.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.
+         */
+        this.entitiesSubject = new BehaviorSubject([]);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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.
+     * @returns A Promise of the created entity.
+     */
+    async create(entity) {
+        const body = omit(entity, EntityUtilities.getOmitForCreate(entity));
+        const e = await firstValueFrom(this.http.post(this.baseUrl, body));
+        this.entities.push(e);
+        this.entitiesSubject.next(this.entities);
+        return e;
+    }
+    /**
+     * Gets all existing entities and pushes them to the entities array.
+     *
+     * @returns A Promise of all received Entities.
+     */
+    async read() {
+        const e = await firstValueFrom(this.http.get(this.baseUrl));
+        this.entitiesSubject.next(e);
+        return e;
+    }
+    /**
+     * 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 reqBody = omit(EntityUtilities.difference(entity, entityPriorChanges), EntityUtilities.getOmitForUpdate(entity));
+        const updatedEntity = await firstValueFrom(this.http.patch(`${this.baseUrl}/${entityPriorChanges[this.idKey]}`, omitBy(reqBody, isNil)));
+        this.entities[this.entities.findIndex(e => e[this.idKey] === entityPriorChanges[this.idKey])] = 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/classes/entity.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { BehaviorSubject, firstValueFrom } from 'rxjs';\nimport { isNil, omit, omitBy } from 'lodash';\nimport { EntityUtilities } from './entity.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 object> {\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     * 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     * 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    constructor(private 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     * @returns A Promise of the created entity.\n     */\n    async create(entity: EntityType): Promise<EntityType> {\n        const body = omit(entity, EntityUtilities.getOmitForCreate(entity));\n        const e = await firstValueFrom(this.http.post<EntityType>(this.baseUrl, body));\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     * @returns A Promise of all received Entities.\n     */\n    async read(): Promise<EntityType[]> {\n        const e = await firstValueFrom(this.http.get<EntityType[]>(this.baseUrl));\n        this.entitiesSubject.next(e);\n        return e;\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 reqBody = omit(\n            EntityUtilities.difference(entity, entityPriorChanges),\n            EntityUtilities.getOmitForUpdate(entity)\n        );\n        const updatedEntity = await firstValueFrom(\n            this.http.patch<EntityType>(\n                `${this.baseUrl}/${entityPriorChanges[this.idKey]}`,\n                omitBy(reqBody, isNil)\n            )\n        );\n        this.entities[this.entities.findIndex(e => e[this.idKey] === entityPriorChanges[this.idKey])] = 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}"]}