coer-elements 0.0.20 → 0.0.22

package/fesm2022/coer-elements.mjs

@@ -25,6 +25,7 @@ import Swal from 'sweetalert2';
 import * as XLSX from 'xlsx';
 import { Observable } from 'rxjs';
 import moment from 'moment';
+import { HttpClient, HttpRequest } from '@angular/common/http';
 
 class CoerRefDirective {
     constructor(template) {
@@ -335,7 +336,7 @@ const Tools = {
 
 class NoImagePipe {
     transform(value) {
-        const NO_IMAGE = '../../images/no-image.png';
+        const NO_IMAGE = '../../../images/no-image.png';
         if (Tools.IsOnlyWhiteSpace(value)) {
             return NO_IMAGE;
         }
@@ -3832,9 +3833,253 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                     args: [String]
                 }] }] });
 
+class Service {
+    constructor() {
+        //Injections
+        this.alert = inject(CoerAlert);
+        this.http = inject(HttpClient);
+        this.httpCode = {
+            Ok: 200,
+            Created: 201,
+            NoContent: 204,
+            BadRequest: 400,
+            Unauthorize: 401,
+            NotFound: 404,
+            NotAllowed: 405,
+            NotAcceptable: 406,
+            Conflict: 409,
+            PayloadTooLarge: 413,
+            InnerError: 500
+        };
+    }
+    /** */
+    ReleaseSubscription(subscription) {
+        if (subscription && !subscription.closed)
+            subscription.unsubscribe();
+    }
+    /** HTTP GET */
+    HTTP_GET(request) {
+        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) {
+                        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: {},
+                        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);
+                    }
+                }
+            });
+        });
+    }
+    /** HTTP POST */
+    HTTP_POST(request) {
+        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) {
+                        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: {},
+                        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);
+                    }
+                }
+            });
+        });
+    }
+    /** HTTP PUT */
+    HTTP_PUT(request) {
+        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) {
+                        Resolve({
+                            body: {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
+                        });
+                    }
+                },
+                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');
+                    }
+                }
+            });
+        });
+    }
+    /** HTTP PATCH */
+    HTTP_PATCH(request) {
+        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) {
+                        Resolve({
+                            body: {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
+                        });
+                    }
+                },
+                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');
+                    }
+                }
+            });
+        });
+    }
+    /** HTTP DELETE */
+    HTTP_DELETE(request) {
+        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) {
+                        Resolve({
+                            body: {},
+                            status: response.status,
+                            message: response.statusText,
+                            ok: true
+                        });
+                    }
+                },
+                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');
+                    }
+                }
+            });
+        });
+    }
+    /** */
+    AlertError(httpError, message) {
+        if (httpError.status >= 500) {
+            if (Tools.IsNotOnlyWhiteSpace(message)) {
+                this.alert.Error('', message, 'fa-solid fa-bug', null);
+            }
+        }
+        else if (httpError.status < 500) {
+            switch (httpError.status) {
+                case 400: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Bad Request', 'fa-regular fa-face-grin-beam-sweat fa-lg');
+                    break;
+                }
+                case 401: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Unauthorize', 'fa-regular fa-face-rolling-eyes fa-lg');
+                    break;
+                }
+                case 404: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Found', 'fa-regular fa-face-meh fa-lg');
+                    break;
+                }
+                case 405: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Allowed', 'fa-regular fa-face-grimace fa-lg');
+                    break;
+                }
+                case 406: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Not Acceptable', 'fa-regular fa-face-frown-open fa-lg');
+                    break;
+                }
+                case 409: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Conflict', 'fa-regular fa-face-dizzy fa-lg');
+                    break;
+                }
+                case 413: {
+                    this.alert.Warning(httpError.error?.message || httpError.error, 'Too Large', 'fa-regular fa-face-flushed fa-lg');
+                    break;
+                }
+                default: {
+                    if (httpError.status <= 0) {
+                        this.alert.Warning('Without Connection', 'WEB API DOWN', 'fa-solid fa-plug-circle-xmark fa-lg', null);
+                    }
+                    else
+                        this.alert.Warning(httpError.error?.message || httpError.error);
+                    break;
+                }
+            }
+        }
+    }
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { Breadcrumbs, CONTROL_VALUE, CoerAlert, CoerButton, CoerCheckbox, CoerFilebox, CoerForm, CoerGrid, CoerModal, CoerNumberBox, CoerPageTitle, CoerRefDirective, CoerSelectbox, CoerSwitch, CoerTab, CoerTextBox, CoerTextarea, ComponentsModule, ControlValue, DateTime, DirectivesModule, Files, GridTemplates, HtmlPipe, LifeCycleDirective, Menu, NoImagePipe, NumericFormatPipe, Page, PipesModule, Screen, Source, Tools, breakpointSIGNAL, isLoadingSIGNAL, isMenuOpenSIGNAL, isModalOpenSIGNAL, menuSIGNAL };
+export { Breadcrumbs, CONTROL_VALUE, CoerAlert, CoerButton, CoerCheckbox, CoerFilebox, CoerForm, CoerGrid, CoerModal, CoerNumberBox, CoerPageTitle, CoerRefDirective, CoerSelectbox, CoerSwitch, CoerTab, CoerTextBox, CoerTextarea, ComponentsModule, ControlValue, DateTime, DirectivesModule, Files, GridTemplates, HtmlPipe, LifeCycleDirective, Menu, NoImagePipe, NumericFormatPipe, Page, PipesModule, Screen, Service, Source, Tools, breakpointSIGNAL, isLoadingSIGNAL, isMenuOpenSIGNAL, isModalOpenSIGNAL, menuSIGNAL };
 //# sourceMappingURL=coer-elements.mjs.map