@sumaris-net/ngx-components 1.2.7 → 1.2.14

package/src/app/social/job/progression/job-progression.icon.d.ts

@@ -0,0 +1,47 @@
+import { ChangeDetectorRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ThemePalette } from '@angular/material/core';
+import { ProgressSpinnerMode } from '@angular/material/progress-spinner';
+import { IJobProgressionService } from './job-progression.service';
+import { JobProgression } from './job-progression.model';
+import { PopoverController } from '@ionic/angular';
+import * as i0 from "@angular/core";
+export interface JobProgressionOptions {
+    autoHide: boolean;
+    autoHideDelay: number;
+    autoRemove: boolean;
+    autoRemoveDelay: number;
+}
+export declare class JobProgressionIcon implements OnInit, OnDestroy {
+    protected jobProgressionService: IJobProgressionService;
+    protected popoverController: PopoverController;
+    protected cd: ChangeDetectorRef;
+    debug: boolean;
+    titleI18n: string;
+    options: JobProgressionOptions;
+    autoHide: boolean;
+    jobFinished: EventEmitter<number>;
+    visible: boolean;
+    disabled: boolean;
+    color: ThemePalette;
+    mode: ProgressSpinnerMode;
+    value: number;
+    jobProgressions: JobProgression[];
+    protected autoHideDelay: number;
+    protected autoRemove: boolean;
+    protected autoRemoveDelay: number;
+    private _listPopover;
+    private _subscriptions;
+    private _subscriptionsById;
+    private _logPrefix;
+    constructor(jobProgressionService: IJobProgressionService, popoverController: PopoverController, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    addJob(id: number, job?: JobProgression): void;
+    removeJob(id: number): void;
+    getProgression(id: number): JobProgression | undefined;
+    updateValue(): void;
+    showList(event: Event): Promise<void>;
+    protected markForCheck(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionIcon, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JobProgressionIcon, "app-job-progression-icon", never, { "debug": "debug"; "titleI18n": "titleI18n"; "options": "options"; "autoHide": "autoHide"; }, { "jobFinished": "jobFinished"; }, never, never, false>;
+}

package/src/app/social/job/progression/job-progression.list.d.ts

@@ -0,0 +1,15 @@
+import { OnInit } from '@angular/core';
+import { JobProgression } from './job-progression.model';
+import * as i0 from "@angular/core";
+export interface JobProgressionListOptions {
+    titleI18n?: string;
+    jobProgressions?: JobProgression[];
+}
+export declare class JobProgressionList implements OnInit, JobProgressionListOptions {
+    titleI18n: string;
+    jobProgressions: JobProgression[];
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionList, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JobProgressionList, "app-job-progression-list", never, { "titleI18n": "titleI18n"; "jobProgressions": "jobProgressions"; }, {}, never, never, false>;
+}

package/src/app/social/job/progression/job-progression.model.d.ts

@@ -0,0 +1,11 @@
+import { Entity } from '../../../core/services/model/entity.model';
+export declare class JobProgression extends Entity<JobProgression> {
+    static fromObject: (source: any, opts?: any) => JobProgression;
+    id: number;
+    name: string;
+    message: string;
+    current: number;
+    total: number;
+    constructor(id?: number);
+    fromObject(source: any): void;
+}

package/src/app/social/job/progression/job-progression.service.d.ts

@@ -0,0 +1,34 @@
+import { InjectionToken } from '@angular/core';
+import { JobProgression } from './job-progression.model';
+import { BaseGraphqlService } from '../../../core/services/base-graphql-service.class';
+import { GraphqlService } from '../../../core/graphql/graphql.service';
+import { Environment } from '../../../../environments/environment.class';
+import { Observable } from 'rxjs';
+import { FetchPolicy, WatchQueryFetchPolicy } from '@apollo/client/core';
+import * as i0 from "@angular/core";
+export declare const APP_JOB_PROGRESSION_SERVICE: InjectionToken<IJobProgressionService>;
+export interface IJobProgressionService {
+    watchAll(): Observable<JobProgression[]>;
+    addJob(id: number, job?: JobProgression): any;
+    removeJob(id: number): any;
+    listenChanges(id: number, options?: {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<JobProgression>;
+}
+export declare class JobProgressionService extends BaseGraphqlService<JobProgression> implements IJobProgressionService {
+    protected graphql: GraphqlService;
+    protected environment: Environment;
+    constructor(graphql: GraphqlService, environment: Environment);
+    watchAll(options?: {
+        fetchPolicy?: WatchQueryFetchPolicy;
+    }): Observable<JobProgression[]>;
+    addJob(id: number, job?: JobProgression): void;
+    removeJob(id: number): void;
+    listenChanges(id: number, options?: {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<JobProgression>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JobProgressionService>;
+}

package/src/app/social/job/testing/job-progression.testing.d.ts

@@ -0,0 +1,17 @@
+import { JobProgressionIcon, JobProgressionOptions } from '../progression/job-progression.icon';
+import { JobProgression } from '../progression/job-progression.model';
+import { IJobProgressionService } from '../progression/job-progression.service';
+import * as i0 from "@angular/core";
+export declare class JobProgressionTestingPage {
+    protected jobProgressionService: IJobProgressionService;
+    jobProgressionIcon: JobProgressionIcon;
+    jobId: number;
+    job: JobProgression;
+    options: JobProgressionOptions;
+    constructor(jobProgressionService: IJobProgressionService);
+    incrementJob(value: number): void;
+    addJob(): void;
+    private createJob;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JobProgressionTestingPage, "job-progression-testing", never, {}, {}, never, never, false>;
+}

package/src/app/social/job/testing/job-progression.testing.service.d.ts

@@ -0,0 +1,17 @@
+import { IJobProgressionService } from '../progression/job-progression.service';
+import { FetchPolicy } from '@apollo/client/core';
+import { Observable } from 'rxjs';
+import { JobProgression } from '../progression/job-progression.model';
+import * as i0 from "@angular/core";
+export declare class JobProgressionTestService implements IJobProgressionService {
+    private jobsSubject;
+    addJob(id: number, job?: JobProgression): void;
+    removeJob(id: number): void;
+    watchAll(): Observable<JobProgression[]>;
+    listenChanges(id: number, options?: {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<JobProgression>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobProgressionTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JobProgressionTestService>;
+}

package/src/app/social/job/testing/job.testing.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./job-progression.testing";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../../../shared/shared.module";
+import * as i5 from "../job.module";
+export declare class JobTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<JobTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<JobTestingModule, [typeof i1.JobProgressionTestingPage], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4.SharedModule, typeof i5.JobModule], [typeof i1.JobProgressionTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<JobTestingModule>;
+}

package/src/app/social/message/message.form.d.ts

@@ -0,0 +1,30 @@
+import { ChangeDetectorRef, Injector, OnInit } from '@angular/core';
+import { UntypedFormBuilder } from '@angular/forms';
+import { Message } from './message.model';
+import { AppForm } from '../../core/form/form.class';
+import { Person } from '../../core/services/model/person.model';
+import { SuggestFn } from '../../shared/services/entity-service.class';
+import { PersonFilter } from '../../admin/services/filter/person.filter';
+import * as i0 from "@angular/core";
+export declare class MessageForm extends AppForm<Message> implements OnInit {
+    private formBuilder;
+    private readonly cd;
+    readonly mobile: boolean;
+    suggestFn: SuggestFn<Person, PersonFilter>;
+    subjectMinLength: number;
+    subjectMaxLength: number;
+    bodyMaxLength: number;
+    bodyAutoHeight: boolean;
+    canSelectType: boolean;
+    types: readonly {
+        id: string;
+        icon: string;
+        label: string;
+    }[];
+    constructor(injector: Injector, formBuilder: UntypedFormBuilder, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    isSamePerson(o1: Person, o2: Person): boolean;
+    protected markForCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageForm, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageForm, "app-message-form", never, { "suggestFn": "suggestFn"; "subjectMinLength": "subjectMinLength"; "subjectMaxLength": "subjectMaxLength"; "bodyMaxLength": "bodyMaxLength"; "bodyAutoHeight": "bodyAutoHeight"; "canSelectType": "canSelectType"; }, {}, never, never, false>;
+}

package/src/app/social/message/message.modal.d.ts

@@ -0,0 +1,39 @@
+import { AfterViewInit, ChangeDetectorRef, OnInit } from '@angular/core';
+import { ModalController } from '@ionic/angular';
+import { Message } from './message.model';
+import { Person } from '../../core/services/model/person.model';
+import { SuggestFn } from '../../shared/services/entity-service.class';
+import { PersonFilter } from '../../admin/services/filter/person.filter';
+import { LocalSettingsService } from '../../core/services/local-settings.service';
+import { AccountService } from '../../core/services/account.service';
+import * as i0 from "@angular/core";
+export interface MessageModalOptions {
+    suggestFn: SuggestFn<Person, PersonFilter>;
+    data?: Message;
+    canSelectType?: boolean;
+}
+export declare class MessageModal implements OnInit, AfterViewInit, MessageModalOptions {
+    protected settings: LocalSettingsService;
+    protected viewCtrl: ModalController;
+    protected accountService: AccountService;
+    protected cd: ChangeDetectorRef;
+    readonly mobile: boolean;
+    suggestFn: SuggestFn<Person, PersonFilter>;
+    data: Message;
+    canSelectType: boolean;
+    private form;
+    constructor(settings: LocalSettingsService, viewCtrl: ModalController, accountService: AccountService, cd: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    cancel(event?: Event): void;
+    doSubmit(event?: Event): Promise<any>;
+    protected markForCheck(): void;
+    protected markAsLoading(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected markAsLoaded(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageModal, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MessageModal, "app-message-modal", never, { "suggestFn": "suggestFn"; "data": "data"; "canSelectType": "canSelectType"; }, {}, never, never, false>;
+}

package/src/app/social/message/message.model.d.ts

@@ -0,0 +1,31 @@
+import { Entity, EntityAsObjectOptions } from '../../core/services/model/entity.model';
+import { StoreObject } from '@apollo/client/core';
+import { EntityFilter } from '../../core/services/model/filter.model';
+import { FilterFn } from '../../shared/services/entity-service.class';
+import { Person } from '../../core/services/model/person.model';
+export declare const MessageTypes: {
+    INBOX_MESSAGE: string;
+    EMAIL: string;
+    FEED: string;
+};
+export declare const MessageTypeList: readonly {
+    id: string;
+    icon: string;
+    label: string;
+}[];
+export declare class Message extends Entity<Message> {
+    static fromObject: (source: any, opts?: any) => Message;
+    type: string;
+    issuer: Person;
+    recipients: Person[];
+    subject: string;
+    body: string;
+    constructor();
+    fromObject(source: any, opts?: any): void;
+    asObject(opts?: EntityAsObjectOptions): StoreObject;
+}
+export declare class MessageFilter extends EntityFilter<MessageFilter, Message> {
+    static fromObject: (source: any, opts?: any) => MessageFilter;
+    fromObject(source: any, opts?: any): void;
+    protected buildFilter(): FilterFn<Message>[];
+}

package/src/app/social/message/message.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./message.modal";
+import * as i2 from "./message.form";
+import * as i3 from "@angular/common";
+import * as i4 from "../../core/core.module";
+import * as i5 from "../../shared/shared.module";
+export declare class MessageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MessageModule, [typeof i1.MessageModal, typeof i2.MessageForm], [typeof i3.CommonModule, typeof i4.CoreModule, typeof i5.SharedModule], [typeof i1.MessageModal]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MessageModule>;
+}

package/src/app/social/message/message.service.d.ts

@@ -0,0 +1,27 @@
+import { GraphqlService } from '../../core/graphql/graphql.service';
+import { ToastController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { BaseGraphqlService } from '../../core/services/base-graphql-service.class';
+import { Environment } from '../../../environments/environment.class';
+import { Message, MessageFilter } from './message.model';
+import { ShowToastOptions } from '../../shared/toast/toasts';
+import * as i0 from "@angular/core";
+export declare class MessageService extends BaseGraphqlService<Message, MessageFilter> {
+    protected graphql: GraphqlService;
+    protected translate: TranslateService;
+    protected toastController: ToastController;
+    protected environment: Environment;
+    constructor(graphql: GraphqlService, translate: TranslateService, toastController: ToastController, environment: Environment);
+    /**
+     * Send a message to recipient(s)
+     *
+     * @param entity
+     * @param opts
+     */
+    send(entity: Message, opts?: {
+        showToast?: boolean;
+    }): Promise<boolean>;
+    protected showToast(opts: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageService, [null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageService>;
+}

package/src/app/social/social.errors.d.ts

@@ -0,0 +1,9 @@
+export declare const SocialErrorCodes: {
+    LOAD_USER_EVENTS_ERROR: number;
+    SAVE_USER_EVENT_ERROR: number;
+    COUNT_USER_EVENT_ERROR: number;
+    SEND_MESSAGE_ERROR: number;
+    SUBSCRIBE_USER_EVENTS_ERROR: number;
+    SUBSCRIBE_JOB_PROGRESSION_ERROR: number;
+    LOAD_JOB_PROGRESSIONS_ERROR: number;
+};

package/src/app/social/social.module.d.ts

@@ -1,4 +1,20 @@
-import { ModuleWithProviders } from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { JobProgressionOptions } from './job/progression/job-progression.icon';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "../core/core.module";
+import * as i3 from "../shared/shared.module";
+import * as i4 from "./user-event/user-event.module";
+import * as i5 from "./job/job.module";
+import * as i6 from "./message/message.module";
+export interface SocialModuleOptions {
+    showUserEventNotification: boolean;
+    showJobProgression: boolean;
+    jobProgressionOptions: JobProgressionOptions;
+}
+export declare const SocialModuleOptionsToken: InjectionToken<SocialModuleOptions>;
 export declare class SocialModule {
-    static forRoot(): ModuleWithProviders<SocialModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SocialModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SocialModule, never, [typeof i1.CommonModule, typeof i2.CoreModule, typeof i3.SharedModule, typeof i4.UserEventModule, typeof i5.JobModule, typeof i6.MessageModule], [typeof i4.UserEventModule, typeof i5.JobModule, typeof i6.MessageModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SocialModule>;
 }

package/src/app/social/social.testing.module.d.ts

@@ -0,0 +1,13 @@
+import { TestingPage } from '../shared/testing/tests.page';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "@angular/router";
+import * as i4 from "./job/testing/job.testing.module";
+import * as i5 from "./user-event/testing/user-event.testing.module";
+export declare const SOCIAL_TESTING_PAGES: TestingPage[];
+export declare class SocialTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SocialTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SocialTestingModule, never, [typeof i1.CommonModule, typeof i2.TranslateModule, typeof i3.RouterModule, typeof i4.JobTestingModule, typeof i5.UserEventTestingModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SocialTestingModule>;
+}

package/src/app/social/user-event/notification/user-event-notification.icon.d.ts

@@ -0,0 +1,29 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { PopoverController } from '@ionic/angular';
+import { IUserEventService } from '../user-event.service';
+import { IUserEvent, IUserEventFilter } from '../user-event.model';
+import { AccountService } from '../../../core/services/account.service';
+import * as i0 from "@angular/core";
+export declare class UserEventNotificationIcon implements OnInit, OnDestroy {
+    userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>;
+    protected accountService: AccountService;
+    protected popoverController: PopoverController;
+    private cd;
+    debug: boolean;
+    titleI18n: string;
+    disabled: boolean;
+    filter: any;
+    autoHide: boolean;
+    visible: boolean;
+    get countChanges(): Observable<number>;
+    private _logPrefix;
+    private _readEvent;
+    private _readEvents;
+    constructor(userEventService: IUserEventService<IUserEvent<any>, IUserEventFilter<any>>, accountService: AccountService, popoverController: PopoverController, cd: ChangeDetectorRef);
+    ngOnInit(): Promise<void>;
+    showList(event: Event): Promise<void>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventNotificationIcon, [{ optional: true; }, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventNotificationIcon, "app-user-event-notification-icon", never, { "debug": "debug"; "titleI18n": "titleI18n"; "disabled": "disabled"; "filter": "filter"; "autoHide": "autoHide"; }, {}, never, never, false>;
+}

package/src/app/social/user-event/notification/user-event-notification.list.d.ts

@@ -0,0 +1,67 @@
+import { ChangeDetectorRef, EventEmitter, InjectionToken, OnDestroy, OnInit, QueryList } from '@angular/core';
+import { IUserEvent, IUserEventFilter, IUserEventAction } from '../user-event.model';
+import { BehaviorSubject, Subscription } from 'rxjs';
+import { IonContent, IonItem, PopoverController } from '@ionic/angular';
+import { IUserEventService } from '../user-event.service';
+import { LocalSettingsService } from '../../../core/services/local-settings.service';
+import { FetchMoreFn, LoadResult } from '../../../shared/services/entity-service.class';
+import { SortDirection } from '@angular/material/sort';
+import * as i0 from "@angular/core";
+export declare const APP_USER_EVENT_LIST_INFINITE_SCROLL_THRESHOLD: InjectionToken<string>;
+export interface UserEventNotificationListOptions<E extends IUserEvent<any> = IUserEvent<any>, F extends IUserEventFilter<any> = IUserEventFilter<any>> {
+    debug?: boolean;
+    titleI18n?: string;
+    readEvent?: EventEmitter<E>;
+    readEvents?: EventEmitter<E[]>;
+    filter?: Partial<F>;
+}
+export declare class UserEventNotificationList<E extends IUserEvent<any> = IUserEvent<any>, F extends IUserEventFilter<any> = IUserEventFilter<any>> implements OnInit, OnDestroy, UserEventNotificationListOptions<E, F> {
+    protected cd: ChangeDetectorRef;
+    protected popoverController: PopoverController;
+    protected settings: LocalSettingsService;
+    userEventService: IUserEventService<E, IUserEventFilter<any>>;
+    infiniteScrollThresholdFromToken: string;
+    debug: boolean;
+    mobile: boolean;
+    titleI18n: string;
+    sortBy: string;
+    sortDirection: SortDirection;
+    filter: Partial<F>;
+    enableInfiniteScroll: boolean;
+    infiniteScrollThreshold: string;
+    set pageSize(value: number);
+    get pageSize(): number;
+    readEvent: EventEmitter<E>;
+    readEvents: EventEmitter<E[]>;
+    ionContent: IonContent;
+    ionItems: QueryList<IonItem>;
+    get canFetchMore(): boolean;
+    fetchingMore: boolean;
+    $items: BehaviorSubject<E[]>;
+    $itemCount: BehaviorSubject<number>;
+    protected _subscriptions: Subscription;
+    protected _fetchMoreFn: FetchMoreFn<LoadResult<E>>;
+    protected _fetchMoreSubscription: Subscription;
+    protected _$pageSize: BehaviorSubject<number>;
+    protected _panelElement: HTMLElement;
+    constructor(cd: ChangeDetectorRef, popoverController: PopoverController, settings: LocalSettingsService, userEventService: IUserEventService<E, IUserEventFilter<any>>, infiniteScrollThresholdFromToken: string);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    click(event: Event, userEvent: E): void;
+    isDefaultAction(action: IUserEventAction): boolean;
+    markAsRead(event: Event, userEvent: E): void;
+    markAllAsRead(event: Event): void;
+    executeAction(event: Event, action: IUserEventAction, userEvent: IUserEvent<any>): Promise<void>;
+    dismiss(): void;
+    fetchMore(event?: CustomEvent & {
+        target?: EventTarget & {
+            complete?: () => void;
+        };
+    }): Promise<void>;
+    trackByFn(index: number, item: E): number;
+    protected initInfiniteScroll(threshold?: string): Promise<void>;
+    protected markForCheck(): void;
+    protected getPanelElement(): Promise<HTMLElement>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventNotificationList<any, any>, [null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventNotificationList<any, any>, "app-user-event-notification-list", never, { "debug": "debug"; "mobile": "mobile"; "titleI18n": "titleI18n"; "sortBy": "sortBy"; "sortDirection": "sortDirection"; "filter": "filter"; "enableInfiniteScroll": "enableInfiniteScroll"; "infiniteScrollThreshold": "infiniteScrollThreshold"; "pageSize": "pageSize"; }, { "readEvent": "readEvent"; "readEvents": "readEvents"; }, never, never, false>;
+}

package/src/app/social/user-event/testing/user-event.testing.d.ts

@@ -0,0 +1,34 @@
+import { OnDestroy } from '@angular/core';
+import { Router } from '@angular/router';
+import { AlertController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { UserEventTestService } from './user-event.testing.service';
+import { UserEventNotificationIcon } from '../notification/user-event-notification.icon';
+import { UserEventTest } from './user-event.testing.model';
+import * as i0 from "@angular/core";
+export declare class UserEventTestingPage implements OnDestroy {
+    protected userEventService: UserEventTestService;
+    protected router: Router;
+    protected alertController: AlertController;
+    protected translateService: TranslateService;
+    private _timerSubscription;
+    notification: UserEventNotificationIcon;
+    get timerStarted(): boolean;
+    constructor(userEventService: UserEventTestService, router: Router, alertController: AlertController, translateService: TranslateService);
+    ngOnDestroy(): void;
+    protected customize(userEvent: UserEventTest): void;
+    addNotification(): void;
+    addError(): void;
+    addWarning(): void;
+    addDebug(): void;
+    addNotificationWithLink(): void;
+    addNotificationWithAction(): void;
+    addMany(count?: number): void;
+    startTimer(period?: number): void;
+    stopTimer(): void;
+    addRandom(value: number): void;
+    addNotificationWithDefaultAction(): void;
+    protected showMessage(text: string): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestingPage, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserEventTestingPage, "job-progression-testing", never, {}, {}, never, never, false>;
+}

package/src/app/social/user-event/testing/user-event.testing.model.d.ts

@@ -0,0 +1,44 @@
+import { Entity, EntityAsObjectOptions } from '../../../core/services/model/entity.model';
+import { Moment } from 'moment';
+import { IconRef } from '../../../shared/types';
+import { EventLevel, IUserEvent, IUserEventFilter, IUserEventAction } from '../user-event.model';
+import { EntityFilter } from '../../../core/services/model/filter.model';
+import { FilterFn } from '../../../shared/services/entity-service.class';
+import { StoreObject } from '@apollo/client/core';
+export declare class UserEventTest extends Entity<UserEventTest> implements IUserEvent<UserEventTest> {
+    static fromObject: (source: any, opts?: any) => UserEventTest;
+    type: string;
+    level: EventLevel;
+    issuer: string;
+    recipient: string;
+    updateDate: Moment;
+    creationDate: Moment;
+    readDate: Moment;
+    message: string | undefined;
+    content: string | any;
+    hash: string;
+    signature: string;
+    readSignature: string;
+    avatar?: string;
+    avatarIcon?: IconRef;
+    icon?: IconRef;
+    jobId?: number;
+    actions?: IUserEventAction[];
+    constructor();
+    asObject(opts?: EntityAsObjectOptions): any;
+    fromObject(source: any): void;
+}
+export declare class UserEventTestFilter extends EntityFilter<UserEventTestFilter, UserEventTest> implements IUserEventFilter<UserEventTest> {
+    static fromObject: (source: any, opts?: any) => UserEventTestFilter;
+    types: string[];
+    levels: EventLevel[];
+    issuers: string[];
+    recipients: string[];
+    startDate: Moment;
+    includedIds: number[];
+    excludeRead: boolean;
+    jobId: number;
+    fromObject(source: any, opts?: any): void;
+    protected buildFilter(): FilterFn<UserEventTest>[];
+    asObject(opts?: EntityAsObjectOptions): StoreObject;
+}

package/src/app/social/user-event/testing/user-event.testing.module.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./user-event.testing";
+import * as i2 from "@angular/common";
+import * as i3 from "@ngx-translate/core";
+import * as i4 from "../../../shared/shared.module";
+import * as i5 from "../user-event.module";
+export declare class UserEventTestingModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestingModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UserEventTestingModule, [typeof i1.UserEventTestingPage], [typeof i2.CommonModule, typeof i3.TranslateModule, typeof i4.SharedModule, typeof i5.UserEventModule], [typeof i1.UserEventTestingPage]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UserEventTestingModule>;
+}

package/src/app/social/user-event/testing/user-event.testing.service.d.ts

@@ -0,0 +1,41 @@
+import { AbstractUserEventService, UserEventLoadOptions, UserEventWatchOptions } from '../user-event.service';
+import { Observable } from 'rxjs';
+import { GraphqlService } from '../../../core/graphql/graphql.service';
+import { AccountService } from '../../../core/services/account.service';
+import { NetworkService } from '../../../core/services/network.service';
+import { TranslateService } from '@ngx-translate/core';
+import { Environment } from '../../../../environments/environment.class';
+import { FetchPolicy } from '@apollo/client/core';
+import { EntityServiceLoadOptions, LoadResult } from '../../../shared/services/entity-service.class';
+import { SortDirection } from '@angular/material/sort';
+import { UserEventTest, UserEventTestFilter } from './user-event.testing.model';
+import * as i0 from "@angular/core";
+export declare class UserEventTestService extends AbstractUserEventService<UserEventTest, UserEventTestFilter> {
+    protected graphql: GraphqlService;
+    protected accountService: AccountService;
+    protected network: NetworkService;
+    protected translate: TranslateService;
+    protected environment: Environment;
+    private $userEvents;
+    private $newUserEvents;
+    constructor(graphql: GraphqlService, accountService: AccountService, network: NetworkService, translate: TranslateService, environment: Environment);
+    fromObject(source: any): UserEventTest;
+    add(entity: UserEventTest): Promise<UserEventTest>;
+    asFilter(filter: Partial<any>): any;
+    count(filter: any, options?: {
+        fetchPolicy?: FetchPolicy;
+    }): Promise<number>;
+    delete(entity: any): Promise<any>;
+    deleteAll(data: any[], opts?: any): Promise<any>;
+    listenAllChanges(filter: any, options?: UserEventWatchOptions & {
+        interval?: number;
+        fetchPolicy?: FetchPolicy;
+    }): Observable<any[]>;
+    save(entity: any, options?: EntityServiceLoadOptions): Promise<any>;
+    saveAll(data: any[], opts?: any): Promise<any[]>;
+    protected defaultRecipient(): any;
+    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, opts?: UserEventWatchOptions): Observable<LoadResult<any>>;
+    loadAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, opts?: UserEventLoadOptions): Promise<LoadResult<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEventTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserEventTestService>;
+}

package/src/app/social/user-event/user-event.model.d.ts

@@ -0,0 +1,45 @@
+import { Moment } from 'moment';
+import { Entity, IEntity } from '../../core/services/model/entity.model';
+import { IEntityFilter } from '../../core/services/model/filter.model';
+import { AppColors, IconRef } from '../../shared/types';
+export declare type EventLevel = 'ERROR' | 'WARNING' | 'INFO' | 'DEBUG';
+export interface IUserEvent<E extends Entity<E, ID>, ID = number, U = string, L = EventLevel> extends IEntity<E, ID> {
+    issuer: U;
+    recipient: U;
+    type: string;
+    level: L;
+    updateDate: Moment;
+    creationDate: Moment;
+    readDate?: Moment;
+    message?: string;
+    content?: string | any;
+    avatar?: string;
+    avatarIcon?: IconRef;
+    avatarJdenticon?: any;
+    icon?: IconRef;
+    jobId?: number;
+    actions?: IUserEventAction[];
+}
+export interface IUserEventFilter<E extends IUserEvent<E, ID, U, L>, ID = number, U = string, L = EventLevel> extends IEntityFilter<any, E> {
+    types: string[];
+    levels: L[];
+    issuers: U[];
+    recipients: U[];
+    startDate: Moment;
+    includedIds: ID[];
+    excludeRead: boolean;
+    jobId?: number;
+}
+export interface IUserEventAction {
+    name: string | any;
+    title?: string;
+    color?: AppColors;
+    iconRef?: IconRef;
+    default?: boolean;
+    executeAction: (event: IUserEvent<any>) => any | Promise<any>;
+}
+/**
+ * @deprecated use IUserEventAction instead
+ */
+export interface UserEventAction extends IUserEventAction {
+}