nuxeo-development-framework 4.1.4 → 4.1.6

package/src/lib/components/notifications/models/notification-subscription.model.ts

@@ -0,0 +1,15 @@
+import { BaseNotificationEntry, BaseNotificationProperties, NotificationBaseOptions } from './common';
+
+export interface NotificationSubscriptionModel extends BaseNotificationEntry {
+  _baseOptions: NotificationBaseOptions;
+  _dirtyProperties: any;
+  properties: SubscriptionProperties;
+}
+
+export interface SubscriptionProperties extends BaseNotificationProperties {
+  'notfsub:notificationKey': string;
+  'notfsub:user': string;
+  'notfsub:companyName': string;
+  'notfsub:applicationKey': string;
+  'notfsub:channel': string;
+}

package/src/lib/components/notifications/models/notification.model.ts

@@ -0,0 +1,18 @@
+import { BaseNotificationEntry, BaseNotificationProperties } from './common';
+
+export interface NotificationModel extends BaseNotificationEntry {
+  _baseOptions: NotificationOptions;
+  properties: NotificationProperties;
+  _dirtyProperties: Record<string, any>;
+}
+
+export interface NotificationProperties extends BaseNotificationProperties {
+  'notif_cnt:company': string;
+  'notif_cnt:sourceDocument': string;
+  'notif_cnt:status': string;
+  'notif_cnt:user': string;
+  'notif_cnt:enMessage': string;
+  'notif_cnt:arMessage': string;
+  'notif_cnt:data': any;
+  'notif_cnt:errorMessage': any;
+}

package/src/lib/components/notifications/models/notifications-list-options.ts

@@ -0,0 +1,40 @@
+import { InjectionToken } from '@angular/core';
+import { PAGINATION_MODE, PANEL_MODE } from '../constants';
+
+export const NOTIFICATIONS_LIST_OPTIONS = new InjectionToken<NotificationsListOptions>(
+  'NOTIFICATIONS_LIST_OPTIONS'
+);
+
+export type NotificationPanelMode = (typeof PANEL_MODE)[keyof typeof PANEL_MODE];
+
+export type NotificationPaginationMode = (typeof PAGINATION_MODE)[keyof typeof PAGINATION_MODE]
+
+export type NotificationsListOptions = {
+  title?: string;
+  panelMode?: NotificationPanelMode;
+  filters?: {
+    active?: boolean;
+    date?: boolean;
+    type?: boolean;
+    state?: boolean;
+  };
+  actions?: {
+    active?: boolean;
+    updateState?: boolean;
+    openSetting?: boolean;
+    openNotification?: boolean;
+  };
+  icons?: {
+    active?: boolean;
+    default: string;
+    property: string;
+    types?: Record<string, string>;
+  };
+  pageSize?: number;
+  paginationMode?: NotificationPaginationMode;
+  scroll?: {
+    distance?: number;
+    throttle?: number;
+    scrollWindow?: boolean;
+  };
+};

package/src/lib/components/notifications/models/paging-response.model.ts

@@ -0,0 +1,13 @@
+import { NotificationModel } from "./notification.model";
+
+export interface NotificationPagingResponseModel<T = NotificationModel> {
+  totalItems: number;
+  page: number;
+  size: number;
+  data: Array<T>;
+  pageCount?: number;
+  hasPreviousPage?: boolean;
+  hasNextPage?: boolean;
+  nextPageNumber?: number;
+  previousPageNumber?: number;
+}

package/src/lib/components/notifications/models/params.model.ts

@@ -0,0 +1,6 @@
+export interface PaginationModel {
+  pageSize: number;
+  currentPageIndex: number;
+}
+
+export interface PayloadParamsModel extends Partial<PaginationModel>, Record<PropertyKey, any> {}

package/src/lib/components/notifications/models/vocabularies.ts

@@ -0,0 +1,13 @@
+export interface VocabularyType {
+  'entity-type': string;
+  directoryName: string;
+  id: string;
+  properties: VocabularyProperties;
+}
+
+export interface VocabularyProperties {
+  ordering: number;
+  obsolete: number;
+  id: string;
+  label: string;
+}

package/src/lib/components/notifications/notifications.module.ts

@@ -0,0 +1,98 @@
+import { CommonModule, DatePipe } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatBadgeModule } from '@angular/material/badge';
+import { MatIconModule } from '@angular/material/icon';
+import { MatListModule } from '@angular/material/list';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatToolbarModule } from '@angular/material/toolbar';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { RouterModule } from '@angular/router';
+import { TranslateModule } from '@ngx-translate/core';
+import { InfiniteScrollModule } from 'ngx-infinite-scroll';
+import { PipesModule } from '../../pipes/pipes.module';
+
+import {
+  NotificationItemComponent,
+  NotificationsButtonComponent,
+  NotificationsDateSelectComponent,
+  NotificationsListComponent,
+  NotificationSourceSelectComponent,
+  NotificationStatusToggleComponent,
+} from './components';
+
+import {
+  NotificationsListContainerComponent,
+  NotificationsSettingsContainerComponent,
+} from './containers';
+
+import { NotificationIconDirective, NotificationItemDirective } from './directives';
+
+import { NotificationsService } from './services';
+
+import { MatButtonModule } from '@angular/material/button';
+import { MatTabsModule } from '@angular/material/tabs';
+import { PaginationModule } from '../pagination/pagination.module';
+
+import { MatDialogModule } from '@angular/material/dialog';
+import { ConfirmationDialogModule } from '../confirmation-dialog/confirmation-dialog.module';
+import { GetIconPipe } from './components/notification-item/get-icon.pipe';
+import { NotificationsListActionsComponent } from './components/notifications-list-actions/notifications-list-actions.component';
+import { CheckIfSubscribedPipe } from './components/notifications-settings/check-if-subscribed.pipe';
+import { NotificationsSettingsComponent } from './components/notifications-settings/notifications-settings.component';
+import { NotificationSidebarContentDirective } from './components/notifications-sidebar/notifications-sidebar-content';
+import { NotificationsSidebarComponent } from './components/notifications-sidebar/notifications-sidebar.component';
+
+const DIRECTIVES = [NotificationIconDirective, NotificationItemDirective];
+
+const COMPONENTS = [
+  NotificationsListComponent,
+  NotificationsButtonComponent,
+  NotificationItemComponent,
+  NotificationsSettingsContainerComponent,
+  NotificationsListContainerComponent,
+  NotificationSourceSelectComponent,
+  NotificationStatusToggleComponent,
+  NotificationsDateSelectComponent,
+];
+
+/** @ignore */
+@NgModule({
+  imports: [
+    CommonModule,
+    RouterModule,
+    InfiniteScrollModule,
+    MatListModule,
+    PipesModule,
+    MatMenuModule,
+    MatIconModule,
+    TranslateModule,
+    MatProgressSpinnerModule,
+    MatTooltipModule,
+    InfiniteScrollModule,
+    MatBadgeModule,
+    TranslateModule,
+    MatToolbarModule,
+    MatSlideToggleModule,
+    PaginationModule,
+    MatButtonModule,
+    MatTabsModule,
+    ConfirmationDialogModule,
+    MatDialogModule,
+  ],
+  declarations: [
+    COMPONENTS,
+    DIRECTIVES,
+    NotificationsListActionsComponent,
+    NotificationsSettingsComponent,
+    CheckIfSubscribedPipe,
+    GetIconPipe,
+    NotificationsSidebarComponent,
+    NotificationSidebarContentDirective,
+  ],
+  exports: [COMPONENTS, DIRECTIVES],
+  providers: [DatePipe, NotificationsService],
+  entryComponents: [COMPONENTS],
+})
+export class NotificationsModule {}

package/src/lib/components/notifications/services/listener.service.ts

@@ -0,0 +1,13 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+
+@Injectable({ providedIn: 'root' })
+export class ListenerService {
+  private readonly _updatesSub = new Subject<string>();
+
+  readonly onUpdate$ = this._updatesSub.asObservable();
+
+  triggerUpdate(actionName: string) {
+    this._updatesSub.next(actionName);
+  }
+}

package/src/lib/components/notifications/services/notifications.service.ts

@@ -0,0 +1,267 @@
+import { Inject, Injectable } from '@angular/core';
+
+import { HttpClient } from '@angular/common/http';
+import { from, Observable, Subject, throwError } from 'rxjs';
+import { catchError, map, switchMap, takeUntil } from 'rxjs/operators';
+import { ApiResponseModel, AutomationResponseModel } from '../../../core/models';
+import { CallApiService } from '../../../core/services/callApi/call-api.service';
+
+import { NuxeoService } from '../../../core/services/nuxeo/nuxeo.service';
+import { NOTIFICATION_STATUS } from '../constants';
+import {
+  NotificationDefinitionModel,
+  NotificationMessageModel,
+  NotificationModel,
+  NotificationSubscriptionModel,
+  PayloadParamsModel,
+  VocabularyType,
+} from '../models';
+import { mapNotificationsToPagingResponse } from '../utilities';
+import { SocketService } from './socket.service';
+@Injectable()
+export class NotificationsService extends SocketService {
+  listenerObserver = new Subject<NotificationMessageModel>();
+  static readonly sourceType = '/api/v1/directory/VOC_Notf_SourceTypes';
+  static readonly channels = '/api/v1/directory/VOC_Notf_NotificationChannels';
+
+  static readonly providers = {
+    notifications: 'PP_NotfNotificationContent',
+    notificationsMango: 'PP_NotfNotificationContent_Mongo',
+    subscription: 'PP_NotfSubscription_Mongo',
+    definition: 'PP_NotfNotificationDefinition_Mongo',
+  };
+
+  static readonly 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',
+  };
+
+  private get _tenantId() {
+    return this._nuxeoService.nuxeoClient.user.properties.tenantId;
+  }
+
+  private get _appKey() {
+    return this._environment?.appKey;
+  }
+
+  /**
+   *
+   */
+  constructor(
+    @Inject('environment') protected _environment: Record<string, any>,
+    protected _nuxeoService: NuxeoService,
+    protected _callApi: CallApiService,
+    protected _http: HttpClient
+  ) {
+    super(_environment, _nuxeoService);
+
+    if (this._nuxeoService.nuxeoClient?.user?.id && this._environment?.socketUrl) {
+      this.socketConnect()
+        .pipe(
+          switchMap(() => this.onMessage$),
+          catchError((error: any) => {
+            console.log(error);
+            return throwError(() => error);
+          }),
+          takeUntil(this._destroy$)
+        )
+        .subscribe((res) => {
+          this.listenerObserver.next(res);
+        });
+    }
+  }
+
+  getUnReadCount(): Observable<number> {
+    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: ApiResponseModel<NotificationModel>) => data.totalSize ?? 0));
+  }
+
+  getNotificationsMongo(payload: PayloadParamsModel = {}) {
+    return this._getNotifications(
+      NotificationsService.providers.notificationsMango,
+      payload
+    );
+  }
+
+  getNotifications(payload: PayloadParamsModel = {}) {
+    return this._getNotifications(NotificationsService.providers.notifications, payload);
+  }
+
+  markAllAsRead() {
+    return this._globalOperation('markAllAsRead');
+  }
+
+  markAllNewAsUnread() {
+    return this._globalOperation('markAllAsUnread');
+  }
+
+  markAsRead(id: string) {
+    return this._operation(id, 'markAsRead');
+  }
+
+  markAsUnread(id: string) {
+    return this._operation(id, 'markAsUnread');
+  }
+
+  markAsDeleted(id: string) {
+    return this._operation(id, 'markAsDeleted');
+  }
+
+  unsubscribe(id: string) {
+    return this._operation(id, 'unsubscribe');
+  }
+
+  subscribe(id: string) {
+    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()
+    ) as Observable<AutomationResponseModel<Record<PropertyKey, any>>>;
+  }
+
+  getSourceTypes() {
+    return this._getVocabulary(
+      `${this._environment.nuxeo}${NotificationsService.sourceType}`
+    );
+  }
+
+  getChannels() {
+    return this._getVocabulary(
+      `${this._environment.nuxeo}${NotificationsService.channels}`
+    );
+  }
+
+  getDefinitions(payload: PayloadParamsModel = {}) {
+    return this._callApi
+      .query(
+        {
+          pageProvider: NotificationsService.providers.definition,
+          notfnotificationdef_applicationKey: this._appKey,
+          pageSize: Number.MAX_SAFE_INTEGER,
+          notfnotificationdef_isActive  : true,
+          ...payload,
+        },
+        {
+          headers: {
+            properties: '*',
+          },
+        }
+      )
+      .pipe(map((data: ApiResponseModel<NotificationDefinitionModel>) => data.entries));
+  }
+
+  getSubscriptions(payload: PayloadParamsModel = {}) {
+    return this._callApi
+      .query(
+        {
+          pageProvider: NotificationsService.providers.subscription,
+          notfsubscription_companyName: this._tenantId,
+          notfsubscription_applicationKey: this._appKey,
+          pageSize: Number.MAX_SAFE_INTEGER,
+          ...payload,
+        },
+        {
+          headers: {
+            properties: '*',
+          },
+        }
+      )
+      .pipe(map((data: ApiResponseModel<NotificationSubscriptionModel>) => data.entries));
+  }
+
+  private _getNotifications(pageProvider: string, payload: PayloadParamsModel = {}) {
+    return this._callApi
+      .query(
+        {
+          pageProvider: pageProvider,
+          notfnotificationcontent_company: this._tenantId,
+          notfnotificationcontent_applicationKey: this._appKey,
+          ...payload,
+        },
+        {
+          headers: {
+            properties: '*',
+          },
+        }
+      )
+      .pipe(
+        map((data: ApiResponseModel<NotificationModel>) =>
+          mapNotificationsToPagingResponse(data)
+        )
+      );
+  }
+
+  private _getVocabulary(url: string) {
+    return this._http.get<ApiResponseModel<VocabularyType>>(url).pipe(
+      map((response) => response.entries),
+      map((data) =>
+        data.sort((a, b) =>
+          b.properties['ordering'] < a.properties['ordering'] ? 1 : -1
+        )
+      )
+    );
+  }
+
+  private _operation<TResponse = Record<PropertyKey, any>>(
+    id: string,
+    option: keyof typeof NotificationsService.operations,
+    params: Record<string, any> = {}
+  ) {
+    return from(
+      this._nuxeoService.nuxeoClient
+        .operation(NotificationsService.operations[option], {
+          url: `${this._environment.nuxeo}${this._environment.customAutomation}`,
+        })
+        .params(params)
+        .input(id)
+        .execute()
+    ) as Observable<AutomationResponseModel<TResponse>>;
+  }
+
+  private _globalOperation(
+    option: keyof typeof NotificationsService.operations,
+    params: Record<string, any> = {},
+    headers: Record<string, any> = {}
+  ) {
+    return from(
+      this._nuxeoService.nuxeoClient
+        .operation(NotificationsService.operations[option], {
+          url: `${this._environment.nuxeo}${this._environment.customAutomation}`,
+        })
+        .params({
+          companyName: this._tenantId,
+          applicationKey: this._appKey,
+          ...params,
+        })
+        .execute({})
+    ) as Observable<AutomationResponseModel<Record<PropertyKey, any>>>;
+  }
+}

package/src/lib/components/notifications/services/params.service.ts

@@ -0,0 +1,44 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, ReplaySubject } from 'rxjs';
+import { PayloadParamsModel } from '../models';
+
+@Injectable()
+export class ParamsService<T = PayloadParamsModel | Record<string, any>> {
+
+
+
+  private readonly _paramsSub = new ReplaySubject<{
+    override?: boolean;
+    params: T;
+  }>(1);
+
+  readonly params$ = this._paramsSub.asObservable();
+
+  private _activatedParams: T = null;
+
+  get activatedQuery() {
+    return this._activatedParams;
+  }
+
+  private _defaultParams = new BehaviorSubject<PayloadParamsModel | T>({});
+
+  setDefaultParams(params: Partial<PayloadParamsModel | T>) {
+    this._defaultParams.next(params);
+  }
+
+  applyParams(
+    payload: {
+      override?: boolean;
+      params: Partial<PayloadParamsModel | T>;
+    } = null,
+    includeDefaults = true
+  ) {
+    const _defaults = includeDefaults ? this._defaultParams.getValue() : {};
+    this._activatedParams = Object.assign({}, _defaults, payload?.params || {}) as T;
+
+    this._paramsSub.next({
+      override: !!payload?.override,
+      params: this._activatedParams,
+    });
+  }
+}

package/src/lib/components/notifications/services/response.service.ts

@@ -0,0 +1,69 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { NotificationModel, NotificationPagingResponseModel } from '../models';
+
+@Injectable()
+export class ResponseService<T = NotificationModel> {
+  totalItems = 0;
+  itemsLength = 0;
+  selectedPage = 0;
+
+  private readonly _responseSub = new BehaviorSubject<NotificationPagingResponseModel<T>>(
+    null
+  );
+
+  response$ = this._responseSub.asObservable();
+
+  getResponse() {
+    return this._responseSub.getValue();
+  }
+
+  setResponse(res: NotificationPagingResponseModel<T>, isOverride = false) {
+    this.totalItems = res.totalItems;
+    if (isOverride) {
+      this.itemsLength = res.data.length;
+      this._responseSub.next(res);
+    } else {
+      const value = this._responseSub.getValue()?.data?.concat(res.data) ?? 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: string) {
+    const _response = this.getResponse();
+    const _data = _response?.data;
+    _response.data = _data.filter((not) => not['uid'] !== uid);
+    this.setResponse(_response, true);
+  }
+
+  patchResponse(uid: string, payload: Record<string, any>) {
+    const _response = this.getResponse();
+    const _data = _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;
+  }
+}

package/src/lib/components/notifications/services/socket.service.ts

@@ -0,0 +1,77 @@
+import { Inject, Injectable, OnDestroy } from '@angular/core';
+import { BehaviorSubject, Observable, ReplaySubject, Subject } from 'rxjs';
+
+import { NuxeoService } from '../../../core/services/nuxeo/nuxeo.service';
+import { NotificationMessageModel } from '../models';
+@Injectable({
+  providedIn: 'root',
+})
+export class SocketService implements OnDestroy {
+  protected _destroy$ = new Subject();
+  protected _socket: WebSocket;
+  protected _messageSub = new ReplaySubject<NotificationMessageModel>();
+  protected _connecting = false;
+  private _connectionSource = new BehaviorSubject<boolean>(false);
+
+  onMessage$ = this._messageSub.asObservable();
+
+  constructor(
+    @Inject('environment') protected _environment: Record<string, any>,
+    protected _nuxeoService: NuxeoService
+  ) {}
+
+  protected _isConnected(): boolean {
+    return this._socket && this._socket.readyState === WebSocket.OPEN;
+  }
+
+  socketConnect(): Observable<boolean> {
+    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();
+    }
+  }
+
+  private _prepareConnection() {
+    try {
+      const socket = new WebSocket(this._environment?.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(): void {
+    this._destroy$.next();
+    this._destroy$.complete();
+  }
+
+  private _handleSocketMessage(event: MessageEvent) {
+    const notificationData = JSON.parse(event.data as string);
+    this._messageSub.next(notificationData);
+  }
+
+  private _handleSocketConnection(isConnected: boolean, event?: Event): void {
+    this._connectionSource.next(isConnected);
+    this._connecting = false;
+    console.log(isConnected ? 'WebSocket connected' : 'WebSocket disconnected', event);
+  }
+
+  private _handleSocketError(event: Event) {
+    this._connectionSource.next(false);
+    this._connecting = false;
+    console.log('WebSocket Error', event);
+  }
+}

package/src/lib/components/notifications/utilities/index.ts

@@ -0,0 +1,2 @@
+
+export * from './response.adapter';