ngx-material-entity 0.1.2 → 0.1.5

package/esm2020/classes/entity.service.mjs

@@ -0,0 +1,180 @@
+import { BehaviorSubject, firstValueFrom } from 'rxjs';
+import { EntityUtilities } from './entity.utilities';
+import { LodashUtilities } from '../capsulation/lodash.utilities';
+import { DecoratorTypes } from '../decorators/base/decorator-types.enum';
+import { FileUtilities } from './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 {
+    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 = LodashUtilities.omit(entity, EntityUtilities.getOmitForCreate(entity));
+        const filePropertyKeys = EntityUtilities.getFileProperties(entity);
+        if (!filePropertyKeys.length) {
+            return await this.createWithJson(body);
+        }
+        else {
+            return await this.createWithFormData(body, filePropertyKeys, entity);
+        }
+    }
+    // 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.
+     * @returns The created entity from the server.
+     */
+    async createWithFormData(body, filePropertyKeys, entity) {
+        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)).file, value.name);
+                }
+            }
+            else {
+                const fileData = body[key];
+                formData.append(key, (await FileUtilities.getFileData(fileData)).file, fileData.name);
+            }
+        }
+        const e = await firstValueFrom(this.http.post(this.baseUrl, formData));
+        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.
+     * @returns The created entity from the server.
+     */
+    async createWithJson(body) {
+        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 body = LodashUtilities.omit(await EntityUtilities.difference(entity, entityPriorChanges), EntityUtilities.getOmitForUpdate(entity));
+        const filePropertyKeys = EntityUtilities.getFileProperties(entityPriorChanges);
+        if (!filePropertyKeys.length) {
+            await this.updateWithJson(body, entityPriorChanges[this.idKey]);
+        }
+        else {
+            await this.updateWithFormData(body, filePropertyKeys, entity, entityPriorChanges[this.idKey]);
+        }
+    }
+    // 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(LodashUtilities.omitBy(body, LodashUtilities.isNil)));
+        for (const key of filePropertyKeys) {
+            if (EntityUtilities.getPropertyMetadata(entity, key, DecoratorTypes.FILE_DEFAULT).multiple) {
+                // eslint-disable-next-line max-len
+                const fileDataValues = body[key];
+                for (const value of fileDataValues) {
+                    formData.append(key, (await FileUtilities.getFileData(value)).file, value.name);
+                }
+            }
+            else {
+                // eslint-disable-next-line max-len
+                const fileData = body[key];
+                formData.append(key, (await FileUtilities.getFileData(fileData)).file, fileData.name);
+            }
+        }
+        const updatedEntity = await firstValueFrom(this.http.patch(`${this.baseUrl}/${id}`, formData));
+        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)));
+        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/classes/entity.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { BehaviorSubject, firstValueFrom } from 'rxjs';\nimport { EntityUtilities } from './entity.utilities';\nimport { LodashUtilities } from '../capsulation/lodash.utilities';\nimport { DecoratorTypes } from '../decorators/base/decorator-types.enum';\nimport { FileData } from '../decorators/file/file-decorator.data';\nimport { FileUtilities } from './file.utilities';\nimport { BaseEntityType } from './entity.model';\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     * 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: Partial<EntityType> = LodashUtilities.omit(entity, EntityUtilities.getOmitForCreate(entity)) as Partial<EntityType>;\n        const filePropertyKeys: (keyof EntityType)[] = EntityUtilities.getFileProperties(entity);\n        if (!filePropertyKeys.length) {\n            return await this.createWithJson(body);\n        }\n        else {\n            return await this.createWithFormData(body, filePropertyKeys, entity);\n        }\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     * @returns The created entity from the server.\n     */\n    protected async createWithFormData(\n        body: Partial<EntityType>,\n        filePropertyKeys: (keyof EntityType)[],\n        entity: EntityType\n    ): Promise<EntityType> {\n        const 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)).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)).file, fileData.name);\n            }\n        }\n        const e = await firstValueFrom(this.http.post<EntityType>(this.baseUrl, formData));\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     * @returns The created entity from the server.\n     */\n    protected async createWithJson(body: Partial<EntityType>): Promise<EntityType> {\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 body: Partial<EntityType> = LodashUtilities.omit(\n            await EntityUtilities.difference(entity, entityPriorChanges),\n            EntityUtilities.getOmitForUpdate(entity)\n        ) as unknown as Partial<EntityType>;\n        const filePropertyKeys = EntityUtilities.getFileProperties(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    // 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 = new FormData();\n        formData.append('body', JSON.stringify(LodashUtilities.omitBy(body, LodashUtilities.isNil)));\n        for (const key of filePropertyKeys) {\n            if (EntityUtilities.getPropertyMetadata(entity, key, DecoratorTypes.FILE_DEFAULT).multiple) {\n                // eslint-disable-next-line max-len\n                const fileDataValues = body[key] as FileData[];\n                for (const value of fileDataValues) {\n                    formData.append(key as string, (await FileUtilities.getFileData(value)).file, value.name);\n                }\n            }\n            else {\n                // eslint-disable-next-line max-len\n                const fileData = body[key] as FileData;\n                formData.append(key as string, (await FileUtilities.getFileData(fileData)).file, fileData.name);\n            }\n        }\n        const updatedEntity = await firstValueFrom(\n            this.http.patch<EntityType>(`${this.baseUrl}/${id}`, formData)\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 = await firstValueFrom(\n            this.http.patch<EntityType>(\n                `${this.baseUrl}/${id}`,\n                LodashUtilities.omitBy(body, LodashUtilities.isNil)\n            )\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}"]}