@sumaris-net/ngx-components 1.21.7 → 1.22.0

package/esm2015/src/app/social/user-event/user-event.service.js

@@ -1,14 +1,14 @@
-import { __awaiter, __decorate } from "tslib";
-import { Inject, Injectable, Optional } from '@angular/core';
+import { __awaiter } from "tslib";
+import { Directive, Inject, Injectable, InjectionToken, Optional } from '@angular/core';
 import { gql } from '@apollo/client/core';
 import { SocialErrorCodes } from '../social.errors';
 import { AccountService } from '../../core/services/account.service';
 import { GraphqlService } from '../../core/graphql/graphql.service';
-import { of } from 'rxjs';
-import { UserEvent, UserEventTypes } from './user-event.model';
+import { BehaviorSubject, merge, of, Subscription } from 'rxjs';
+import { UserEvent, UserEventFilter, UserEventTypes } from './user-event.model';
 import { UserEventFragments } from './user-event.fragments';
-import { map } from 'rxjs/operators';
-import { isEmptyArray, isNil, isNilOrBlank, toNumber } from '../../shared/functions';
+import { distinctUntilChanged, map, mergeMap } from 'rxjs/operators';
+import { isEmptyArray, isNotNil, toNumber } from '../../shared/functions';
 import { Toasts } from '../../shared/toast/toasts';
 import { ToastController } from '@ionic/angular';
 import { TranslateService } from '@ngx-translate/core';
@@ -16,155 +16,249 @@ import { NetworkService } from '../../core/services/network.service';
 import { BaseGraphqlService } from '../../core/services/base-graphql-service.class';
 import { Entity, EntityUtils } from '../../core/services/model/entity.model';
 import { Environment, ENVIRONMENT } from '../../../environments/environment.class';
-import { EntityFilter } from '../../core/services/model/filter.model';
-import { EntityClass } from '../../core/services/model/entity.decorators';
-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 "@ionic/angular";
-import * as i6 from "../../../environments/environment.class";
-// @dynamic
-let UserEventFilter = class UserEventFilter extends EntityFilter {
-    constructor() {
-        super(...arguments);
-        this.issuer = null;
-        this.recipient = null;
-    }
-    fromObject(source, opts) {
-        super.fromObject(source, opts);
-        this.issuer = source.issuer;
-        this.recipient = source.recipient;
-    }
-    buildFilter() {
-        const filterFns = super.buildFilter();
-        // issuer
-        if (this.issuer) {
-            filterFns.push(t => (t.issuer === this.issuer));
-        }
-        if (this.recipient) {
-            filterFns.push(t => (t.recipient === this.recipient));
-        }
-        return filterFns;
-    }
-};
-UserEventFilter = __decorate([
-    EntityClass({ typename: 'UserEventFilterVO' })
-], UserEventFilter);
-export { UserEventFilter };
-const SaveQuery = gql `
-  mutation SaveUserEvent($data: UserEventVOInput){
-    data: saveUserEvent(userEvent: $data){
-      ...UserEventFragment
-    }
-  }
-  ${UserEventFragments.userEvent}
-`;
-const LoadAllQuery = gql `
-  query UserEvents($filter: UserEventFilterVOInput, $page: PageInput){
-    data: userEvents(filter: $filter, page: $page){
-      ...LightUserEventFragment
-    }
-  }
-  ${UserEventFragments.lightUserEvent}
-`;
-const DeleteByIdsMutation = gql `
-  mutation DeleteUserEvents($ids:[Int]){
-    deleteUserEvents(ids: $ids)
-  }
-`;
-const LoadAllWithContentQuery = gql `
-  query UserEventsWithContent($filter: UserEventFilterVOInput, $page: PageInput){
-    data: userEvents(filter: $filter, page: $page){
-      ...UserEventFragment
-    }
-  }
-  ${UserEventFragments.userEvent}
-`;
-export class UserEventService extends BaseGraphqlService {
-    constructor(graphql, accountService, network, translate, toastController, environment) {
+import { DateUtils } from '../../shared/dates';
+import * as momentImported from 'moment';
+const moment = momentImported;
+export const UserEventServiceToken = new InjectionToken('UserEventService');
+export class AbstractUserEventService extends BaseGraphqlService {
+    constructor(graphql, accountService, network, translate, queries, mutations, subscriptions, environment) {
         super(graphql, environment);
         this.graphql = graphql;
         this.accountService = accountService;
         this.network = network;
         this.translate = translate;
-        this.toastController = toastController;
+        this.queries = queries;
+        this.mutations = mutations;
+        this.subscriptions = subscriptions;
         this.environment = environment;
-        this._userEventActions = [];
+        this.count$ = new BehaviorSubject(0);
+        this.listeners = [];
+        this._subscriptions = new Subscription();
+        this._logPrefix = '[user-event-service] ';
         // For DEV only
-        this._debug = environment && !environment.production;
-    }
-    /**
-     *
-     * @param offset
-     * @param size
-     * @param sortBy
-     * @param sortDirection
-     * @param filter
-     * @param options
-     * @deprecated use watchPage() instead
-     */
+        this._debug = !(environment === null || environment === void 0 ? void 0 : environment.production);
+    }
+    get userEventCount() {
+        return this.count$.asObservable();
+    }
+    ngOnStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Update component when refresh is need (=login events)
+            this._subscriptions.add(merge(this.accountService.onLogin, this.accountService.onLogout)
+                .pipe(
+            // Wait account service ready (can be restarted)
+            mergeMap(() => this.accountService.ready()), map(() => this.accountService.isLogin()), distinctUntilChanged())
+                .subscribe(login => {
+                if (login) {
+                    this.onLogin();
+                }
+                else {
+                    this.onLogout();
+                }
+            }));
+            // First attempt if account is ready
+            yield this.accountService.ready();
+            if (this.accountService.isLogin()) {
+                setTimeout(() => this.onLogin());
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+    }
     watchAll(offset, size, sortBy, sortDirection, filter, options) {
         return this.watchPage({ offset, size, sortBy, sortDirection }, filter, options);
     }
     watchPage(page, filter, options) {
+        var _a;
         let now = this._debug && Date.now();
-        //if (this._debug)
-        console.debug('[user-event-service] Loading user events...', filter);
+        if (!filter) {
+            filter = this.defaultFilter();
+        }
+        console.debug(`${this._logPrefix}Loading user events...`, filter);
         filter = this.asFilter(filter);
         // Force recipient to current issuer, if not admin and not specified
-        if (isNilOrBlank(filter.recipient) || !this.accountService.isAdmin()) {
-            const recipient = this.accountService.account.pubkey;
-            if (recipient !== filter.recipient) {
+        if (isEmptyArray(filter === null || filter === void 0 ? void 0 : filter.recipients) || !this.accountService.isAdmin()) {
+            const recipient = this.defaultRecipient();
+            if (!((_a = filter === null || filter === void 0 ? void 0 : filter.recipients) === null || _a === void 0 ? void 0 : _a.includes(recipient))) {
                 console.warn('[user-events-service] Force user event filter.recipient=' + recipient);
-                filter.recipient = recipient;
+                filter.recipients = [recipient];
             }
         }
-        const withContent = options && options.withContent === true;
+        const withContent = (options === null || options === void 0 ? void 0 : options.withContent) === true;
         return this.mutableWatchQuery({
             queryName: withContent ? 'LoadAllWithContent' : 'LoadAll',
-            query: withContent ? LoadAllWithContentQuery : LoadAllQuery,
+            query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,
             variables: {
-                page: Object.assign(Object.assign({ sortBy: 'updateDate' }, page), { sortDirection: (page.sortDirection || 'DESC').toUpperCase() }),
+                page: Object.assign(Object.assign({ sortBy: 'creationDate' }, page), { 
+                    // @ts-ignore
+                    sortDirection: (page.sortDirection || 'desc').toUpperCase() }),
                 filter: filter && filter.asPodObject()
             },
             arrayFieldName: 'data',
             error: { code: SocialErrorCodes.LOAD_USER_EVENTS_ERROR, message: 'SOCIAL.ERROR.LOAD_USER_EVENTS_ERROR' },
-            fetchPolicy: options && options.fetchPolicy || undefined
+            fetchPolicy: (options === null || options === void 0 ? void 0 : options.fetchPolicy) || 'cache-first'
         })
             .pipe(map(res => {
-            const data = res && (res.data || []).map(UserEvent.fromObject);
+            let data = ((res === null || res === void 0 ? void 0 : res.data) || []).map(value => this.processUserEvent(value, this));
             if (now) {
-                console.debug(`[user-event-service] ${data.length} user events loaded in ${Date.now() - now}ms`);
+                console.debug(`${this._logPrefix}${data.length} user events loaded in ${Date.now() - now}ms`);
                 now = null;
             }
+            // Must re-order because of listenChanges result will add new event at the end
+            data = EntityUtils.sort(data, page.sortBy, page.sortDirection);
             return {
                 data,
-                total: res && toNumber(res.total, data.length)
+                total: toNumber(res === null || res === void 0 ? void 0 : res.total, data.length)
             };
         }));
     }
-    saveAll(data, options) {
-        return Promise.all(data
-            .map(entity => this.save(entity, options)));
+    add(entity) {
+        // TODO set an id !!!!!!!!!!!!!!!!!!!!!!!!!
+        entity = this.processUserEvent(entity);
+        const withContent = !!entity.content;
+        // Add user event locally
+        this.insertIntoMutableCachedQueries(this.graphql.cache, {
+            query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,
+            data: entity
+        });
+        // Update count
+        this.count$.next(this.count$.value + 1);
+    }
+    count(filter, options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!((_a = this.queries) === null || _a === void 0 ? void 0 : _a.count)) {
+                console.warn(`${this._logPrefix}Query 'count' not provided, skip.`);
+                return undefined;
+            }
+            if (!filter)
+                filter = this.defaultFilter();
+            // Apply last reset date as start date
+            filter.startDate = this.resetCountDate;
+            filter = this.asFilter(filter);
+            if (this._debug)
+                console.debug(`${this._logPrefix}Counting user events with filter:`, filter);
+            const res = yield this.graphql.query({
+                query: this.queries.count,
+                variables: {
+                    filter: filter.asPodObject()
+                },
+                error: { code: SocialErrorCodes.COUNT_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.COUNT_USER_EVENT_ERROR' },
+                fetchPolicy: (options === null || options === void 0 ? void 0 : options.fetchPolicy) || 'network-only'
+            });
+            return res.total;
+        });
+    }
+    listenCountChanges(filter, options) {
+        var _a;
+        if (!((_a = this.subscriptions) === null || _a === void 0 ? void 0 : _a.listenCountChanges)) {
+            console.warn(`${this._logPrefix}Subscription query 'listenCountChanges' not provided, skip.`);
+            return of();
+        }
+        if (!filter)
+            filter = this.defaultFilter();
+        // Apply last reset date as start date
+        filter.startDate = this.resetCountDate;
+        filter = this.asFilter(filter);
+        if (this._debug)
+            console.debug(`${this._logPrefix}[WS] Listening count changes for user events with filter:`, filter);
+        return this.graphql.subscribe({
+            query: this.subscriptions.listenCountChanges,
+            fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
+            variables: { filter: filter.asPodObject(), interval: toNumber(options === null || options === void 0 ? void 0 : options.interval, 10) },
+            error: {
+                code: SocialErrorCodes.SUBSCRIBE_USER_EVENTS_ERROR,
+                message: 'SOCIAL.ERROR.SUBSCRIBE_USER_EVENTS_ERROR'
+            }
+        }).pipe(map(({ total }) => {
+            if (total && this._debug)
+                console.debug(`${this._logPrefix}Received new user events count:`, total);
+            // update count
+            this.count$.next(total);
+            return total;
+        }));
+    }
+    listenChanges(filter, options) {
+        var _a;
+        if (!((_a = this.subscriptions) === null || _a === void 0 ? void 0 : _a.listenChanges)) {
+            console.warn(`${this._logPrefix}Subscription query 'listenChanges' not provided, skip.`);
+            return of();
+        }
+        if (!filter)
+            filter = this.defaultFilter();
+        filter = this.asFilter(filter);
+        const withContent = (options === null || options === void 0 ? void 0 : options.withContent) === true;
+        if (this._debug)
+            console.debug(`${this._logPrefix}[WS] Listening changes for user events with filter:`, filter);
+        return this.graphql.subscribe({
+            query: this.subscriptions.listenChanges,
+            fetchPolicy: options === null || options === void 0 ? void 0 : options.fetchPolicy,
+            variables: { filter: filter.asPodObject(), interval: toNumber(options === null || options === void 0 ? void 0 : options.interval, 10) },
+            error: {
+                code: SocialErrorCodes.SUBSCRIBE_USER_EVENTS_ERROR,
+                message: 'SOCIAL.ERROR.SUBSCRIBE_USER_EVENTS_ERROR'
+            }
+        }).pipe(map(({ data }) => {
+            if (data && this._debug)
+                console.debug(`${this._logPrefix}Received new user events:`, data);
+            const updatedData = data === null || data === void 0 ? void 0 : data.map(value => this.processUserEvent(value, this));
+            // Update cache
+            this.insertIntoMutableCachedQueries(this.graphql.cache, {
+                query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,
+                data: updatedData
+            });
+            return updatedData;
+        }));
+    }
+    delete(entity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!entity)
+                return; // skip
+            yield this.deleteAll([entity]);
+        });
+    }
+    deleteAll(entities, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ids = entities && entities
+                .map(t => t.id);
+            if (isEmptyArray(ids))
+                return; // stop, if nothing else to do
+            const now = Date.now();
+            if (this._debug)
+                console.debug(`${this._logPrefix}Deleting events... ids:`, ids);
+            yield this.graphql.mutate({
+                mutation: this.mutations.deleteByIds,
+                variables: {
+                    ids
+                },
+                update: (proxy) => {
+                    // Remove from caches
+                    this.removeFromMutableCachedQueriesByIds(proxy, {
+                        query: this.queries.loadAll,
+                        ids
+                    });
+                    this.removeFromMutableCachedQueriesByIds(proxy, {
+                        query: this.queries.loadAllWithContent,
+                        ids
+                    });
+                    if (this._debug)
+                        console.debug(`${this._logPrefix}Events deleted in ${Date.now() - now}ms`);
+                }
+            });
+        });
     }
-    /**
-     * Save a userEvent entity
-     *
-     * @param entity
-     */
     save(entity, options) {
         return __awaiter(this, void 0, void 0, function* () {
             this.fillDefaultProperties(entity);
             // Transform into json
-            const isNew = isNil(entity.id);
+            const withContent = !!entity.content;
             const json = entity.asObject();
             const now = Date.now();
             if (this._debug)
-                console.debug(`[user-event-service] Saving user event...`, json);
+                console.debug(`${this._logPrefix}Saving user event...`, json);
             yield this.graphql.mutate({
-                mutation: SaveQuery,
+                mutation: this.mutations.save,
                 variables: {
                     data: json
                 },
@@ -174,17 +268,19 @@ export class UserEventService extends BaseGraphqlService {
                     const savedEntity = data && data.data;
                     if (savedEntity) {
                         if (this._debug)
-                            console.debug(`[user-event-service] User event saved in ${Date.now() - now}ms`, entity);
+                            console.debug(`${this._logPrefix}User event saved in ${Date.now() - now}ms`, entity);
                         this.copyIdAndUpdateDate(savedEntity, entity);
                         // Add to cache
-                        if (isNew) {
+                        if (withContent) {
                             this.insertIntoMutableCachedQueries(proxy, {
-                                query: LoadAllQuery,
-                                data: Object.assign(Object.assign({}, savedEntity), { content: null })
+                                query: this.queries.loadAllWithContent,
+                                data: savedEntity
                             });
+                        }
+                        else {
                             this.insertIntoMutableCachedQueries(proxy, {
-                                query: LoadAllWithContentQuery,
-                                data: savedEntity
+                                query: this.queries.loadAll,
+                                data: Object.assign(Object.assign({}, savedEntity), { content: null })
                             });
                         }
                     }
@@ -193,63 +289,207 @@ export class UserEventService extends BaseGraphqlService {
             return entity;
         });
     }
-    /**
-     * Save many trips
-     *
-     * @param entities
-     * @param opts
-     */
-    deleteAll(entities, opts) {
+    saveAll(entities, opts) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ids = entities && entities
-                .map(t => t.id);
-            if (isEmptyArray(ids))
-                return; // stop, if nothing else to do
-            const now = Date.now();
-            if (this._debug)
-                console.debug('[user-event-service] Deleting events... ids:', ids);
-            yield this.graphql.mutate({
-                mutation: DeleteByIdsMutation,
-                variables: {
-                    ids
-                },
-                update: (proxy) => {
-                    // Remove from caches
-                    this.removeFromMutableCachedQueriesByIds(proxy, {
-                        query: LoadAllQuery,
-                        ids
-                    });
-                    this.removeFromMutableCachedQueriesByIds(proxy, {
-                        query: LoadAllWithContentQuery,
-                        ids
-                    });
-                    if (this._debug)
-                        console.debug(`[user-event-service] Events deleted in ${Date.now() - now}ms`);
+            return Promise.all(entities
+                .map(entity => this.save(entity, opts)));
+        });
+    }
+    markAsRead(entities) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userEventWithoutReadListeners = [];
+            for (const entity of (entities || [])) {
+                // Get onRead listeners
+                const onReadListeners = (this.listeners || []).filter(listener => !!listener.onRead).filter(listener => listener.accept(entity));
+                if (onReadListeners.length) {
+                    for (const listener of onReadListeners) {
+                        yield listener.onRead(entity);
+                    }
                 }
-            });
+                else {
+                    // Add to this list for default operation
+                    userEventWithoutReadListeners.push(entity);
+                }
+            }
+            // Use default
+            yield this.defaultMarkAsRead(userEventWithoutReadListeners);
         });
     }
-    /**
-     * Delete userEvent entities
-     */
-    delete(data) {
+    registerListener(listener) {
+        if (!this.listeners)
+            this.listeners = [];
+        this.listeners.push(listener);
+    }
+    resetCount() {
+        this.count$.next(undefined);
+        this.resetCountDate = moment();
+        // restart listening count changes
+        this.startListenCountChanges();
+    }
+    /* -- protected methods -- */
+    onLogin() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!data)
-                return; // skip
-            yield this.deleteAll([data]);
+            // Get first count
+            const count = yield this.count(undefined);
+            if (this._debug)
+                console.debug(`${this._logPrefix}Receiving user events count`, count);
+            // Update count
+            this.count$.next(count);
+            // Then listen changes
+            this.startListenCountChanges();
+        });
+    }
+    onLogout() {
+        this.stopListenCountChanges();
+    }
+    startListenCountChanges() {
+        this.stopListenCountChanges();
+        this._listenSubscription = this.listenCountChanges(undefined).subscribe();
+    }
+    stopListenCountChanges() {
+        var _a;
+        (_a = this._listenSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this._listenSubscription = undefined;
+    }
+    processUserEvent(source, that) {
+        that = that || this;
+        // Convert json source to IUserEvent
+        let target = that.fromObject(source);
+        // Get listeners
+        const listeners = (that.listeners || []).filter(listener => listener.onReceived).filter(listener => listener.accept(target));
+        for (const listener of listeners) {
+            if (target) {
+                target = listener.onReceived(target);
+            }
+            else {
+                if (that._debug)
+                    console.debug(`${that._logPrefix}Event has been rejected by a listener`, source);
+                break;
+            }
+        }
+        return target;
+    }
+    defaultMarkAsRead(userEvents) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!userEvents)
+                throw new Error(`${this._logPrefix}Invalid event to save`);
+            if (!userEvents.length)
+                return;
+            // set read date
+            userEvents.forEach(userEvent => userEvent.readDate = moment());
+            // split local/remote entities
+            const localEntities = userEvents.filter(userEvent => !userEvent.id || userEvent.id < 0);
+            const remoteEntities = userEvents.filter(userEvent => userEvent.id > 0);
+            // save local entities
+            if (localEntities.length) {
+                if (this._debug)
+                    console.debug(`${this._logPrefix}Save local user event`);
+                // TODO !!!!!!!!!!!!!
+            }
+            // mark remote entities as read
+            if (remoteEntities.length) {
+                if (!((_a = this.mutations) === null || _a === void 0 ? void 0 : _a.markAsRead)) {
+                    console.warn(`${this._logPrefix}Mutation query 'markAsRead' not provided, skip.`);
+                    return;
+                }
+                // Collect ids
+                const ids = remoteEntities.map(value => value.id);
+                const now = Date.now();
+                if (this._debug)
+                    console.debug(`${this._logPrefix}Mark user events as read...`, ids);
+                yield this.graphql.mutate({
+                    mutation: this.mutations.markAsRead,
+                    variables: {
+                        ids
+                    },
+                    error: { code: SocialErrorCodes.SAVE_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.SAVE_USER_EVENT_ERROR' },
+                });
+                if (this._debug)
+                    console.debug(`${this._logPrefix}User events marked as read in ${Date.now() - now}ms`, ids);
+            }
         });
     }
-    listenChanges(id, options) {
-        // TODO
-        console.warn('TODO: implement listen changes on user events');
-        return of();
+    defaultFilter() {
+        // By default
+        return {
+            recipients: [this.defaultRecipient()]
+        };
+    }
+    defaultRecipient() {
+        return this.accountService.person.pubkey;
+    }
+    fillDefaultProperties(entity) {
+    }
+    unreadEvents(events) {
+        // default calculation on unread events from a list
+        if (isEmptyArray(events))
+            return undefined;
+        const lastReadDate = events
+            .filter(event => isNotNil(event.readDate))
+            .reduce((lastDate, event) => DateUtils.max(lastDate, event.readDate), undefined);
+        return events
+            .filter(event => event.creationDate.isSameOrAfter(lastReadDate)).length;
+    }
+    copyIdAndUpdateDate(source, target) {
+        EntityUtils.copyIdAndUpdateDate(source, target);
+    }
+}
+AbstractUserEventService.decorators = [
+    { type: Directive }
+];
+AbstractUserEventService.ctorParameters = () => [
+    { type: GraphqlService },
+    { type: AccountService },
+    { type: NetworkService },
+    { type: TranslateService },
+    { type: undefined },
+    { type: undefined },
+    { type: undefined },
+    { type: Environment, decorators: [{ type: Optional }, { type: Inject, args: [ENVIRONMENT,] }] }
+];
+const userEventQueries = {
+    loadAll: gql `
+    query UserEvents($filter: UserEventFilterVOInput, $page: PageInput){
+      data: userEvents(filter: $filter, page: $page){
+        ...LightUserEventFragment
+      }
+    }
+    ${UserEventFragments.lightUserEvent}
+  `,
+    loadAllWithContent: gql `
+    query UserEventsWithContent($filter: UserEventFilterVOInput, $page: PageInput){
+      data: userEvents(filter: $filter, page: $page){
+        ...UserEventFragment
+      }
     }
-    registerAction(definition) {
-        console.info(`[user-event-service] Registering action ${definition.name} for ${definition.__typename}`);
-        this._userEventActions.push(definition);
+    ${UserEventFragments.userEvent}
+  `
+};
+const userEventMutations = {
+    deleteByIds: gql `
+    mutation DeleteUserEvents($ids:[Int]){
+      deleteUserEvents(ids: $ids)
     }
-    getActionsByTypename(typename) {
-        return this._userEventActions.filter(def => def.__typename === typename);
+  `,
+    save: gql `
+    mutation SaveUserEvent($data: UserEventVOInput){
+      data: saveUserEvent(userEvent: $data){
+        ...UserEventFragment
+      }
+    }
+    ${UserEventFragments.userEvent}
+  `
+};
+export class UserEventService extends AbstractUserEventService {
+    constructor(graphql, accountService, network, translate, toastController, environment) {
+        super(graphql, accountService, network, translate, userEventQueries, userEventMutations, undefined, environment);
+        this.graphql = graphql;
+        this.accountService = accountService;
+        this.network = network;
+        this.translate = translate;
+        this.toastController = toastController;
+        this.environment = environment;
     }
     showToastErrorWithContext(opts) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -313,13 +553,16 @@ export class UserEventService extends BaseGraphqlService {
     }
     sendDataForDebug(data) {
         const userEvent = new UserEvent();
-        userEvent.eventType = UserEventTypes.DEBUG_DATA;
+        userEvent.type = UserEventTypes.DEBUG_DATA;
         userEvent.content = this.convertObjectToString(data);
         return this.save(userEvent);
     }
     asFilter(filter) {
         return UserEventFilter.fromObject(filter);
     }
+    fromObject(source) {
+        return UserEvent.fromObject(source);
+    }
     /* -- protected methods -- */
     convertObjectToString(data) {
         if (typeof data === 'string') {
@@ -348,13 +591,9 @@ export class UserEventService extends BaseGraphqlService {
         // TODO: compute sign
         console.warn('TODO: sign user event before sending');
     }
-    copyIdAndUpdateDate(source, target) {
-        EntityUtils.copyIdAndUpdateDate(source, target);
-    }
 }
-UserEventService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserEventService_Factory() { return new UserEventService(i0.ɵɵinject(i1.GraphqlService), i0.ɵɵinject(i2.AccountService), i0.ɵɵinject(i3.NetworkService), i0.ɵɵinject(i4.TranslateService), i0.ɵɵinject(i5.ToastController), i0.ɵɵinject(i6.ENVIRONMENT, 8)); }, token: UserEventService, providedIn: "root" });
 UserEventService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
+    { type: Injectable }
 ];
 UserEventService.ctorParameters = () => [
     { type: GraphqlService },
@@ -364,4 +603,4 @@ UserEventService.ctorParameters = () => [
     { type: ToastController },
     { type: Environment, decorators: [{ type: Optional }, { type: Inject, args: [ENVIRONMENT,] }] }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-event.service.js","sourceRoot":"","sources":["../../../../../../src/app/social/user-event/user-event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable, Optional} from '@angular/core';\nimport {gql} from '@apollo/client/core';\nimport {SocialErrorCodes} from '../social.errors';\nimport {AccountService} from '../../core/services/account.service';\nimport {GraphqlService} from '../../core/graphql/graphql.service';\nimport {Observable, of} from 'rxjs';\nimport {UserEvent, UserEventAction, UserEventTypes} from './user-event.model';\nimport {UserEventFragments} from './user-event.fragments';\nimport {SortDirection} from '@angular/material/sort';\nimport {EntitiesServiceWatchOptions, EntityServiceLoadOptions, FilterFn, IEntitiesService, LoadResult, Page} from '../../shared/services/entity-service.class';\nimport {map} from 'rxjs/operators';\nimport {isEmptyArray, isNil, isNilOrBlank, toNumber} from '../../shared/functions';\nimport {ShowToastOptions, Toasts} from '../../shared/toast/toasts';\nimport {OverlayEventDetail} from '@ionic/core';\nimport {ToastController} from '@ionic/angular';\nimport {TranslateService} from '@ngx-translate/core';\nimport {NetworkService} from '../../core/services/network.service';\nimport {BaseGraphqlService} from '../../core/services/base-graphql-service.class';\nimport {Entity, EntityUtils} from '../../core/services/model/entity.model';\nimport {Environment, ENVIRONMENT} from '../../../environments/environment.class';\nimport {EntityFilter} from '../../core/services/model/filter.model';\nimport {EntityClass} from '../../core/services/model/entity.decorators';\n\n// @dynamic\n@EntityClass({typename: 'UserEventFilterVO'})\nexport class UserEventFilter extends EntityFilter<UserEventFilter, UserEvent> {\n\n  static fromObject: (source: any, opts?: any) => UserEventFilter;\n\n  issuer: string = null;\n  recipient: string = null;\n\n  fromObject(source: any, opts?: any) {\n    super.fromObject(source, opts);\n    this.issuer = source.issuer;\n    this.recipient = source.recipient;\n  }\n\n  protected buildFilter(): FilterFn<UserEvent>[] {\n    const filterFns = super.buildFilter();\n\n    // issuer\n    if (this.issuer) {\n      filterFns.push(t => (t.issuer === this.issuer));\n    }\n    if (this.recipient) {\n      filterFns.push(t => (t.recipient === this.recipient));\n    }\n\n    return filterFns;\n  }\n}\n\nconst SaveQuery: any = gql`\n  mutation SaveUserEvent($data: UserEventVOInput){\n    data: saveUserEvent(userEvent: $data){\n      ...UserEventFragment\n    }\n  }\n  ${UserEventFragments.userEvent}\n`;\n\nconst LoadAllQuery: any = gql`\n  query UserEvents($filter: UserEventFilterVOInput, $page: PageInput){\n    data: userEvents(filter: $filter, page: $page){\n      ...LightUserEventFragment\n    }\n  }\n  ${UserEventFragments.lightUserEvent}\n`;\n\nconst DeleteByIdsMutation: any = gql`\n  mutation DeleteUserEvents($ids:[Int]){\n    deleteUserEvents(ids: $ids)\n  }\n`;\n\nconst LoadAllWithContentQuery: any = gql`\n  query UserEventsWithContent($filter: UserEventFilterVOInput, $page: PageInput){\n    data: userEvents(filter: $filter, page: $page){\n      ...UserEventFragment\n    }\n  }\n  ${UserEventFragments.userEvent}\n`;\n\nexport declare interface UserEventWatchOptions extends EntitiesServiceWatchOptions {\n  withContent?: boolean; // Default to false\n}\n\nexport interface UserEventActionDefinition extends UserEventAction<any> {\n  __typename: string;\n}\n\n@Injectable({providedIn: 'root'})\nexport class UserEventService\n  extends BaseGraphqlService<UserEvent, UserEventFilter>\n  implements IEntitiesService<UserEvent, UserEventFilter, UserEventWatchOptions> {\n\n  private _userEventActions: UserEventActionDefinition[] = [];\n\n  constructor(\n    protected graphql: GraphqlService,\n    protected accountService: AccountService,\n    protected network: NetworkService,\n    protected translate: TranslateService,\n    protected toastController: ToastController,\n    @Optional() @Inject(ENVIRONMENT) protected environment: Environment\n  ) {\n    super(graphql, environment);\n\n    // For DEV only\n    this._debug = environment && !environment.production;\n  }\n\n  /**\n   *\n   * @param offset\n   * @param size\n   * @param sortBy\n   * @param sortDirection\n   * @param filter\n   * @param options\n   * @deprecated use watchPage() instead\n   */\n  watchAll(offset: number,\n           size: number,\n           sortBy?: string,\n           sortDirection?: SortDirection,\n           filter?: UserEventFilter,\n           options?: UserEventWatchOptions): Observable<LoadResult<UserEvent>> {\n    return this.watchPage(<Page>{offset, size, sortBy, sortDirection}, filter, options);\n  }\n\n  watchPage(page: Page,\n            filter?: Partial<UserEventFilter>,\n            options?: UserEventWatchOptions): Observable<LoadResult<UserEvent>> {\n\n    let now = this._debug && Date.now();\n    //if (this._debug)\n    console.debug('[user-event-service] Loading user events...', filter);\n\n    filter = this.asFilter(filter);\n\n    // Force recipient to current issuer, if not admin and not specified\n    if (isNilOrBlank(filter.recipient) || !this.accountService.isAdmin()) {\n      const recipient = this.accountService.account.pubkey;\n      if (recipient !== filter.recipient) {\n        console.warn('[user-events-service] Force user event filter.recipient=' + recipient);\n        filter.recipient = recipient;\n      }\n    }\n\n    const withContent = options && options.withContent === true;\n\n    return this.mutableWatchQuery<LoadResult<any>>({\n      queryName: withContent ? 'LoadAllWithContent' : 'LoadAll',\n      query: withContent ? LoadAllWithContentQuery : LoadAllQuery,\n      variables: {\n        page: {\n          sortBy: 'updateDate',\n          ...page,\n          sortDirection: (page.sortDirection || 'DESC').toUpperCase(),\n        },\n        filter: filter && filter.asPodObject()\n      },\n      arrayFieldName: 'data',\n      error: {code: SocialErrorCodes.LOAD_USER_EVENTS_ERROR, message: 'SOCIAL.ERROR.LOAD_USER_EVENTS_ERROR'},\n      fetchPolicy: options && options.fetchPolicy || undefined\n    })\n      .pipe(\n        map(res => {\n          const data = res && (res.data || []).map(UserEvent.fromObject);\n\n          if (now) {\n            console.debug(`[user-event-service] ${data.length} user events loaded in ${Date.now() - now}ms`);\n            now = null;\n          }\n          return {\n            data,\n            total: res && toNumber(res.total, data.length)\n          };\n        })\n      );\n  }\n\n  saveAll(data: UserEvent[], options?: any): Promise<UserEvent[]> {\n    return Promise.all(data\n      .map(entity => this.save(entity, options))\n    );\n  }\n\n  /**\n   * Save a userEvent entity\n   *\n   * @param entity\n   */\n  async save(entity: UserEvent, options?: EntityServiceLoadOptions): Promise<UserEvent> {\n\n    this.fillDefaultProperties(entity);\n\n    // Transform into json\n    const isNew = isNil(entity.id);\n    const json = entity.asObject();\n\n    const now = Date.now();\n    if (this._debug) console.debug(`[user-event-service] Saving user event...`, json);\n\n    await this.graphql.mutate<{ data: any }>({\n      mutation: SaveQuery,\n      variables: {\n        data: json\n      },\n      error: { code: SocialErrorCodes.SAVE_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.SAVE_USER_EVENT_ERROR' },\n      update: (proxy, {data}) => {\n        // Update entity\n        const savedEntity = data && data.data;\n        if (savedEntity) {\n          if (this._debug) console.debug(`[user-event-service] User event saved in ${Date.now() - now}ms`, entity);\n          this.copyIdAndUpdateDate(savedEntity, entity);\n\n          // Add to cache\n          if (isNew) {\n            this.insertIntoMutableCachedQueries(proxy,{\n              query: LoadAllQuery,\n              data: {\n                ...savedEntity,\n                content: null\n              }\n            });\n            this.insertIntoMutableCachedQueries(proxy,{\n              query: LoadAllWithContentQuery,\n              data: savedEntity\n            });\n          }\n        }\n      }\n    });\n\n    return entity;\n  }\n\n\n\n  /**\n   * Save many trips\n   *\n   * @param entities\n   * @param opts\n   */\n  async deleteAll(entities: UserEvent[], opts?: {\n    trash?: boolean; // True by default\n  }): Promise<any> {\n\n    const ids = entities && entities\n      .map(t => t.id);\n    if (isEmptyArray(ids)) return; // stop, if nothing else to do\n\n    const now = Date.now();\n    if (this._debug) console.debug('[user-event-service] Deleting events... ids:', ids);\n\n    await this.graphql.mutate<any>({\n      mutation: DeleteByIdsMutation,\n      variables: {\n        ids\n      },\n      update: (proxy) => {\n        // Remove from caches\n        this.removeFromMutableCachedQueriesByIds(proxy, {\n          query: LoadAllQuery,\n          ids\n        });\n        this.removeFromMutableCachedQueriesByIds(proxy, {\n          query: LoadAllWithContentQuery,\n          ids\n        });\n\n        if (this._debug) console.debug(`[user-event-service] Events deleted in ${Date.now() - now}ms`);\n      }\n    });\n  }\n\n  /**\n   * Delete userEvent entities\n   */\n  async delete(data: UserEvent): Promise<any> {\n    if (!data) return; // skip\n    await this.deleteAll([data]);\n  }\n\n  listenChanges(id: number, options?: any): Observable<UserEvent | undefined> {\n    // TODO\n    console.warn('TODO: implement listen changes on user events');\n    return of();\n  }\n\n  registerAction(definition: UserEventActionDefinition) {\n    console.info(`[user-event-service] Registering action ${definition.name} for ${definition.__typename}`);\n    this._userEventActions.push(definition);\n  }\n\n  getActionsByTypename(typename: string): UserEventAction<any>[] {\n    return this._userEventActions.filter(def => def.__typename === typename);\n  }\n\n  async showToastErrorWithContext(opts: {\n    error?: any;\n    message?: string;\n    context: any | (() => any) | Promise<any>;}) {\n\n    let message = opts.message || (opts.error && opts.error.message || opts.error);\n\n    // Make sure message a string\n    if (!message || typeof message !== 'string') {\n      message = 'ERROR.UNKNOWN_TECHNICAL_ERROR';\n    }\n\n    // If offline, display a simple alert\n    if (this.network.offline) {\n      this.showToast({message, type: 'error'});\n      return;\n    }\n\n    // Translate the message (to be able to extract details content)\n    message = this.translate.instant(message);\n\n    // Clean details parts\n    if (message && message.indexOf('<small>') !== -1) {\n      message = message.substr(0, message.indexOf('<small>') - 1);\n    }\n\n    const res = await this.showToast({\n      type: 'error',\n      duration: 15000,\n      message: message + '<br/><br/><b>' + this.translate.instant('CONFIRM.SEND_DEBUG_DATA') + '</b>',\n      buttons: [{\n        icon: 'bug',\n        text: this.translate.instant('COMMON.BTN_SEND'),\n        role: 'send'\n      }]\n    });\n    if (!res || res.role !== 'send') return;\n\n    // Send debug data\n    try {\n      if (this._debug) console.debug('Sending debug data...');\n\n      // Call content factory\n      let context: any = opts && opts.context;\n      if (typeof context === 'function') {\n        context = context();\n      }\n      if (context instanceof Promise) {\n        context = await context;\n      }\n\n      // Send the message\n      const userEvent = await this.sendDataForDebug({\n        message,\n        error: opts.error || undefined,\n        context: this.convertObjectToString(context)\n      });\n\n      console.info('Debug data successfully sent to admin', userEvent);\n      this.showToast({\n        type: 'info',\n        message: 'INFO.DEBUG_DATA_SEND',\n        showCloseButton: true\n      });\n    }\n    catch (err) {\n      console.error('Error while sending debug data:', err);\n    }\n  }\n\n  sendDataForDebug(data: any): Promise<UserEvent> {\n    const userEvent = new UserEvent();\n    userEvent.eventType = UserEventTypes.DEBUG_DATA;\n    userEvent.content = this.convertObjectToString(data);\n    return this.save(userEvent);\n  }\n\n  asFilter(filter: Partial<UserEventFilter>): UserEventFilter {\n    return UserEventFilter.fromObject(filter);\n  }\n\n  /* -- protected methods -- */\n\n  protected convertObjectToString(data: any): string {\n    if (typeof data === 'string'){\n      return data;\n    }\n    // Serialize content into string\n    else if (typeof data === 'object'){\n      if (data instanceof Entity) {\n        return JSON.stringify(data.asObject({keepTypename: true, keepLocalId: true, minify: false}));\n      }\n      else {\n        return JSON.stringify(data);\n      }\n    }\n  }\n\n  protected async showToast<T=any>(opts: ShowToastOptions): Promise<OverlayEventDetail<T>> {\n    if (!this.toastController) throw new Error('Missing toastController in component\\'s constructor');\n    return await Toasts.show(this.toastController, this.translate, opts);\n  }\n\n  protected fillDefaultProperties(entity: UserEvent) {\n    entity.issuer = this.accountService.account.pubkey;\n\n    // TODO: compute hash (using cryptoService)\n    // TODO: compute sign\n    console.warn('TODO: sign user event before sending');\n  }\n\n  protected copyIdAndUpdateDate(source: UserEvent, target: UserEvent) {\n    EntityUtils.copyIdAndUpdateDate(source, target);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-event.service.js","sourceRoot":"","sources":["../../../../../../src/app/social/user-event/user-event.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Inject, Injectable, InjectionToken, OnDestroy, Optional } from '@angular/core';\nimport { FetchPolicy, gql } from '@apollo/client/core';\nimport { SocialErrorCodes } from '../social.errors';\nimport { AccountService } from '../../core/services/account.service';\nimport { GraphqlService } from '../../core/graphql/graphql.service';\nimport { BehaviorSubject, merge, Observable, of, Subscription } from 'rxjs';\nimport { IUserEvent, IUserEventFilter, UserEvent, UserEventFilter, UserEventTypes } from './user-event.model';\nimport { UserEventFragments } from './user-event.fragments';\nimport { SortDirection } from '@angular/material/sort';\nimport { EntitiesServiceWatchOptions, EntityServiceLoadOptions, IEntitiesService, LoadResult, Page } from '../../shared/services/entity-service.class';\nimport { distinctUntilChanged, map, mergeMap } from 'rxjs/operators';\nimport { isEmptyArray, isNotNil, toNumber } from '../../shared/functions';\nimport { ShowToastOptions, Toasts } from '../../shared/toast/toasts';\nimport { OverlayEventDetail } from '@ionic/core';\nimport { ToastController } from '@ionic/angular';\nimport { TranslateService } from '@ngx-translate/core';\nimport { NetworkService } from '../../core/services/network.service';\nimport { BaseGraphqlService } from '../../core/services/base-graphql-service.class';\nimport { Entity, EntityUtils } from '../../core/services/model/entity.model';\nimport { Environment, ENVIRONMENT } from '../../../environments/environment.class';\nimport { DateUtils } from '../../shared/dates';\nimport * as momentImported from 'moment';\nimport { Moment } from 'moment';\nimport { IStartableService } from '../../shared/services/startable-service.class';\n\nconst moment = momentImported;\n\nexport const UserEventServiceToken = new InjectionToken<IUserEventService<any, any>>('UserEventService');\n\nexport declare interface UserEventWatchOptions extends EntitiesServiceWatchOptions {\n  withContent?: boolean; // Default to false\n}\n\nexport interface IUserEventQueries {\n  loadAll: any;\n  loadAllWithContent: any;\n  count?: any;\n}\n\nexport interface IUserEventMutations {\n  save: any;\n  markAsRead?: any;\n  deleteByIds: any;\n}\n\nexport interface IUserEventSubscriptions {\n  listenChanges: any;\n  listenCountChanges?: any;\n}\n\nexport interface IUserEventListener<E extends IUserEvent<E>> {\n  accept: (E) => boolean;\n  onReceived?: (E) => E | undefined;\n  onRead?: (E) => Promise<void> | void;\n}\n\n\nexport interface IUserEventService<E extends IUserEvent<E>,\n  F extends IUserEventFilter<E>,\n  WO extends UserEventWatchOptions = UserEventWatchOptions>\n  extends IEntitiesService<E, F, WO>, IStartableService {\n\n  userEventCount: Observable<number>;\n\n  add(entity: E);\n\n  count(filter: Partial<F>, options?: { fetchPolicy?: FetchPolicy; }): Promise<number>;\n\n  listenCountChanges(filter: Partial<F>, options?: WO & { interval?: number; fetchPolicy?: FetchPolicy; }): Observable<number>;\n\n  listenChanges(filter: Partial<F>, options?: WO & { interval?: number; fetchPolicy?: FetchPolicy; }): Observable<E[]>;\n\n  save(entity: E, options?: EntityServiceLoadOptions): Promise<E>;\n\n  delete(entity: E): Promise<any>;\n\n  markAsRead(entities: E[]);\n\n  registerListener(listener: IUserEventListener<E>);\n\n  resetCount();\n}\n\n@Directive()\nexport abstract class AbstractUserEventService<E extends IUserEvent<E, any>,\n  F extends IUserEventFilter<E, any>,\n  WO extends UserEventWatchOptions = UserEventWatchOptions>\n  extends BaseGraphqlService<E, F>\n  implements IUserEventService<E, F, WO>, OnDestroy {\n\n  protected count$ = new BehaviorSubject<number>(0);\n  protected resetCountDate: Moment;\n  protected listeners: IUserEventListener<E>[] = [];\n  private _subscriptions = new Subscription();\n  private _listenSubscription: Subscription;\n\n  get userEventCount(): Observable<number> {\n    return this.count$.asObservable();\n  }\n\n  protected constructor(\n    protected graphql: GraphqlService,\n    protected accountService: AccountService,\n    protected network: NetworkService,\n    protected translate: TranslateService,\n    protected queries: IUserEventQueries,\n    protected mutations: IUserEventMutations,\n    protected subscriptions: IUserEventSubscriptions,\n    @Optional() @Inject(ENVIRONMENT) protected environment: Environment\n  ) {\n    super(graphql, environment);\n    this._logPrefix = '[user-event-service] ';\n    // For DEV only\n    this._debug = !environment?.production;\n  }\n\n  protected async ngOnStart(): Promise<void> {\n\n    // Update component when refresh is need (=login events)\n    this._subscriptions.add(\n      merge(\n        this.accountService.onLogin,\n        this.accountService.onLogout\n      )\n        .pipe(\n          // Wait account service ready (can be restarted)\n          mergeMap(() => this.accountService.ready()),\n          map(() => this.accountService.isLogin()),\n          distinctUntilChanged()\n        )\n        .subscribe(login => {\n          if (login) {\n            this.onLogin();\n          } else {\n            this.onLogout();\n          }\n        }));\n\n    // First attempt if account is ready\n    await this.accountService.ready();\n    if (this.accountService.isLogin()) {\n      setTimeout(() => this.onLogin());\n    }\n  }\n\n  ngOnDestroy() {\n    this._subscriptions.unsubscribe();\n  }\n\n  abstract asFilter(filter: Partial<F>): F;\n\n  abstract fromObject(source: any): E;\n\n  watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<F>, options?: WO): Observable<LoadResult<E>> {\n    return this.watchPage(<Page>{ offset, size, sortBy, sortDirection }, filter, options);\n  }\n\n  watchPage(page: Page,\n            filter?: Partial<F>,\n            options?: WO): Observable<LoadResult<E>> {\n\n    let now = this._debug && Date.now();\n    if (!filter) {\n      filter = this.defaultFilter();\n    }\n    console.debug(`${this._logPrefix}Loading user events...`, filter);\n\n    filter = this.asFilter(filter);\n\n    // Force recipient to current issuer, if not admin and not specified\n    if (isEmptyArray(filter?.recipients) || !this.accountService.isAdmin()) {\n      const recipient = this.defaultRecipient();\n      if (!filter?.recipients?.includes(recipient)) {\n        console.warn('[user-events-service] Force user event filter.recipient=' + recipient);\n        filter.recipients = [recipient];\n      }\n    }\n\n    const withContent = options?.withContent === true;\n\n    return this.mutableWatchQuery<LoadResult<E>, { filter: any, page: Page }>({\n      queryName: withContent ? 'LoadAllWithContent' : 'LoadAll',\n      query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,\n      variables: {\n        page: {\n          sortBy: 'creationDate',\n          ...page,\n          // @ts-ignore\n          sortDirection: (page.sortDirection || 'desc').toUpperCase()\n        },\n        filter: filter && filter.asPodObject()\n      },\n      arrayFieldName: 'data',\n      error: { code: SocialErrorCodes.LOAD_USER_EVENTS_ERROR, message: 'SOCIAL.ERROR.LOAD_USER_EVENTS_ERROR' },\n      fetchPolicy: options?.fetchPolicy || 'cache-first'\n    })\n      .pipe(\n        map(res => {\n          let data = (res?.data || []).map(value => this.processUserEvent(value, this));\n\n          if (now) {\n            console.debug(`${this._logPrefix}${data.length} user events loaded in ${Date.now() - now}ms`);\n            now = null;\n          }\n\n          // Must re-order because of listenChanges result will add new event at the end\n          data = EntityUtils.sort(data, page.sortBy, page.sortDirection);\n\n          return {\n            data,\n            total: toNumber(res?.total, data.length)\n          };\n        })\n      );\n  }\n\n  add(entity: E) {\n\n    // TODO set an id !!!!!!!!!!!!!!!!!!!!!!!!!\n\n    entity = this.processUserEvent(entity);\n\n    const withContent = !!entity.content;\n\n    // Add user event locally\n    this.insertIntoMutableCachedQueries(\n      this.graphql.cache,\n      {\n        query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,\n        data: entity\n      }\n    );\n\n    // Update count\n    this.count$.next(this.count$.value + 1);\n  }\n\n  async count(filter: Partial<F>, options?: { fetchPolicy?: FetchPolicy; }): Promise<number> {\n\n    if (!this.queries?.count) {\n      console.warn(`${this._logPrefix}Query 'count' not provided, skip.`);\n      return undefined;\n    }\n\n    if (!filter) filter = this.defaultFilter();\n    // Apply last reset date as start date\n    filter.startDate = this.resetCountDate;\n    filter = this.asFilter(filter);\n\n    if (this._debug) console.debug(`${this._logPrefix}Counting user events with filter:`, filter);\n\n    const res = await this.graphql.query<{ total: number; }>({\n      query: this.queries.count,\n      variables: {\n        filter: filter.asPodObject()\n      },\n      error: { code: SocialErrorCodes.COUNT_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.COUNT_USER_EVENT_ERROR' },\n      fetchPolicy: options?.fetchPolicy || 'network-only'\n    });\n    return res.total;\n  }\n\n  listenCountChanges(filter: Partial<F>, options?: WO & { interval?: number; fetchPolicy?: FetchPolicy }): Observable<number> {\n\n    if (!this.subscriptions?.listenCountChanges) {\n      console.warn(`${this._logPrefix}Subscription query 'listenCountChanges' not provided, skip.`);\n      return of();\n    }\n\n    if (!filter) filter = this.defaultFilter();\n    // Apply last reset date as start date\n    filter.startDate = this.resetCountDate\n    filter = this.asFilter(filter);\n\n    if (this._debug) console.debug(`${this._logPrefix}[WS] Listening count changes for user events with filter:`, filter);\n\n    return this.graphql.subscribe<{ total: number }, { filter: any, interval: number }>({\n      query: this.subscriptions.listenCountChanges,\n      fetchPolicy: options?.fetchPolicy,\n      variables: { filter: filter.asPodObject(), interval: toNumber(options?.interval, 10) },\n      error: {\n        code: SocialErrorCodes.SUBSCRIBE_USER_EVENTS_ERROR,\n        message: 'SOCIAL.ERROR.SUBSCRIBE_USER_EVENTS_ERROR'\n      }\n    }).pipe(\n      map(({ total }) => {\n          if (total && this._debug) console.debug(`${this._logPrefix}Received new user events count:`, total);\n          // update count\n          this.count$.next(total);\n          return total;\n        }\n      )\n    );\n\n  }\n\n  listenChanges(filter: Partial<F>, options?: WO & { interval?: number; fetchPolicy?: FetchPolicy; }): Observable<E[]> {\n\n    if (!this.subscriptions?.listenChanges) {\n      console.warn(`${this._logPrefix}Subscription query 'listenChanges' not provided, skip.`);\n      return of();\n    }\n\n    if (!filter) filter = this.defaultFilter();\n    filter = this.asFilter(filter);\n\n    const withContent = options?.withContent === true;\n\n    if (this._debug) console.debug(`${this._logPrefix}[WS] Listening changes for user events with filter:`, filter);\n\n    return this.graphql.subscribe<{ data: any[] }, { filter: any, interval: number }>({\n      query: this.subscriptions.listenChanges,\n      fetchPolicy: options?.fetchPolicy,\n      variables: { filter: filter.asPodObject(), interval: toNumber(options?.interval, 10) },\n      error: {\n        code: SocialErrorCodes.SUBSCRIBE_USER_EVENTS_ERROR,\n        message: 'SOCIAL.ERROR.SUBSCRIBE_USER_EVENTS_ERROR'\n      }\n    }).pipe(\n      map(({ data }) => {\n          if (data && this._debug) console.debug(`${this._logPrefix}Received new user events:`, data);\n          const updatedData = data?.map(value => this.processUserEvent(value, this));\n          // Update cache\n          this.insertIntoMutableCachedQueries(\n            this.graphql.cache,\n            {\n              query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,\n              data: updatedData\n            }\n          );\n          return updatedData;\n        }\n      )\n    );\n\n  }\n\n  async delete(entity: E): Promise<any> {\n    if (!entity) return; // skip\n    await this.deleteAll([entity]);\n  }\n\n  async deleteAll(entities: E[], opts?: any): Promise<any> {\n    const ids = entities && entities\n      .map(t => t.id);\n    if (isEmptyArray(ids)) return; // stop, if nothing else to do\n\n    const now = Date.now();\n    if (this._debug) console.debug(`${this._logPrefix}Deleting events... ids:`, ids);\n\n    await this.graphql.mutate<any>({\n      mutation: this.mutations.deleteByIds,\n      variables: {\n        ids\n      },\n      update: (proxy) => {\n        // Remove from caches\n        this.removeFromMutableCachedQueriesByIds(proxy, {\n          query: this.queries.loadAll,\n          ids\n        });\n        this.removeFromMutableCachedQueriesByIds(proxy, {\n          query: this.queries.loadAllWithContent,\n          ids\n        });\n\n        if (this._debug) console.debug(`${this._logPrefix}Events deleted in ${Date.now() - now}ms`);\n      }\n    });\n  }\n\n  async save(entity: E, options?: EntityServiceLoadOptions): Promise<E> {\n    this.fillDefaultProperties(entity);\n\n    // Transform into json\n    const withContent = !!entity.content;\n    const json = entity.asObject();\n\n    const now = Date.now();\n    if (this._debug) console.debug(`${this._logPrefix}Saving user event...`, json);\n\n    await this.graphql.mutate<{ data: any }>({\n      mutation: this.mutations.save,\n      variables: {\n        data: json\n      },\n      error: { code: SocialErrorCodes.SAVE_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.SAVE_USER_EVENT_ERROR' },\n      update: (proxy, { data }) => {\n        // Update entity\n        const savedEntity = data && data.data;\n        if (savedEntity) {\n          if (this._debug) console.debug(`${this._logPrefix}User event saved in ${Date.now() - now}ms`, entity);\n          this.copyIdAndUpdateDate(savedEntity, entity);\n\n          // Add to cache\n          if (withContent) {\n            this.insertIntoMutableCachedQueries(proxy, {\n              query: this.queries.loadAllWithContent,\n              data: savedEntity\n            });\n          } else {\n            this.insertIntoMutableCachedQueries(proxy, {\n              query: this.queries.loadAll,\n              data: {\n                ...savedEntity,\n                content: null\n              }\n            });\n          }\n        }\n      }\n    });\n\n    return entity;\n  }\n\n  async saveAll(entities: E[], opts?: any): Promise<E[]> {\n    return Promise.all(entities\n      .map(entity => this.save(entity, opts))\n    );\n  }\n\n  async markAsRead(entities: E[]) {\n\n    const userEventWithoutReadListeners: E[] = [];\n    for (const entity of (entities || [])) {\n      // Get onRead listeners\n      const onReadListeners = (this.listeners || []).filter(listener => !!listener.onRead).filter(listener => listener.accept(entity));\n      if (onReadListeners.length) {\n        for (const listener of onReadListeners) {\n          await listener.onRead(entity);\n        }\n      } else {\n        // Add to this list for default operation\n        userEventWithoutReadListeners.push(entity);\n      }\n    }\n\n    // Use default\n    await this.defaultMarkAsRead(userEventWithoutReadListeners);\n  }\n\n  registerListener(listener: IUserEventListener<E>) {\n    if (!this.listeners) this.listeners = [];\n    this.listeners.push(listener);\n  }\n\n  resetCount() {\n    this.count$.next(undefined);\n    this.resetCountDate = moment();\n    // restart listening count changes\n    this.startListenCountChanges();\n  }\n\n  /* -- protected methods -- */\n\n  protected async onLogin() {\n    // Get first count\n    const count = await this.count(undefined);\n    if (this._debug) console.debug(`${this._logPrefix}Receiving user events count`, count);\n    // Update count\n    this.count$.next(count);\n\n    // Then listen changes\n    this.startListenCountChanges();\n  }\n\n  protected onLogout() {\n    this.stopListenCountChanges();\n  }\n\n  protected startListenCountChanges() {\n    this.stopListenCountChanges();\n    this._listenSubscription = this.listenCountChanges(undefined).subscribe();\n  }\n\n  protected stopListenCountChanges() {\n    this._listenSubscription?.unsubscribe();\n    this._listenSubscription = undefined;\n  }\n\n  protected processUserEvent(source: any, that?: AbstractUserEventService<E, F>): E {\n    that = that || this;\n\n    // Convert json source to IUserEvent\n    let target = that.fromObject(source);\n\n    // Get listeners\n    const listeners = (that.listeners || []).filter(listener => listener.onReceived).filter(listener => listener.accept(target));\n    for (const listener of listeners) {\n      if (target) {\n        target = listener.onReceived(target);\n      } else {\n        if (that._debug) console.debug(`${that._logPrefix}Event has been rejected by a listener`, source);\n        break;\n      }\n    }\n\n    return target;\n  }\n\n  protected async defaultMarkAsRead(userEvents: E[]) {\n    if (!userEvents) throw new Error(`${this._logPrefix}Invalid event to save`);\n    if (!userEvents.length) return;\n\n    // set read date\n    userEvents.forEach(userEvent => userEvent.readDate = moment());\n\n    // split local/remote entities\n    const localEntities = userEvents.filter(userEvent => !userEvent.id || userEvent.id < 0);\n    const remoteEntities = userEvents.filter(userEvent => userEvent.id > 0);\n\n    // save local entities\n    if (localEntities.length) {\n      if (this._debug) console.debug(`${this._logPrefix}Save local user event`);\n      // TODO !!!!!!!!!!!!!\n    }\n    // mark remote entities as read\n    if (remoteEntities.length) {\n      if (!this.mutations?.markAsRead) {\n        console.warn(`${this._logPrefix}Mutation query 'markAsRead' not provided, skip.`);\n        return;\n      }\n\n      // Collect ids\n      const ids = remoteEntities.map(value => value.id);\n      const now = Date.now();\n      if (this._debug) console.debug(`${this._logPrefix}Mark user events as read...`, ids);\n\n      await this.graphql.mutate<{ data: any }>({\n        mutation: this.mutations.markAsRead,\n        variables: {\n          ids\n        },\n        error: { code: SocialErrorCodes.SAVE_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.SAVE_USER_EVENT_ERROR' },\n      });\n\n      if (this._debug) console.debug(`${this._logPrefix}User events marked as read in ${Date.now() - now}ms`, ids);\n    }\n  }\n\n  protected defaultFilter(): F {\n    // By default\n    return <F>{\n      recipients: [this.defaultRecipient()]\n    };\n  }\n\n  protected defaultRecipient(): any {\n    return this.accountService.person.pubkey;\n  }\n\n  protected fillDefaultProperties(entity: E) {\n  }\n\n  protected unreadEvents(events: E[]): number {\n    // default calculation on unread events from a list\n    if (isEmptyArray(events)) return undefined;\n    const lastReadDate = events\n      .filter(event => isNotNil(event.readDate))\n      .reduce((lastDate, event) => DateUtils.max(lastDate, event.readDate), undefined as Moment);\n    return events\n      .filter(event => event.creationDate.isSameOrAfter(lastReadDate)).length;\n  }\n\n  protected copyIdAndUpdateDate(source: E, target: E) {\n    EntityUtils.copyIdAndUpdateDate(source, target);\n  }\n\n}\n\n\nconst userEventQueries: IUserEventQueries = {\n  loadAll: gql`\n    query UserEvents($filter: UserEventFilterVOInput, $page: PageInput){\n      data: userEvents(filter: $filter, page: $page){\n        ...LightUserEventFragment\n      }\n    }\n    ${UserEventFragments.lightUserEvent}\n  `,\n\n  loadAllWithContent: gql`\n    query UserEventsWithContent($filter: UserEventFilterVOInput, $page: PageInput){\n      data: userEvents(filter: $filter, page: $page){\n        ...UserEventFragment\n      }\n    }\n    ${UserEventFragments.userEvent}\n  `\n};\n\nconst userEventMutations: IUserEventMutations = {\n  deleteByIds: gql`\n    mutation DeleteUserEvents($ids:[Int]){\n      deleteUserEvents(ids: $ids)\n    }\n  `,\n\n  save: gql`\n    mutation SaveUserEvent($data: UserEventVOInput){\n      data: saveUserEvent(userEvent: $data){\n        ...UserEventFragment\n      }\n    }\n    ${UserEventFragments.userEvent}\n  `\n};\n\n\n@Injectable()\nexport class UserEventService\n  extends AbstractUserEventService<UserEvent, UserEventFilter> {\n\n  constructor(\n    protected graphql: GraphqlService,\n    protected accountService: AccountService,\n    protected network: NetworkService,\n    protected translate: TranslateService,\n    protected toastController: ToastController,\n    @Optional() @Inject(ENVIRONMENT) protected environment: Environment\n  ) {\n    super(graphql, accountService, network, translate, userEventQueries, userEventMutations, undefined, environment);\n  }\n\n  async showToastErrorWithContext(opts: {\n    error?: any;\n    message?: string;\n    context: any | (() => any) | Promise<any>;\n  }) {\n\n    let message = opts.message || (opts.error && opts.error.message || opts.error);\n\n    // Make sure message a string\n    if (!message || typeof message !== 'string') {\n      message = 'ERROR.UNKNOWN_TECHNICAL_ERROR';\n    }\n\n    // If offline, display a simple alert\n    if (this.network.offline) {\n      this.showToast({ message, type: 'error' });\n      return;\n    }\n\n    // Translate the message (to be able to extract details content)\n    message = this.translate.instant(message);\n\n    // Clean details parts\n    if (message && message.indexOf('<small>') !== -1) {\n      message = message.substr(0, message.indexOf('<small>') - 1);\n    }\n\n    const res = await this.showToast({\n      type: 'error',\n      duration: 15000,\n      message: message + '<br/><br/><b>' + this.translate.instant('CONFIRM.SEND_DEBUG_DATA') + '</b>',\n      buttons: [{\n        icon: 'bug',\n        text: this.translate.instant('COMMON.BTN_SEND'),\n        role: 'send'\n      }]\n    });\n    if (!res || res.role !== 'send') return;\n\n    // Send debug data\n    try {\n      if (this._debug) console.debug('Sending debug data...');\n\n      // Call content factory\n      let context: any = opts && opts.context;\n      if (typeof context === 'function') {\n        context = context();\n      }\n      if (context instanceof Promise) {\n        context = await context;\n      }\n\n      // Send the message\n      const userEvent = await this.sendDataForDebug({\n        message,\n        error: opts.error || undefined,\n        context: this.convertObjectToString(context)\n      });\n\n      console.info('Debug data successfully sent to admin', userEvent);\n      this.showToast({\n        type: 'info',\n        message: 'INFO.DEBUG_DATA_SEND',\n        showCloseButton: true\n      });\n    } catch (err) {\n      console.error('Error while sending debug data:', err);\n    }\n  }\n\n  sendDataForDebug(data: any): Promise<UserEvent> {\n    const userEvent = new UserEvent();\n    userEvent.type = UserEventTypes.DEBUG_DATA;\n    userEvent.content = this.convertObjectToString(data);\n    return this.save(userEvent);\n  }\n\n  asFilter(filter: Partial<UserEventFilter>): UserEventFilter {\n    return UserEventFilter.fromObject(filter);\n  }\n\n  fromObject(source: any): UserEvent {\n    return UserEvent.fromObject(source);\n  }\n\n  /* -- protected methods -- */\n\n  protected convertObjectToString(data: any): string {\n    if (typeof data === 'string') {\n      return data;\n    }\n    // Serialize content into string\n    else if (typeof data === 'object') {\n      if (data instanceof Entity) {\n        return JSON.stringify(data.asObject({ keepTypename: true, keepLocalId: true, minify: false }));\n      } else {\n        return JSON.stringify(data);\n      }\n    }\n  }\n\n  protected async showToast<T = any>(opts: ShowToastOptions): Promise<OverlayEventDetail<T>> {\n    if (!this.toastController) throw new Error('Missing toastController in component\\'s constructor');\n    return await Toasts.show(this.toastController, this.translate, opts);\n  }\n\n  protected fillDefaultProperties(entity: UserEvent) {\n    entity.issuer = this.accountService.account.pubkey;\n\n    // TODO: compute hash (using cryptoService)\n    // TODO: compute sign\n    console.warn('TODO: sign user event before sending');\n  }\n\n}\n"]}