@sumaris-net/ngx-components 18.14.0 → 18.14.1

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

@@ -1,686 +0,0 @@
-import { Directive, InjectionToken, OnDestroy } from '@angular/core';
-import { FetchPolicy } from '@apollo/client/core';
-import { SocialErrorCodes } from '../social.errors';
-import { AccountService } from '../../core/services/account.service';
-import { GraphqlService } from '../../core/graphql/graphql.service';
-import { BehaviorSubject, merge, Observable, of, Subscription, timer } from 'rxjs';
-import { IUserEvent, IUserEventFilter } from './user-event.model';
-import { SortDirection } from '@angular/material/sort';
-import {
-  EntitiesServiceLoadOptions,
-  EntitiesServiceWatchOptions,
-  IEntitiesService,
-  LoadResult,
-  Page,
-} from '../../shared/services/entity-service.class';
-import { distinctUntilChanged, map, mergeMap, startWith } from 'rxjs/operators';
-import { isEmptyArray, isNotEmptyArray, isNotNil, toNumber } from '../../shared/functions';
-import { TranslateService } from '@ngx-translate/core';
-import { NetworkService } from '../../core/services/network.service';
-import { BaseGraphqlService, BaseGraphqlServiceOptions } from '../../core/services/base-graphql-service.class';
-import { EntityUtils } from '../../core/services/model/entity.model';
-import { DateUtils } from '../../shared/dates';
-import { Moment } from 'moment';
-import { IStartableService } from '../../shared/services/startable-service.class';
-import { MINIFY_ENTITY_FOR_POD } from '../../core/services/model/referential.model';
-import { DocumentNode } from 'graphql/index';
-import { EntitySaveOptions, MutableWatchQueriesUpdatePolicy } from '../../core/services/base-entity-service.class';
-
-export const APP_USER_EVENT_SERVICE = new InjectionToken<IUserEventService<any, any>>('UserEventService');
-
-export declare interface UserEventLoadOptions<T> extends EntitiesServiceLoadOptions<T> {
-  withContent?: boolean; // Default to false
-}
-export declare interface UserEventWatchOptions<T> extends EntitiesServiceWatchOptions<T> {
-  withContent?: boolean; // Default to false
-}
-export interface IUserEventQueries {
-  loadAll: any;
-  loadAllWithContent: any;
-  count?: any;
-}
-
-export interface IUserEventMutations {
-  save: any;
-  markAsRead?: any;
-  deleteByIds: any;
-}
-
-export interface IUserEventSubscriptions {
-  listenAllChanges: any;
-  listenCountChanges?: any;
-}
-
-export interface IUserEventListener<E extends IUserEvent<E, ID>, ID = number> {
-  accept: (E) => boolean;
-  onReceived?: (E) => Promise<E> | E | undefined;
-  onRead?: (E) => Promise<void> | void;
-}
-
-export interface UserEventServiceOptions<
-  Q extends IUserEventQueries = IUserEventQueries,
-  M extends IUserEventMutations = IUserEventMutations,
-  S extends IUserEventSubscriptions = IUserEventSubscriptions,
-> extends BaseGraphqlServiceOptions {
-  queries: Q;
-  mutations?: Partial<M>;
-  subscriptions?: Partial<S>;
-  watchQueriesUpdatePolicy?: MutableWatchQueriesUpdatePolicy;
-}
-
-export interface IUserEventService<
-  E extends IUserEvent<E, ID>,
-  F extends IUserEventFilter<E, ID>,
-  ID = number,
-  WO extends UserEventWatchOptions<E> = UserEventWatchOptions<E>,
-  LO extends UserEventLoadOptions<E> = UserEventLoadOptions<E>,
-> extends IEntitiesService<E, F, WO>,
-    IStartableService {
-  countSubject: Observable<number>;
-
-  add(entity: E): Promise<E>;
-
-  load(id: ID, opts?: LO): Promise<E>;
-
-  count(filter: Partial<F>, options?: { fetchPolicy?: FetchPolicy }): Promise<number>;
-
-  listenCountChanges(filter: Partial<F>, options?: Omit<LO, 'toEntity'> & { interval?: number }): Observable<number>;
-
-  listenAllChanges(filter: Partial<F>, options?: LO & { interval?: number }): Observable<E[]>;
-
-  save(entity: E, options?: EntitySaveOptions<E>): Promise<E>;
-
-  delete(entity: E): Promise<any>;
-
-  markAllAsRead(entities: E[]);
-
-  registerListener(listener: IUserEventListener<E, ID>);
-
-  resetCount();
-}
-
-@Directive()
-export abstract class AbstractUserEventService<
-    E extends IUserEvent<E, ID, any>,
-    F extends IUserEventFilter<E, ID, any>,
-    ID = number,
-    WO extends UserEventWatchOptions<E> = UserEventWatchOptions<E>,
-    LO extends UserEventLoadOptions<E> = UserEventLoadOptions<E>,
-    Q extends IUserEventQueries = IUserEventQueries,
-    M extends IUserEventMutations = IUserEventMutations,
-    S extends IUserEventSubscriptions = IUserEventSubscriptions,
-  >
-  extends BaseGraphqlService<E, F, ID>
-  implements IUserEventService<E, F, ID, WO, LO>, OnDestroy
-{
-  protected readonly queries: Q;
-  protected readonly mutations: Partial<M>;
-  protected readonly subscriptions: Partial<S>;
-  protected readonly _countSubject = new BehaviorSubject<number>(0);
-  protected readonly watchQueriesUpdatePolicy: MutableWatchQueriesUpdatePolicy;
-  protected resetCountDate: Moment;
-  protected listeners: IUserEventListener<E, ID>[] = [];
-  private _subscriptions = new Subscription();
-  private _listenSubscription: Subscription;
-
-  get countSubject(): Observable<number> {
-    return this._countSubject.pipe(startWith(this._countSubject.getValue()), distinctUntilChanged());
-  }
-
-  protected constructor(
-    protected graphql: GraphqlService,
-    protected accountService: AccountService,
-    protected network: NetworkService,
-    protected translate: TranslateService,
-    protected options: UserEventServiceOptions<Q, M, S>
-  ) {
-    super(graphql, options);
-    this.queries = options.queries;
-    this.mutations = options.mutations || <Partial<M>>{};
-    this.subscriptions = options.subscriptions || <Partial<S>>{};
-    this.watchQueriesUpdatePolicy = options.watchQueriesUpdatePolicy || 'update-cache';
-    this._logPrefix = '[user-event-service] ';
-  }
-
-  protected async ngOnStart(): Promise<void> {
-    // Update component when refresh is need (=login events)
-    this._subscriptions.add(
-      merge(
-        this.accountService.onLogin,
-        this.accountService.onLogout,
-        timer(1000) // Starts with -  first attempt if account is ready
-      )
-        .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();
-          }
-        })
-    );
-  }
-
-  ngOnDestroy() {
-    this._subscriptions.unsubscribe();
-  }
-
-  abstract asFilter(filter: Partial<F>): F;
-
-  abstract fromObject(source: any): E;
-
-  watchAll(
-    offset: number,
-    size: number,
-    sortBy?: string,
-    sortDirection?: SortDirection,
-    filter?: Partial<F>,
-    options?: WO
-  ): Observable<LoadResult<E>> {
-    return this.watchPage(<Page>{ offset, size, sortBy, sortDirection }, filter, options);
-  }
-
-  watchPage(page: Page, filter?: Partial<F>, opts?: WO): Observable<LoadResult<E>> {
-    let now = this._debug && Date.now();
-    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 (isEmptyArray(filter?.recipients) || !this.accountService.isAdmin()) {
-      const recipient = this.defaultRecipient();
-      if (!filter?.recipients?.includes(recipient)) {
-        console.warn('[user-events-service] Force user event filter.recipient=' + recipient);
-        filter.recipients = [recipient];
-      }
-    }
-
-    const withContent = opts?.withContent === true;
-
-    return this.mutableWatchQuery<LoadResult<E>, { filter: any; page: Page }>({
-      queryName: withContent ? 'LoadAllWithContent' : 'LoadAll',
-      query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,
-      variables: {
-        page: {
-          sortBy: 'creationDate',
-          ...page,
-          sortDirection: (page.sortDirection || 'desc').toUpperCase() as SortDirection,
-        },
-        filter: filter && filter.asPodObject(),
-      },
-      arrayFieldName: 'data',
-      error: { code: SocialErrorCodes.LOAD_USER_EVENTS_ERROR, message: 'SOCIAL.ERROR.LOAD_USER_EVENTS_ERROR' },
-      fetchPolicy: opts?.fetchPolicy || 'cache-first',
-      insertFilterFn: filter && filter.asFilterFn(),
-    }).pipe(
-      mergeMap(async (res) => {
-        let data = await Promise.all((res?.data || []).map((value) => this.processUserEvent(value)));
-
-        if (now) {
-          console.debug(`${this._logPrefix}${data.length} user events loaded in ${Date.now() - now}ms`);
-          now = null;
-        }
-
-        // Must re-order because of listenAllChanges result will add new event at the end
-        data = EntityUtils.sort(data, page.sortBy, page.sortDirection);
-
-        const result = <LoadResult<E>>{
-          data,
-          total: toNumber(res?.total, data.length),
-        };
-
-        // Add fetch more capability, if total was fetched
-        if (isNotNil(res.total)) {
-          const nextOffset = (page.offset || 0) + data.length;
-          if (nextOffset < result.total) {
-            result.fetchMore = (_) =>
-              this.loadPage({ ...page, offset: nextOffset }, filter, { ...opts, fetchPolicy: <FetchPolicy>'no-cache' } as unknown as LO);
-          }
-        }
-
-        return result;
-      })
-    );
-  }
-
-  async loadPage(page: Page, filter?: Partial<F>, opts?: LO): Promise<LoadResult<E>> {
-    const now = this._debug && Date.now();
-    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 (isEmptyArray(filter?.recipients) || !this.accountService.isAdmin()) {
-      const recipient = this.defaultRecipient();
-      if (!filter?.recipients?.includes(recipient)) {
-        console.warn('[user-events-service] Force user event filter.recipient=' + recipient);
-        filter.recipients = [recipient];
-      }
-    }
-
-    const withContent = opts?.withContent === true;
-
-    const res = await this.graphql.query<LoadResult<E>>({
-      query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,
-      variables: {
-        page: {
-          sortBy: 'creationDate',
-          ...page,
-          sortDirection: (page.sortDirection || 'desc').toUpperCase() as SortDirection,
-        },
-        filter: filter && filter.asPodObject(),
-      },
-      error: { code: SocialErrorCodes.LOAD_USER_EVENTS_ERROR, message: 'SOCIAL.ERROR.LOAD_USER_EVENTS_ERROR' },
-      fetchPolicy: opts?.fetchPolicy,
-    });
-    let data = await Promise.all((res?.data || []).map((value) => this.processUserEvent(value)));
-
-    if (now) console.debug(`${this._logPrefix}${data.length} user events loaded in ${Date.now() - now}ms`);
-
-    // Must re-order because of listenAllChanges result will add new event at the end
-    data = EntityUtils.sort(data, page.sortBy, page.sortDirection);
-
-    const result = <LoadResult<E>>{
-      data,
-      total: toNumber(res?.total, data.length),
-    };
-
-    // Add fetch more capability, if total was fetched
-    if (isNotNil(res.total)) {
-      const nextOffset = (page.offset || 0) + data.length;
-      if (nextOffset < result.total) {
-        result.fetchMore = (_) => this.loadPage({ ...page, offset: nextOffset }, filter, opts);
-      }
-    }
-
-    return result;
-  }
-
-  async load(id: ID, opts?: LO): Promise<E> {
-    const filter = this.defaultFilter();
-    filter.includedIds = [id];
-    const { data } = await this.loadPage({ offset: 0, size: 1 }, filter, opts);
-    return data && data[0];
-  }
-
-  async add(entity: E): Promise<E> {
-    entity = await this.processUserEvent(entity);
-
-    if (!entity) return; // Rejected
-
-    const withContent = !!entity.content;
-
-    // Add user event locally
-    if (this.watchQueriesUpdatePolicy === 'update-cache') {
-      if (withContent) {
-        this.insertIntoMutableCachedQueries(this.graphql.cache, {
-          query: this.queries.loadAllWithContent,
-          data: entity,
-        });
-      }
-      this.insertIntoMutableCachedQueries(this.graphql.cache, {
-        query: this.queries.loadAll,
-        data: {
-          ...entity,
-          content: null,
-        },
-      });
-    }
-
-    // Update count
-    this._countSubject.next(this._countSubject.value + 1);
-
-    // Add id
-    //console.log('TODO: add an ID to user event ?');
-
-    return entity;
-  }
-
-  async count(filter: Partial<F>, options?: { fetchPolicy?: FetchPolicy }): Promise<number> {
-    if (!this.queries?.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 = await this.graphql.query<{ total: number }>({
-      query: this.queries.count,
-      variables: {
-        filter: filter.asPodObject(),
-      },
-      error: { code: SocialErrorCodes.COUNT_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.COUNT_USER_EVENT_ERROR' },
-      fetchPolicy: options?.fetchPolicy || 'network-only',
-    });
-    return res.total;
-  }
-
-  listenCountChanges(filter: Partial<F>, options?: Omit<LO, 'toEntity'> & { interval?: number }): Observable<number> {
-    if (!this.subscriptions?.listenCountChanges) {
-      console.warn(`${this._logPrefix}Subscription query 'listenCountChanges' not provided, skip.`);
-      return of();
-    }
-
-    const isDefault = !filter;
-    if (isDefault) filter = this.defaultFilter();
-    // Apply last reset date as start date
-    filter.startDate = this.resetCountDate;
-    filter.excludeRead = true;
-    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<{ total: number }, { filter: any; interval: number }>({
-        query: this.subscriptions.listenCountChanges,
-        fetchPolicy: options?.fetchPolicy,
-        variables: { filter: filter.asPodObject(), interval: toNumber(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
-          if (isDefault) this._countSubject.next(total);
-
-          return total;
-        })
-      );
-  }
-
-  listenAllChanges(filter: Partial<F>, opts?: LO & { interval?: number }): Observable<E[]> {
-    if (!this.subscriptions?.listenAllChanges) {
-      console.warn(`${this._logPrefix}Subscription query 'listenAllChanges' not provided, skip.`);
-      return of();
-    }
-
-    if (!filter) filter = this.defaultFilter();
-    filter = this.asFilter(filter);
-
-    const withContent = opts?.withContent === true;
-
-    if (this._debug) console.debug(`${this._logPrefix}[WS] Listening changes for user events with filter:`, filter);
-
-    return this.graphql
-      .subscribe<{ data: any[] }, { filter: any; interval: number }>({
-        query: this.subscriptions.listenAllChanges,
-        fetchPolicy: opts?.fetchPolicy,
-        variables: { filter: filter.asPodObject(), interval: toNumber(opts?.interval, 10) },
-        error: {
-          code: SocialErrorCodes.SUBSCRIBE_USER_EVENTS_ERROR,
-          message: 'SOCIAL.ERROR.SUBSCRIBE_USER_EVENTS_ERROR',
-        },
-      })
-      .pipe(
-        mergeMap(async ({ data }) => {
-          if (data && this._debug) console.debug(`${this._logPrefix}Received new user events:`, data);
-
-          // Update cache (will update watchAll queries)
-          if (isNotEmptyArray(data)) {
-            this.insertIntoMutableCachedQueries(this.graphql.cache, {
-              query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,
-              data,
-            });
-          }
-
-          // Convert to entities
-          if (!opts || opts.toEntity !== false) {
-            return await Promise.all((data || []).map((value) => this.processUserEvent(value)));
-          } else {
-            return data;
-          }
-        })
-      );
-  }
-
-  async delete(entity: E): Promise<any> {
-    if (!entity) return; // skip
-    await this.deleteAll([entity]);
-  }
-
-  async deleteAll(entities: E[], opts?: any): Promise<any> {
-    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);
-
-    await this.graphql.mutate<any>({
-      mutation: this.mutations.deleteByIds,
-      variables: {
-        ids,
-      },
-      update: (cache) => {
-        // Remove from cache
-        if (this.watchQueriesUpdatePolicy === 'update-cache') {
-          this.removeFromMutableCachedQueriesByIds(cache, {
-            queries: this.getLoadQueries(),
-            ids,
-          });
-        }
-
-        if (this._debug) console.debug(`${this._logPrefix}Events deleted in ${Date.now() - now}ms`);
-      },
-    });
-  }
-
-  async save(entity: E, opts?: EntitySaveOptions<E>): Promise<E> {
-    this.fillDefaultProperties(entity);
-
-    // Transform into json
-    const withContent = !!entity.content;
-    const json = entity.asObject(MINIFY_ENTITY_FOR_POD);
-
-    const now = Date.now();
-    if (this._debug) console.debug(`${this._logPrefix}Saving user event...`, json);
-
-    await this.graphql.mutate<{ data: any }>({
-      mutation: this.mutations.save,
-      variables: {
-        data: json,
-      },
-      error: { code: SocialErrorCodes.SAVE_USER_EVENT_ERROR, message: 'SOCIAL.ERROR.SAVE_USER_EVENT_ERROR' },
-      update: (cache, { data }, { context, variables }) => {
-        // Update entity
-        const savedEntity = data && data.data;
-        if (savedEntity) {
-          if (this._debug) console.debug(`${this._logPrefix}User event saved in ${Date.now() - now}ms`, entity);
-          this.copyIdAndUpdateDate(savedEntity, entity);
-
-          // Add to cache
-          if (this.watchQueriesUpdatePolicy === 'update-cache') {
-            if (withContent) {
-              this.insertIntoMutableCachedQueries(cache, {
-                query: this.queries.loadAllWithContent,
-                data: savedEntity,
-              });
-            }
-            this.insertIntoMutableCachedQueries(cache, {
-              query: this.queries.loadAll,
-              data: {
-                ...savedEntity,
-                content: null,
-              },
-            });
-          }
-
-          if (opts?.update) {
-            opts.update(cache, { data }, { context, variables });
-          }
-        }
-      },
-    });
-
-    return entity;
-  }
-
-  async saveAll(entities: E[], opts?: EntitySaveOptions<E>): Promise<E[]> {
-    return Promise.all(entities.map((entity) => this.save(entity, opts)));
-  }
-
-  async markAllAsRead(entities: E[]) {
-    const userEventWithoutReadListeners: E[] = [];
-    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) {
-          await listener.onRead(entity);
-        }
-      } else {
-        // Add to this list for default operation
-        userEventWithoutReadListeners.push(entity);
-      }
-    }
-
-    // Use default
-    await this.defaultMarkAsRead(userEventWithoutReadListeners);
-  }
-
-  registerListener(listener: IUserEventListener<E, ID>) {
-    if (!this.listeners) this.listeners = [];
-    this.listeners.push(listener);
-  }
-
-  resetCount() {
-    this._countSubject.next(undefined);
-    this.resetCountDate = DateUtils.moment();
-    // restart listening count changes
-    this.startListenCountChanges();
-  }
-
-  /* -- protected methods -- */
-
-  protected async onLogin() {
-    // Get first count
-    const count = await this.count(undefined);
-    if (this._debug) console.debug(`${this._logPrefix}Receiving user events count`, count);
-    // Update count
-    this._countSubject.next(count);
-
-    // Then listen changes
-    this.startListenCountChanges();
-  }
-
-  protected onLogout() {
-    // Reset counter
-    this._countSubject.next(0);
-    // Stop listening
-    this.stopListenCountChanges();
-  }
-
-  protected startListenCountChanges() {
-    this.stopListenCountChanges();
-    this._listenSubscription = this.listenCountChanges(undefined).subscribe();
-  }
-
-  protected stopListenCountChanges() {
-    this._listenSubscription?.unsubscribe();
-    this._listenSubscription = undefined;
-  }
-
-  protected async processUserEvent(source: any): Promise<E> {
-    // Convert json source to IUserEvent
-    let target = this.fromObject(source);
-
-    // Get listeners
-    const listeners = (this.listeners || []).filter((listener) => !!listener.onReceived).filter((listener) => listener.accept(target));
-    for (const listener of listeners) {
-      if (target) {
-        const res = listener.onReceived(target);
-        target = res instanceof Promise ? await res : res;
-      } else {
-        if (this._debug) console.debug(`${this._logPrefix}Event has been rejected by a listener`, source);
-        break;
-      }
-    }
-
-    return target;
-  }
-
-  protected async defaultMarkAsRead(userEvents: E[]) {
-    if (!userEvents) throw new Error(`${this._logPrefix}Invalid event to save`);
-    if (!userEvents.length) return;
-
-    // set read date
-    userEvents.forEach((userEvent) => (userEvent.readDate = DateUtils.moment()));
-
-    // split local/remote entities
-    const localEntities = userEvents.filter(EntityUtils.isLocal);
-    const remoteEntities = userEvents.filter(EntityUtils.isRemote);
-
-    // 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 (!this.mutations?.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);
-
-      await this.graphql.mutate<{ data: any }>({
-        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);
-    }
-  }
-
-  protected defaultFilter(): F {
-    // By default
-    return <F>{
-      recipients: [this.defaultRecipient()],
-    };
-  }
-
-  protected abstract defaultRecipient(): any;
-
-  protected fillDefaultProperties(entity: E) {}
-
-  protected unreadEvents(events: E[]): number {
-    // 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 as Moment);
-    return events.filter((event) => event.creationDate.isSameOrAfter(lastReadDate)).length;
-  }
-
-  protected copyIdAndUpdateDate(source: E, target: E) {
-    EntityUtils.copyIdAndUpdateDate(source, target);
-  }
-
-  protected getLoadQueries(): DocumentNode[] {
-    return [this.queries.loadAll, this.queries.loadAllWithContent].filter(isNotNil);
-  }
-}

package/src/browserslist

@@ -1,9 +0,0 @@
-# This file is currently used by autoprefixer to adjust CSS to support the below specified browsers
-# For additional information regarding the format and rule options, please see:
-# https://github.com/browserslist/browserslist#queries
-# For IE 9-11 support, please uncomment the last line of the file and adjust as needed
-# > 0.5%
-# last 2 versions
-Firefox ESR
-not dead
-not IE 9-11