coer-elements 0.0.31 → 0.0.33

package/esm2022/tools/lib/service.class.mjs

@@ -27,173 +27,333 @@ export class Service {
             subscription.unsubscribe();
     }
     /** HTTP GET */
-    HTTP_GET(request) {
+    HTTP_GET(request, cancelPrevious = true) {
         return new Promise(Resolve => {
-            this.ReleaseSubscription(this._GET$);
-            this._GET$ = this.http.request(new HttpRequest("GET", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
-                next: (response) => {
-                    if (response.type > 0) {
+            if (cancelPrevious) {
+                this.ReleaseSubscription(this._GET$);
+                this._GET$ = this.http.request(new HttpRequest("GET", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: Tools.BreakReference(response.body),
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(this._GET$);
+                        this.AlertError(httpError, request.alertError);
                         Resolve({
-                            body: Tools.BreakReference(response.body),
-                            status: response.status,
-                            message: response.statusText,
-                            ok: true
+                            body: {},
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
                         });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(this._GET$);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess);
+                        }
                     }
-                },
-                error: (httpError) => {
-                    this.ReleaseSubscription(this._GET$);
-                    this.AlertError(httpError, request.alertError);
-                    Resolve({
-                        body: {},
-                        status: httpError.status,
-                        message: httpError.error?.message || httpError.error,
-                        ok: false
-                    });
-                },
-                complete: () => {
-                    this.ReleaseSubscription(this._GET$);
-                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                        this.alert.Success(request.alertSuccess);
+                });
+            }
+            else {
+                const subscription = this.http.request(new HttpRequest("GET", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: Tools.BreakReference(response.body),
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(subscription);
+                        this.AlertError(httpError, request.alertError);
+                        Resolve({
+                            body: {},
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
+                        });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(subscription);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess);
+                        }
                     }
-                }
-            });
+                });
+            }
         });
     }
     /** HTTP POST */
-    HTTP_POST(request) {
+    HTTP_POST(request, cancelPrevious = true) {
         return new Promise(Resolve => {
-            this.ReleaseSubscription(this._POST$);
-            this._POST$ = this.http.request(new HttpRequest("POST", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
-                next: (response) => {
-                    if (response.type > 0) {
+            if (cancelPrevious) {
+                this.ReleaseSubscription(this._POST$);
+                this._POST$ = this.http.request(new HttpRequest("POST", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: Tools.BreakReference(response.body),
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(this._POST$);
+                        this.AlertError(httpError, request.alertError);
                         Resolve({
-                            body: Tools.BreakReference(response.body),
-                            status: response.status,
-                            message: response.statusText,
-                            ok: true
+                            body: {},
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
                         });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(this._POST$);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess);
+                        }
                     }
-                },
-                error: (httpError) => {
-                    this.ReleaseSubscription(this._POST$);
-                    this.AlertError(httpError, request.alertError);
-                    Resolve({
-                        body: {},
-                        status: httpError.status,
-                        message: httpError.error?.message || httpError.error,
-                        ok: false
-                    });
-                },
-                complete: () => {
-                    this.ReleaseSubscription(this._POST$);
-                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                        this.alert.Success(request.alertSuccess);
+                });
+            }
+            else {
+                const subscription = this.http.request(new HttpRequest("POST", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: Tools.BreakReference(response.body),
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(subscription);
+                        this.AlertError(httpError, request.alertError);
+                        Resolve({
+                            body: {},
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
+                        });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(subscription);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess);
+                        }
                     }
-                }
-            });
+                });
+            }
         });
     }
     /** HTTP PUT */
-    HTTP_PUT(request) {
+    HTTP_PUT(request, cancelPrevious = true) {
         return new Promise(Resolve => {
-            this.ReleaseSubscription(this._PUT$);
-            this._PUT$ = this.http.request(new HttpRequest("PUT", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
-                next: (response) => {
-                    if (response.type > 0) {
+            if (cancelPrevious) {
+                this.ReleaseSubscription(this._PUT$);
+                this._PUT$ = this.http.request(new HttpRequest("PUT", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: {},
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(this._PUT$);
+                        this.AlertError(httpError, request.alertError);
                         Resolve({
                             body: {},
-                            status: response.status,
-                            message: response.statusText,
-                            ok: true
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
                         });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(this._PUT$);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                        }
                     }
-                },
-                error: (httpError) => {
-                    this.ReleaseSubscription(this._PUT$);
-                    this.AlertError(httpError, request.alertError);
-                    Resolve({
-                        body: {},
-                        status: httpError.status,
-                        message: httpError.error?.message || httpError.error,
-                        ok: false
-                    });
-                },
-                complete: () => {
-                    this.ReleaseSubscription(this._PUT$);
-                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                });
+            }
+            else {
+                const subscription = this.http.request(new HttpRequest("PUT", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: {},
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(subscription);
+                        this.AlertError(httpError, request.alertError);
+                        Resolve({
+                            body: {},
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
+                        });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(subscription);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                        }
                     }
-                }
-            });
+                });
+            }
         });
     }
     /** HTTP PATCH */
-    HTTP_PATCH(request) {
+    HTTP_PATCH(request, cancelPrevious = true) {
         return new Promise(Resolve => {
-            this.ReleaseSubscription(this._PATCH$);
-            this._PATCH$ = this.http.request(new HttpRequest("PATCH", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
-                next: (response) => {
-                    if (response.type > 0) {
+            if (cancelPrevious) {
+                this.ReleaseSubscription(this._PATCH$);
+                this._PATCH$ = this.http.request(new HttpRequest("PATCH", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: {},
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(this._PATCH$);
+                        this.AlertError(httpError, request.alertError);
                         Resolve({
                             body: {},
-                            status: response.status,
-                            message: response.statusText,
-                            ok: true
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
                         });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(this._PATCH$);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                        }
                     }
-                },
-                error: (httpError) => {
-                    this.ReleaseSubscription(this._PATCH$);
-                    this.AlertError(httpError, request.alertError);
-                    Resolve({
-                        body: {},
-                        status: httpError.status,
-                        message: httpError.error?.message || httpError.error,
-                        ok: false
-                    });
-                },
-                complete: () => {
-                    this.ReleaseSubscription(this._PATCH$);
-                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                });
+            }
+            else {
+                const subscription = this.http.request(new HttpRequest("PATCH", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: {},
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(subscription);
+                        this.AlertError(httpError, request.alertError);
+                        Resolve({
+                            body: {},
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
+                        });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(subscription);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
+                        }
                     }
-                }
-            });
+                });
+            }
         });
     }
     /** HTTP DELETE */
-    HTTP_DELETE(request) {
+    HTTP_DELETE(request, cancelPrevious = true) {
         return new Promise(Resolve => {
-            this.ReleaseSubscription(this._DELETE$);
-            this._DELETE$ = this.http.request(new HttpRequest("DELETE", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
-                next: (response) => {
-                    if (response.type > 0) {
+            if (cancelPrevious) {
+                this.ReleaseSubscription(this._DELETE$);
+                this._DELETE$ = this.http.request(new HttpRequest("DELETE", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: {},
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(this._DELETE$);
+                        this.AlertError(httpError, request.alertError);
                         Resolve({
                             body: {},
-                            status: response.status,
-                            message: response.statusText,
-                            ok: true
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
                         });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(this._DELETE$);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
+                        }
                     }
-                },
-                error: (httpError) => {
-                    this.ReleaseSubscription(this._DELETE$);
-                    this.AlertError(httpError, request.alertError);
-                    Resolve({
-                        body: {},
-                        status: httpError.status,
-                        message: httpError.error?.message || httpError.error,
-                        ok: false
-                    });
-                },
-                complete: () => {
-                    this.ReleaseSubscription(this._DELETE$);
-                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
-                        this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
+                });
+            }
+            else {
+                const subscription = this.http.request(new HttpRequest("DELETE", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
+                    next: (response) => {
+                        if (response.type > 0) {
+                            Resolve({
+                                body: {},
+                                status: response.status,
+                                message: response.statusText,
+                                ok: true
+                            });
+                        }
+                    },
+                    error: (httpError) => {
+                        this.ReleaseSubscription(subscription);
+                        this.AlertError(httpError, request.alertError);
+                        Resolve({
+                            body: {},
+                            status: httpError.status,
+                            message: httpError.error?.message || httpError.error,
+                            ok: false
+                        });
+                    },
+                    complete: () => {
+                        this.ReleaseSubscription(subscription);
+                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
+                            this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
+                        }
                     }
-                }
-            });
+                });
+            }
         });
     }
     /** */
@@ -245,4 +405,4 @@ export class Service {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.class.js","sourceRoot":"","sources":["../../../../../projects/coer-elements/tools/lib/service.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from \"@angular/core\";\r\nimport { HttpClient, HttpErrorResponse, HttpEvent, HttpRequest } from \"@angular/common/http\";\r\nimport { CoerAlert } from \"./coer-alert/coer-alert.component\";\r\nimport { IHttpRequest, IHttpResponse } from \"coer-elements/interfaces\";\r\nimport { Tools } from \"./tools\";\r\nimport { Subscription } from \"rxjs\";\r\n\r\nexport class Service {\r\n\r\n    //Injections\r\n    protected readonly alert = inject(CoerAlert);\r\n    protected readonly http = inject(HttpClient);\r\n\r\n    protected httpCode = {\r\n        Ok: 200,\r\n        Created: 201,\r\n        NoContent: 204,\r\n        BadRequest: 400,\r\n        Unauthorize: 401,\r\n        NotFound: 404,\r\n        NotAllowed: 405,\r\n        NotAcceptable: 406,\r\n        Conflict: 409,\r\n        PayloadTooLarge: 413,\r\n        InnerError: 500\r\n    }\r\n\r\n\r\n    //Subscriptions\r\n    private _GET$!: Subscription;\r\n    private _POST$!: Subscription;\r\n    private _PUT$!: Subscription;\r\n    private _PATCH$!: Subscription;\r\n    private _DELETE$!: Subscription;\r\n\r\n\r\n    /** */\r\n    private ReleaseSubscription(subscription: Subscription): void {\r\n        if (subscription && !subscription.closed) subscription.unsubscribe();\r\n    }\r\n\r\n\r\n    /** HTTP GET */\r\n    protected HTTP_GET<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<T>>(Resolve => {\r\n            this.ReleaseSubscription(this._GET$);\r\n\r\n            this._GET$ = this.http.request<T>(new HttpRequest(\"GET\", request.url, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: Tools.BreakReference<T>(response.body),\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._GET$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._GET$);\r\n\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess);\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP POST */\r\n    protected HTTP_POST<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<T>>(Resolve => {\r\n            this.ReleaseSubscription(this._POST$);\r\n\r\n            this._POST$ = this.http.request<T>(new HttpRequest(\"POST\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: Tools.BreakReference<T>(response.body),\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._POST$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._POST$);\r\n\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess);\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP PUT */\r\n    protected HTTP_PUT<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            this.ReleaseSubscription(this._PUT$);\r\n\r\n            this._PUT$ = this.http.request<T>(new HttpRequest(\"PUT\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._PUT$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._PUT$);\r\n\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP PATCH */\r\n    protected HTTP_PATCH<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            this.ReleaseSubscription(this._PATCH$);\r\n\r\n            this._PATCH$ = this.http.request<T>(new HttpRequest(\"PATCH\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._PATCH$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._PATCH$);\r\n\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP DELETE */\r\n    protected HTTP_DELETE<T>(request: IHttpRequest<T>) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            this.ReleaseSubscription(this._DELETE$);\r\n\r\n            this._DELETE$ = this.http.request<T>(new HttpRequest(\"DELETE\", request.url, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                next: (response: HttpEvent<T> | any) => {\r\n                    if (response.type > 0) {\r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: response.status,\r\n                            message: response.statusText,\r\n                            ok: true\r\n                        });\r\n                    }\r\n                },\r\n\r\n                error: (httpError: HttpErrorResponse) => {\r\n                    this.ReleaseSubscription(this._DELETE$);\r\n                    this.AlertError(httpError, request.alertError);\r\n\r\n                    Resolve({\r\n                        body: {} as any,\r\n                        status: httpError.status,\r\n                        message: httpError.error?.message || httpError.error,\r\n                        ok: false\r\n                    });\r\n                },\r\n\r\n                complete: () => {\r\n                    this.ReleaseSubscription(this._DELETE$);\r\n                    if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                        this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');\r\n                    }\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n\r\n    /** */\r\n    private AlertError(httpError: HttpErrorResponse, message?: string): void {\r\n        if (httpError.status >= 500) {\r\n            if (Tools.IsNotOnlyWhiteSpace(message)) {\r\n                this.alert.Error(message, `BUG ${httpError.status}`, 'fa-solid fa-bug', null);\r\n            }\r\n        }\r\n\r\n        else if (httpError.status < 500) {\r\n            switch(httpError.status) {\r\n                case 400: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Bad Request', 'fa-regular fa-face-grin-beam-sweat fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 401: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Unauthorize', 'fa-regular fa-face-rolling-eyes fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 404: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Found', 'fa-regular fa-face-meh fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 405: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Allowed', 'fa-regular fa-face-grimace fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 406: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Acceptable', 'fa-regular fa-face-frown-open fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 409: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Conflict', 'fa-regular fa-face-dizzy fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 413: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Too Large', 'fa-regular fa-face-flushed fa-lg');\r\n                    break;\r\n                }\r\n\r\n                default: {\r\n                    if (httpError.status <= 0) {\r\n                        this.alert.Warning('Without Connection', 'WEB API DOWN', 'fa-solid fa-plug-circle-xmark fa-lg', null);\r\n                    }\r\n\r\n                    else this.alert.Warning(httpError.error?.message || httpError.error);\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.class.js","sourceRoot":"","sources":["../../../../../projects/coer-elements/tools/lib/service.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject } from \"@angular/core\";\r\nimport { HttpClient, HttpErrorResponse, HttpEvent, HttpRequest } from \"@angular/common/http\";\r\nimport { CoerAlert } from \"./coer-alert/coer-alert.component\";\r\nimport { IHttpRequest, IHttpResponse } from \"coer-elements/interfaces\";\r\nimport { Tools } from \"./tools\";\r\nimport { Subscription } from \"rxjs\";\r\n\r\nexport class Service {\r\n\r\n    //Injections\r\n    protected readonly alert = inject(CoerAlert);\r\n    protected readonly http = inject(HttpClient);\r\n\r\n    protected httpCode = {\r\n        Ok: 200,\r\n        Created: 201,\r\n        NoContent: 204,\r\n        BadRequest: 400,\r\n        Unauthorize: 401,\r\n        NotFound: 404,\r\n        NotAllowed: 405,\r\n        NotAcceptable: 406,\r\n        Conflict: 409,\r\n        PayloadTooLarge: 413,\r\n        InnerError: 500\r\n    }\r\n\r\n\r\n    //Subscriptions\r\n    private _GET$!: Subscription;\r\n    private _POST$!: Subscription;\r\n    private _PUT$!: Subscription;\r\n    private _PATCH$!: Subscription;\r\n    private _DELETE$!: Subscription;\r\n\r\n\r\n    /** */\r\n    private ReleaseSubscription(subscription: Subscription): void {\r\n        if (subscription && !subscription.closed) subscription.unsubscribe();\r\n    }\r\n\r\n\r\n    /** HTTP GET */\r\n    protected HTTP_GET<T>(request: IHttpRequest<T>, cancelPrevious: boolean = true) {\r\n        return new Promise<IHttpResponse<T>>(Resolve => {\r\n            if(cancelPrevious) {\r\n                this.ReleaseSubscription(this._GET$);\r\n    \r\n                this._GET$ = this.http.request<T>(new HttpRequest(\"GET\", request.url, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: Tools.BreakReference<T>(response.body),\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(this._GET$);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(this._GET$);\r\n    \r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess);\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n\r\n            else {\r\n                const subscription = this.http.request<T>(new HttpRequest(\"GET\", request.url, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: Tools.BreakReference<T>(response.body),\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(subscription);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(subscription);\r\n    \r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess);\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP POST */\r\n    protected HTTP_POST<T>(request: IHttpRequest<T>, cancelPrevious: boolean = true) {\r\n        return new Promise<IHttpResponse<T>>(Resolve => {\r\n            if(cancelPrevious) {\r\n                this.ReleaseSubscription(this._POST$);\r\n    \r\n                this._POST$ = this.http.request<T>(new HttpRequest(\"POST\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: Tools.BreakReference<T>(response.body),\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(this._POST$);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(this._POST$);\r\n    \r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess);\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n\r\n            else {\r\n                const subscription = this.http.request<T>(new HttpRequest(\"POST\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: Tools.BreakReference<T>(response.body),\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(subscription);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(subscription);\r\n    \r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess);\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP PUT */\r\n    protected HTTP_PUT<T>(request: IHttpRequest<T>, cancelPrevious: boolean = true) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            if(cancelPrevious) {\r\n                this.ReleaseSubscription(this._PUT$);\r\n    \r\n                this._PUT$ = this.http.request<T>(new HttpRequest(\"PUT\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: {} as any,\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(this._PUT$);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(this._PUT$);\r\n    \r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n\r\n            else {\r\n                const subscription = this.http.request<T>(new HttpRequest(\"PUT\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: {} as any,\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(subscription);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(subscription);\r\n    \r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP PATCH */\r\n    protected HTTP_PATCH<T>(request: IHttpRequest<T>, cancelPrevious: boolean = true) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            if(cancelPrevious) {\r\n                this.ReleaseSubscription(this._PATCH$);\r\n    \r\n                this._PATCH$ = this.http.request<T>(new HttpRequest(\"PATCH\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: {} as any,\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(this._PATCH$);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(this._PATCH$);\r\n    \r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n\r\n            else {\r\n                const subscription = this.http.request<T>(new HttpRequest(\"PATCH\", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: {} as any,\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(subscription);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(subscription);\r\n    \r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        });\r\n    }\r\n\r\n\r\n    /** HTTP DELETE */\r\n    protected HTTP_DELETE<T>(request: IHttpRequest<T>, cancelPrevious: boolean = true) {\r\n        return new Promise<IHttpResponse<void>>(Resolve => {\r\n            if(cancelPrevious) {\r\n                this.ReleaseSubscription(this._DELETE$);\r\n    \r\n                this._DELETE$ = this.http.request<T>(new HttpRequest(\"DELETE\", request.url, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: {} as any,\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(this._DELETE$);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(this._DELETE$);\r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n\r\n            else {\r\n                const subscription = this.http.request<T>(new HttpRequest(\"DELETE\", request.url, { params: request.queryParams, headers: request.headers })).subscribe({\r\n                    next: (response: HttpEvent<T> | any) => {\r\n                        if (response.type > 0) {\r\n                            Resolve({\r\n                                body: {} as any,\r\n                                status: response.status,\r\n                                message: response.statusText,\r\n                                ok: true\r\n                            });\r\n                        }\r\n                    },\r\n    \r\n                    error: (httpError: HttpErrorResponse) => {\r\n                        this.ReleaseSubscription(subscription);\r\n                        this.AlertError(httpError, request.alertError);\r\n    \r\n                        Resolve({\r\n                            body: {} as any,\r\n                            status: httpError.status,\r\n                            message: httpError.error?.message || httpError.error,\r\n                            ok: false\r\n                        });\r\n                    },\r\n    \r\n                    complete: () => {\r\n                        this.ReleaseSubscription(subscription);\r\n                        if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {\r\n                            this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n        });\r\n    }\r\n\r\n\r\n    /** */\r\n    private AlertError(httpError: HttpErrorResponse, message?: string): void {\r\n        if (httpError.status >= 500) {\r\n            if (Tools.IsNotOnlyWhiteSpace(message)) {\r\n                this.alert.Error(message, `BUG ${httpError.status}`, 'fa-solid fa-bug', null);\r\n            }\r\n        }\r\n\r\n        else if (httpError.status < 500) {\r\n            switch(httpError.status) {\r\n                case 400: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Bad Request', 'fa-regular fa-face-grin-beam-sweat fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 401: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Unauthorize', 'fa-regular fa-face-rolling-eyes fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 404: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Found', 'fa-regular fa-face-meh fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 405: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Allowed', 'fa-regular fa-face-grimace fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 406: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Acceptable', 'fa-regular fa-face-frown-open fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 409: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Conflict', 'fa-regular fa-face-dizzy fa-lg');\r\n                    break;\r\n                }\r\n\r\n                case 413: {\r\n                    this.alert.Warning(httpError.error?.message || httpError.error, 'Too Large', 'fa-regular fa-face-flushed fa-lg');\r\n                    break;\r\n                }\r\n\r\n                default: {\r\n                    if (httpError.status <= 0) {\r\n                        this.alert.Warning('Without Connection', 'WEB API DOWN', 'fa-solid fa-plug-circle-xmark fa-lg', null);\r\n                    }\r\n\r\n                    else this.alert.Warning(httpError.error?.message || httpError.error);\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n}"]}