@sumaris-net/ngx-components 2.6.17 → 4.0.0-rc1

package/esm2022/src/app/social/user-event/testing/user-event.testing.model.mjs

@@ -0,0 +1,128 @@
+var UserEventTest_1;
+import { __decorate } from "tslib";
+// @dynamic
+import { EntityClass } from '../../../core/services/model/entity.decorators';
+import { Entity } from '../../../core/services/model/entity.model';
+import { fromDateISOString, toDateISOString } from '../../../shared/dates';
+import { EntityFilter } from '../../../core/services/model/filter.model';
+import { isNil, isNotEmptyArray, isNotNil } from '../../../shared/functions';
+// @dynamic
+let UserEventTest = UserEventTest_1 = class UserEventTest extends Entity {
+    static fromObject;
+    type;
+    level;
+    issuer;
+    recipient;
+    creationDate;
+    readDate;
+    message;
+    content;
+    hash;
+    signature;
+    readSignature;
+    avatar;
+    avatarIcon;
+    icon;
+    jobId;
+    actions;
+    constructor() {
+        super(UserEventTest_1.TYPENAME);
+    }
+    asObject(opts) {
+        const target = super.asObject(opts);
+        target.creationDate = toDateISOString(this.creationDate);
+        target.readDate = toDateISOString(this.readDate);
+        // Serialize content
+        if (typeof target.content === 'object') {
+            target.content = JSON.stringify(target.content);
+        }
+        delete target.avatar;
+        delete target.avatarIcon;
+        delete target.icon;
+        delete target.actions;
+        return target;
+    }
+    fromObject(source) {
+        Object.assign(this, source); // Copy all properties
+        super.fromObject(source);
+        this.creationDate = fromDateISOString(source.creationDate);
+        this.readDate = fromDateISOString(source.readDate);
+        try {
+            // Deserialize content
+            if (typeof source.content === 'string' && source.content.startsWith('{')) {
+                this.content = JSON.parse(source.content);
+            }
+            // Deserialize content.context
+            if (this.content && typeof this.content.context === 'string' && this.content.context.startsWith('{')) {
+                this.content.context = JSON.parse(this.content.context);
+            }
+        }
+        catch (err) {
+            console.error('Error during UserEvent deserialization', err);
+        }
+    }
+};
+UserEventTest = UserEventTest_1 = __decorate([
+    EntityClass({ typename: 'UserEventTestVO' })
+], UserEventTest);
+export { UserEventTest };
+// @dynamic
+let UserEventTestFilter = class UserEventTestFilter extends EntityFilter {
+    static fromObject;
+    types = [];
+    levels = [];
+    issuers = [];
+    recipients = [];
+    startDate = null;
+    includedIds;
+    excludeRead = false;
+    jobId = null;
+    fromObject(source, opts) {
+        super.fromObject(source, opts);
+        this.types = source.types || [];
+        this.levels = source.levels || [];
+        this.issuers = source.issuers || [];
+        this.recipients = source.recipients || [];
+        this.startDate = fromDateISOString(source.startDate);
+        this.excludeRead = source.excludeRead || false;
+        this.includedIds = source.includedIds || [];
+        this.jobId = source.jobId;
+    }
+    buildFilter() {
+        const filterFns = super.buildFilter();
+        if (isNotEmptyArray(this.types)) {
+            filterFns.push(t => this.types.includes(t.type));
+        }
+        if (isNotEmptyArray(this.levels)) {
+            filterFns.push(t => this.levels.includes(t.level));
+        }
+        if (isNotEmptyArray(this.issuers)) {
+            filterFns.push(t => this.issuers.includes(t.issuer));
+        }
+        if (isNotEmptyArray(this.recipients)) {
+            filterFns.push(t => this.recipients.includes(t.recipient));
+        }
+        if (isNotNil(this.startDate)) {
+            filterFns.push(t => this.startDate.isSameOrBefore(t.creationDate));
+        }
+        if (isNotEmptyArray(this.includedIds)) {
+            filterFns.push((t) => this.includedIds.includes(t.id));
+        }
+        if (this.excludeRead === true) {
+            filterFns.push(t => isNil(t.readSignature)); // todo or t.signature ?
+        }
+        if (isNotNil(this.jobId)) {
+            filterFns.push(t => this.jobId === t.jobId);
+        }
+        return filterFns;
+    }
+    asObject(opts) {
+        const target = super.asObject(opts);
+        return target;
+    }
+};
+UserEventTestFilter = __decorate([
+    EntityClass({ typename: 'UserEventTestFilterVO' })
+], UserEventTestFilter);
+export { UserEventTestFilter };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-event.testing.model.js","sourceRoot":"","sources":["../../../../../../../src/app/social/user-event/testing/user-event.testing.model.ts"],"names":[],"mappings":"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","sourcesContent":["// @dynamic\nimport {EntityClass} from '../../../core/services/model/entity.decorators';\nimport {Entity, EntityAsObjectOptions} from '../../../core/services/model/entity.model';\nimport {Moment} from 'moment';\nimport {IconRef} from '../../../shared/types';\nimport {fromDateISOString, toDateISOString} from '../../../shared/dates';\nimport {EventLevel, IUserEvent, IUserEventFilter, IUserEventAction} from '../user-event.model';\nimport {EntityFilter} from '../../../core/services/model/filter.model';\nimport {FilterFn} from '../../../shared/services/entity-service.class';\nimport {isNil, isNotEmptyArray, isNotNil} from '../../../shared/functions';\nimport {StoreObject} from '@apollo/client/core';\n\n// @dynamic\n@EntityClass({typename: 'UserEventTestVO'})\nexport class UserEventTest extends Entity<UserEventTest> implements IUserEvent<UserEventTest> {\n\n  static fromObject: (source: any, opts?: any) => UserEventTest;\n\n  type: string;\n  level: EventLevel;\n  issuer: string;\n  recipient: string;\n  creationDate: Moment;\n  readDate: Moment;\n\n  message: string | undefined;\n  content: string | any;\n  hash: string;\n  signature: string;\n  readSignature: string;\n\n  avatar?: string;\n  avatarIcon?: IconRef;\n  icon?: IconRef;\n  jobId?: number;\n\n  actions?: IUserEventAction[];\n\n  constructor() {\n    super(UserEventTest.TYPENAME);\n  }\n\n  asObject(opts?: EntityAsObjectOptions): any {\n    const target = super.asObject(opts);\n    target.creationDate = toDateISOString(this.creationDate);\n    target.readDate = toDateISOString(this.readDate);\n\n    // Serialize content\n    if (typeof target.content === 'object') {\n      target.content = JSON.stringify(target.content);\n    }\n\n    delete target.avatar;\n    delete target.avatarIcon;\n    delete target.icon;\n    delete target.actions;\n\n    return target;\n  }\n\n  fromObject(source: any) {\n    Object.assign(this, source); // Copy all properties\n    super.fromObject(source);\n    this.creationDate = fromDateISOString(source.creationDate);\n    this.readDate = fromDateISOString(source.readDate);\n\n    try {\n      // Deserialize content\n      if (typeof source.content === 'string' && source.content.startsWith('{')) {\n        this.content = JSON.parse(source.content);\n      }\n\n      // Deserialize content.context\n      if (this.content && typeof this.content.context === 'string' && this.content.context.startsWith('{')) {\n        this.content.context = JSON.parse(this.content.context);\n      }\n    } catch (err) {\n      console.error('Error during UserEvent deserialization', err);\n    }\n  }\n}\n\n// @dynamic\n@EntityClass({typename: 'UserEventTestFilterVO'})\nexport class UserEventTestFilter extends EntityFilter<UserEventTestFilter, UserEventTest> implements IUserEventFilter<UserEventTest> {\n\n  static fromObject: (source: any, opts?: any) => UserEventTestFilter;\n\n  types: string[] = [];\n  levels: EventLevel[] = [];\n  issuers: string[] = [];\n  recipients: string[] = [];\n  startDate: Moment = null;\n  includedIds: number[];\n  excludeRead = false;\n  jobId: number = null;\n\n  fromObject(source: any, opts?: any) {\n    super.fromObject(source, opts);\n    this.types = source.types || [];\n    this.levels = source.levels || [];\n    this.issuers = source.issuers || [];\n    this.recipients = source.recipients || [];\n    this.startDate = fromDateISOString(source.startDate);\n    this.excludeRead = source.excludeRead || false;\n    this.includedIds = source.includedIds || [];\n    this.jobId = source.jobId;\n  }\n\n  protected buildFilter(): FilterFn<UserEventTest>[] {\n    const filterFns = super.buildFilter();\n\n    if (isNotEmptyArray(this.types)) {\n      filterFns.push(t => this.types.includes(t.type));\n    }\n    if (isNotEmptyArray(this.levels)) {\n      filterFns.push(t => this.levels.includes(t.level));\n    }\n    if (isNotEmptyArray(this.issuers)) {\n      filterFns.push(t => this.issuers.includes(t.issuer));\n    }\n    if (isNotEmptyArray(this.recipients)) {\n      filterFns.push(t => this.recipients.includes(t.recipient));\n    }\n\n    if (isNotNil(this.startDate)) {\n      filterFns.push(t => this.startDate.isSameOrBefore(t.creationDate));\n    }\n    if (isNotEmptyArray(this.includedIds)) {\n      filterFns.push((t) => this.includedIds.includes(t.id));\n    }\n    if (this.excludeRead === true) {\n      filterFns.push(t => isNil(t.readSignature)); // todo or t.signature ?\n    }\n    if (isNotNil(this.jobId)) {\n      filterFns.push(t => this.jobId === t.jobId);\n    }\n    return filterFns;\n  }\n\n  asObject(opts?: EntityAsObjectOptions): StoreObject {\n    const target = super.asObject(opts);\n    return target;\n  }\n}\n"]}

package/{esm2020 → esm2022}/src/app/social/user-event/testing/user-event.testing.module.mjs

@@ -7,15 +7,15 @@ import { UserEventTestingPage } from './user-event.testing';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngx-translate/core";
 export class UserEventTestingModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: UserEventTestingModule, declarations: [UserEventTestingPage], imports: [CommonModule, i1.TranslateModule, SharedModule,
+            UserEventModule], exports: [UserEventTestingPage] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTestingModule, imports: [CommonModule,
+            TranslateModule.forChild(),
+            SharedModule,
+            UserEventModule] });
 }
-UserEventTestingModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UserEventTestingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-UserEventTestingModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: UserEventTestingModule, declarations: [UserEventTestingPage], imports: [CommonModule, i1.TranslateModule, SharedModule,
-        UserEventModule], exports: [UserEventTestingPage] });
-UserEventTestingModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UserEventTestingModule, imports: [CommonModule,
-        TranslateModule.forChild(),
-        SharedModule,
-        UserEventModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UserEventTestingModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTestingModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -32,4 +32,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1ldmVudC50ZXN0aW5nLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc29jaWFsL3VzZXItZXZlbnQvdGVzdGluZy91c2VyLWV2ZW50LnRlc3RpbmcubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDN0QsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDOzs7QUFnQjVELE1BQU0sT0FBTyxzQkFBc0I7O21IQUF0QixzQkFBc0I7b0hBQXRCLHNCQUFzQixpQkFOL0Isb0JBQW9CLGFBTnBCLFlBQVksc0JBRVosWUFBWTtRQUNaLGVBQWUsYUFNZixvQkFBb0I7b0hBR1gsc0JBQXNCLFlBWi9CLFlBQVk7UUFDWixlQUFlLENBQUMsUUFBUSxFQUFFO1FBQzFCLFlBQVk7UUFDWixlQUFlOzJGQVNOLHNCQUFzQjtrQkFkbEMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUU7d0JBQ1AsWUFBWTt3QkFDWixlQUFlLENBQUMsUUFBUSxFQUFFO3dCQUMxQixZQUFZO3dCQUNaLGVBQWU7cUJBQ2hCO29CQUNELFlBQVksRUFBRTt3QkFDWixvQkFBb0I7cUJBQ3JCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxvQkFBb0I7cUJBQ3JCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBUcmFuc2xhdGVNb2R1bGUgfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcbmltcG9ydCB7IFNoYXJlZE1vZHVsZSB9IGZyb20gJy4uLy4uLy4uL3NoYXJlZC9zaGFyZWQubW9kdWxlJztcbmltcG9ydCB7IFVzZXJFdmVudE1vZHVsZSB9IGZyb20gJy4uL3VzZXItZXZlbnQubW9kdWxlJztcbmltcG9ydCB7IFVzZXJFdmVudFRlc3RpbmdQYWdlIH0gZnJvbSAnLi91c2VyLWV2ZW50LnRlc3RpbmcnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIFRyYW5zbGF0ZU1vZHVsZS5mb3JDaGlsZCgpLFxuICAgIFNoYXJlZE1vZHVsZSxcbiAgICBVc2VyRXZlbnRNb2R1bGVcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgVXNlckV2ZW50VGVzdGluZ1BhZ2VcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIFVzZXJFdmVudFRlc3RpbmdQYWdlXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgVXNlckV2ZW50VGVzdGluZ01vZHVsZSB7fVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1ldmVudC50ZXN0aW5nLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc29jaWFsL3VzZXItZXZlbnQvdGVzdGluZy91c2VyLWV2ZW50LnRlc3RpbmcubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDN0QsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDOzs7QUFnQjVELE1BQU0sT0FBTyxzQkFBc0I7d0dBQXRCLHNCQUFzQjt5R0FBdEIsc0JBQXNCLGlCQU4vQixvQkFBb0IsYUFOcEIsWUFBWSxzQkFFWixZQUFZO1lBQ1osZUFBZSxhQU1mLG9CQUFvQjt5R0FHWCxzQkFBc0IsWUFaL0IsWUFBWTtZQUNaLGVBQWUsQ0FBQyxRQUFRLEVBQUU7WUFDMUIsWUFBWTtZQUNaLGVBQWU7OzRGQVNOLHNCQUFzQjtrQkFkbEMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUU7d0JBQ1AsWUFBWTt3QkFDWixlQUFlLENBQUMsUUFBUSxFQUFFO3dCQUMxQixZQUFZO3dCQUNaLGVBQWU7cUJBQ2hCO29CQUNELFlBQVksRUFBRTt3QkFDWixvQkFBb0I7cUJBQ3JCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxvQkFBb0I7cUJBQ3JCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBUcmFuc2xhdGVNb2R1bGUgfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcbmltcG9ydCB7IFNoYXJlZE1vZHVsZSB9IGZyb20gJy4uLy4uLy4uL3NoYXJlZC9zaGFyZWQubW9kdWxlJztcbmltcG9ydCB7IFVzZXJFdmVudE1vZHVsZSB9IGZyb20gJy4uL3VzZXItZXZlbnQubW9kdWxlJztcbmltcG9ydCB7IFVzZXJFdmVudFRlc3RpbmdQYWdlIH0gZnJvbSAnLi91c2VyLWV2ZW50LnRlc3RpbmcnO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIFRyYW5zbGF0ZU1vZHVsZS5mb3JDaGlsZCgpLFxuICAgIFNoYXJlZE1vZHVsZSxcbiAgICBVc2VyRXZlbnRNb2R1bGVcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgVXNlckV2ZW50VGVzdGluZ1BhZ2VcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIFVzZXJFdmVudFRlc3RpbmdQYWdlXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgVXNlckV2ZW50VGVzdGluZ01vZHVsZSB7fVxuIl19

package/esm2022/src/app/social/user-event/testing/user-event.testing.service.mjs

@@ -0,0 +1,116 @@
+import { Inject, Injectable } from '@angular/core';
+import { AbstractUserEventService } from '../user-event.service';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { ENVIRONMENT } from '../../../../environments/environment.class';
+import { EntityUtils } from '../../../core/services/model/entity.model';
+import { map } from 'rxjs/operators';
+import { UserEventTest } from './user-event.testing.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/graphql/graphql.service";
+import * as i2 from "../../../core/services/account.service";
+import * as i3 from "../../../core/services/network.service";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "../../../../environments/environment.class";
+export class UserEventTestService extends AbstractUserEventService {
+    graphql;
+    accountService;
+    network;
+    translate;
+    environment;
+    $userEvents = new BehaviorSubject([]);
+    $newUserEvents = new Subject();
+    constructor(graphql, accountService, network, translate, environment) {
+        super(graphql, accountService, network, translate, {
+            queries: {
+                loadAll: null,
+                loadAllWithContent: null
+            },
+            production: environment?.production
+        });
+        this.graphql = graphql;
+        this.accountService = accountService;
+        this.network = network;
+        this.translate = translate;
+        this.environment = environment;
+    }
+    fromObject(source) {
+        return UserEventTest.fromObject(source);
+    }
+    async add(entity) {
+        entity = await this.processUserEvent(entity);
+        entity.id = (this.$userEvents.value?.length || 0) + 1;
+        this.$userEvents.next([
+            entity,
+            ...this.$userEvents.value
+        ]);
+        this._countSubject.next((this._countSubject.value || 0) + 1);
+        this.$newUserEvents.next([entity]);
+        return entity;
+    }
+    asFilter(filter) {
+        return filter;
+    }
+    count(filter, options) {
+        return Promise.resolve(this.$userEvents.value?.length || 0);
+    }
+    delete(entity) {
+        return Promise.resolve(undefined);
+    }
+    deleteAll(data, opts) {
+        return Promise.resolve(undefined);
+    }
+    listenAllChanges(filter, options) {
+        return this.$newUserEvents.asObservable();
+    }
+    save(entity, options) {
+        const toSave = this.$userEvents.value?.find(value => value.id == entity?.id);
+        Object.assign(toSave, entity);
+        return entity;
+    }
+    async saveAll(data, opts) {
+        for (const entity of (data || [])) {
+            await this.save(entity);
+        }
+        return this.$userEvents.toPromise();
+    }
+    defaultRecipient() {
+        return this.accountService.isLogin() ? this.accountService.person.pubkey : undefined;
+    }
+    watchAll(offset, size, sortBy, sortDirection, filter, opts) {
+        return this.$userEvents.pipe(map(userEvents => {
+            let data = (userEvents || []).slice(offset || 0, offset + size);
+            const total = this.$userEvents.value?.length || 0;
+            const res = { data, total };
+            // Must re-order because of listenChanges result will add new event at the end
+            data = EntityUtils.sort(data, sortBy, sortDirection);
+            // Add fetch more
+            const nextOffset = offset + data.length;
+            if (nextOffset < res.total) {
+                res.fetchMore = (_) => this.loadAll(nextOffset, size, sortBy, sortDirection, filter, { ...opts, fetchPolicy: 'no-cache' });
+            }
+            return res;
+        }));
+    }
+    loadAll(offset, size, sortBy, sortDirection, filter, opts) {
+        let data = (this.$userEvents.value || []).slice(offset || 0, offset + size);
+        const total = this.$userEvents.value?.length || 0;
+        const res = { data, total };
+        // Must re-order because of listenChanges result will add new event at the end
+        data = EntityUtils.sort(data, sortBy, sortDirection);
+        // Add fetch more
+        const nextOffset = offset + data.length;
+        if (nextOffset < res.total) {
+            res.fetchMore = (_) => this.loadAll(nextOffset, size, sortBy, sortDirection, filter, { ...opts, fetchPolicy: 'no-cache' });
+        }
+        return Promise.resolve(res);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTestService, deps: [{ token: i1.GraphqlService }, { token: i2.AccountService }, { token: i3.NetworkService }, { token: i4.TranslateService }, { token: ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTestService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventTestService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.GraphqlService }, { type: i2.AccountService }, { type: i3.NetworkService }, { type: i4.TranslateService }, { type: i5.Environment, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-event.testing.service.js","sourceRoot":"","sources":["../../../../../../../src/app/social/user-event/testing/user-event.testing.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport {AbstractUserEventService, UserEventLoadOptions, UserEventWatchOptions} from '../user-event.service';\nimport {BehaviorSubject, Observable, Subject} from 'rxjs';\nimport {GraphqlService} from '../../../core/graphql/graphql.service';\nimport {AccountService} from '../../../core/services/account.service';\nimport {NetworkService} from '../../../core/services/network.service';\nimport {TranslateService} from '@ngx-translate/core';\nimport {Environment, ENVIRONMENT} from '../../../../environments/environment.class';\nimport {FetchPolicy} from '@apollo/client/core';\nimport {EntityServiceLoadOptions, LoadResult} from '../../../shared/services/entity-service.class';\nimport {SortDirection} from '@angular/material/sort';\nimport {EntityUtils} from '../../../core/services/model/entity.model';\nimport {map} from 'rxjs/operators';\nimport {UserEventTest, UserEventTestFilter} from './user-event.testing.model';\n\n@Injectable()\nexport class UserEventTestService extends AbstractUserEventService<UserEventTest, UserEventTestFilter> {\n\n  private $userEvents = new BehaviorSubject<UserEventTest[]>([]);\n  private $newUserEvents = new Subject<UserEventTest[]>();\n\n  constructor(\n    protected graphql: GraphqlService,\n    protected accountService: AccountService,\n    protected network: NetworkService,\n    protected translate: TranslateService,\n    @Inject(ENVIRONMENT) protected environment: Environment\n  ) {\n    super(graphql, accountService, network, translate, {\n      queries: {\n        loadAll: null,\n        loadAllWithContent: null\n      },\n      production: environment?.production\n    });\n  }\n\n\n  fromObject(source: any): UserEventTest {\n    return UserEventTest.fromObject(source);\n  }\n\n  async add(entity: UserEventTest): Promise<UserEventTest> {\n    entity = await this.processUserEvent(entity);\n    entity.id = (this.$userEvents.value?.length || 0) + 1;\n    this.$userEvents.next([\n      entity,\n      ...this.$userEvents.value\n    ]);\n    this._countSubject.next((this._countSubject.value || 0) + 1);\n    this.$newUserEvents.next([entity]);\n    return entity;\n  }\n\n  asFilter(filter: Partial<any>): any {\n    return filter;\n  }\n\n  count(filter: any, options?: { fetchPolicy?: FetchPolicy }): Promise<number> {\n    return Promise.resolve(this.$userEvents.value?.length || 0);\n  }\n\n  delete(entity: any): Promise<any> {\n    return Promise.resolve(undefined);\n  }\n\n  deleteAll(data: any[], opts?: any): Promise<any> {\n    return Promise.resolve(undefined);\n  }\n\n  listenAllChanges(filter: any, options?: UserEventWatchOptions & { interval?: number; fetchPolicy?: FetchPolicy }): Observable<any[]> {\n    return this.$newUserEvents.asObservable();\n  }\n\n  save(entity: any, options?: EntityServiceLoadOptions): Promise<any> {\n\n    const toSave = this.$userEvents.value?.find(value => value.id == entity?.id);\n    Object.assign(toSave, entity);\n\n    return entity;\n  }\n\n  async saveAll(data: any[], opts?: any): Promise<any[]> {\n\n    for (const entity of (data || [])) {\n      await this.save(entity);\n    }\n\n    return this.$userEvents.toPromise();\n  }\n\n  protected defaultRecipient(): any {\n    return this.accountService.isLogin() ? this.accountService.person.pubkey : undefined;\n  }\n\n  watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>, opts?: UserEventWatchOptions): Observable<LoadResult<any>> {\n    return this.$userEvents.pipe(\n      map(userEvents => {\n        let data = (userEvents || []).slice(offset||0, offset + size);\n        const total = this.$userEvents.value?.length || 0;\n\n        const res = <LoadResult<UserEventTest>>{ data, total };\n\n        // Must re-order because of listenChanges result will add new event at the end\n        data = EntityUtils.sort(data, sortBy, sortDirection);\n\n        // Add fetch more\n        const nextOffset = offset + data.length;\n        if (nextOffset < res.total) {\n          res.fetchMore =  (_) => this.loadAll(nextOffset, size, sortBy, sortDirection, filter,\n            {...opts, fetchPolicy: <FetchPolicy>'no-cache'} as unknown as UserEventLoadOptions\n          );\n        }\n\n        return res;\n      })\n    );\n\n  }\n\n  loadAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<any>,\n          opts?: UserEventLoadOptions): Promise<LoadResult<any>> {\n    let data = (this.$userEvents.value || []).slice(offset||0, offset + size);\n    const total = this.$userEvents.value?.length || 0;\n\n    const res = <LoadResult<UserEventTest>>{ data, total };\n\n    // Must re-order because of listenChanges result will add new event at the end\n    data = EntityUtils.sort(data, sortBy, sortDirection);\n\n    // Add fetch more\n    const nextOffset = offset + data.length;\n    if (nextOffset < res.total) {\n      res.fetchMore =  (_) => this.loadAll(nextOffset, size, sortBy, sortDirection, filter,\n        {...opts, fetchPolicy: <FetchPolicy>'no-cache'} as unknown as UserEventLoadOptions\n      );\n    }\n\n    return Promise.resolve(res);\n  }\n}\n"]}

package/esm2022/src/app/social/user-event/user-event.module.mjs

@@ -0,0 +1,43 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SharedModule } from '../../shared/shared.module';
+import { UserEventNotificationIcon } from './notification/user-event-notification.icon';
+import { UserEventNotificationList } from './notification/user-event-notification.list';
+import { AppIconModule } from '../../core/icon/icon.module';
+import { NgxJdenticonModule } from 'ngx-jdenticon';
+import { RxStateModule } from '../../shared/rx-state.module';
+import * as i0 from "@angular/core";
+export class UserEventModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: UserEventModule, declarations: [UserEventNotificationIcon,
+            UserEventNotificationList], imports: [CommonModule,
+            SharedModule,
+            AppIconModule,
+            RxStateModule,
+            NgxJdenticonModule], exports: [UserEventNotificationIcon] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventModule, imports: [CommonModule,
+            SharedModule,
+            AppIconModule,
+            RxStateModule,
+            NgxJdenticonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: UserEventModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        SharedModule,
+                        AppIconModule,
+                        RxStateModule,
+                        NgxJdenticonModule
+                    ],
+                    declarations: [
+                        UserEventNotificationIcon,
+                        UserEventNotificationList
+                    ],
+                    exports: [
+                        UserEventNotificationIcon
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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