@sumaris-net/ngx-components 1.18.7 → 1.19.2

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

@@ -0,0 +1,367 @@
+import { __awaiter, __decorate } from "tslib";
+import { Inject, Injectable, 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 { UserEventFragments } from './user-event.fragments';
+import { map } from 'rxjs/operators';
+import { isEmptyArray, isNil, isNilOrBlank, toNumber } from '../../shared/functions';
+import { Toasts } from '../../shared/toast/toasts';
+import { ToastController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+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) {
+        super(graphql, environment);
+        this.graphql = graphql;
+        this.accountService = accountService;
+        this.network = network;
+        this.translate = translate;
+        this.toastController = toastController;
+        this.environment = environment;
+        this._userEventActions = [];
+        // For DEV only
+        this._debug = environment && !environment.production;
+    }
+    /**
+     *
+     * @param offset
+     * @param size
+     * @param sortBy
+     * @param sortDirection
+     * @param filter
+     * @param options
+     * @deprecated use watchPage() instead
+     */
+    watchAll(offset, size, sortBy, sortDirection, filter, options) {
+        return this.watchPage({ offset, size, sortBy, sortDirection }, filter, options);
+    }
+    watchPage(page, filter, options) {
+        let now = this._debug && Date.now();
+        //if (this._debug)
+        console.debug('[user-event-service] 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) {
+                console.warn('[user-events-service] Force user event filter.recipient=' + recipient);
+                filter.recipient = recipient;
+            }
+        }
+        const withContent = options && options.withContent === true;
+        return this.mutableWatchQuery({
+            queryName: withContent ? 'LoadAllWithContent' : 'LoadAll',
+            query: withContent ? LoadAllWithContentQuery : LoadAllQuery,
+            variables: {
+                page: Object.assign(Object.assign({ sortBy: 'updateDate' }, page), { 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
+        })
+            .pipe(map(res => {
+            const data = res && (res.data || []).map(UserEvent.fromObject);
+            if (now) {
+                console.debug(`[user-event-service] ${data.length} user events loaded in ${Date.now() - now}ms`);
+                now = null;
+            }
+            return {
+                data,
+                total: res && toNumber(res.total, data.length)
+            };
+        }));
+    }
+    saveAll(data, options) {
+        return Promise.all(data
+            .map(entity => this.save(entity, options)));
+    }
+    /**
+     * 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 json = entity.asObject();
+            const now = Date.now();
+            if (this._debug)
+                console.debug(`[user-event-service] Saving user event...`, json);
+            yield this.graphql.mutate({
+                mutation: SaveQuery,
+                variables: {
+                    data: json
+                },
+                error: { code: SocialErrorCodes.SAVE_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.SAVE_USER_EVENT_ERROR' },
+                update: (proxy, { data }) => {
+                    // Update entity
+                    const savedEntity = data && data.data;
+                    if (savedEntity) {
+                        if (this._debug)
+                            console.debug(`[user-event-service] User event saved in ${Date.now() - now}ms`, entity);
+                        this.copyIdAndUpdateDate(savedEntity, entity);
+                        // Add to cache
+                        if (isNew) {
+                            this.insertIntoMutableCachedQueries(proxy, {
+                                query: LoadAllQuery,
+                                data: Object.assign(Object.assign({}, savedEntity), { content: null })
+                            });
+                            this.insertIntoMutableCachedQueries(proxy, {
+                                query: LoadAllWithContentQuery,
+                                data: savedEntity
+                            });
+                        }
+                    }
+                }
+            });
+            return entity;
+        });
+    }
+    /**
+     * Save many trips
+     *
+     * @param entities
+     * @param opts
+     */
+    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('[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`);
+                }
+            });
+        });
+    }
+    /**
+     * Delete userEvent entities
+     */
+    delete(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data)
+                return; // skip
+            yield this.deleteAll([data]);
+        });
+    }
+    listenChanges(id, options) {
+        // TODO
+        console.warn('TODO: implement listen changes on user events');
+        return of();
+    }
+    registerAction(definition) {
+        console.info(`[user-event-service] Registering action ${definition.name} for ${definition.__typename}`);
+        this._userEventActions.push(definition);
+    }
+    getActionsByTypename(typename) {
+        return this._userEventActions.filter(def => def.__typename === typename);
+    }
+    showToastErrorWithContext(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let message = opts.message || (opts.error && opts.error.message || opts.error);
+            // Make sure message a string
+            if (!message || typeof message !== 'string') {
+                message = 'ERROR.UNKNOWN_TECHNICAL_ERROR';
+            }
+            // If offline, display a simple alert
+            if (this.network.offline) {
+                this.showToast({ message, type: 'error' });
+                return;
+            }
+            // Translate the message (to be able to extract details content)
+            message = this.translate.instant(message);
+            // Clean details parts
+            if (message && message.indexOf('<small>') !== -1) {
+                message = message.substr(0, message.indexOf('<small>') - 1);
+            }
+            const res = yield this.showToast({
+                type: 'error',
+                duration: 15000,
+                message: message + '<br/><br/><b>' + this.translate.instant('CONFIRM.SEND_DEBUG_DATA') + '</b>',
+                buttons: [{
+                        icon: 'bug',
+                        text: this.translate.instant('COMMON.BTN_SEND'),
+                        role: 'send'
+                    }]
+            });
+            if (!res || res.role !== 'send')
+                return;
+            // Send debug data
+            try {
+                if (this._debug)
+                    console.debug('Sending debug data...');
+                // Call content factory
+                let context = opts && opts.context;
+                if (typeof context === 'function') {
+                    context = context();
+                }
+                if (context instanceof Promise) {
+                    context = yield context;
+                }
+                // Send the message
+                const userEvent = yield this.sendDataForDebug({
+                    message,
+                    error: opts.error || undefined,
+                    context: this.convertObjectToString(context)
+                });
+                console.info('Debug data successfully sent to admin', userEvent);
+                this.showToast({
+                    type: 'info',
+                    message: 'INFO.DEBUG_DATA_SEND',
+                    showCloseButton: true
+                });
+            }
+            catch (err) {
+                console.error('Error while sending debug data:', err);
+            }
+        });
+    }
+    sendDataForDebug(data) {
+        const userEvent = new UserEvent();
+        userEvent.eventType = UserEventTypes.DEBUG_DATA;
+        userEvent.content = this.convertObjectToString(data);
+        return this.save(userEvent);
+    }
+    asFilter(filter) {
+        return UserEventFilter.fromObject(filter);
+    }
+    /* -- protected methods -- */
+    convertObjectToString(data) {
+        if (typeof data === 'string') {
+            return data;
+        }
+        // Serialize content into string
+        else if (typeof data === 'object') {
+            if (data instanceof Entity) {
+                return JSON.stringify(data.asObject({ keepTypename: true, keepLocalId: true, minify: false }));
+            }
+            else {
+                return JSON.stringify(data);
+            }
+        }
+    }
+    showToast(opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.toastController)
+                throw new Error('Missing toastController in component\'s constructor');
+            return yield Toasts.show(this.toastController, this.translate, opts);
+        });
+    }
+    fillDefaultProperties(entity) {
+        entity.issuer = this.accountService.account.pubkey;
+        // TODO: compute hash (using cryptoService)
+        // 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' },] }
+];
+UserEventService.ctorParameters = () => [
+    { type: GraphqlService },
+    { type: AccountService },
+    { type: NetworkService },
+    { type: TranslateService },
+    { 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":";AAAA,OAAO,EAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAC,GAAG,EAAC,MAAM,qBAAqB,CAAC;AACxC,OAAO,EAAC,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAC,cAAc,EAAC,MAAM,qCAAqC,CAAC;AACnE,OAAO,EAAC,cAAc,EAAC,MAAM,oCAAoC,CAAC;AAClE,OAAO,EAAa,EAAE,EAAC,MAAM,MAAM,CAAC;AACpC,OAAO,EAAC,SAAS,EAAmB,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAG1D,OAAO,EAAC,GAAG,EAAC,MAAM,gBAAgB,CAAC;AACnC,OAAO,EAAC,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAC,MAAM,wBAAwB,CAAC;AACnF,OAAO,EAAmB,MAAM,EAAC,MAAM,2BAA2B,CAAC;AAEnE,OAAO,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAC,gBAAgB,EAAC,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,cAAc,EAAC,MAAM,qCAAqC,CAAC;AACnE,OAAO,EAAC,kBAAkB,EAAC,MAAM,gDAAgD,CAAC;AAClF,OAAO,EAAC,MAAM,EAAE,WAAW,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,WAAW,EAAE,WAAW,EAAC,MAAM,yCAAyC,CAAC;AACjF,OAAO,EAAC,YAAY,EAAC,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAC,WAAW,EAAC,MAAM,6CAA6C,CAAC;;;;;;;;AAExE,WAAW;IAEE,eAAe,SAAf,eAAgB,SAAQ,YAAwC;;;QAI3E,WAAM,GAAW,IAAI,CAAC;QACtB,cAAS,GAAW,IAAI,CAAC;IAqB3B,CAAC;IAnBC,UAAU,CAAC,MAAW,EAAE,IAAU;QAChC,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IACpC,CAAC;IAES,WAAW;QACnB,MAAM,SAAS,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QAEtC,SAAS;QACT,IAAI,IAAI,CAAC,MAAM,EAAE;YACf,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;SACjD;QACD,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,KAAK,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;SACvD;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;CACF,CAAA;AA1BY,eAAe;IAD3B,WAAW,CAAC,EAAC,QAAQ,EAAE,mBAAmB,EAAC,CAAC;GAChC,eAAe,CA0B3B;SA1BY,eAAe;AA4B5B,MAAM,SAAS,GAAQ,GAAG,CAAA;;;;;;IAMtB,kBAAkB,CAAC,SAAS;CAC/B,CAAC;AAEF,MAAM,YAAY,GAAQ,GAAG,CAAA;;;;;;IAMzB,kBAAkB,CAAC,cAAc;CACpC,CAAC;AAEF,MAAM,mBAAmB,GAAQ,GAAG,CAAA;;;;CAInC,CAAC;AAEF,MAAM,uBAAuB,GAAQ,GAAG,CAAA;;;;;;IAMpC,kBAAkB,CAAC,SAAS;CAC/B,CAAC;AAWF,MAAM,OAAO,gBACX,SAAQ,kBAA8C;IAKtD,YACY,OAAuB,EACvB,cAA8B,EAC9B,OAAuB,EACvB,SAA2B,EAC3B,eAAgC,EACC,WAAwB;QAEnE,KAAK,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QAPlB,YAAO,GAAP,OAAO,CAAgB;QACvB,mBAAc,GAAd,cAAc,CAAgB;QAC9B,YAAO,GAAP,OAAO,CAAgB;QACvB,cAAS,GAAT,SAAS,CAAkB;QAC3B,oBAAe,GAAf,eAAe,CAAiB;QACC,gBAAW,GAAX,WAAW,CAAa;QAR7D,sBAAiB,GAAgC,EAAE,CAAC;QAY1D,eAAe;QACf,IAAI,CAAC,MAAM,GAAG,WAAW,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC;IACvD,CAAC;IAED;;;;;;;;;OASG;IACH,QAAQ,CAAC,MAAc,EACd,IAAY,EACZ,MAAe,EACf,aAA6B,EAC7B,MAAwB,EACxB,OAA+B;QACtC,OAAO,IAAI,CAAC,SAAS,CAAO,EAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAC,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IACtF,CAAC;IAED,SAAS,CAAC,IAAU,EACV,MAAiC,EACjC,OAA+B;QAEvC,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;QACpC,kBAAkB;QAClB,OAAO,CAAC,KAAK,CAAC,6CAA6C,EAAE,MAAM,CAAC,CAAC;QAErE,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAE/B,oEAAoE;QACpE,IAAI,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,EAAE;YACpE,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC;YACrD,IAAI,SAAS,KAAK,MAAM,CAAC,SAAS,EAAE;gBAClC,OAAO,CAAC,IAAI,CAAC,0DAA0D,GAAG,SAAS,CAAC,CAAC;gBACrF,MAAM,CAAC,SAAS,GAAG,SAAS,CAAC;aAC9B;SACF;QAED,MAAM,WAAW,GAAG,OAAO,IAAI,OAAO,CAAC,WAAW,KAAK,IAAI,CAAC;QAE5D,OAAO,IAAI,CAAC,iBAAiB,CAAkB;YAC7C,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,SAAS;YACzD,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,uBAAuB,CAAC,CAAC,CAAC,YAAY;YAC3D,SAAS,EAAE;gBACT,IAAI,gCACF,MAAM,EAAE,YAAY,IACjB,IAAI,KACP,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,MAAM,CAAC,CAAC,WAAW,EAAE,GAC5D;gBACD,MAAM,EAAE,MAAM,IAAI,MAAM,CAAC,WAAW,EAAE;aACvC;YACD,cAAc,EAAE,MAAM;YACtB,KAAK,EAAE,EAAC,IAAI,EAAE,gBAAgB,CAAC,sBAAsB,EAAE,OAAO,EAAE,qCAAqC,EAAC;YACtG,WAAW,EAAE,OAAO,IAAI,OAAO,CAAC,WAAW,IAAI,SAAS;SACzD,CAAC;aACC,IAAI,CACH,GAAG,CAAC,GAAG,CAAC,EAAE;YACR,MAAM,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;YAE/D,IAAI,GAAG,EAAE;gBACP,OAAO,CAAC,KAAK,CAAC,wBAAwB,IAAI,CAAC,MAAM,0BAA0B,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC;gBACjG,GAAG,GAAG,IAAI,CAAC;aACZ;YACD,OAAO;gBACL,IAAI;gBACJ,KAAK,EAAE,GAAG,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC;aAC/C,CAAC;QACJ,CAAC,CAAC,CACH,CAAC;IACN,CAAC;IAED,OAAO,CAAC,IAAiB,EAAE,OAAa;QACtC,OAAO,OAAO,CAAC,GAAG,CAAC,IAAI;aACpB,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAC3C,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACG,IAAI,CAAC,MAAiB,EAAE,OAAkC;;YAE9D,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;YAEnC,sBAAsB;YACtB,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAC/B,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;YAE/B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,IAAI,IAAI,CAAC,MAAM;gBAAE,OAAO,CAAC,KAAK,CAAC,2CAA2C,EAAE,IAAI,CAAC,CAAC;YAElF,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAgB;gBACvC,QAAQ,EAAE,SAAS;gBACnB,SAAS,EAAE;oBACT,IAAI,EAAE,IAAI;iBACX;gBACD,KAAK,EAAE,EAAE,IAAI,EAAE,gBAAgB,CAAC,qBAAqB,EAAE,OAAO,EAAE,oCAAoC,EAAE;gBACtG,MAAM,EAAE,CAAC,KAAK,EAAE,EAAC,IAAI,EAAC,EAAE,EAAE;oBACxB,gBAAgB;oBAChB,MAAM,WAAW,GAAG,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;oBACtC,IAAI,WAAW,EAAE;wBACf,IAAI,IAAI,CAAC,MAAM;4BAAE,OAAO,CAAC,KAAK,CAAC,4CAA4C,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;wBACzG,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;wBAE9C,eAAe;wBACf,IAAI,KAAK,EAAE;4BACT,IAAI,CAAC,8BAA8B,CAAC,KAAK,EAAC;gCACxC,KAAK,EAAE,YAAY;gCACnB,IAAI,kCACC,WAAW,KACd,OAAO,EAAE,IAAI,GACd;6BACF,CAAC,CAAC;4BACH,IAAI,CAAC,8BAA8B,CAAC,KAAK,EAAC;gCACxC,KAAK,EAAE,uBAAuB;gCAC9B,IAAI,EAAE,WAAW;6BAClB,CAAC,CAAC;yBACJ;qBACF;gBACH,CAAC;aACF,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC;QAChB,CAAC;KAAA;IAID;;;;;OAKG;IACG,SAAS,CAAC,QAAqB,EAAE,IAEtC;;YAEC,MAAM,GAAG,GAAG,QAAQ,IAAI,QAAQ;iBAC7B,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAClB,IAAI,YAAY,CAAC,GAAG,CAAC;gBAAE,OAAO,CAAC,8BAA8B;YAE7D,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,IAAI,IAAI,CAAC,MAAM;gBAAE,OAAO,CAAC,KAAK,CAAC,8CAA8C,EAAE,GAAG,CAAC,CAAC;YAEpF,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAM;gBAC7B,QAAQ,EAAE,mBAAmB;gBAC7B,SAAS,EAAE;oBACT,GAAG;iBACJ;gBACD,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;oBAChB,qBAAqB;oBACrB,IAAI,CAAC,mCAAmC,CAAC,KAAK,EAAE;wBAC9C,KAAK,EAAE,YAAY;wBACnB,GAAG;qBACJ,CAAC,CAAC;oBACH,IAAI,CAAC,mCAAmC,CAAC,KAAK,EAAE;wBAC9C,KAAK,EAAE,uBAAuB;wBAC9B,GAAG;qBACJ,CAAC,CAAC;oBAEH,IAAI,IAAI,CAAC,MAAM;wBAAE,OAAO,CAAC,KAAK,CAAC,0CAA0C,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC;gBACjG,CAAC;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAED;;OAEG;IACG,MAAM,CAAC,IAAe;;YAC1B,IAAI,CAAC,IAAI;gBAAE,OAAO,CAAC,OAAO;YAC1B,MAAM,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC/B,CAAC;KAAA;IAED,aAAa,CAAC,EAAU,EAAE,OAAa;QACrC,OAAO;QACP,OAAO,CAAC,IAAI,CAAC,+CAA+C,CAAC,CAAC;QAC9D,OAAO,EAAE,EAAE,CAAC;IACd,CAAC;IAED,cAAc,CAAC,UAAqC;QAClD,OAAO,CAAC,IAAI,CAAC,2CAA2C,UAAU,CAAC,IAAI,QAAQ,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC;QACxG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC1C,CAAC;IAED,oBAAoB,CAAC,QAAgB;QACnC,OAAO,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,KAAK,QAAQ,CAAC,CAAC;IAC3E,CAAC;IAEK,yBAAyB,CAAC,IAGa;;YAE3C,IAAI,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC;YAE/E,6BAA6B;YAC7B,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;gBAC3C,OAAO,GAAG,+BAA+B,CAAC;aAC3C;YAED,qCAAqC;YACrC,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;gBACxB,IAAI,CAAC,SAAS,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,CAAC,CAAC;gBACzC,OAAO;aACR;YAED,gEAAgE;YAChE,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YAE1C,sBAAsB;YACtB,IAAI,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE;gBAChD,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC;aAC7D;YAED,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC;gBAC/B,IAAI,EAAE,OAAO;gBACb,QAAQ,EAAE,KAAK;gBACf,OAAO,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,yBAAyB,CAAC,GAAG,MAAM;gBAC/F,OAAO,EAAE,CAAC;wBACR,IAAI,EAAE,KAAK;wBACX,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,iBAAiB,CAAC;wBAC/C,IAAI,EAAE,MAAM;qBACb,CAAC;aACH,CAAC,CAAC;YACH,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM;gBAAE,OAAO;YAExC,kBAAkB;YAClB,IAAI;gBACF,IAAI,IAAI,CAAC,MAAM;oBAAE,OAAO,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;gBAExD,uBAAuB;gBACvB,IAAI,OAAO,GAAQ,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC;gBACxC,IAAI,OAAO,OAAO,KAAK,UAAU,EAAE;oBACjC,OAAO,GAAG,OAAO,EAAE,CAAC;iBACrB;gBACD,IAAI,OAAO,YAAY,OAAO,EAAE;oBAC9B,OAAO,GAAG,MAAM,OAAO,CAAC;iBACzB;gBAED,mBAAmB;gBACnB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC;oBAC5C,OAAO;oBACP,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,SAAS;oBAC9B,OAAO,EAAE,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC;iBAC7C,CAAC,CAAC;gBAEH,OAAO,CAAC,IAAI,CAAC,uCAAuC,EAAE,SAAS,CAAC,CAAC;gBACjE,IAAI,CAAC,SAAS,CAAC;oBACb,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE,sBAAsB;oBAC/B,eAAe,EAAE,IAAI;iBACtB,CAAC,CAAC;aACJ;YACD,OAAO,GAAG,EAAE;gBACV,OAAO,CAAC,KAAK,CAAC,iCAAiC,EAAE,GAAG,CAAC,CAAC;aACvD;QACH,CAAC;KAAA;IAED,gBAAgB,CAAC,IAAS;QACxB,MAAM,SAAS,GAAG,IAAI,SAAS,EAAE,CAAC;QAClC,SAAS,CAAC,SAAS,GAAG,cAAc,CAAC,UAAU,CAAC;QAChD,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC;QACrD,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC9B,CAAC;IAED,QAAQ,CAAC,MAAgC;QACvC,OAAO,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC5C,CAAC;IAED,6BAA6B;IAEnB,qBAAqB,CAAC,IAAS;QACvC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAC;YAC3B,OAAO,IAAI,CAAC;SACb;QACD,gCAAgC;aAC3B,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAC;YAChC,IAAI,IAAI,YAAY,MAAM,EAAE;gBAC1B,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAC,CAAC,CAAC,CAAC;aAC9F;iBACI;gBACH,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;aAC7B;SACF;IACH,CAAC;IAEe,SAAS,CAAQ,IAAsB;;YACrD,IAAI,CAAC,IAAI,CAAC,eAAe;gBAAE,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;YAClG,OAAO,MAAM,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;QACvE,CAAC;KAAA;IAES,qBAAqB,CAAC,MAAiB;QAC/C,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC;QAEnD,2CAA2C;QAC3C,qBAAqB;QACrB,OAAO,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;IACvD,CAAC;IAES,mBAAmB,CAAC,MAAiB,EAAE,MAAiB;QAChE,WAAW,CAAC,mBAAmB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,CAAC;;;;YApUF,UAAU,SAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;;YA1FxB,cAAc;YADd,cAAc;YAad,cAAc;YADd,gBAAgB;YADhB,eAAe;YAKf,WAAW,uBAwFd,QAAQ,YAAI,MAAM,SAAC,WAAW","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"]}

package/esm2015/src/app/social/user-event/user-events.table.js

@@ -0,0 +1,154 @@
+import { __awaiter } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Inject, Injector, Input } from '@angular/core';
+import { UserEventFilter, UserEventService } from './user-event.service';
+import { AccountService } from '../../core/services/account.service';
+import { UserEvent, UserEventTypes } from './user-event.model';
+import { toBoolean } from '../../shared/functions';
+import { AppTable, RESERVED_END_COLUMNS, RESERVED_START_COLUMNS } from '../../core/table/table.class';
+import { EntitiesTableDataSource } from '../../core/table/entities-table-datasource.class';
+import { EntitiesStorage } from '../../core/services/storage/entities-storage.service';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+const ICONS_MAP = {
+    DEBUG_DATA: { matIcon: 'bug_report' },
+    INBOX_MESSAGE: { matIcon: 'mail' },
+};
+// TODO: refactor with a registration done by data service:
+// - userEventService.registerEventAction({__typename: 'TripVO', ...})
+// - userEventService.getActionsFor(__typename): UserEventDetailAction
+/*const DETAILS_MAP: {[key: string]: UserEventAction<RootDataEntity<any>>} = {
+  "TripVO": {
+    icon: null,
+    matIcon: "content_copy",
+    action: 'copyToLocal',
+    actionTitle: 'SOCIAL.USER_EVENT.BTN_COPY_TO_LOCAL',
+    actionColor: 'primary',
+    fromObject: Trip.fromObject,
+    childrenFields: ['operation', 'landing']
+  },
+  "ObservedLocationVO": {
+    icon: null,
+    matIcon: "content_copy",
+    action: 'copyToLocal',
+    actionTitle: 'SOCIAL.USER_EVENT.BTN_COPY_TO_LOCAL',
+    actionColor: 'primary',
+    fromObject: ObservedLocation.fromObject,
+    childrenFields: ['landings']
+  }
+}*/
+export class UserEventsTable extends AppTable {
+    constructor(injector, accountService, service, entities, cd, environment) {
+        super(injector, 
+        // columns
+        RESERVED_START_COLUMNS
+            .concat([
+            'creationDate',
+            'icon',
+            'eventType',
+            'message'
+        ])
+            .concat(RESERVED_END_COLUMNS), null, null);
+        this.accountService = accountService;
+        this.service = service;
+        this.entities = entities;
+        this.cd = cd;
+        this.environment = environment;
+        this.i18nColumnPrefix = 'SOCIAL.USER_EVENT.';
+        this.autoLoad = false; // this.start()
+        this.inlineEdition = false;
+        this.defaultSortBy = 'creationDate';
+        this.defaultSortDirection = 'desc';
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        // Load date/time pattern
+        this.dateTimePattern = this.translate.instant('COMMON.DATE_TIME_PATTERN');
+        this.withContent = toBoolean(this.withContent, false);
+        const account = this.accountService.account;
+        const pubkey = account && account.pubkey;
+        this.isAdmin = this.accountService.isAdmin();
+        this.canEdit = this.isAdmin || pubkey === this.recipient;
+        this.canDelete = this.canEdit;
+        this.setDatasource(new EntitiesTableDataSource(UserEvent, this.service, null, {
+            prependNewElements: false,
+            suppressErrors: true,
+            dataServiceOptions: {
+                withContent: this.withContent
+            }
+        }));
+        const filter = this.filter || new UserEventFilter();
+        filter.recipient = this.recipient;
+        this.setFilter(filter, { emitEvent: true });
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.debug('[user-event] Starting...');
+            // Waiting account to be ready
+            yield this.accountService.ready();
+            // Load data
+            this.onRefresh.emit();
+        });
+    }
+    getIcon(source) {
+        return ICONS_MAP[source.eventType];
+    }
+    getDetail(source) {
+        if (!source)
+            return undefined;
+        if (source.content && source.eventType === UserEventTypes.DEBUG_DATA) {
+            const context = source.content.context;
+            if (context && context.__typename) {
+                const actions = this.service.getActionsByTypename(context.__typename);
+                return {
+                    actions,
+                    title: source.content.error && source.content.error.message || source.content.message,
+                    description: source.content.error && source.content.error.details || undefined
+                };
+            }
+        }
+        console.debug('TODO: implement getDetail() for event: ', source);
+        return {};
+    }
+    doAction(action, row) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const event = row.currentData;
+            const context = event.content && event.content.context;
+            this.markAsLoading();
+            if (action && typeof action.executeAction === 'function') {
+                try {
+                    let res = action.executeAction(event, context);
+                    res = (res instanceof Promise) ? yield res : res;
+                }
+                catch (err) {
+                    this.setError(err && err.message || err);
+                    console.error(`[user-event] Failed to execute action ${action.name}: ${err && err.message || err}`, err);
+                }
+                finally {
+                    this.markAsLoaded();
+                }
+            }
+        });
+    }
+}
+UserEventsTable.decorators = [
+    { type: Component, args: [{
+                selector: 'app-user-events-table',
+                template: "\n<!-- Type = options menu -->\n<mat-menu #optionsMenu=\"matMenu\" xPosition=\"after\">\n\n  <!-- display columns -->\n  <button mat-menu-item\n          (click)=\"openSelectColumnsModal($event)\">\n    <mat-icon>view_column</mat-icon>\n    <ion-label translate>COMMON.DISPLAYED_COLUMNS_DOTS</ion-label>\n  </button>\n\n</mat-menu>\n\n<!-- top header -->\n<mat-toolbar>\n\n  <ng-container *ngIf=\"!selection.hasValue(); else hasSelection\">\n\n    <button mat-icon-button [title]=\"'COMMON.BTN_REFRESH'|translate\" (click)=\"onRefresh.emit()\">\n      <mat-icon>refresh</mat-icon>\n    </button>\n\n  </ng-container>\n\n  <!-- if row selection -->\n  <ng-template #hasSelection>\n\n    <!-- delete -->\n    <button mat-icon-button class=\"hidden-xs hidden-sm\" *ngIf=\"canDelete\"\n            [title]=\"'COMMON.BTN_DELETE'|translate\" (click)=\"deleteSelection($event)\">\n      <mat-icon>delete</mat-icon>\n    </button>\n  </ng-template>\n\n  <!-- error -->\n  <ion-item *ngIf=\"error\" hidden-xs hidden-sm hidden-mobile lines=\"none\">\n    <ion-icon color=\"danger\" slot=\"start\" name=\"alert-circle\"></ion-icon>\n    <ion-label color=\"danger\" class=\"error\" [innerHTML]=\"error|translate\"></ion-label>\n  </ion-item>\n\n  <div class=\"toolbar-spacer\"></div>\n\n  <button mat-icon-button\n          [title]=\"'COMMON.BTN_OPTIONS'|translate\"\n          [matMenuTriggerFor]=\"optionsMenu\">\n    <mat-icon>more_vert</mat-icon>\n  </button>\n</mat-toolbar>\n\n\n<mat-table [dataSource]=\"dataSource\" matSort\n           [matSortActive]=\"defaultSortBy\"\n           [matSortDirection]=\"defaultSortDirection\"\n           matSortDisableClear [trackBy]=\"trackByFn\">\n\n  <!-- select -->\n  <ng-container matColumnDef=\"select\">\n    <mat-header-cell *matHeaderCellDef [class.cdk-visually-hidden]=\"!canEdit\">\n      <mat-checkbox (change)=\"$event ? masterToggle() : null\" [checked]=\"selection.hasValue() && isAllSelected()\"\n                    [indeterminate]=\"selection.hasValue() && !isAllSelected()\">\n      </mat-checkbox>\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row\" [class.cdk-visually-hidden]=\"!canEdit\">\n      <mat-checkbox (click)=\"$event.stopPropagation()\" (change)=\"$event ? selection.toggle(row) : null\" [checked]=\"selection.isSelected(row)\">\n      </mat-checkbox>\n    </mat-cell>\n  </ng-container>\n\n  <!-- id -->\n  <ng-container matColumnDef=\"id\">\n    <mat-header-cell *matHeaderCellDef mat-sort-header [class.cdk-visually-hidden]=\"!isAdmin\">\n      <app-loading-spinner [loading]=\"loadingSubject|async\"><ion-label>#</ion-label></app-loading-spinner>\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row\" [class.cdk-visually-hidden]=\"!isAdmin\">{{ row.currentData.id | mathAbs }}</mat-cell>\n  </ng-container>\n\n  <!-- creationDate -->\n  <ng-container matColumnDef=\"creationDate\">\n    <mat-header-cell *matHeaderCellDef mat-sort-header>\n      <ion-label translate>SOCIAL.USER_EVENT.CREATION_DATE</ion-label>\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row\">\n      <ion-text>\n        {{row.currentData.creationDate | dateFromNow }}<br/>\n        <ion-text color=\"medium\"><small>{{row.currentData.creationDate | dateFormat: {time: true} }}</small></ion-text>\n      </ion-text>\n    </mat-cell>\n  </ng-container>\n\n  <!-- icon -->\n  <ng-container matColumnDef=\"icon\">\n    <mat-header-cell *matHeaderCellDef>\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row;\">\n      <ng-container *ngIf=\"getIcon(row.currentData); let details\">\n        <ion-icon slot=\"start\" *ngIf=\"details.icon\" [name]=\"details.icon\"></ion-icon>\n        <mat-icon slot=\"start\" *ngIf=\"details.matIcon\">{{details.matIcon}}</mat-icon>\n      </ng-container>\n    </mat-cell>\n  </ng-container>\n\n  <!-- event type -->\n  <ng-container matColumnDef=\"eventType\">\n    <mat-header-cell *matHeaderCellDef mat-sort-header>\n      <ion-label translate>SOCIAL.USER_EVENT.EVENT_TYPE</ion-label>\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row;\">\n      <span>{{'SOCIAL.USER_EVENT.TYPE_ENUM.' + row.currentData.eventType | translate}}</span>\n    </mat-cell>\n  </ng-container>\n\n  <!-- message -->\n  <ng-container matColumnDef=\"message\">\n    <mat-header-cell *matHeaderCellDef>\n      <ion-label translate>SOCIAL.USER_EVENT.MESSAGE</ion-label>\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row;\">\n      <ng-container *ngIf=\"getDetail(row.currentData); let details\">\n        <ion-text [innerHTML]=\"details.title|translate\">\n        </ion-text>\n      </ng-container>\n    </mat-cell>\n  </ng-container>\n\n  <!-- Actions buttons column -->\n  <ng-container matColumnDef=\"actions\">\n    <mat-header-cell *matHeaderCellDef>\n    </mat-header-cell>\n    <mat-cell *matCellDef=\"let row\">\n      <ng-container *ngIf=\"getDetail(row.currentData); let details\">\n        <button mat-icon-button color=\"light\"\n                *ngFor=\"let action of details.actions\"\n                [title]=\"action.title |translate\"\n                [color]=\"action.color\"\n                (click)=\"doAction(action, row)\">\n          <ion-icon slot=\"start\" *ngIf=\"action.icon\" [name]=\"action.icon\"></ion-icon>\n          <mat-icon slot=\"start\" *ngIf=\"action.matIcon\">{{action.matIcon}}</mat-icon>\n        </button>\n      </ng-container>\n    </mat-cell>\n  </ng-container>\n\n  <mat-header-row *matHeaderRowDef=\"displayedColumns\"></mat-header-row>\n  <mat-row *matRowDef=\"let row; columns: displayedColumns;\"\n           class=\"mat-row-disabled\"\n           (click)=\"clickRow($event, row)\"></mat-row>\n\n</mat-table>\n\n<ion-row class=\"ion-no-padding\">\n  <ion-col></ion-col>\n  <ion-col class=\"ion-no-padding\" size=\"auto\">\n    <mat-paginator [length]=\"totalRowCount\" [pageSize]=\"defaultPageSize\" [pageSizeOptions]=\"defaultPageSizeOptions\" showFirstLastButtons>\n    </mat-paginator>\n  </ion-col>\n</ion-row>\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [".mat-header-row .mat-column-icon,.mat-row .mat-column-icon{max-width:40px;padding-left:0}.mat-header-row .mat-column-icon ion-icon,.mat-header-row .mat-column-icon mat-icon,.mat-row .mat-column-icon ion-icon,.mat-row .mat-column-icon mat-icon{font-size:1.2em;height:1.2em;width:1.2em}.mat-header-row .mat-column-creationDate,.mat-row .mat-column-creationDate{min-width:100px;max-width:120px}"]
+            },] }
+];
+UserEventsTable.ctorParameters = () => [
+    { type: Injector },
+    { type: AccountService },
+    { type: UserEventService },
+    { type: EntitiesStorage },
+    { type: ChangeDetectorRef },
+    { type: undefined, decorators: [{ type: Inject, args: [ENVIRONMENT,] }] }
+];
+UserEventsTable.propDecorators = {
+    recipient: [{ type: Input }],
+    withContent: [{ type: Input }],
+    defaultSortBy: [{ type: Input }],
+    defaultSortDirection: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-events.table.js","sourceRoot":"","sources":["../../../../../../src/app/social/user-event/user-events.table.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, ChangeDetectorRef, Component, Inject, Injector, Input, OnInit } from '@angular/core';\nimport { TableElement } from '@e-is/ngx-material-table';\nimport { UserEventFilter, UserEventService } from './user-event.service';\nimport { AccountService } from '../../core/services/account.service';\nimport { UserEvent, UserEventAction, UserEventTypes } from './user-event.model';\nimport { LocalSettingsService } from '../../core/services/local-settings.service';\nimport { toBoolean } from '../../shared/functions';\nimport { Moment } from 'moment';\nimport { AppTable, RESERVED_END_COLUMNS, RESERVED_START_COLUMNS } from '../../core/table/table.class';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport { ModalController, Platform } from '@ionic/angular';\nimport { Location } from '@angular/common';\nimport { EntitiesTableDataSource } from '../../core/table/entities-table-datasource.class';\nimport { SortDirection } from '@angular/material/sort';\nimport { EntitiesStorage } from '../../core/services/storage/entities-storage.service';\nimport { PredefinedColors } from '@ionic/core';\nimport { IEntity } from '../../core/services/model/entity.model';\nimport { ENVIRONMENT } from '../../../environments/environment.class';\n\n\nexport interface UserEventDetail<T extends IEntity<T>> {\n  title: string;\n  description?: string;\n  path?: string;\n\n  action?: string | any;\n  actionTitle?: string;\n  actionColor?: PredefinedColors;\n\n  icon?: string;\n  matIcon?: string;\n  color?: string;\n  cssClass?: string;\n  time?: Moment;\n\n  // A config property, to override the title\n  titleProperty?: string;\n  titleArgs?: {[key: string]: string};\n\n  // conversion\n  fromObject?: (source: any) => T;\n  childrenFields?: string[];\n}\nexport interface UserEventIcon{\n  icon?: string;\n  matIcon?: string;\n  color?: PredefinedColors;\n}\nconst ICONS_MAP: {[key: string]: UserEventIcon } = {\n  DEBUG_DATA: {matIcon: 'bug_report'},\n  INBOX_MESSAGE: {matIcon: 'mail'},\n};\n\n// TODO: refactor with a registration done by data service:\n// - userEventService.registerEventAction({__typename: 'TripVO', ...})\n// - userEventService.getActionsFor(__typename): UserEventDetailAction\n/*const DETAILS_MAP: {[key: string]: UserEventAction<RootDataEntity<any>>} = {\n  \"TripVO\": {\n    icon: null,\n    matIcon: \"content_copy\",\n    action: 'copyToLocal',\n    actionTitle: 'SOCIAL.USER_EVENT.BTN_COPY_TO_LOCAL',\n    actionColor: 'primary',\n    fromObject: Trip.fromObject,\n    childrenFields: ['operation', 'landing']\n  },\n  \"ObservedLocationVO\": {\n    icon: null,\n    matIcon: \"content_copy\",\n    action: 'copyToLocal',\n    actionTitle: 'SOCIAL.USER_EVENT.BTN_COPY_TO_LOCAL',\n    actionColor: 'primary',\n    fromObject: ObservedLocation.fromObject,\n    childrenFields: ['landings']\n  }\n}*/\n\n\n@Component({\n  selector: 'app-user-events-table',\n  styleUrls: ['user-events.table.scss'],\n  templateUrl: './user-events.table.html',\n  changeDetection: ChangeDetectionStrategy.OnPush\n  })\nexport class UserEventsTable extends AppTable<UserEvent, UserEventFilter>\n  implements OnInit {\n\n  dateTimePattern: string;\n  canEdit: boolean;\n  canDelete: boolean;\n  isAdmin: boolean;\n\n  @Input() recipient: string;\n\n  @Input() withContent: boolean;\n  @Input() defaultSortBy: string;\n  @Input() defaultSortDirection: SortDirection;\n\n  constructor(\n    injector: Injector,\n    protected accountService: AccountService,\n    protected service: UserEventService,\n    protected entities: EntitiesStorage,\n    protected cd: ChangeDetectorRef,\n    @Inject(ENVIRONMENT) protected environment\n  ) {\n    super(injector,\n      // columns\n      RESERVED_START_COLUMNS\n        .concat([\n          'creationDate',\n          'icon',\n          'eventType',\n          'message'\n        ])\n        .concat(RESERVED_END_COLUMNS),\n      null,\n      null);\n\n    this.i18nColumnPrefix = 'SOCIAL.USER_EVENT.';\n    this.autoLoad = false; // this.start()\n    this.inlineEdition = false;\n    this.defaultSortBy = 'creationDate';\n    this.defaultSortDirection = 'desc';\n\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n\n    // Load date/time pattern\n    this.dateTimePattern = this.translate.instant('COMMON.DATE_TIME_PATTERN');\n    this.withContent = toBoolean(this.withContent, false);\n\n    const account = this.accountService.account;\n    const pubkey = account && account.pubkey;\n    this.isAdmin = this.accountService.isAdmin();\n    this.canEdit = this.isAdmin || pubkey === this.recipient;\n    this.canDelete = this.canEdit;\n\n    this.setDatasource(new EntitiesTableDataSource(UserEvent,\n      this.service,\n      null,\n      {\n        prependNewElements: false,\n        suppressErrors: true,\n        dataServiceOptions: {\n          withContent: this.withContent\n        }\n      }));\n\n    const filter = this.filter || new UserEventFilter();\n    filter.recipient = this.recipient;\n    this.setFilter(filter, {emitEvent: true});\n  }\n\n  async start() {\n    console.debug('[user-event] Starting...');\n\n    // Waiting account to be ready\n    await this.accountService.ready();\n\n    // Load data\n    this.onRefresh.emit();\n  }\n\n  getIcon(source: UserEvent): UserEventIcon {\n    return ICONS_MAP[source.eventType];\n  }\n\n  getDetail(source: UserEvent): Partial<UserEventDetail<IEntity<any>> & {actions: UserEventAction<any>[]}> {\n    if (!source) return undefined;\n\n    if (source.content && source.eventType === UserEventTypes.DEBUG_DATA) {\n      const context = source.content.context;\n      if (context && context.__typename) {\n        const actions = this.service.getActionsByTypename(context.__typename);\n        return {\n          actions,\n          title: source.content.error && source.content.error.message || source.content.message,\n          description: source.content.error && source.content.error.details || undefined\n        };\n      }\n    }\n\n    console.debug('TODO: implement getDetail() for event: ', source);\n    return {};\n  }\n\n\n  async doAction(action: UserEventAction<any>, row: TableElement<UserEvent>) {\n\n    const event = row.currentData;\n    const context = event.content && event.content.context;\n\n    this.markAsLoading();\n\n    if (action && typeof action.executeAction === 'function') {\n      try {\n        let res = action.executeAction(event, context);\n        res = (res instanceof Promise) ? await res : res;\n      } catch (err) {\n        this.setError(err && err.message || err);\n        console.error(`[user-event] Failed to execute action ${action.name}: ${err && err.message || err}`, err);\n      }\n      finally {\n        this.markAsLoaded();\n      }\n    }\n  }\n\n}\n"]}