@bizdoc/core 1.14.9 → 1.14.10

package/src/lib/core/lottie-animation.ts

@@ -1,37 +0,0 @@
-import { Component, OnInit, ElementRef, Input } from '@angular/core';
-import { AnimationConfig, AnimationItem } from 'lottie-web';
-
-import player from 'lottie-web/build/player/lottie';
-
-@Component({
-  selector: 'lottie', template: '',
-  host: {
-    style: 'display:block',
-    '[style.width]': 'size',
-    '[style.height]': 'size'
-  }
-})
-export
-  class LottieAnimation implements OnInit {
-  private _instance: AnimationItem;
-  @Input() name!: string;
-  @Input() size: string = '100px';
-  @Input() autoplay: boolean = true;
-  constructor(private _element: ElementRef) { }
-  ngOnInit(): void {
-    this._instance = player.loadAnimation({
-      container: this._element.nativeElement,
-      renderer: 'svg',
-      loop: true,
-      autoplay: this.autoplay,
-      width: '20px',
-      rendererSettings: {
-        //className: ''        
-      },
-      background: "transparent",
-      path: `assets/animations/${this.name}.json`
-    } as AnimationConfig);
-    this._instance.show();
-  }
-  play() { this._instance.play(); }
-}

package/src/lib/core/mailbox.service.ts

@@ -1,471 +0,0 @@
-import { Injectable, InjectionToken } from '@angular/core';
-import {
-  HttpClient, HttpEvent,
-  HttpEventType,
-  HttpProgressEvent, HttpRequest, HttpResponse
-} from '@angular/common/http';
-import { Comment, UserInfo, RecipientModel, Attachment, ScheduledEvent, HeaderModel, DocumentModel, Vote, CommentVersion, Chain } from './models';
-import { SessionService } from './session.service';
-import { Observable, Subject } from 'rxjs';
-import { tap, switchMap, map } from 'rxjs/operators';
-import { cleanup, isArray } from './functions';
-import { HubService } from './hub.service';
-import { AuthenticationImpl } from './authentication';
-import { SafeUrl } from '@angular/platform-browser';
-
-export const DOCUMENT_MODEL = new InjectionToken<DocumentModel<any>>('model');
-
-export type FilterType = 'recent' | 'unread' | 'flagged';
-
-export interface ChangeEvent<T> {
-  model: RecipientModel<T>;
-}
-
-@Injectable({ providedIn: 'root' })
-export class MailboxService {
-  private readonly _change$ = new Subject<RecipientModel<any>>();
-  private readonly _delete$ = new Subject<number>();
-  /** */
-  public readonly changed = this._change$.asObservable();
-  public readonly deleted = this._delete$.asObservable();
-  constructor(private _session: SessionService,
-    private _auth: AuthenticationImpl,
-    messaging: HubService,
-    private _http: HttpClient) {
-    messaging.new$.
-      subscribe(m => {
-        if (m.userId !== _session.profile.userId) return;
-        _session.profile.inboxCount++;
-        const folder = _session.profile.folders.find(f => f.name === m.model.folderId);
-        folder.count++;
-      });
-  }
-  formatDownloadUrl(documentId: number, fileId: number, inline?: boolean): string {
-    const token = this._auth.getAccessToken();
-    return `/api/attachments/${documentId}/${fileId}?access_token=${token}&inline=${inline ? true : false}`;
-  }
-  download(documentId: number, fileId: number): Observable<any> {
-    //new Observable<any>(observe => {
-    //  observe.next({});
-    //  return {
-    //    unsubscribe() { }
-    //  }
-    //});
-    return this._http.get(`/api/attachments/${documentId}/${fileId}`, {
-      responseType: 'arraybuffer',
-      reportProgress: true
-    });
-  }
-  removeattachment(recipientId: number, fileId: number): Observable<any> {
-    return this._http.delete(`/api/attachments/${recipientId}/${fileId}`);
-  }
-  read(id: number, read: boolean, folderId?: string, received?: Date): Observable<any> {
-    return this._http.put(`/api/mailbox/read/${id}`, undefined, { params: { read } as any }).pipe(tap(() =>
-      folderId && this._updateunreadcounter(received, folderId, read ? 1 : -1)
-    ));
-  }
-  comments(id: number, before: Date): Observable<Comment[]> {
-    return this._http.get<Comment[]>(`/api/comments/${id}`, { params: { before: new Date(before).toJSON() } });
-  }
-  tags(id: number, tags: string[]): Observable<any> {
-    return this._http.put(`/api/mailbox/tag/${id}`, { tags }).pipe(tap(() => {
-      this._change$.next({ id, tags } as any);
-    }));
-  }
-  /**
-   * 
-   * @param documentId
-   * @param stateId
-   * @param userId substitute
-   */
-  changeState(documentId: number, stateId: string, userId?: string): Observable<any> {
-    return this._http.put(`/api/mailbox/changestate/${documentId}`, { stateId, userId });
-  }
-  move(id: number, folderId: string): Observable<any> {
-    return this._http.put(`/api/mailbox/move/${id}?folderId=${folderId}`, {}).pipe(tap(() => {
-      this._change$.next({
-        id,
-        folderId
-      } as any);
-    }));
-  }
-  checkOut(recipientId: number, version: number, attachmentId: number) {
-    return this._http.put<Attachment>(`/api/attachments/${recipientId}/${attachmentId}/checkout`, null, { params: { version } });
-  }
-  checkIn(recipientId: number, version: number, attachmentId: number, file: File): Observable<Attachment> {
-    const fd = new FormData();
-    fd.append(file.name, file);
-    const req = new HttpRequest('PUT',
-      `/api/attachments/${recipientId}/${attachmentId}/checkin?version=${version}`, fd, {
-      reportProgress: true,
-    });
-    //const initialState: UploadEvent = { state: 'PENDING', progress: 0 }
-    //const calculateState = (
-    //  upload: UploadEvent,
-    //  event: HttpEvent<unknown>
-    //): UploadEvent => {
-    //  // implementation
-    //}
-    return new Observable<any>(observe => {
-      this._http.request(req).subscribe(event => {
-        if (event instanceof ProgressEvent) {
-          //  observe.next(new UploadEvent(
-          //    file.name,
-          //    (event as ProgressEvent).loaded,
-          //    (event as ProgressEvent).total
-          //  ));
-        } else if (event instanceof HttpResponse) {
-          const res = event as HttpResponse<any>;
-          if (res.status === 200) {
-            const model = res.body as Attachment;
-            observe.next(model);
-          }
-          else
-            observe.error({ status: res.status, error: res.body });
-          observe.complete();
-        }
-      }, e => {
-        observe.error(e);
-        observe.complete();
-      });
-      return {
-        unsubscribe() {
-          //req.
-        }
-      }
-    });
-  }
-  upload(recipientId: number, formId: string, version: number, file: File, options?: { isPrivate?: boolean }): Observable<Attachment>;
-  upload(recipientId: number, formId: string, version: number, files: File[], options?: { isPrivate?: boolean }): Observable<Attachment[]>;
-  upload(recipientId: number, formId: string, version: number, files: File | File[], options?: { isPrivate?: boolean }): Observable<Attachment | Attachment[]> {
-    const fd = new FormData();
-    if (isArray(files)) files.forEach(f =>
-      fd.append(f.name, f));
-    else fd.append(files.name, files);
-    //const bytesPerChunk = 20 * 1024 * 1024;
-    // aquire the location prior to sending the request
-    return this._geoLocation(formId).pipe(switchMap(params =>
-      new Observable<any>(observe => {
-        let url = `/api/attachments/${recipientId}?version=${version}`;
-        Object.keys(params).forEach(p => url += `&${p}=${params[p]}`);
-        if (options) {
-          if (options.isPrivate) url += '&isprivate=true'
-        }
-        const req = new HttpRequest('POST', url, fd, {
-          reportProgress: true,
-        });
-        this._http.request(req).subscribe(event => {
-          if (event instanceof ProgressEvent) {
-            // This is an upload progress event. Compute and show the % done:
-            //const percentDone = Math.round(100 * event.loaded / event.total);
-            //console.log(`File is ${percentDone}% uploaded.`);
-          } else if (event instanceof HttpResponse) {
-            const res = event as HttpResponse<any>;
-            if (res.status === 200) {
-              const model = res.body as Attachment[];
-              observe.next(isArray(files) ? model : model[0]);
-            }
-            else
-              observe.error({ status: res.status, error: res.body });
-            observe.complete();
-          }
-        }, e => {
-          observe.error(e);
-          observe.complete();
-        });
-        return {
-          unsubscribe() {
-          }
-        }
-      })));
-  }
-  /**
-   * retrieve senders
-   * @param name
-   */
-  senders(name: string): Observable<UserInfo[]> {
-    return this._http.get<UserInfo[]>('/api/mailbox/senders/', {
-      params: {
-        name
-      }
-    });
-  }
-  flag(id: number, flag: boolean): Observable<any> {
-    return this._http.put(`/api/mailbox/flag/${id}?flag=${flag}`, null).pipe(tap(() => this._change$.next({ id, flag } as any)));
-  }
-  viewedcomments(id: number): Observable<{ time: Date }> {
-    return this._http.put<{ time: Date }>(`/api/comments/viewed/${id}`, {}, { headers: { 'no-progress': 'true' } }).pipe(tap((e: { time: Date }) => this._change$.next({ id, viewed: e.time } as any)));
-  }
-  typing(id: number): Promise<any> {
-    return this._http.put(`/api/comments/typing/${id}`, {}, { headers: { 'no-progress': 'true' } }).toPromise();
-  }
-  editing(id: number): Promise<any> {
-    return this._http.put(`/api/mailbox/editing/${id}`, {}, { headers: { 'no-progress': 'true' } }).toPromise();
-  }
-  copy(id: number): Observable<RecipientModel<any>> {
-    return this._http.post<RecipientModel<any>>(`/api/mailbox/copy/${id}`, {});
-  }
-  /**
-   * 
-   * @param id document id
-   * @param options
-   */
-  comment(id: number, options: {
-    text?: string,
-    resource?: { [key: string]: any },
-    image?: string,
-    parentId?: number
-  }): Observable<Comment> {
-    return this._http.post<Comment>(`/api/comments/${id}`, options);
-  }
-  commentupdate(id: number, commentId: number, options: {
-    text?: string,
-    image?: string,
-    resource?: { [key: string]: any }
-  }): Observable<Comment> {
-    return this._http.put<Comment>(`/api/comments/edit/${id}/${commentId}`, options);
-  }
-  info<T = any>(documentId: number): Observable<DocumentModel<T>> {
-    return this._http.get<DocumentModel<T>>(`/api/mailbox/info/${documentId}`);
-  }
-  timeline(documentId: number): Observable<Chain> {
-    return this._http.get<Chain>(`/api/mailbox/timeline/${documentId}`);
-  }
-  vote(id: number, commentId: number, value: number): Observable<any> {
-    return this._http.post(`/api/comments/vote/${id}/${commentId}`, {}, { params: { value: value.toString() } });
-  }
-  votes(id: number, commentId: number): Observable<Vote[]> {
-    return this._http.get<Vote[]>(`/api/comments/votes/${id}/${commentId}`);
-  }
-  edits(id: number, commentId: number): Observable<CommentVersion[]> {
-    return this._http.get<CommentVersion[]>(`/api/comments/edits/${id}/${commentId}`);
-  }
-  findAll(filter: { type?: FilterType; contains?: string; state?: string; form?: string; folderId?: string; senderId?: string; },
-    options?: { skip?: number; take?: number; orderBy?: 'value' | 'viewed' | 'date' }): Observable<HeaderModel[]> {
-    const params: any = { ...filter, ...options };
-    cleanup(params);
-    return this._http.get<HeaderModel[]>('/api/mail', { params });
-  }
-  create<T = any>(form: string): Observable<RecipientModel<T>> {
-    return this._geoLocation(form).pipe(switchMap(p =>
-      this._http.post<RecipientModel<any>>('/api/mail', null, {
-        params: {
-          form,
-          ...p
-        }
-      })), this._notify<T>());
-  }
-  get<T = any>(id: number, read?: boolean): Observable<RecipientModel<T>> {
-    return this._http.get<RecipientModel<T>>(`/api/mail/${id}`).pipe(
-      tap((m: RecipientModel) =>
-        read === false && m.read === true &&
-        this._updateunreadcounter(m.received, m.folderId, -1)
-      ));
-  }
-  private _updateunreadcounter(date: Date, folderId: string, val: number) {
-    if (
-      // date is above watermark
-      this._session.profile.options.inboxView &&
-      this._session.profile.options.inboxView < date
-    )
-      this._session.profile.inboxCount += val;
-    // decrease
-    const folder = this._session.profile.folders.
-      find(f => f.name === folderId);
-    folder.count = Math.max(0, folder.count + val);
-  }
-
-  save<T = any>(id: number, form: string, version: number, model: {}, files?: File[] | FileList): Observable<RecipientModel<T>> {
-    //const fd = new FormData();
-    //const modelBlob = new Blob([JSON.stringify(model)], {
-    //  type: 'application/json',
-    //});
-    //fd.append('form-data', modelBlob);
-    //if (files) {
-    //  if (isArray(files)) files.forEach(f =>
-    //    fd.append(f.name, f));
-    //  else for (let i = 0; i < files.length; i++) {
-    //    let file = files.item(i);
-    //    fd.append(file.name, file);
-    //  }
-    //}
-    //  return this._withGeoLocation(form).pipe(switchMap(params => {
-    //    let url = `/api/mail/${id}?version=${version}`;
-    //    Object.keys(params).forEach(p => url += `&${p}=${params[p]}`);
-    //    const req = new HttpRequest('PUT', url, fd, {
-    //    });
-    //    return this._http.request(req).pipe(map(event => {
-    //      const res = event as HttpResponse<any>;
-    //      if (res.status === 200) {
-    //        const model = res.body as RecipientModel<any>;
-    //        return model;
-    //      }
-    //      else
-    //        return throwError({ status: res.status, error: res.body });
-    //    }))
-    //  }), this._notify<T>());
-    return this._geoLocation(form).pipe(
-      switchMap(params =>this._http.put<RecipientModel<T>>(`/api/mail/${id}?version=${version}`, model, { params })),
-      this._notify<T>());
-  }
-  delete(id: number): Observable<any> {
-    return this._http.delete(`/api/mail/${id}`).pipe(tap(() =>
-      this._delete$.next(id)));
-  }
-  removecomment(id: number): Observable<any> {
-    return this._http.delete(`/api/comments/${id}`);
-  }
-  submit<T = any>(id: number, version: number, form: string, model?: any, read?: boolean, folderId?: string, received?: Date): Observable<RecipientModel<T>> {
-    return this._geoLocation(form).pipe(switchMap(params =>
-      this._http.put<RecipientModel<any>>(`/api/mail/${id}?version=${version}&go=true`, model, { params }))).pipe(
-        this._notify<T>());
-  }
-  send<T = any>(id: number, version: number, form: string, model: any, action: string, actionArgs: {}, read?: boolean, folderId?: string, received?: Date): Observable<RecipientModel<T>> {
-    return this._geoLocation(form).pipe(switchMap(params =>
-      this._http.put<RecipientModel<T>>(`/api/mail/${id}?version=${version}&action=${action}`, model, { params: { ...params, ...actionArgs } }))).pipe(
-        tap(() =>
-          read === false && this._updateunreadcounter(received, folderId, -1)
-        ),
-        this._notify<T>());
-  }
-  events(starting: Date, ending?: Date, contains?: string): Observable<ScheduledEvent[]> {
-    return this._http.get<ScheduledEvent[]>(`/api/events`, {
-      params: {
-        starting: starting.toJSON(),
-        ending: ending.toJSON(),
-        contains: contains || ''
-      }
-    });
-  }
-  changeEvent(id: number, options: { starting: Date; ending?: Date; complete?: boolean }): Observable<any> {
-    return this._http.put(`/api/events/${id}`, options);
-  }
-  /**
-   * get geo location if form settings requies
-   * @param form
-   */
-  private _geoLocation(form: string): Observable<{ lng?: string; lat?: string }> {
-    const configuration = this._session.profile.forms.find(f => f.name === form);
-    return new Observable<any>(observe => {
-      switch (configuration.position) {
-        case 'Require':
-        case 'Ask':
-          navigator.geolocation.getCurrentPosition(r => {
-            observe.next({
-              lng: r.coords.longitude.toString(),
-              lat: r.coords.latitude.toString()
-            });
-            observe.complete();
-          }, e => {
-            if (configuration.position === 'Ask')
-              observe.next({});
-            else
-              observe.error('no position');
-            observe.complete();
-          });
-          break;
-        default:
-          observe.next({});
-          observe.complete();
-      }
-    });
-  }
-  /**
-   */
-  private _notify = <T>() => (observe: Observable<RecipientModel<T>>) => {
-    return observe.pipe(tap(m => {
-      (m as ItemExtra).loaded = true;
-      this._change$.next(m);
-    }));
-  };
-}
-export interface ItemExtra {
-  loading?: boolean;
-  loaded?: boolean;
-  working?: boolean;
-}
-export interface AttachmentExtra extends Attachment {
-  url: SafeUrl;
-  icon?: string;
-  fileExt: string;
-  isImage: boolean;
-  progress?: number;
-  viewed?: Date;
-  failed?: boolean;
-}
-function isHttpResponse<T>(event: HttpEvent<T>): event is HttpResponse<T> {
-  return event.type === HttpEventType.Response
-}
-
-function isHttpProgressEvent(
-  event: HttpEvent<unknown>
-): event is HttpProgressEvent {
-  return (
-    event.type === HttpEventType.DownloadProgress ||
-    event.type === HttpEventType.UploadProgress
-  )
-}
-function calculateState(upload: UploadEvent, event: HttpEvent<unknown>): UploadEvent {
-  if (isHttpProgressEvent(event)) {
-    return new UploadEvent({
-      progress: event.total
-        ? Math.round((100 * event.loaded) / event.total)
-        : upload.progress,
-      state: 'progress',
-    });
-  }
-  if (isHttpResponse(event)) {
-    return new UploadEvent({
-      progress: 100,
-      state: 'done',
-    })
-  }
-  return upload
-}
-export class UploadEvent {
-  readonly fileName: string;
-  progress: number;
-  // bytes
-  total: number;
-  state: 'pending' | 'progress' | 'done';
-  constructor(options) { }
-}
-
-function reportprogress(filename: string): (source: Observable<Attachment>) => Observable<Attachment> {
-  return (source: Observable<Attachment>) =>
-    source.pipe(map(r => {
-      //if (event instanceof ProgressEvent) {
-      //  observe.next(new UploadEvent(
-      //    file.name,
-      //    (event as ProgressEvent).loaded,
-      //    (event as ProgressEvent).total
-      //  ));
-      //} else if (event instanceof HttpResponse) {
-      //  const res = event as HttpResponse<any>;
-      //  if (res.status === 200) {
-      //    const model = res.body as Attachment;
-      //    observe.next(model);
-      //  }
-      //  else
-      //    observe.error({ status: res.status, error: res.body });
-      //  observe.complete();
-      return r;
-    }));
-}
-
-export function reportProgress(attachment: AttachmentExtra) {
-  return (source: Observable<Attachment>) => new Observable(observe => {
-    source.subscribe(r => {
-      //TODO progress
-          //if (a instanceof UploadEvent) {
-          //  Object.assign(item, {
-          //    progress: a.loaded / a.total
-          //  });
-          //  return;
-          //}
-      observe.next(r);
-      observe.complete();
-
-    }, e => observe.error(e));
-  });
-}