coer-elements 0.0.32 → 0.0.33

Sign up to get free protection for your applications and to get access to all the features.
Files changed (5) hide show
  1. package/esm2022/tools/lib/service.class.mjs +288 -128
  2. package/fesm2022/coer-elements-tools.mjs +287 -127
  3. package/fesm2022/coer-elements-tools.mjs.map +1 -1
  4. package/package.json +7 -7
  5. package/tools/lib/service.class.d.ts +5 -5
package/esm2022/tools/lib/service.class.mjs CHANGED
@@ -27,173 +27,333 @@ export class Service {
27
27
  subscription.unsubscribe();
28
28
  }
29
29
  /** HTTP GET */
30
- HTTP_GET(request) {
30
+ HTTP_GET(request, cancelPrevious = true) {
31
31
  return new Promise(Resolve => {
32
- this.ReleaseSubscription(this._GET$);
33
- this._GET$ = this.http.request(new HttpRequest("GET", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
34
- next: (response) => {
35
- if (response.type > 0) {
32
+ if (cancelPrevious) {
33
+ this.ReleaseSubscription(this._GET$);
34
+ this._GET$ = this.http.request(new HttpRequest("GET", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
35
+ next: (response) => {
36
+ if (response.type > 0) {
37
+ Resolve({
38
+ body: Tools.BreakReference(response.body),
39
+ status: response.status,
40
+ message: response.statusText,
41
+ ok: true
42
+ });
43
+ }
44
+ },
45
+ error: (httpError) => {
46
+ this.ReleaseSubscription(this._GET$);
47
+ this.AlertError(httpError, request.alertError);
36
48
  Resolve({
37
- body: Tools.BreakReference(response.body),
38
- status: response.status,
39
- message: response.statusText,
40
- ok: true
49
+ body: {},
50
+ status: httpError.status,
51
+ message: httpError.error?.message || httpError.error,
52
+ ok: false
41
53
  });
54
+ },
55
+ complete: () => {
56
+ this.ReleaseSubscription(this._GET$);
57
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
58
+ this.alert.Success(request.alertSuccess);
59
+ }
42
60
  }
43
- },
44
- error: (httpError) => {
45
- this.ReleaseSubscription(this._GET$);
46
- this.AlertError(httpError, request.alertError);
47
- Resolve({
48
- body: {},
49
- status: httpError.status,
50
- message: httpError.error?.message || httpError.error,
51
- ok: false
52
- });
53
- },
54
- complete: () => {
55
- this.ReleaseSubscription(this._GET$);
56
- if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
57
- this.alert.Success(request.alertSuccess);
61
+ });
62
+ }
63
+ else {
64
+ const subscription = this.http.request(new HttpRequest("GET", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
65
+ next: (response) => {
66
+ if (response.type > 0) {
67
+ Resolve({
68
+ body: Tools.BreakReference(response.body),
69
+ status: response.status,
70
+ message: response.statusText,
71
+ ok: true
72
+ });
73
+ }
74
+ },
75
+ error: (httpError) => {
76
+ this.ReleaseSubscription(subscription);
77
+ this.AlertError(httpError, request.alertError);
78
+ Resolve({
79
+ body: {},
80
+ status: httpError.status,
81
+ message: httpError.error?.message || httpError.error,
82
+ ok: false
83
+ });
84
+ },
85
+ complete: () => {
86
+ this.ReleaseSubscription(subscription);
87
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
88
+ this.alert.Success(request.alertSuccess);
89
+ }
58
90
  }
59
- }
60
- });
91
+ });
92
+ }
61
93
  });
62
94
  }
63
95
  /** HTTP POST */
64
- HTTP_POST(request) {
96
+ HTTP_POST(request, cancelPrevious = true) {
65
97
  return new Promise(Resolve => {
66
- this.ReleaseSubscription(this._POST$);
67
- this._POST$ = this.http.request(new HttpRequest("POST", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
68
- next: (response) => {
69
- if (response.type > 0) {
98
+ if (cancelPrevious) {
99
+ this.ReleaseSubscription(this._POST$);
100
+ this._POST$ = this.http.request(new HttpRequest("POST", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
101
+ next: (response) => {
102
+ if (response.type > 0) {
103
+ Resolve({
104
+ body: Tools.BreakReference(response.body),
105
+ status: response.status,
106
+ message: response.statusText,
107
+ ok: true
108
+ });
109
+ }
110
+ },
111
+ error: (httpError) => {
112
+ this.ReleaseSubscription(this._POST$);
113
+ this.AlertError(httpError, request.alertError);
70
114
  Resolve({
71
- body: Tools.BreakReference(response.body),
72
- status: response.status,
73
- message: response.statusText,
74
- ok: true
115
+ body: {},
116
+ status: httpError.status,
117
+ message: httpError.error?.message || httpError.error,
118
+ ok: false
75
119
  });
120
+ },
121
+ complete: () => {
122
+ this.ReleaseSubscription(this._POST$);
123
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
124
+ this.alert.Success(request.alertSuccess);
125
+ }
76
126
  }
77
- },
78
- error: (httpError) => {
79
- this.ReleaseSubscription(this._POST$);
80
- this.AlertError(httpError, request.alertError);
81
- Resolve({
82
- body: {},
83
- status: httpError.status,
84
- message: httpError.error?.message || httpError.error,
85
- ok: false
86
- });
87
- },
88
- complete: () => {
89
- this.ReleaseSubscription(this._POST$);
90
- if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
91
- this.alert.Success(request.alertSuccess);
127
+ });
128
+ }
129
+ else {
130
+ const subscription = this.http.request(new HttpRequest("POST", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
131
+ next: (response) => {
132
+ if (response.type > 0) {
133
+ Resolve({
134
+ body: Tools.BreakReference(response.body),
135
+ status: response.status,
136
+ message: response.statusText,
137
+ ok: true
138
+ });
139
+ }
140
+ },
141
+ error: (httpError) => {
142
+ this.ReleaseSubscription(subscription);
143
+ this.AlertError(httpError, request.alertError);
144
+ Resolve({
145
+ body: {},
146
+ status: httpError.status,
147
+ message: httpError.error?.message || httpError.error,
148
+ ok: false
149
+ });
150
+ },
151
+ complete: () => {
152
+ this.ReleaseSubscription(subscription);
153
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
154
+ this.alert.Success(request.alertSuccess);
155
+ }
92
156
  }
93
- }
94
- });
157
+ });
158
+ }
95
159
  });
96
160
  }
97
161
  /** HTTP PUT */
98
- HTTP_PUT(request) {
162
+ HTTP_PUT(request, cancelPrevious = true) {
99
163
  return new Promise(Resolve => {
100
- this.ReleaseSubscription(this._PUT$);
101
- this._PUT$ = this.http.request(new HttpRequest("PUT", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
102
- next: (response) => {
103
- if (response.type > 0) {
164
+ if (cancelPrevious) {
165
+ this.ReleaseSubscription(this._PUT$);
166
+ this._PUT$ = this.http.request(new HttpRequest("PUT", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
167
+ next: (response) => {
168
+ if (response.type > 0) {
169
+ Resolve({
170
+ body: {},
171
+ status: response.status,
172
+ message: response.statusText,
173
+ ok: true
174
+ });
175
+ }
176
+ },
177
+ error: (httpError) => {
178
+ this.ReleaseSubscription(this._PUT$);
179
+ this.AlertError(httpError, request.alertError);
104
180
  Resolve({
105
181
  body: {},
106
- status: response.status,
107
- message: response.statusText,
108
- ok: true
182
+ status: httpError.status,
183
+ message: httpError.error?.message || httpError.error,
184
+ ok: false
109
185
  });
186
+ },
187
+ complete: () => {
188
+ this.ReleaseSubscription(this._PUT$);
189
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
190
+ this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
191
+ }
110
192
  }
111
- },
112
- error: (httpError) => {
113
- this.ReleaseSubscription(this._PUT$);
114
- this.AlertError(httpError, request.alertError);
115
- Resolve({
116
- body: {},
117
- status: httpError.status,
118
- message: httpError.error?.message || httpError.error,
119
- ok: false
120
- });
121
- },
122
- complete: () => {
123
- this.ReleaseSubscription(this._PUT$);
124
- if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
125
- this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
193
+ });
194
+ }
195
+ else {
196
+ const subscription = this.http.request(new HttpRequest("PUT", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
197
+ next: (response) => {
198
+ if (response.type > 0) {
199
+ Resolve({
200
+ body: {},
201
+ status: response.status,
202
+ message: response.statusText,
203
+ ok: true
204
+ });
205
+ }
206
+ },
207
+ error: (httpError) => {
208
+ this.ReleaseSubscription(subscription);
209
+ this.AlertError(httpError, request.alertError);
210
+ Resolve({
211
+ body: {},
212
+ status: httpError.status,
213
+ message: httpError.error?.message || httpError.error,
214
+ ok: false
215
+ });
216
+ },
217
+ complete: () => {
218
+ this.ReleaseSubscription(subscription);
219
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
220
+ this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
221
+ }
126
222
  }
127
- }
128
- });
223
+ });
224
+ }
129
225
  });
130
226
  }
131
227
  /** HTTP PATCH */
132
- HTTP_PATCH(request) {
228
+ HTTP_PATCH(request, cancelPrevious = true) {
133
229
  return new Promise(Resolve => {
134
- this.ReleaseSubscription(this._PATCH$);
135
- this._PATCH$ = this.http.request(new HttpRequest("PATCH", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
136
- next: (response) => {
137
- if (response.type > 0) {
230
+ if (cancelPrevious) {
231
+ this.ReleaseSubscription(this._PATCH$);
232
+ this._PATCH$ = this.http.request(new HttpRequest("PATCH", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
233
+ next: (response) => {
234
+ if (response.type > 0) {
235
+ Resolve({
236
+ body: {},
237
+ status: response.status,
238
+ message: response.statusText,
239
+ ok: true
240
+ });
241
+ }
242
+ },
243
+ error: (httpError) => {
244
+ this.ReleaseSubscription(this._PATCH$);
245
+ this.AlertError(httpError, request.alertError);
138
246
  Resolve({
139
247
  body: {},
140
- status: response.status,
141
- message: response.statusText,
142
- ok: true
248
+ status: httpError.status,
249
+ message: httpError.error?.message || httpError.error,
250
+ ok: false
143
251
  });
252
+ },
253
+ complete: () => {
254
+ this.ReleaseSubscription(this._PATCH$);
255
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
256
+ this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
257
+ }
144
258
  }
145
- },
146
- error: (httpError) => {
147
- this.ReleaseSubscription(this._PATCH$);
148
- this.AlertError(httpError, request.alertError);
149
- Resolve({
150
- body: {},
151
- status: httpError.status,
152
- message: httpError.error?.message || httpError.error,
153
- ok: false
154
- });
155
- },
156
- complete: () => {
157
- this.ReleaseSubscription(this._PATCH$);
158
- if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
159
- this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
259
+ });
260
+ }
261
+ else {
262
+ const subscription = this.http.request(new HttpRequest("PATCH", request.url, request.body, { params: request.queryParams, headers: request.headers })).subscribe({
263
+ next: (response) => {
264
+ if (response.type > 0) {
265
+ Resolve({
266
+ body: {},
267
+ status: response.status,
268
+ message: response.statusText,
269
+ ok: true
270
+ });
271
+ }
272
+ },
273
+ error: (httpError) => {
274
+ this.ReleaseSubscription(subscription);
275
+ this.AlertError(httpError, request.alertError);
276
+ Resolve({
277
+ body: {},
278
+ status: httpError.status,
279
+ message: httpError.error?.message || httpError.error,
280
+ ok: false
281
+ });
282
+ },
283
+ complete: () => {
284
+ this.ReleaseSubscription(subscription);
285
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
286
+ this.alert.Success(request.alertSuccess, 'Updated', 'fa-solid fa-arrows-rotate fa-spin');
287
+ }
160
288
  }
161
- }
162
- });
289
+ });
290
+ }
163
291
  });
164
292
  }
165
293
  /** HTTP DELETE */
166
- HTTP_DELETE(request) {
294
+ HTTP_DELETE(request, cancelPrevious = true) {
167
295
  return new Promise(Resolve => {
168
- this.ReleaseSubscription(this._DELETE$);
169
- this._DELETE$ = this.http.request(new HttpRequest("DELETE", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
170
- next: (response) => {
171
- if (response.type > 0) {
296
+ if (cancelPrevious) {
297
+ this.ReleaseSubscription(this._DELETE$);
298
+ this._DELETE$ = this.http.request(new HttpRequest("DELETE", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
299
+ next: (response) => {
300
+ if (response.type > 0) {
301
+ Resolve({
302
+ body: {},
303
+ status: response.status,
304
+ message: response.statusText,
305
+ ok: true
306
+ });
307
+ }
308
+ },
309
+ error: (httpError) => {
310
+ this.ReleaseSubscription(this._DELETE$);
311
+ this.AlertError(httpError, request.alertError);
172
312
  Resolve({
173
313
  body: {},
174
- status: response.status,
175
- message: response.statusText,
176
- ok: true
314
+ status: httpError.status,
315
+ message: httpError.error?.message || httpError.error,
316
+ ok: false
177
317
  });
318
+ },
319
+ complete: () => {
320
+ this.ReleaseSubscription(this._DELETE$);
321
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
322
+ this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
323
+ }
178
324
  }
179
- },
180
- error: (httpError) => {
181
- this.ReleaseSubscription(this._DELETE$);
182
- this.AlertError(httpError, request.alertError);
183
- Resolve({
184
- body: {},
185
- status: httpError.status,
186
- message: httpError.error?.message || httpError.error,
187
- ok: false
188
- });
189
- },
190
- complete: () => {
191
- this.ReleaseSubscription(this._DELETE$);
192
- if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
193
- this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
325
+ });
326
+ }
327
+ else {
328
+ const subscription = this.http.request(new HttpRequest("DELETE", request.url, { params: request.queryParams, headers: request.headers })).subscribe({
329
+ next: (response) => {
330
+ if (response.type > 0) {
331
+ Resolve({
332
+ body: {},
333
+ status: response.status,
334
+ message: response.statusText,
335
+ ok: true
336
+ });
337
+ }
338
+ },
339
+ error: (httpError) => {
340
+ this.ReleaseSubscription(subscription);
341
+ this.AlertError(httpError, request.alertError);
342
+ Resolve({
343
+ body: {},
344
+ status: httpError.status,
345
+ message: httpError.error?.message || httpError.error,
346
+ ok: false
347
+ });
348
+ },
349
+ complete: () => {
350
+ this.ReleaseSubscription(subscription);
351
+ if (Tools.IsNotOnlyWhiteSpace(request.alertSuccess)) {
352
+ this.alert.Success(request.alertSuccess, 'Deleted', 'fa-regular fa-trash-can');
353
+ }
194
354
  }
195
- }
196
- });
355
+ });
356
+ }
197
357
  });
198
358
  }
199
359
  /** */
@@ -245,4 +405,4 @@ export class Service {
245
405
  }
246
406
  }
247
407
  }
248
- //# 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}"]}
408
+ //# 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}"]}