@bizdoc/core 1.14.8 → 1.14.9

package/src/lib/modules/paginator.intl.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { MatPaginatorIntl } from '@angular/material/paginator';
+import { TranslateService } from '../core/translate.service';
+
+
+@Injectable()
+export class PaginatorIntl extends MatPaginatorIntl {
+    constructor(private _translate: TranslateService) {
+        super();
+    }
+    firstPageLabel = this._translate.get('FirstPage');
+    lastPageLabel = this._translate.get('LastPage');
+    nextPageLabel = this._translate.get('NextPage');
+    previousPageLabel = this._translate.get('PrevPage');
+    getRangeLabel = (_page: number, _pageSize: number, _length: number): string => { return ''; };
+}

package/src/lib/modules/pivot.module.ts

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import {
+  PivotViewModule, ExcelExportService, GroupingBarService,
+  NumberFormattingService, GroupingService, PivotChartService,
+  ConditionalFormattingService,
+  PivotView,
+  ExcelExport,
+  GroupingBar,
+  PivotChart
+} from '@syncfusion/ej2-angular-pivotview';
+
+@NgModule({
+  exports: [
+    PivotViewModule
+  ],
+  imports: [
+    PivotViewModule
+  ],
+  providers: [ExcelExportService, GroupingBarService, NumberFormattingService, GroupingService, PivotChartService, ConditionalFormattingService]
+})
+export class SyncfusionPivotModule { }
+
+PivotView.Inject(GroupingBar, ExcelExport, PivotChart);

package/src/lib/modules/schedule.module.ts

@@ -0,0 +1,12 @@
+import { NgModule } from "@angular/core";
+import { ScheduleModule, ExcelExportService, DayService, WorkWeekService, MonthService, MonthAgendaService, ICalendarExportService, AgendaService, YearService } from '@syncfusion/ej2-angular-schedule';
+
+@NgModule({
+  imports: [ScheduleModule],
+  exports: [ScheduleModule],
+  providers: [
+    ScheduleModule, ExcelExportService, DayService, WorkWeekService, MonthService, MonthAgendaService, ICalendarExportService, AgendaService, YearService  ]
+})
+export
+  class SyncfusionScheduleModule {
+}

package/src/lib/modules/spreadsheet.module.ts

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import {
+  SpreadsheetModule, SelectionService, BasicModuleService, ClipboardService, CellFormatService,
+  KeyboardNavigationService, KeyboardShortcutService, NumberFormatService
+} from '@syncfusion/ej2-angular-spreadsheet';
+
+@NgModule({
+  declarations: [],
+  exports: [
+    SpreadsheetModule
+  ],
+  imports: [
+    SpreadsheetModule,
+    CommonModule
+  ],
+  providers: [SelectionService, BasicModuleService, ClipboardService, CellFormatService, KeyboardNavigationService,
+    KeyboardShortcutService, NumberFormatService]
+})
+export class SyncfusionSpreadsheetModule {
+}

package/src/lib/modules/stepper.intl.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@angular/core';
+import { MatStepperIntl } from '@angular/material/stepper';
+import { TranslateService } from '../core/translate.service';
+
+
+@Injectable()
+export class StepperIntl extends MatStepperIntl {
+    constructor(private _translate: TranslateService) {
+        super();
+    }
+    optionalLabel: string = this._translate.get('Optional');
+}

package/src/lib/modules/texteditor.module.ts

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { HtmlEditorService, RichTextEditorModule, ToolbarService, PasteCleanupService } from '@syncfusion/ej2-angular-richtexteditor';
+
+@NgModule({
+  declarations: [],
+  exports: [RichTextEditorModule
+  ],
+  imports: [
+    CommonModule,
+    RichTextEditorModule
+  ],
+  providers: [HtmlEditorService, ToolbarService, PasteCleanupService ]
+})
+export class SyncfusionTextEditorModule {
+}

package/src/lib/notifications/filter.component.html

@@ -0,0 +1,6 @@
+<form autocomplete="off" fxLayout="column" [formGroup]="form">
+  <mat-form-field>
+    <input type="search" formControlName="text" matInput placeholder="{{'Search' | translate}}" />
+  </mat-form-field>
+  <mat-slide-toggle formControlName="showDeleted">{{'ShowDeleted' | translate}}</mat-slide-toggle>
+</form>

package/src/lib/notifications/filter.component.ts

@@ -0,0 +1,16 @@
+import { Component } from '@angular/core';
+import { FormBuilder } from '@angular/forms';
+
+
+@Component({
+    templateUrl: './filter.component.html',
+    styles: [':host { padding: 8px }']
+})
+/** notifications component*/
+export class NotificationsFilterComponent {
+    constructor(private _fb: FormBuilder) { }
+    readonly form = this._fb.group({
+        text: this._fb.control(null),
+        showDeleted: this._fb.control(false)
+    });
+}

package/src/lib/notifications/notifications-table.component.html

@@ -0,0 +1,54 @@
+<mat-toolbar>
+  <button mat-icon-button *ngIf="selection.selected.length" (click)="discardAll()" bizdocTooltip="{{'DiscardSelected' | translate : selection.selected.length }}"><mat-icon>delete</mat-icon></button>
+  <span class="divider"></span>
+  <button mat-icon-button (click)="openFilter($event)" [bizdocTooltip]="'Filter' | translate" [attr.aria-label]="'Filter' | translate"><mat-icon>filter_list</mat-icon></button>
+</mat-toolbar>
+<table [hidden]="!dataSource||dataSource.data.length===0" mat-table matSort [dataSource]="dataSource" [@list]="dataSource?.data.length" class="data-table">
+  <ng-container matColumnDef="select">
+    <th mat-header-cell *matHeaderCellDef>
+      <mat-checkbox (change)="$event ? masterToggle() : null"
+                    [checked]="selection.hasValue() && isAllSelected()"
+                    [indeterminate]="selection.hasValue() && !isAllSelected()">
+      </mat-checkbox>
+    </th>
+    <td mat-cell *matCellDef="let element">
+      <mat-checkbox (click)="$event.stopPropagation()"
+                    (change)="$event ? selection.toggle(element) : null"
+                    [checked]="selection.isSelected(element)">
+      </mat-checkbox>
+    </td>
+  </ng-container>
+  <ng-container matColumnDef="content">
+    <th mat-header-cell *matHeaderCellDef>{{ 'Content' | translate}}</th>
+    <td mat-cell *matCellDef="let element">
+      <h3 *ngComponentOutlet="element.comp; injector: element.injector"></h3>
+    </td>
+  </ng-container>
+  <ng-container matColumnDef="sent">
+    <th mat-header-cell *matHeaderCellDef mat-sort-header>{{ 'Time' | translate}}</th>
+    <td mat-cell *matCellDef="let element">
+      <span [bizdocTooltip]="element.sent | amCalendar">{{element.sent | amTimeAgo }}</span>
+    </td>
+  </ng-container>
+  <ng-container matColumnDef="options">
+    <th mat-header-cell *matHeaderCellDef></th>
+    <td mat-cell *matCellDef="let element">
+      <button mat-icon-button [matMenuTriggerFor]="options" [matMenuTriggerData]="{muted: false}" class="tool"><mat-icon>more_vert</mat-icon></button>
+      <mat-menu #options>
+        <ng-template matMenuContent let-muted="muted">
+          <ng-container *ngIf="element.recipientId">
+            <button mat-menu-item (click)="read(element, !element.read)">{{'MarkAsRead' | translate}}</button>
+            <mat-divider></mat-divider>
+          </ng-container>
+          <button mat-menu-item (click)="mute(element, true)" *ngIf="element.documentId">{{ (!(muted | async) ? 'Mute': 'Unmute') | translate}}</button>
+          <ng-container *ngIf="!element.deleted">
+            <mat-divider></mat-divider>
+            <button mat-menu-item (click)="delete(element)">{{ 'Discard' | translate}}</button>
+          </ng-container>
+        </ng-template>
+      </mat-menu>
+    </td>
+  </ng-container>
+  <tr mat-header-row *matHeaderRowDef="['select','content','sent','options']"></tr>
+  <tr mat-row *matRowDef="let element; columns: ['select','content','sent','options'];" @item class="item" [class.read]="element.read"></tr>
+</table>

package/src/lib/notifications/notifications-table.component.scss

@@ -0,0 +1,14 @@
+:host {
+  /*min-width: 400px;*/
+  display: block
+}
+
+.item {
+  &.read {
+  }
+
+.tool {opacity:0 }
+  &:hover .tool {
+    opacity: 1
+  }
+}

package/src/lib/notifications/notifications-table.component.ts

@@ -0,0 +1,94 @@
+import { Component, Injector, OnInit, ViewChild } from '@angular/core';
+import { MatSort } from '@angular/material/sort';
+import { MatTableDataSource } from '@angular/material/table';
+import { SelectionModel } from '@angular/cdk/collections';
+import { Observable } from 'rxjs';
+import { takeUntil, debounceTime, map } from 'rxjs/operators';
+import { Notification } from '../core/models';
+import { NotificationsService } from './notifications.service';
+import { NotificationExtra, NotificationsComponentBase } from "./notifications.component-base";
+import { Popup } from '../core/popup/popup.service';
+import { NotificationsFilterComponent } from './filter.component';
+import { itemAnimation, listAnimation } from '../core/animations';
+
+@Component({
+  selector: 'bizdoc-notifications-table',
+  templateUrl: './notifications-table.component.html',
+  styleUrls: ['./notifications-table.component.scss'],
+  animations: [listAnimation, itemAnimation]
+})
+/** notifications component*/
+export class NotificationsTableComponent extends NotificationsComponentBase implements OnInit {
+  @ViewChild(MatSort, { static: true }) sort: MatSort;
+  dataSource: MatTableDataSource<any>;
+
+  showDeleted = false;
+  readonly selection = new SelectionModel<NotificationExtra>(true, []);
+  /** notifications ctor */
+  constructor(private _service: NotificationsService, injector: Injector, private _popup: Popup
+  ) {
+    super(injector);
+  }
+  ngOnInit(): void {
+    this._query();
+  }
+  private _query() {
+    this._service.getAll({ exclude: !this.showDeleted }).subscribe((n: NotificationExtra[]) => {
+      n.forEach(n => {
+        n.comp = this._comp(n.type);
+        n.injector = this._getInjector(n);
+      });
+      this.dataSource = new MatTableDataSource(n);
+      this.dataSource.sort = this.sort;
+    });
+  }
+  discardAll() {
+    this.selection.selected.forEach(n => this.delete(n));
+  }
+  read(item: Notification, read: boolean) {
+    if (item.read !== read)
+      this._service.read(item.id, item.sent, read).subscribe(() => item.read = read);
+  }
+  isMuted(item: Notification): Observable<boolean> {
+    return this._service.get(item.id).pipe(map(i => i.muted));
+  }
+  mute(item: Notification, mute: boolean) {
+    this._service.mute(item.id, mute);
+  }
+  delete(item: Notification) {
+    this._service.delete(item.id).subscribe(i => {
+      item.deleted = true;
+      if (!this.showDeleted) {
+        this.dataSource.data.remove(i);
+        this.dataSource.filter = '';
+      }
+    });
+  }
+  isAllSelected() {
+    const numSelected = this.selection.selected.length;
+    const numRows = this.dataSource.data.length;
+    return numSelected === numRows;
+  }
+  masterToggle() {
+    this.isAllSelected() ?
+      this.selection.clear() :
+      this.selection.select(...this.dataSource.data);
+  }
+  openFilter(evt: Event) {
+    const popupRef = this._popup.open(NotificationsFilterComponent, evt.srcElement as HTMLButtonElement);
+    popupRef.opened.
+      subscribe(e => {
+        e.form.setValue({ text: this.dataSource.filter, showDeleted: this.showDeleted });
+        e.
+          form.valueChanges.pipe(debounceTime(150), takeUntil(popupRef.closed)).
+          subscribe(v => {
+            this.dataSource.filter = v.text;
+            if (this.showDeleted !== v.showDeleted) {
+              this.showDeleted = v.showDeleted;
+              this._query();
+            }
+          });
+      }
+      );
+  }
+}

package/src/lib/notifications/notifications.component-base.ts

@@ -0,0 +1,49 @@
+import { Injector } from '@angular/core';
+import { Notification, NotificationType } from '../core/models';
+import { NOTIFICATION_DATA } from './types/notification-base';
+import { CommentedNotification } from './types/commented.notification';
+import { CubeAnomalyNotification } from './types/cube-anomaly.notification';
+import { EscalatedNotification } from './types/escalated.notification';
+import { LikedNotification } from './types/liked.notification';
+import { StateChangedNotification } from './types/state-changed.notification';
+import { TextNotification } from './types/text.notification';
+import { UpcomingEventNotification } from './types/upcoming-event.notification';
+import { NudgeNotification } from "./types/nudge.notification";
+import { LongRunningTaskNotification } from "./types/long-running-task.notification";
+import { TaggedNotification } from './types/tagged.notification';
+export abstract class NotificationsComponentBase {
+  constructor(private _injector: Injector) { }
+  protected _comp(type: NotificationType): any {
+    switch (type) {
+      case 'Commented':
+        return CommentedNotification;
+      case 'CubeAnomaly':
+        return CubeAnomalyNotification;
+      case 'Escalated':
+        return EscalatedNotification;
+      case 'Liked':
+        return LikedNotification;
+      case 'StateChanged':
+        return StateChangedNotification;
+      case 'Nudge':
+        return NudgeNotification;
+      case 'TextMessage':
+        return TextNotification;
+      case 'UpcomingEvent':
+        return UpcomingEventNotification;
+      case 'Tagged':
+        return TaggedNotification;
+      case 'JobProgress':
+        return LongRunningTaskNotification;
+      default:
+        throw `Notificationtype ${type} has no component.`;
+    }
+  }
+  protected _getInjector(item: Notification): Injector {
+    return Injector.create([{ provide: NOTIFICATION_DATA, useValue: item }], this._injector);
+  }
+}
+export interface NotificationExtra extends Notification {
+  injector: any;
+  comp: any;
+}

package/src/lib/notifications/notifications.mobile.component.ts

@@ -0,0 +1,13 @@
+import { Component } from '@angular/core';
+import { WindowTitleService } from '../core/window-title.service';
+import { TranslateService } from '../core/translate.service';
+
+@Component({
+  template: '<bizdoc-notifications-table></bizdoc-notifications-table>'
+})
+/** notifications component*/
+export class NotificationsComponent {
+  constructor(title: WindowTitleService, translate: TranslateService) {
+    title.set(translate.get('Notifications'));
+  }
+}

package/src/lib/notifications/notifications.pane.component.ts

@@ -0,0 +1,16 @@
+import { Component } from '@angular/core';
+import { TranslateService } from '../core/translate.service';
+import { PaneRef } from '../core/slots/pane-ref';
+
+
+@Component({
+    template: '<bizdoc-notifications-table></bizdoc-notifications-table>',
+  host: {
+    class: 'pane'
+  }})
+/** notifications component*/
+export class NotificationsPaneComponent {
+    constructor(pane: PaneRef, translate: TranslateService) {
+        pane.title = translate.get('Notifications');
+    }
+}

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

@@ -0,0 +1,66 @@
+import { Injectable } from "@angular/core";
+import { HttpClient } from "@angular/common/http";
+import { Notification } from "../core/models";
+import { Observable } from "rxjs";
+import { tap } from "rxjs/operators";
+import { HubService } from "../core/hub.service";
+import { SessionService } from "../core/session.service";
+
+@Injectable()
+export class NotificationsService {
+  constructor(private _http: HttpClient, messaging: HubService, private _session: SessionService) {
+    messaging.notify$.subscribe(n => {
+      _session.profile.notifications.push(n.model);
+      _session.profile.notificationsCount++;
+    });
+    messaging.updateNotify$.subscribe(e => {
+      const item = _session.profile.notifications.find(n => n.id === e.model.id);
+      if (item)
+        Object.assign(item, e.model);
+      else
+        _session.profile.notifications.push(e.model);
+      if (e.originalRead !== undefined && e.model.read !== e.originalRead &&
+        this._isAboveWatermark(e.model.sent)) {
+        const val = e.model.read ? -1 : 1;
+        _session.profile.notificationsCount += val;
+      }
+    });
+  }
+  deleteAll(arg0: number[]) {
+    throw new Error("Method not implemented.");
+  }
+  getAll(options?: { exclude?: boolean, skip?: number, before?: Date }): Observable<Notification[]> {
+    const { exclude, skip, before } = options || {};
+    const params = {
+      skip: skip ? skip.toString() : '0',
+      exclude: exclude ? 'true' : 'false',
+    };
+    if (before)
+      Object.assign(params, {
+        before: before.toJSON()
+      });
+    return this._http.get<Notification[]>(`/api/notifications/`, {
+      params
+    });
+  }
+  private _isAboveWatermark(date: Date): boolean {
+    return !this._session.isImpersonating &&
+      this._session.profile.options.notificationsView &&
+      this._session.profile.options.notificationsView < date;
+  }
+  read(id: number, date: Date, read: boolean): Observable<any> {
+    return this._http.put(`/api/notifications/${id}?read=${read}`, {}, { headers: { 'no-progress': 'true' } }).pipe(tap(() => {
+      if (this._isAboveWatermark(date))
+        this._session.profile.notificationsCount--;
+    }))
+  }
+  get(id: number): Observable<any> {
+    return this._http.get(`/api/notifications/${id}`)
+  }
+  mute(id: number, mute: boolean): Observable<any> {
+    return this._http.put(`/api/notifications/${id}?mute=${mute}`, {});
+  }
+  delete(id: number): Observable<any> {
+    return this._http.delete(`/api/notifications/${id}`)
+  }
+}

package/src/lib/notifications/types/commented.notification.html

@@ -0,0 +1,14 @@
+<ng-container *ngIf='one else more'>
+  {{one.gender === 'Male' ? 'CommentedOneMaleNotify' : one.gender === 'Female' ? 'CommentedOneFemaleNotify' : 'CommentedOneNotify' | translate : one.name : notification.text : notification.number }}
+</ng-container>
+<ng-template #more>
+  <ng-container *ngIf='names'>
+    <ng-container *ngIf='names.length < 4'>
+      {{'CommentedManyNotify' | translate : translate.join(names) : notification.number }}
+    </ng-container>
+    <ng-container *ngIf='names.length >= 4'>
+      <!--[bizdocTooltip]='translate.join(names)'-->
+      {{'CommentedManyMoreNotify' | translate : names.slice(0, 2).join(translate.get('JoinComma')) : names.length - 2 : notification.number}}
+    </ng-container>
+  </ng-container>
+</ng-template>

package/src/lib/notifications/types/commented.notification.ts

@@ -0,0 +1,51 @@
+import { Component, OnInit, Inject } from "@angular/core";
+import { AccountService } from "../../core/account.service";
+import { TranslateService } from "../../core/translate.service";
+import { NOTIFICATION_DATA, NotificationBase } from "./notification-base";
+import { Notification } from "../../core/models";
+import { SessionService } from "../../core/session.service";
+import { ChatInfo } from "../../chat/chat-info";
+import { RouterImpl } from "../../core/router";
+
+/** */
+@Component({
+  template: `<ng-container *ngIf='message'>
+  <span *ngIf='notification.userIds.length < 3' [innerHTML]='message | sanitizeHtml'></span>
+  <span *ngIf='notification.userIds.length >= 3' [bizdocTooltip]='names' [innerHTML]='message | sanitizeHtml'></span>
+</ng-container>`
+})
+export
+  class CommentedNotification extends NotificationBase implements OnInit {
+  names?: string;
+  message: string;
+  ngOnInit(): void {
+    if (this.notification.userIds.length === 1)
+      this._accounts.get(this.notification.userIds[0]).subscribe(u => {
+        this.message = this._translate.get(`CommentedOne${u.gender || ''}Notify`, this._formatUserElement(u), this.notification.text, this.notification.number);
+      });
+    else
+      this._accounts.getAll(this.notification.userIds).subscribe(us => {
+        if (us.length < 3)
+          this.message = this._translate.get('CommentedManyNotify',
+            this._translate.join(us.map(u => this._formatUserElement(u))), this.notification.number);
+        else {
+          const comma = this._translate.comma;
+          this.names = us.map(u => u.name).join(comma);
+          this.message = this._translate.get('CommentedManyMoreNotify',
+            us.slice(0, 2).map(u => this._formatUserElement(u)).join(comma), us.length - 2, this.notification.number);
+        }
+      });
+  }
+  constructor(@Inject(NOTIFICATION_DATA) public notification: Commented,
+    private _accounts: AccountService,
+    translate: TranslateService,
+    router: RouterImpl,
+    session: SessionService, chat: ChatInfo) {
+    super(notification, router, session, translate, chat);
+  }
+}
+interface Commented extends Notification {
+  userIds: string[];
+  text: string;
+  number: string;
+}

package/src/lib/notifications/types/cube-anomaly.notification.ts

@@ -0,0 +1,51 @@
+import { Component, Inject, OnInit, HostListener } from "@angular/core";
+import { NOTIFICATION_DATA } from "./notification-base";
+import { SessionService } from "../../core/session.service";
+import { Cube } from "../../core/models";
+import { Observable, forkJoin } from "rxjs";
+import { DatasourceService } from "../../core/datasource.service";
+import { TranslateService } from "../../core/translate.service";
+import { RouterImpl } from "../../core/router";
+
+@Component({
+  template: `<span [innerHTML]=" 'CubeAnomalyNotify' | translate : (cube.title | lowercase) : (notification.value | currency : cube.currencyCode : 'symbol') : axes | sanitizeHtml"></span>`
+})
+export
+  class CubeAnomalyNotification implements OnInit {
+  cube: Cube;
+  axes = '';
+  ngOnInit(): void {
+    this.cube = this._session.profile.cubes.find(c => c.name === this.notification.cube);
+    const observables: Observable<string>[] = [];
+    this.cube.axes.forEach((a, i) => {
+      if (!a.hidden && this.notification.axes && this.notification.axes[i]) {
+        observables.push(this._ds.get(a.dataType, this.notification.axes[i]));
+      }
+    });
+    forkJoin(observables).subscribe(a =>
+      this.axes = this._translate.join(a.map((e, i) => e || this.notification.axes[i])));
+  }
+  @HostListener('click', ['$event'])
+  open(e: MouseEvent) {
+    const id = (e.srcElement as HTMLElement).getAttribute('data-info');
+    if (id) {
+      this._router.navigate(['mailbox/i', parseInt(id).encodeId()]);
+    }
+    else {
+      const params = {};
+      if (this.notification.axes) this.notification.axes.forEach((a, i) =>
+        a && (params[this.cube.axes[i].name] = a));
+      this._router.navigate(['cube', this.notification.cube, 'v', this.cube.views[0].name], { queryParams: params });
+    }
+  }
+  constructor(
+    @Inject(NOTIFICATION_DATA) public notification: CubeAnomaly,
+    private _ds: DatasourceService, private _session: SessionService, private _router: RouterImpl, private _translate: TranslateService) { }
+}
+interface CubeAnomaly extends Notification {
+  cube: string;
+  axes: string[];
+  value: number;
+  numbers: string[];
+  documentIds: number[];
+}

package/src/lib/notifications/types/escalated.notification.ts

@@ -0,0 +1,36 @@
+import { Component, OnInit, Inject } from "@angular/core";
+import { AccountService } from "../../core/account.service";
+import { TranslateService } from "../../core/translate.service";
+import { NOTIFICATION_DATA, NotificationBase } from "./notification-base";
+import { SessionService } from "../../core/session.service";
+import { Notification } from "../../core/models";
+import { ChatInfo } from "../../chat/chat-info";
+import { RouterImpl } from "../../core/router";
+
+@Component({
+  template: `<span *ngIf='name' [innerHTML]="'EscalatedNotify' | translate : notification.number : name | sanitizeHtml"></span>`
+})
+export
+  class EscalatedNotification extends NotificationBase implements OnInit {
+  name: string;
+  ngOnInit(): void {
+    this._accounts.get(this.notification.substituteId).subscribe(u =>
+      this.name = this._formatUserElement(u)
+    );
+  }
+  constructor(
+    router: RouterImpl,
+    @Inject(NOTIFICATION_DATA) public notification: Escalated,
+    private _accounts: AccountService,
+    translate: TranslateService,
+    session: SessionService,
+    chat: ChatInfo) {
+    super(notification, router, session, translate, chat);
+  }
+}
+interface Escalated extends Notification {
+  substituteId: string;
+  role?: string;
+  duration: number;
+  number: string;
+}

package/src/lib/notifications/types/liked.notification.ts

@@ -0,0 +1,49 @@
+import { Component, OnInit, Inject } from "@angular/core";
+import { AccountService } from "../../core/account.service";
+import { TranslateService } from "../../core/translate.service";
+import { NOTIFICATION_DATA, NotificationBase } from "./notification-base";
+import { SessionService } from "../../core/session.service";
+import { Notification } from "../../core/models";
+import { ChatInfo } from "../../chat/chat-info";
+import { RouterImpl } from "../../core/router";
+
+@Component({
+  template: `<ng-container *ngIf='message'>
+  <span *ngIf='notification.userIds.length < 3' [innerHTML]='message | sanitizeHtml'></span>
+  <span *ngIf='notification.userIds.length >= 3' [bizdocTooltip]='names' [innerHTML]='message | sanitizeHtml'></span>
+</ng-container>` })
+export
+  class LikedNotification extends NotificationBase implements OnInit {
+  names?: string;
+  message: string;
+  ngOnInit(): void {
+    if (this.notification.userIds.length === 1)
+      this._accounts.get(this.notification.userIds[0]).subscribe(u => 
+        this.message = this._translate.personalize(this.notification.voted === 1 ? 'LikedOneNotify' : 'DislikedOneNotify', u.gender, this._formatUserElement(u), this.notification.number)
+      );
+    else
+      this._accounts.getAll(this.notification.userIds).subscribe(us => {
+        if (us.length < 3)
+          this.message = this._translate.get(this.notification.voted === 1 ? 'LikedManyNotify' : this.notification.voted === -1 ? 'DislikedManyNotify' : 'MixedLikeManyNotify',
+            this._translate.join(us.map(u => this._formatUserElement(u))), this.notification.number);
+        else {
+          const comma = this._translate.comma;
+          this.names = us.map(u => u.name).join(comma);
+          this.message = this._translate.get(this.notification.voted === 1 ? 'LikedManyMoreNotify' : this.notification.voted === -1 ? 'DislikedManyMoreNotify' : 'MixedLikeManyMoreNotify',
+            us.slice(0, 2).map(u => this._formatUserElement(u)).join(comma), us.length - 2, this.notification.number);
+        }
+      });
+  }
+  constructor(@Inject(NOTIFICATION_DATA) public notification: Liked,
+    private _accounts: AccountService,
+    translate: TranslateService,
+    router: RouterImpl,
+    session: SessionService, chat: ChatInfo) {
+    super(notification, router, session, translate, chat);
+  }
+}
+interface Liked extends Notification {
+  userIds: string[];
+  voted?: number;
+  number: string;
+}