nuxeo-development-framework 4.1.6 → 4.1.7

package/esm2015/lib/components/notifications/public-api.js

@@ -0,0 +1,12 @@
+export * from './components';
+export * from './constants/date';
+export * from './constants/pagination';
+export * from './constants/panel';
+export * from './constants/status';
+export * from './containers';
+export * from './directives/button.directive';
+export * from './directives/notification.directive';
+export * from './models';
+export * from './notifications.module';
+export * from './services/notifications.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL251eGVvLWRldmVsb3BtZW50LWZyYW1ld29yay9zcmMvbGliL2NvbXBvbmVudHMvbm90aWZpY2F0aW9ucy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHFDQUFxQyxDQUFDO0FBQ3BELGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxrQ0FBa0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29tcG9uZW50cyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzL2RhdGUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbnN0YW50cy9wYWdpbmF0aW9uJztcclxuZXhwb3J0ICogZnJvbSAnLi9jb25zdGFudHMvcGFuZWwnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbnN0YW50cy9zdGF0dXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NvbnRhaW5lcnMnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGl2ZXMvYnV0dG9uLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9ub3RpZmljYXRpb24uZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL25vdGlmaWNhdGlvbnMubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9ub3RpZmljYXRpb25zLnNlcnZpY2UnO1xyXG4iXX0=

package/esm2015/lib/components/notifications/services/index.js

@@ -0,0 +1,2 @@
+export * from './notifications.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25vdGlmaWNhdGlvbnMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbm90aWZpY2F0aW9ucy5zZXJ2aWNlJztcclxuIl19

package/esm2015/lib/components/notifications/services/listener.service.js

@@ -0,0 +1,19 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ListenerService {
+    constructor() {
+        this._updatesSub = new Subject();
+        this.onUpdate$ = this._updatesSub.asObservable();
+    }
+    triggerUpdate(actionName) {
+        this._updatesSub.next(actionName);
+    }
+}
+ListenerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ListenerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ListenerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ListenerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ListenerService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdGVuZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL251eGVvLWRldmVsb3BtZW50LWZyYW1ld29yay9zcmMvbGliL2NvbXBvbmVudHMvbm90aWZpY2F0aW9ucy9zZXJ2aWNlcy9saXN0ZW5lci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQzs7QUFHL0IsTUFBTSxPQUFPLGVBQWU7SUFENUI7UUFFbUIsZ0JBQVcsR0FBRyxJQUFJLE9BQU8sRUFBVSxDQUFDO1FBRTVDLGNBQVMsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLFlBQVksRUFBRSxDQUFDO0tBS3REO0lBSEMsYUFBYSxDQUFDLFVBQWtCO1FBQzlCLElBQUksQ0FBQyxXQUFXLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBQ3BDLENBQUM7OzZHQVBVLGVBQWU7aUhBQWYsZUFBZSxjQURGLE1BQU07NEZBQ25CLGVBQWU7a0JBRDNCLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XHJcblxyXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxyXG5leHBvcnQgY2xhc3MgTGlzdGVuZXJTZXJ2aWNlIHtcclxuICBwcml2YXRlIHJlYWRvbmx5IF91cGRhdGVzU3ViID0gbmV3IFN1YmplY3Q8c3RyaW5nPigpO1xyXG5cclxuICByZWFkb25seSBvblVwZGF0ZSQgPSB0aGlzLl91cGRhdGVzU3ViLmFzT2JzZXJ2YWJsZSgpO1xyXG5cclxuICB0cmlnZ2VyVXBkYXRlKGFjdGlvbk5hbWU6IHN0cmluZykge1xyXG4gICAgdGhpcy5fdXBkYXRlc1N1Yi5uZXh0KGFjdGlvbk5hbWUpO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2015/lib/components/notifications/services/notifications.service.js

@@ -0,0 +1,172 @@
+import { Inject, Injectable } from '@angular/core';
+import { from, Subject, throwError } from 'rxjs';
+import { catchError, map, switchMap, takeUntil } from 'rxjs/operators';
+import { NOTIFICATION_STATUS } from '../constants';
+import { mapNotificationsToPagingResponse } from '../utilities';
+import { SocketService } from './socket.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/services/nuxeo/nuxeo.service";
+import * as i2 from "../../../core/services/callApi/call-api.service";
+import * as i3 from "@angular/common/http";
+export class NotificationsService extends SocketService {
+    /**
+     *
+     */
+    constructor(_environment, _nuxeoService, _callApi, _http) {
+        var _a, _b, _c;
+        super(_environment, _nuxeoService);
+        this._environment = _environment;
+        this._nuxeoService = _nuxeoService;
+        this._callApi = _callApi;
+        this._http = _http;
+        this.listenerObserver = new Subject();
+        if (((_b = (_a = this._nuxeoService.nuxeoClient) === null || _a === void 0 ? void 0 : _a.user) === null || _b === void 0 ? void 0 : _b.id) && ((_c = this._environment) === null || _c === void 0 ? void 0 : _c.socketUrl)) {
+            this.socketConnect()
+                .pipe(switchMap(() => this.onMessage$), catchError((error) => {
+                console.log(error);
+                return throwError(() => error);
+            }), takeUntil(this._destroy$))
+                .subscribe((res) => {
+                this.listenerObserver.next(res);
+            });
+        }
+    }
+    get _tenantId() {
+        return this._nuxeoService.nuxeoClient.user.properties.tenantId;
+    }
+    get _appKey() {
+        var _a;
+        return (_a = this._environment) === null || _a === void 0 ? void 0 : _a.appKey;
+    }
+    getUnReadCount() {
+        return this._callApi
+            .query({
+            pageProvider: NotificationsService.providers.notificationsMango,
+            pageSize: 1,
+            notfnotificationcontent_company: this._tenantId,
+            notfnotificationcontent_applicationKey: this._appKey,
+            notfnotificationcontent_status: NOTIFICATION_STATUS.new,
+        }, {})
+            .pipe(map((data) => { var _a; return (_a = data.totalSize) !== null && _a !== void 0 ? _a : 0; }));
+    }
+    getNotificationsMongo(payload = {}) {
+        return this._getNotifications(NotificationsService.providers.notificationsMango, payload);
+    }
+    getNotifications(payload = {}) {
+        return this._getNotifications(NotificationsService.providers.notifications, payload);
+    }
+    markAllAsRead() {
+        return this._globalOperation('markAllAsRead');
+    }
+    markAllNewAsUnread() {
+        return this._globalOperation('markAllAsUnread');
+    }
+    markAsRead(id) {
+        return this._operation(id, 'markAsRead');
+    }
+    markAsUnread(id) {
+        return this._operation(id, 'markAsUnread');
+    }
+    markAsDeleted(id) {
+        return this._operation(id, 'markAsDeleted');
+    }
+    unsubscribe(id) {
+        return this._operation(id, 'unsubscribe');
+    }
+    subscribe(id) {
+        return this._operation(id, 'subscribe', {
+            companyName: this._tenantId,
+        });
+    }
+    resetSubscriptions() {
+        return from(this._nuxeoService.nuxeoClient
+            .operation(NotificationsService.operations.reset, {
+            url: `${this._environment.nuxeo}${this._environment.customAutomation}`,
+        })
+            .params({
+            companyName: this._tenantId,
+            applicationKey: this._appKey,
+        })
+            .execute());
+    }
+    getSourceTypes() {
+        return this._getVocabulary(`${this._environment.nuxeo}${NotificationsService.sourceType}`);
+    }
+    getChannels() {
+        return this._getVocabulary(`${this._environment.nuxeo}${NotificationsService.channels}`);
+    }
+    getDefinitions(payload = {}) {
+        return this._callApi
+            .query(Object.assign({ pageProvider: NotificationsService.providers.definition, notfnotificationdef_applicationKey: this._appKey, pageSize: Number.MAX_SAFE_INTEGER, notfnotificationdef_isActive: true }, payload), {
+            headers: {
+                properties: '*',
+            },
+        })
+            .pipe(map((data) => data.entries));
+    }
+    getSubscriptions(payload = {}) {
+        return this._callApi
+            .query(Object.assign({ pageProvider: NotificationsService.providers.subscription, notfsubscription_companyName: this._tenantId, notfsubscription_applicationKey: this._appKey, pageSize: Number.MAX_SAFE_INTEGER }, payload), {
+            headers: {
+                properties: '*',
+            },
+        })
+            .pipe(map((data) => data.entries));
+    }
+    _getNotifications(pageProvider, payload = {}) {
+        return this._callApi
+            .query(Object.assign({ pageProvider: pageProvider, notfnotificationcontent_company: this._tenantId, notfnotificationcontent_applicationKey: this._appKey }, payload), {
+            headers: {
+                properties: '*',
+            },
+        })
+            .pipe(map((data) => mapNotificationsToPagingResponse(data)));
+    }
+    _getVocabulary(url) {
+        return this._http.get(url).pipe(map((response) => response.entries), map((data) => data.sort((a, b) => b.properties['ordering'] < a.properties['ordering'] ? 1 : -1)));
+    }
+    _operation(id, option, params = {}) {
+        return from(this._nuxeoService.nuxeoClient
+            .operation(NotificationsService.operations[option], {
+            url: `${this._environment.nuxeo}${this._environment.customAutomation}`,
+        })
+            .params(params)
+            .input(id)
+            .execute());
+    }
+    _globalOperation(option, params = {}, headers = {}) {
+        return from(this._nuxeoService.nuxeoClient
+            .operation(NotificationsService.operations[option], {
+            url: `${this._environment.nuxeo}${this._environment.customAutomation}`,
+        })
+            .params(Object.assign({ companyName: this._tenantId, applicationKey: this._appKey }, params))
+            .execute({}));
+    }
+}
+NotificationsService.sourceType = '/api/v1/directory/VOC_Notf_SourceTypes';
+NotificationsService.channels = '/api/v1/directory/VOC_Notf_NotificationChannels';
+NotificationsService.providers = {
+    notifications: 'PP_NotfNotificationContent',
+    notificationsMango: 'PP_NotfNotificationContent_Mongo',
+    subscription: 'PP_NotfSubscription_Mongo',
+    definition: 'PP_NotfNotificationDefinition_Mongo',
+};
+NotificationsService.operations = {
+    markAllAsRead: 'AC_UA_NotfNotification_ReadAll',
+    markAsRead: 'AC_UA_NotfNotification_Read',
+    markAsUnread: 'AC_UA_NotfNotification_Unread',
+    markAsDeleted: 'AC_UA_NotfNotification_ToDeleted',
+    unsubscribe: 'AC_UA_NotfNotification_Unsubscribe',
+    subscribe: 'AC_UA_NotfNotification_Subscribe',
+    reset: 'AC_UA_NotfNotification_ResetSubscription',
+    markAllAsUnread: 'AC_UA_NotfNotification_UnreadAll',
+};
+NotificationsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationsService, deps: [{ token: 'environment' }, { token: i1.NuxeoService }, { token: i2.CallApiService }, { token: i3.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+NotificationsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NotificationsService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.NuxeoService }, { type: i2.CallApiService }, { type: i3.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notifications.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/notifications/services/notifications.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGnD,OAAO,EAAE,IAAI,EAAc,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAKvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AASnD,OAAO,EAAE,gCAAgC,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;;;;;AAEjD,MAAM,OAAO,oBAAqB,SAAQ,aAAa;IA+BrD;;OAEG;IACH,YACmC,YAAiC,EACxD,aAA2B,EAC3B,QAAwB,EACxB,KAAiB;;QAE3B,KAAK,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;QALF,iBAAY,GAAZ,YAAY,CAAqB;QACxD,kBAAa,GAAb,aAAa,CAAc;QAC3B,aAAQ,GAAR,QAAQ,CAAgB;QACxB,UAAK,GAAL,KAAK,CAAY;QArC7B,qBAAgB,GAAG,IAAI,OAAO,EAA4B,CAAC;QAyCzD,IAAI,CAAA,MAAA,MAAA,IAAI,CAAC,aAAa,CAAC,WAAW,0CAAE,IAAI,0CAAE,EAAE,MAAI,MAAA,IAAI,CAAC,YAAY,0CAAE,SAAS,CAAA,EAAE;YAC5E,IAAI,CAAC,aAAa,EAAE;iBACjB,IAAI,CACH,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,EAChC,UAAU,CAAC,CAAC,KAAU,EAAE,EAAE;gBACxB,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACnB,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;YACjC,CAAC,CAAC,EACF,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAC1B;iBACA,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE;gBACjB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClC,CAAC,CAAC,CAAC;SACN;IACH,CAAC;IAjCD,IAAY,SAAS;QACnB,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;IACjE,CAAC;IAED,IAAY,OAAO;;QACjB,OAAO,MAAA,IAAI,CAAC,YAAY,0CAAE,MAAM,CAAC;IACnC,CAAC;IA6BD,cAAc;QACZ,OAAO,IAAI,CAAC,QAAQ;aACjB,KAAK,CACJ;YACE,YAAY,EAAE,oBAAoB,CAAC,SAAS,CAAC,kBAAkB;YAC/D,QAAQ,EAAE,CAAC;YACX,+BAA+B,EAAE,IAAI,CAAC,SAAS;YAC/C,sCAAsC,EAAE,IAAI,CAAC,OAAO;YACpD,8BAA8B,EAAE,mBAAmB,CAAC,GAAG;SACxD,EACD,EAAE,CACH;aACA,IAAI,CAAC,GAAG,CAAC,CAAC,IAAyC,EAAE,EAAE,WAAC,OAAA,MAAA,IAAI,CAAC,SAAS,mCAAI,CAAC,CAAA,EAAA,CAAC,CAAC,CAAC;IACnF,CAAC;IAED,qBAAqB,CAAC,UAA8B,EAAE;QACpD,OAAO,IAAI,CAAC,iBAAiB,CAC3B,oBAAoB,CAAC,SAAS,CAAC,kBAAkB,EACjD,OAAO,CACR,CAAC;IACJ,CAAC;IAED,gBAAgB,CAAC,UAA8B,EAAE;QAC/C,OAAO,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,SAAS,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;IACvF,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC;IAChD,CAAC;IAED,kBAAkB;QAChB,OAAO,IAAI,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAAC;IAClD,CAAC;IAED,UAAU,CAAC,EAAU;QACnB,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC;IAC3C,CAAC;IAED,YAAY,CAAC,EAAU;QACrB,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC;IAC7C,CAAC;IAED,aAAa,CAAC,EAAU;QACtB,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,eAAe,CAAC,CAAC;IAC9C,CAAC;IAED,WAAW,CAAC,EAAU;QACpB,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,aAAa,CAAC,CAAC;IAC5C,CAAC;IAED,SAAS,CAAC,EAAU;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,WAAW,EAAE;YACtC,WAAW,EAAE,IAAI,CAAC,SAAS;SAC5B,CAAC,CAAC;IACL,CAAC;IAED,kBAAkB;QAChB,OAAO,IAAI,CACT,IAAI,CAAC,aAAa,CAAC,WAAW;aAC3B,SAAS,CAAC,oBAAoB,CAAC,UAAU,CAAC,KAAK,EAAE;YAChD,GAAG,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE;SACvE,CAAC;aACD,MAAM,CAAC;YACN,WAAW,EAAE,IAAI,CAAC,SAAS;YAC3B,cAAc,EAAE,IAAI,CAAC,OAAO;SAC7B,CAAC;aACD,OAAO,EAAE,CACoD,CAAC;IACrE,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,cAAc,CACxB,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,oBAAoB,CAAC,UAAU,EAAE,CAC/D,CAAC;IACJ,CAAC;IAED,WAAW;QACT,OAAO,IAAI,CAAC,cAAc,CACxB,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,oBAAoB,CAAC,QAAQ,EAAE,CAC7D,CAAC;IACJ,CAAC;IAED,cAAc,CAAC,UAA8B,EAAE;QAC7C,OAAO,IAAI,CAAC,QAAQ;aACjB,KAAK,iBAEF,YAAY,EAAE,oBAAoB,CAAC,SAAS,CAAC,UAAU,EACvD,kCAAkC,EAAE,IAAI,CAAC,OAAO,EAChD,QAAQ,EAAE,MAAM,CAAC,gBAAgB,EACjC,4BAA4B,EAAI,IAAI,IACjC,OAAO,GAEZ;YACE,OAAO,EAAE;gBACP,UAAU,EAAE,GAAG;aAChB;SACF,CACF;aACA,IAAI,CAAC,GAAG,CAAC,CAAC,IAAmD,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACtF,CAAC;IAED,gBAAgB,CAAC,UAA8B,EAAE;QAC/C,OAAO,IAAI,CAAC,QAAQ;aACjB,KAAK,iBAEF,YAAY,EAAE,oBAAoB,CAAC,SAAS,CAAC,YAAY,EACzD,4BAA4B,EAAE,IAAI,CAAC,SAAS,EAC5C,+BAA+B,EAAE,IAAI,CAAC,OAAO,EAC7C,QAAQ,EAAE,MAAM,CAAC,gBAAgB,IAC9B,OAAO,GAEZ;YACE,OAAO,EAAE;gBACP,UAAU,EAAE,GAAG;aAChB;SACF,CACF;aACA,IAAI,CAAC,GAAG,CAAC,CAAC,IAAqD,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IACxF,CAAC;IAEO,iBAAiB,CAAC,YAAoB,EAAE,UAA8B,EAAE;QAC9E,OAAO,IAAI,CAAC,QAAQ;aACjB,KAAK,iBAEF,YAAY,EAAE,YAAY,EAC1B,+BAA+B,EAAE,IAAI,CAAC,SAAS,EAC/C,sCAAsC,EAAE,IAAI,CAAC,OAAO,IACjD,OAAO,GAEZ;YACE,OAAO,EAAE;gBACP,UAAU,EAAE,GAAG;aAChB;SACF,CACF;aACA,IAAI,CACH,GAAG,CAAC,CAAC,IAAyC,EAAE,EAAE,CAChD,gCAAgC,CAAC,IAAI,CAAC,CACvC,CACF,CAAC;IACN,CAAC;IAEO,cAAc,CAAC,GAAW;QAChC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAmC,GAAG,CAAC,CAAC,IAAI,CAC/D,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,EACnC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACX,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACjB,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAC7D,CACF,CACF,CAAC;IACJ,CAAC;IAEO,UAAU,CAChB,EAAU,EACV,MAAoD,EACpD,SAA8B,EAAE;QAEhC,OAAO,IAAI,CACT,IAAI,CAAC,aAAa,CAAC,WAAW;aAC3B,SAAS,CAAC,oBAAoB,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;YAClD,GAAG,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE;SACvE,CAAC;aACD,MAAM,CAAC,MAAM,CAAC;aACd,KAAK,CAAC,EAAE,CAAC;aACT,OAAO,EAAE,CACqC,CAAC;IACtD,CAAC;IAEO,gBAAgB,CACtB,MAAoD,EACpD,SAA8B,EAAE,EAChC,UAA+B,EAAE;QAEjC,OAAO,IAAI,CACT,IAAI,CAAC,aAAa,CAAC,WAAW;aAC3B,SAAS,CAAC,oBAAoB,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE;YAClD,GAAG,EAAE,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,GAAG,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE;SACvE,CAAC;aACD,MAAM,iBACL,WAAW,EAAE,IAAI,CAAC,SAAS,EAC3B,cAAc,EAAE,IAAI,CAAC,OAAO,IACzB,MAAM,EACT;aACD,OAAO,CAAC,EAAE,CAAC,CACkD,CAAC;IACrE,CAAC;;AAlPe,+BAAU,GAAG,wCAAwC,CAAC;AACtD,6BAAQ,GAAG,iDAAiD,CAAC;AAE7D,8BAAS,GAAG;IAC1B,aAAa,EAAE,4BAA4B;IAC3C,kBAAkB,EAAE,kCAAkC;IACtD,YAAY,EAAE,2BAA2B;IACzC,UAAU,EAAE,qCAAqC;CAClD,CAAC;AAEc,+BAAU,GAAG;IAC3B,aAAa,EAAE,gCAAgC;IAC/C,UAAU,EAAE,6BAA6B;IACzC,YAAY,EAAE,+BAA+B;IAC7C,aAAa,EAAE,kCAAkC;IACjD,WAAW,EAAE,oCAAoC;IACjD,SAAS,EAAE,kCAAkC;IAC7C,KAAK,EAAE,0CAA0C;IACjD,eAAe,EAAE,kCAAkC;CACpD,CAAC;kHArBS,oBAAoB,kBAmCrB,aAAa;sHAnCZ,oBAAoB;4FAApB,oBAAoB;kBADhC,UAAU;;0BAoCN,MAAM;2BAAC,aAAa","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\n\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { from, Observable, Subject, throwError } from 'rxjs';\r\nimport { catchError, map, switchMap, takeUntil } from 'rxjs/operators';\r\nimport { ApiResponseModel, AutomationResponseModel } from '../../../core/models';\r\nimport { CallApiService } from '../../../core/services/callApi/call-api.service';\r\n\r\nimport { NuxeoService } from '../../../core/services/nuxeo/nuxeo.service';\r\nimport { NOTIFICATION_STATUS } from '../constants';\r\nimport {\r\n  NotificationDefinitionModel,\r\n  NotificationMessageModel,\r\n  NotificationModel,\r\n  NotificationSubscriptionModel,\r\n  PayloadParamsModel,\r\n  VocabularyType,\r\n} from '../models';\r\nimport { mapNotificationsToPagingResponse } from '../utilities';\r\nimport { SocketService } from './socket.service';\r\n@Injectable()\r\nexport class NotificationsService extends SocketService {\r\n  listenerObserver = new Subject<NotificationMessageModel>();\r\n  static readonly sourceType = '/api/v1/directory/VOC_Notf_SourceTypes';\r\n  static readonly channels = '/api/v1/directory/VOC_Notf_NotificationChannels';\r\n\r\n  static readonly providers = {\r\n    notifications: 'PP_NotfNotificationContent',\r\n    notificationsMango: 'PP_NotfNotificationContent_Mongo',\r\n    subscription: 'PP_NotfSubscription_Mongo',\r\n    definition: 'PP_NotfNotificationDefinition_Mongo',\r\n  };\r\n\r\n  static readonly operations = {\r\n    markAllAsRead: 'AC_UA_NotfNotification_ReadAll',\r\n    markAsRead: 'AC_UA_NotfNotification_Read',\r\n    markAsUnread: 'AC_UA_NotfNotification_Unread',\r\n    markAsDeleted: 'AC_UA_NotfNotification_ToDeleted',\r\n    unsubscribe: 'AC_UA_NotfNotification_Unsubscribe',\r\n    subscribe: 'AC_UA_NotfNotification_Subscribe',\r\n    reset: 'AC_UA_NotfNotification_ResetSubscription',\r\n    markAllAsUnread: 'AC_UA_NotfNotification_UnreadAll',\r\n  };\r\n\r\n  private get _tenantId() {\r\n    return this._nuxeoService.nuxeoClient.user.properties.tenantId;\r\n  }\r\n\r\n  private get _appKey() {\r\n    return this._environment?.appKey;\r\n  }\r\n\r\n  /**\r\n   *\r\n   */\r\n  constructor(\r\n    @Inject('environment') protected _environment: Record<string, any>,\r\n    protected _nuxeoService: NuxeoService,\r\n    protected _callApi: CallApiService,\r\n    protected _http: HttpClient\r\n  ) {\r\n    super(_environment, _nuxeoService);\r\n\r\n    if (this._nuxeoService.nuxeoClient?.user?.id && this._environment?.socketUrl) {\r\n      this.socketConnect()\r\n        .pipe(\r\n          switchMap(() => this.onMessage$),\r\n          catchError((error: any) => {\r\n            console.log(error);\r\n            return throwError(() => error);\r\n          }),\r\n          takeUntil(this._destroy$)\r\n        )\r\n        .subscribe((res) => {\r\n          this.listenerObserver.next(res);\r\n        });\r\n    }\r\n  }\r\n\r\n  getUnReadCount(): Observable<number> {\r\n    return this._callApi\r\n      .query(\r\n        {\r\n          pageProvider: NotificationsService.providers.notificationsMango,\r\n          pageSize: 1,\r\n          notfnotificationcontent_company: this._tenantId,\r\n          notfnotificationcontent_applicationKey: this._appKey,\r\n          notfnotificationcontent_status: NOTIFICATION_STATUS.new,\r\n        },\r\n        {}\r\n      )\r\n      .pipe(map((data: ApiResponseModel<NotificationModel>) => data.totalSize ?? 0));\r\n  }\r\n\r\n  getNotificationsMongo(payload: PayloadParamsModel = {}) {\r\n    return this._getNotifications(\r\n      NotificationsService.providers.notificationsMango,\r\n      payload\r\n    );\r\n  }\r\n\r\n  getNotifications(payload: PayloadParamsModel = {}) {\r\n    return this._getNotifications(NotificationsService.providers.notifications, payload);\r\n  }\r\n\r\n  markAllAsRead() {\r\n    return this._globalOperation('markAllAsRead');\r\n  }\r\n\r\n  markAllNewAsUnread() {\r\n    return this._globalOperation('markAllAsUnread');\r\n  }\r\n\r\n  markAsRead(id: string) {\r\n    return this._operation(id, 'markAsRead');\r\n  }\r\n\r\n  markAsUnread(id: string) {\r\n    return this._operation(id, 'markAsUnread');\r\n  }\r\n\r\n  markAsDeleted(id: string) {\r\n    return this._operation(id, 'markAsDeleted');\r\n  }\r\n\r\n  unsubscribe(id: string) {\r\n    return this._operation(id, 'unsubscribe');\r\n  }\r\n\r\n  subscribe(id: string) {\r\n    return this._operation(id, 'subscribe', {\r\n      companyName: this._tenantId,\r\n    });\r\n  }\r\n\r\n  resetSubscriptions() {\r\n    return from(\r\n      this._nuxeoService.nuxeoClient\r\n        .operation(NotificationsService.operations.reset, {\r\n          url: `${this._environment.nuxeo}${this._environment.customAutomation}`,\r\n        })\r\n        .params({\r\n          companyName: this._tenantId,\r\n          applicationKey: this._appKey,\r\n        })\r\n        .execute()\r\n    ) as Observable<AutomationResponseModel<Record<PropertyKey, any>>>;\r\n  }\r\n\r\n  getSourceTypes() {\r\n    return this._getVocabulary(\r\n      `${this._environment.nuxeo}${NotificationsService.sourceType}`\r\n    );\r\n  }\r\n\r\n  getChannels() {\r\n    return this._getVocabulary(\r\n      `${this._environment.nuxeo}${NotificationsService.channels}`\r\n    );\r\n  }\r\n\r\n  getDefinitions(payload: PayloadParamsModel = {}) {\r\n    return this._callApi\r\n      .query(\r\n        {\r\n          pageProvider: NotificationsService.providers.definition,\r\n          notfnotificationdef_applicationKey: this._appKey,\r\n          pageSize: Number.MAX_SAFE_INTEGER,\r\n          notfnotificationdef_isActive  : true,\r\n          ...payload,\r\n        },\r\n        {\r\n          headers: {\r\n            properties: '*',\r\n          },\r\n        }\r\n      )\r\n      .pipe(map((data: ApiResponseModel<NotificationDefinitionModel>) => data.entries));\r\n  }\r\n\r\n  getSubscriptions(payload: PayloadParamsModel = {}) {\r\n    return this._callApi\r\n      .query(\r\n        {\r\n          pageProvider: NotificationsService.providers.subscription,\r\n          notfsubscription_companyName: this._tenantId,\r\n          notfsubscription_applicationKey: this._appKey,\r\n          pageSize: Number.MAX_SAFE_INTEGER,\r\n          ...payload,\r\n        },\r\n        {\r\n          headers: {\r\n            properties: '*',\r\n          },\r\n        }\r\n      )\r\n      .pipe(map((data: ApiResponseModel<NotificationSubscriptionModel>) => data.entries));\r\n  }\r\n\r\n  private _getNotifications(pageProvider: string, payload: PayloadParamsModel = {}) {\r\n    return this._callApi\r\n      .query(\r\n        {\r\n          pageProvider: pageProvider,\r\n          notfnotificationcontent_company: this._tenantId,\r\n          notfnotificationcontent_applicationKey: this._appKey,\r\n          ...payload,\r\n        },\r\n        {\r\n          headers: {\r\n            properties: '*',\r\n          },\r\n        }\r\n      )\r\n      .pipe(\r\n        map((data: ApiResponseModel<NotificationModel>) =>\r\n          mapNotificationsToPagingResponse(data)\r\n        )\r\n      );\r\n  }\r\n\r\n  private _getVocabulary(url: string) {\r\n    return this._http.get<ApiResponseModel<VocabularyType>>(url).pipe(\r\n      map((response) => response.entries),\r\n      map((data) =>\r\n        data.sort((a, b) =>\r\n          b.properties['ordering'] < a.properties['ordering'] ? 1 : -1\r\n        )\r\n      )\r\n    );\r\n  }\r\n\r\n  private _operation<TResponse = Record<PropertyKey, any>>(\r\n    id: string,\r\n    option: keyof typeof NotificationsService.operations,\r\n    params: Record<string, any> = {}\r\n  ) {\r\n    return from(\r\n      this._nuxeoService.nuxeoClient\r\n        .operation(NotificationsService.operations[option], {\r\n          url: `${this._environment.nuxeo}${this._environment.customAutomation}`,\r\n        })\r\n        .params(params)\r\n        .input(id)\r\n        .execute()\r\n    ) as Observable<AutomationResponseModel<TResponse>>;\r\n  }\r\n\r\n  private _globalOperation(\r\n    option: keyof typeof NotificationsService.operations,\r\n    params: Record<string, any> = {},\r\n    headers: Record<string, any> = {}\r\n  ) {\r\n    return from(\r\n      this._nuxeoService.nuxeoClient\r\n        .operation(NotificationsService.operations[option], {\r\n          url: `${this._environment.nuxeo}${this._environment.customAutomation}`,\r\n        })\r\n        .params({\r\n          companyName: this._tenantId,\r\n          applicationKey: this._appKey,\r\n          ...params,\r\n        })\r\n        .execute({})\r\n    ) as Observable<AutomationResponseModel<Record<PropertyKey, any>>>;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/notifications/services/params.service.js

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ParamsService {
+    constructor() {
+        this._paramsSub = new ReplaySubject(1);
+        this.params$ = this._paramsSub.asObservable();
+        this._activatedParams = null;
+        this._defaultParams = new BehaviorSubject({});
+    }
+    get activatedQuery() {
+        return this._activatedParams;
+    }
+    setDefaultParams(params) {
+        this._defaultParams.next(params);
+    }
+    applyParams(payload = null, includeDefaults = true) {
+        const _defaults = includeDefaults ? this._defaultParams.getValue() : {};
+        this._activatedParams = Object.assign({}, _defaults, (payload === null || payload === void 0 ? void 0 : payload.params) || {});
+        this._paramsSub.next({
+            override: !!(payload === null || payload === void 0 ? void 0 : payload.override),
+            params: this._activatedParams,
+        });
+    }
+}
+ParamsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ParamsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ParamsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ParamsService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ParamsService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/notifications/services/response.service.js

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ResponseService {
+    constructor() {
+        this.totalItems = 0;
+        this.itemsLength = 0;
+        this.selectedPage = 0;
+        this._responseSub = new BehaviorSubject(null);
+        this.response$ = this._responseSub.asObservable();
+    }
+    getResponse() {
+        return this._responseSub.getValue();
+    }
+    setResponse(res, isOverride = false) {
+        var _a, _b, _c;
+        this.totalItems = res.totalItems;
+        if (isOverride) {
+            this.itemsLength = res.data.length;
+            this._responseSub.next(res);
+        }
+        else {
+            const value = (_c = (_b = (_a = this._responseSub.getValue()) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.concat(res.data)) !== null && _c !== void 0 ? _c : res.data;
+            this.itemsLength = value.length;
+            res.data = value;
+            this._responseSub.next(res);
+        }
+    }
+    increasePage(size = 1) {
+        this.selectedPage = this.selectedPage + size;
+    }
+    decreasePage(size = 1) {
+        this.selectedPage = this.selectedPage - size;
+    }
+    setPage(size = 1) {
+        this.selectedPage = size;
+    }
+    removeFromResponse(uid) {
+        const _response = this.getResponse();
+        const _data = _response === null || _response === void 0 ? void 0 : _response.data;
+        _response.data = _data.filter((not) => not['uid'] !== uid);
+        this.setResponse(_response, true);
+    }
+    patchResponse(uid, payload) {
+        const _response = this.getResponse();
+        const _data = _response === null || _response === void 0 ? void 0 : _response.data;
+        const index = _data.findIndex((not) => not['uid'] === uid);
+        if (index > -1) {
+            _data[index] = Object.assign({}, _data[index], payload);
+            _response.data = _data;
+            this.setResponse(_response, true);
+        }
+    }
+    resetPagination() {
+        this.totalItems = 0;
+        this.itemsLength = 0;
+        this.selectedPage = 0;
+    }
+}
+ResponseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ResponseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ResponseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ResponseService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ResponseService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/notifications/services/socket.service.js

@@ -0,0 +1,76 @@
+import { Inject, Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/services/nuxeo/nuxeo.service";
+export class SocketService {
+    constructor(_environment, _nuxeoService) {
+        this._environment = _environment;
+        this._nuxeoService = _nuxeoService;
+        this._destroy$ = new Subject();
+        this._messageSub = new ReplaySubject();
+        this._connecting = false;
+        this._connectionSource = new BehaviorSubject(false);
+        this.onMessage$ = this._messageSub.asObservable();
+    }
+    _isConnected() {
+        return this._socket && this._socket.readyState === WebSocket.OPEN;
+    }
+    socketConnect() {
+        if (!this._connecting && !this._isConnected()) {
+            this._connecting = true;
+            this._prepareConnection();
+        }
+        return this._connectionSource.asObservable();
+    }
+    disconnect() {
+        if (this._isConnected()) {
+            this._socket.close();
+            this._connectionSource.next(false);
+            this.ngOnDestroy();
+        }
+    }
+    _prepareConnection() {
+        var _a;
+        try {
+            const socket = new WebSocket((_a = this._environment) === null || _a === void 0 ? void 0 : _a.socketUrl);
+            socket.onopen = (event) => this._handleSocketConnection(true, event);
+            socket.onclose = (event) => this._handleSocketConnection(false, event);
+            socket.onerror = (event) => this._handleSocketError(event);
+            socket.onmessage = (event) => this._handleSocketMessage(event);
+            this._socket = socket;
+        }
+        catch (error) {
+            this._handleSocketError(error);
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    _handleSocketMessage(event) {
+        const notificationData = JSON.parse(event.data);
+        this._messageSub.next(notificationData);
+    }
+    _handleSocketConnection(isConnected, event) {
+        this._connectionSource.next(isConnected);
+        this._connecting = false;
+        console.log(isConnected ? 'WebSocket connected' : 'WebSocket disconnected', event);
+    }
+    _handleSocketError(event) {
+        this._connectionSource.next(false);
+        this._connecting = false;
+        console.log('WebSocket Error', event);
+    }
+}
+SocketService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SocketService, deps: [{ token: 'environment' }, { token: i1.NuxeoService }], target: i0.ɵɵFactoryTarget.Injectable });
+SocketService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SocketService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: i1.NuxeoService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/notifications/utilities/index.js

@@ -0,0 +1,2 @@
+export * from './response.adapter';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9udXhlby1kZXZlbG9wbWVudC1mcmFtZXdvcmsvc3JjL2xpYi9jb21wb25lbnRzL25vdGlmaWNhdGlvbnMvdXRpbGl0aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJcclxuZXhwb3J0ICogZnJvbSAnLi9yZXNwb25zZS5hZGFwdGVyJztcclxuIl19

package/esm2015/lib/components/notifications/utilities/response.adapter.js

@@ -0,0 +1,12 @@
+export const mapNotificationsToPagingResponse = (res) => {
+    return {
+        data: res.entries,
+        page: res.currentPageIndex,
+        totalItems: res.resultsCount || res.totalSize,
+        pageCount: res.pageCount,
+        size: res.pageSize,
+        hasPreviousPage: res.isPreviousPageAvailable,
+        hasNextPage: res.isNextPageAvailable,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzcG9uc2UuYWRhcHRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL251eGVvLWRldmVsb3BtZW50LWZyYW1ld29yay9zcmMvbGliL2NvbXBvbmVudHMvbm90aWZpY2F0aW9ucy91dGlsaXRpZXMvcmVzcG9uc2UuYWRhcHRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLENBQUMsTUFBTSxnQ0FBZ0MsR0FFYSxDQUFDLEdBQUcsRUFBRSxFQUFFO0lBQ2hFLE9BQU87UUFDTCxJQUFJLEVBQUUsR0FBRyxDQUFDLE9BQU87UUFDakIsSUFBSSxFQUFFLEdBQUcsQ0FBQyxnQkFBZ0I7UUFDMUIsVUFBVSxFQUFFLEdBQUcsQ0FBQyxZQUFZLElBQUksR0FBRyxDQUFDLFNBQVM7UUFDN0MsU0FBUyxFQUFFLEdBQUcsQ0FBQyxTQUFTO1FBQ3hCLElBQUksRUFBRSxHQUFHLENBQUMsUUFBUTtRQUNsQixlQUFlLEVBQUUsR0FBRyxDQUFDLHVCQUF1QjtRQUM1QyxXQUFXLEVBQUUsR0FBRyxDQUFDLG1CQUFtQjtLQUNyQyxDQUFDO0FBQ0osQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXBpUmVzcG9uc2VNb2RlbCB9IGZyb20gJy4uLy4uLy4uL2NvcmUvbW9kZWxzJztcclxuaW1wb3J0IHsgTm90aWZpY2F0aW9uTW9kZWwsIE5vdGlmaWNhdGlvblBhZ2luZ1Jlc3BvbnNlTW9kZWwgfSBmcm9tICcuLi9tb2RlbHMnO1xyXG5cclxuZXhwb3J0IGNvbnN0IG1hcE5vdGlmaWNhdGlvbnNUb1BhZ2luZ1Jlc3BvbnNlOiAoXHJcbiAgcmVzcG9uc2U6IEFwaVJlc3BvbnNlTW9kZWw8Tm90aWZpY2F0aW9uTW9kZWw+XHJcbikgPT4gTm90aWZpY2F0aW9uUGFnaW5nUmVzcG9uc2VNb2RlbDxOb3RpZmljYXRpb25Nb2RlbD4gPSAocmVzKSA9PiB7XHJcbiAgcmV0dXJuIHtcclxuICAgIGRhdGE6IHJlcy5lbnRyaWVzLFxyXG4gICAgcGFnZTogcmVzLmN1cnJlbnRQYWdlSW5kZXgsXHJcbiAgICB0b3RhbEl0ZW1zOiByZXMucmVzdWx0c0NvdW50IHx8IHJlcy50b3RhbFNpemUsXHJcbiAgICBwYWdlQ291bnQ6IHJlcy5wYWdlQ291bnQsXHJcbiAgICBzaXplOiByZXMucGFnZVNpemUsXHJcbiAgICBoYXNQcmV2aW91c1BhZ2U6IHJlcy5pc1ByZXZpb3VzUGFnZUF2YWlsYWJsZSxcclxuICAgIGhhc05leHRQYWdlOiByZXMuaXNOZXh0UGFnZUF2YWlsYWJsZSxcclxuICB9O1xyXG59O1xyXG4iXX0=

package/esm2015/lib/components/pagination/pagination/pagination.component.js

@@ -0,0 +1,124 @@
+import { Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../../../directive/rtl/set-rtl.directive";
+/**
+ * you can use this component for any pagination
+ *
+ * ![Screenshot-1](../screenshots/pagination.png)
+ * @title
+ * Pagination
+ *
+ * @example
+ * <cts-pagination
+ *    [page]="pageNumber"
+ *    (change)="PaginationChange($event)"
+ *    [size]="PageSize"
+ *    [count]="totalRecords">
+ * </cts-pagination>
+ */
+export class PaginationComponent {
+    constructor() {
+        /** Page changed event */
+        this.change = new EventEmitter();
+        this._count = 0;
+        this._page = 1;
+        this._size = 0;
+    }
+    ngOnInit() {
+    }
+    /** Page Size */
+    set size(val) {
+        this._size = val;
+        this.pages = this.calcPages();
+    }
+    get size() {
+        return this._size;
+    }
+    /** Total records count */
+    set count(val) {
+        this._count = val;
+        this.pages = this.calcPages();
+    }
+    get count() {
+        return this._count;
+    }
+    /** Page Number */
+    set page(val) {
+        this._page = val;
+        this.pages = this.calcPages();
+    }
+    get page() {
+        return this._page;
+    }
+    /** Pages Count */
+    get totalPages() {
+        const count = this.size < 1 ? 1 : Math.ceil(this.count / this.size);
+        return Math.max(count || 0, 1);
+    }
+    canPrevious() {
+        return this.page > 1;
+    }
+    canNext() {
+        return this.page < this.totalPages;
+    }
+    prevPage() {
+        this.selectPage(this.page - 1);
+    }
+    nextPage() {
+        this.selectPage(this.page + 1);
+    }
+    selectPage(page) {
+        if (page > 0 && page <= this.totalPages && page !== this.page) {
+            this.page = page;
+            this.change.emit(page);
+        }
+    }
+    calcPages(page) {
+        const pages = [];
+        let startPage = 1;
+        let endPage = this.totalPages;
+        const maxSize = 5;
+        const isMaxSized = maxSize < this.totalPages;
+        page = page || this.page;
+        if (isMaxSized) {
+            startPage = page - Math.floor(maxSize / 2);
+            endPage = page + Math.floor(maxSize / 2);
+            if (startPage < 1) {
+                startPage = 1;
+                endPage = Math.min(startPage + maxSize - 1, this.totalPages);
+            }
+            else if (endPage > this.totalPages) {
+                startPage = Math.max(this.totalPages - maxSize + 1, 1);
+                endPage = this.totalPages;
+            }
+        }
+        for (let num = startPage; num <= endPage; num++) {
+            pages.push({
+                number: num,
+                text: num
+            });
+        }
+        return pages;
+    }
+}
+PaginationComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PaginationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+PaginationComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: PaginationComponent, selector: "cts-pagination", inputs: { size: "size", count: "count", page: "page" }, outputs: { change: "change" }, ngImport: i0, template: "<ul class=\"pagination\" SetRtl *ngIf=\"pages.length > 1\">\r\n  <li class=\"rotat-icon\" [class.disabled]=\"!canPrevious()\">\r\n    <a\r\n      role=\"button\"\r\n      aria-label=\"go to previous page\"\r\n      href=\"javascript:void(0)\"\r\n      (click)=\"prevPage()\"\r\n    >\r\n      <i class=\"bi bi-caret-left\"></i>\r\n    </a>\r\n  </li>\r\n  <li\r\n    role=\"button\"\r\n    [attr.aria-label]=\"'page ' + pg.number\"\r\n    class=\"pages\"\r\n    *ngFor=\"let pg of pages\"\r\n    [class.active]=\"pg.number === page\"\r\n  >\r\n    <a href=\"javascript:void(0)\" (click)=\"selectPage(pg.number)\">\r\n      {{ pg.text }}\r\n    </a>\r\n  </li>\r\n  <li class=\"rotat-icon\" [class.disabled]=\"!canNext()\">\r\n    <a\r\n      role=\"button\"\r\n      aria-label=\"go to next page\"\r\n      href=\"javascript:void(0)\"\r\n      (click)=\"nextPage()\"\r\n    >\r\n      <i class=\"bi bi-caret-right\"></i>\r\n    </a>\r\n  </li>\r\n</ul>\r\n", styles: [".pagination{padding:0;margin:0;display:inline-block;list-style:none}.pagination li{padding:0;margin:0;display:inline-block;list-style:none}.pagination li a{height:22px;min-width:24px;line-height:22px;padding:0 6px;border-radius:5px;margin:6px 3px;text-align:center;vertical-align:top;color:#0000008a;text-decoration:none;vertical-align:bottom}.pagination li a i{font-size:20px;line-height:20px;padding:0 3px}.pagination li.disabled a{color:#00000042!important;background-color:transparent!important;cursor:not-allowed}.pagination li.active{background-color:#9e9e9e33;font-weight:bold}.pagination.rtl .rotat-icon{transform:rotate(180deg)}\n"], directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.SetRtlDirective, selector: "[SetRtl]" }, { type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PaginationComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cts-pagination',
+                    templateUrl: './pagination.component.html',
+                    styleUrls: ['./pagination.component.scss'],
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { size: [{
+                type: Input
+            }], count: [{
+                type: Input
+            }], page: [{
+                type: Input
+            }], change: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.component.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/components/pagination/pagination/pagination.component.ts","../../../../../../../projects/nuxeo-development-framework/src/lib/components/pagination/pagination/pagination.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output, ViewEncapsulation } from '@angular/core';\r\n\r\n/**\r\n * you can use this component for any pagination\r\n *\r\n * ![Screenshot-1](../screenshots/pagination.png)\r\n * @title\r\n * Pagination\r\n *\r\n * @example\r\n * <cts-pagination\r\n *    [page]=\"pageNumber\"\r\n *    (change)=\"PaginationChange($event)\"\r\n *    [size]=\"PageSize\"\r\n *    [count]=\"totalRecords\">\r\n * </cts-pagination>\r\n */\r\n@Component({\r\n  selector: 'cts-pagination',\r\n  templateUrl: './pagination.component.html',\r\n  styleUrls: ['./pagination.component.scss'],\r\n  encapsulation : ViewEncapsulation.None\r\n})\r\nexport class PaginationComponent implements OnInit {\r\n\r\n  constructor() { }\r\n\r\n  ngOnInit(): void {\r\n  }\r\n\r\n  /** Page Size */\r\n  @Input()\r\n  set size(val: number) {\r\n    this._size = val;\r\n    this.pages = this.calcPages();\r\n  }\r\n\r\n  get size(): number {\r\n    return this._size;\r\n  }\r\n\r\n  /** Total records count */\r\n  @Input()\r\n  set count(val: number) {\r\n    this._count = val;\r\n    this.pages = this.calcPages();\r\n  }\r\n\r\n  get count(): number {\r\n    return this._count;\r\n  }\r\n /** Page Number */\r\n  @Input()\r\n  set page(val: number) {\r\n    this._page = val;\r\n    this.pages = this.calcPages();\r\n  }\r\n\r\n  get page(): number {\r\n    return this._page;\r\n  }\r\n /** Pages Count */\r\n  get totalPages(): number {\r\n    const count = this.size < 1 ? 1 : Math.ceil(this.count / this.size);\r\n    return Math.max(count || 0, 1);\r\n  }\r\n  /** Page changed event */\r\n  @Output() change: EventEmitter<any> = new EventEmitter();\r\n\r\n  _count: number = 0;\r\n  _page: number = 1;\r\n  _size: number = 0;\r\n  pages: any;\r\n\r\n  canPrevious(): boolean {\r\n    return this.page > 1;\r\n  }\r\n\r\n  canNext(): boolean {\r\n    return this.page < this.totalPages;\r\n  }\r\n\r\n  prevPage(): void {\r\n    this.selectPage(this.page - 1);\r\n  }\r\n\r\n  nextPage(): void {\r\n    this.selectPage(this.page + 1);\r\n  }\r\n\r\n  selectPage(page: number): void {\r\n    if (page > 0 && page <= this.totalPages && page !== this.page) {\r\n      this.page = page;\r\n\r\n      this.change.emit(\r\n        page\r\n      );\r\n    }\r\n  }\r\n\r\n  calcPages(page?: number): any[] {\r\n    const pages = [];\r\n    let startPage = 1;\r\n    let endPage = this.totalPages;\r\n    const maxSize = 5;\r\n    const isMaxSized = maxSize < this.totalPages;\r\n\r\n    page = page || this.page;\r\n\r\n    if (isMaxSized) {\r\n      startPage = page - Math.floor(maxSize / 2);\r\n      endPage = page + Math.floor(maxSize / 2);\r\n\r\n      if (startPage < 1) {\r\n        startPage = 1;\r\n        endPage = Math.min(startPage + maxSize - 1, this.totalPages);\r\n      } else if (endPage > this.totalPages) {\r\n        startPage = Math.max(this.totalPages - maxSize + 1, 1);\r\n        endPage = this.totalPages;\r\n      }\r\n    }\r\n\r\n    for (let num = startPage; num <= endPage; num++) {\r\n      pages.push({\r\n        number: num,\r\n        text: <string>(<any>num)\r\n      });\r\n    }\r\n\r\n    return pages;\r\n  }\r\n}\r\n","<ul class=\"pagination\" SetRtl *ngIf=\"pages.length > 1\">\r\n  <li class=\"rotat-icon\" [class.disabled]=\"!canPrevious()\">\r\n    <a\r\n      role=\"button\"\r\n      aria-label=\"go to previous page\"\r\n      href=\"javascript:void(0)\"\r\n      (click)=\"prevPage()\"\r\n    >\r\n      <i class=\"bi bi-caret-left\"></i>\r\n    </a>\r\n  </li>\r\n  <li\r\n    role=\"button\"\r\n    [attr.aria-label]=\"'page ' + pg.number\"\r\n    class=\"pages\"\r\n    *ngFor=\"let pg of pages\"\r\n    [class.active]=\"pg.number === page\"\r\n  >\r\n    <a href=\"javascript:void(0)\" (click)=\"selectPage(pg.number)\">\r\n      {{ pg.text }}\r\n    </a>\r\n  </li>\r\n  <li class=\"rotat-icon\" [class.disabled]=\"!canNext()\">\r\n    <a\r\n      role=\"button\"\r\n      aria-label=\"go to next page\"\r\n      href=\"javascript:void(0)\"\r\n      (click)=\"nextPage()\"\r\n    >\r\n      <i class=\"bi bi-caret-right\"></i>\r\n    </a>\r\n  </li>\r\n</ul>\r\n"]}