@bizdoc/core 1.8.5 → 1.8.9

package/src/lib/core/layout/timespan.field.ts

@@ -0,0 +1,25 @@
+import { Component, ViewChild } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { TimespanInput } from '../controls/timespan.input';
+import { FieldBase } from './input.base';
+
+
+@Component({
+    template: `<mat-form-field>
+  <mat-label *ngIf="field.placeholder">{{field.label || field.name}}</mat-label>          
+<bizdoc-timespan-input
+[placeholder]="field.placeholder || field.label || field.name" [formControl]=control
+  [required]="field.required"></bizdoc-timespan-input>
+                <mat-icon matSuffix>timer</mat-icon>
+  <mat-hint *ngIf="field.hint"> {{ field.hint }}</mat-hint>
+  <ng-container>
+    <mat-error *ngFor="let v of field.validations" [style.display]="control.hasError(v.type) ? '': 'none'"> {{ v.message }} </mat-error>
+  </ng-container>
+</mat-form-field>`
+})
+/** layout component*/
+export class TimespanField extends FieldBase {
+  @ViewChild(TimespanInput) input: TimespanInput;
+    readonly control = new FormControl();
+  focus() { this.input.focus(); }
+}

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,296 @@
+import { Injectable, InjectionToken } from '@angular/core';
+import { HttpClient, 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 } from 'rxjs/operators';
+import { AttachmentInfo } from './info/attachment-info.service';
+import { cleanup } from './functions';
+import { HubService } from './hub.service';
+
+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,
+    messaging: HubService,
+    private _http: HttpClient) {
+    messaging.new$.
+      subscribe(m => {
+        _session.profile.inboxCount++;
+        const folder = _session.profile.folders.find(f => f.name === m.model.folderId);
+        folder.count++;
+        // _session.profile.inbox.push(m.model);
+      });
+  }
+  /**
+   * 
+   * @param date
+   */
+  private _isAboveWatermark(date: Date): boolean {
+    return !this._session.isImpersonating &&
+      this._session.profile.options.inboxView &&
+      this._session.profile.options.inboxView < date;
+  }
+  download(documentId: number, fileId: number): Observable<any> {
+    return this._http.get(AttachmentInfo.formatUrl(documentId, fileId), {
+      responseType: 'arraybuffer'
+    });
+  }
+  removeattachment(id: number, fileId: number): Observable<any> {
+    return this._http.delete(`/api/mailbox/attachment/${id}`, { params: { fileId: fileId.toString() } });
+  }
+  read(id: number, read: boolean): Observable<any> {
+    return this._http.put(`/api/mailbox/read/${id}`, undefined, { params: { read } as any });
+  }
+  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);
+    }));
+  }
+  upload(item: RecipientModel<any>, files: File[]): Observable<RecipientModel<any>> {
+    const now = new Date(), utc = new Date(now.getTime() + now.getTimezoneOffset() * 60000);
+    const models: Attachment[] = [];
+    files.forEach(f => {
+      const retry = item.attachments.findIndex(a => a.fileName === f.name && (a as AttachmentExtra).failed);
+      if (retry > -1)
+        item.attachments.splice(retry, 1);
+      const model: Attachment = {
+        userId: this._session.profile.userId,
+        time: utc.toJSON() as any,
+        fileName: f.name,
+        contentType: f.type
+      };
+      models.push(model);
+      item.attachments.push(model);
+    });
+    //const bytesPerChunk = 20 * 1024 * 1024;
+    // aquire the location prior to sending the request
+    return this._withGeoLocation(item.formId).pipe(switchMap(params =>
+      new Observable<any>(observe => {
+        const fd = new FormData();
+        files.forEach(f =>
+          fd.append(f.name, f));
+        let url = `/api/mail/${item.id}?version=${item.version}`;
+        Object.keys(params).forEach(p => url += `&${p}=${params[p]}`);
+        const req = new HttpRequest('PUT', 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 newItem = res.body as RecipientModel<any>;
+              observe.next(newItem);
+            }
+            else
+              observe.error({ status: res.status, error: res.body });
+            observe.complete();
+          }
+        }, e => {
+          observe.error({ status: e.status, error: e.body });
+          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 => this._change$.next({ id, viewed: e.time } as any)));
+  }
+  typing(id: number): Observable<any> {
+    return this._http.put(`/api/comments/typing/${id}`, {}, { headers: { 'no-progress': 'true' } });
+  }
+  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' | 'received' }): 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._withGeoLocation(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 => {
+        if (read !== undefined && m.read !== read) {
+          if (this._isAboveWatermark(m.received))
+            this._session.profile.inboxCount -= read ? -1 : 1;
+          const folder = this._session.profile.folders.find(f => f.name === m.folderId);
+          folder.count -= read ? -1 : 1;
+        }
+      }
+      ));
+  }
+  save<T = any>(id: number, version: number, form: string, model: {}): Observable<RecipientModel<T>> {
+    return this._withGeoLocation(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}`).pipe(tap(() => { }));
+  }
+  submit<T = any>(id: number, version: number, form: string, model?: any): Observable<RecipientModel<T>> {
+    return this._withGeoLocation(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: {}): Observable<RecipientModel<T>> {
+    return this._withGeoLocation(form).pipe(switchMap(params =>
+      this._http.put<RecipientModel<T>>(`/api/mail/${id}?version=${version}&action=${action}`, model, { params: Object.assign(params, actionArgs) }))).pipe(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 _withGeoLocation(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();
+          }, () => {
+            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 {
+  uploading?: number;
+  failed?: boolean;
+}