@sumaris-net/ngx-components 2.6.4-alpha5 → 2.6.4-alpha6

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

@@ -1,679 +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, empty, merge, Observable, of, Subject, Subscription, timer } from 'rxjs';
-import { IUserEvent, IUserEventFilter } from './user-event.model';
-import { SortDirection } from '@angular/material/sort';
-import { EntitiesServiceLoadOptions, EntitiesServiceWatchOptions, EntityServiceLoadOptions, IEntitiesService, LoadResult, Page } from '../../shared/services/entity-service.class';
-import { distinctUntilChanged, map, mergeMap } 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';
-
-export const APP_USER_EVENT_SERVICE = new InjectionToken<IUserEventService<any, any>>('UserEventService');
-
-export declare interface UserEventLoadOptions extends EntitiesServiceLoadOptions {
-  withContent?: boolean; // Default to false
-}
-export declare interface UserEventWatchOptions extends EntitiesServiceWatchOptions {
-  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>;
-}
-
-export interface IUserEventService<
-  E extends IUserEvent<E, ID>,
-  F extends IUserEventFilter<E, ID>,
-  ID = number,
-  WO extends UserEventWatchOptions = UserEventWatchOptions,
-  LO extends UserEventLoadOptions = UserEventLoadOptions
-  >
-  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?: WO & { interval?: number; fetchPolicy?: FetchPolicy; }): Observable<number>;
-
-  listenAllChanges(filter: Partial<F>, options?: WO & { interval?: number; fetchPolicy?: FetchPolicy; }): Observable<E[]>;
-
-  save(entity: E, options?: EntityServiceLoadOptions): 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 = UserEventWatchOptions,
-  LO extends UserEventLoadOptions = UserEventLoadOptions,
-  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 resetCountDate: Moment;
-  protected listeners: IUserEventListener<E, ID>[] = [];
-  private _subscriptions = new Subscription();
-  private _listenSubscription: Subscription;
-
-  get countSubject(): Subject<number> {
-    return this._countSubject;
-  }
-
-  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._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,
-          // @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: 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,
-          // @ts-ignore
-          sortDirection: (page.sortDirection || 'desc').toUpperCase()
-        },
-        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
-    this.insertIntoMutableCachedQueries(
-      this.graphql.cache,
-      {
-        query: withContent ? this.queries.loadAllWithContent : this.queries.loadAll,
-        data: entity
-      }
-    );
-
-    // 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?: WO & { interval?: number; fetchPolicy?: FetchPolicy }): Observable<number> {
-
-    if (!this.subscriptions?.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.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
-          this._countSubject.next(total);
-          return total;
-        }
-      )
-    );
-
-  }
-
-  listenAllChanges(filter: Partial<F>, opts?: WO & { interval?: number; fetchPolicy?: FetchPolicy; toEntity?: boolean }): 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: 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: (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`);
-      }
-    });
-  }
-
-  async save(entity: E, options?: EntityServiceLoadOptions): Promise<E> {
-    this.fillDefaultProperties(entity);
-
-    // Transform into json
-    const withContent = !!entity.content;
-    const json = entity.asObject();
-
-    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: (proxy, { data }) => {
-        // 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 (withContent) {
-            this.insertIntoMutableCachedQueries(proxy, {
-              query: this.queries.loadAllWithContent,
-              data: savedEntity
-            });
-          } else {
-            this.insertIntoMutableCachedQueries(proxy, {
-              query: this.queries.loadAll,
-              data: {
-                ...savedEntity,
-                content: null
-              }
-            });
-          }
-        }
-      }
-    });
-
-    return entity;
-  }
-
-  async saveAll(entities: E[], opts?: any): 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);
-  }
-
-}

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