npm - @bizdoc/core - Versions diffs - 1.15.6 → 1.16.1 - Mend

@bizdoc/core 1.15.6 → 1.16.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (109) hide show

package/esm2020/lib/core/mailbox.service.mjs CHANGED Viewed

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

package/esm2020/lib/core/models.mjs CHANGED Viewed

@@ -37,4 +37,4 @@ export var FieldType;
     FieldType["DateRange"] = "DateRange";
 })(FieldType || (FieldType = {}));
 ;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../../libraries/core/src/lib/core/models.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,KAAK,GAAG,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;AA8WxC,MAAM,CAAN,IAAY,cASX;AATD,WAAY,cAAc;IACxB,uCAAqB,CAAA;IACrB,6BAAW,CAAA;IACX,6BAAW,CAAA;IACX,yCAAuB,CAAA;IACvB,yCAAuB,CAAA;IACvB,qCAAmB,CAAA;IACnB,iCAAe,CAAA;IACf,iCAAe,CAAA;AACjB,CAAC,EATW,cAAc,KAAd,cAAc,QASzB;AACD,MAAM,CAAN,IAAY,SAwBX;AAxBD,WAAY,SAAS;IACnB,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,0BAAa,CAAA;IACb,0BAAa,CAAA;IACb,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,8BAAiB,CAAA;IACjB,0CAA6B,CAAA;IAC7B,0BAAa,CAAA;IACb,0BAAa,CAAA;IACb,kCAAqB,CAAA;IACrB,wCAA2B,CAAA;IAC3B,0BAAa,CAAA;IACb,wBAAW,CAAA;IACX,8BAAiB,CAAA;IACjB,gCAAmB,CAAA;IACnB,8BAAiB,CAAA;IACjB,sCAAyB,CAAA;IACzB,kCAAqB,CAAA;IACrB,0CAA6B,CAAA;IAC7B,gCAAmB,CAAA;IACnB,oCAAuB,CAAA;AACzB,CAAC,EAxBW,SAAS,KAAT,SAAS,QAwBpB;AAmFA,CAAC","sourcesContent":["import { NodeModel, ConnectorModel, ShapeModel, FlowShapeModel, BasicShapeModel, ImageModel, PathModel, TextModel, BpmnShapeModel, NativeModel } from \"@syncfusion/ej2-angular-diagrams\";\r\n\r\nexport const INBOX = 'ib', DRAFT = 'df';\r\n\r\nexport interface HeaderModel<T = any> {\r\n  parentId?: number;\r\n  draft?: boolean;\r\n  issued?: Date;\r\n  documentId: number;\r\n  substituteId?: string;\r\n  ownerId: string;\r\n  action?: string;\r\n  ownerById?: string;\r\n  id: number;\r\n  version: number;\r\n  formId: string;\r\n  number?: string;\r\n  subject?: string;\r\n  value?: number;\r\n  received: Date;\r\n  replied?: Date;\r\n  folderId: string;\r\n  read: boolean;\r\n  note?: string;\r\n  senderId?: string;\r\n  stateId: string;\r\n  currencyCode?: string;\r\n  flag?: boolean;\r\n  summary?: string;\r\n  pending?: boolean;\r\n  model?: T;\r\n}\r\nexport interface DocumentModel<T = any> {\r\n  draft?: boolean;\r\n  extra?: any;\r\n  number?: string;\r\n  subject?: string;\r\n  summary?: string;\r\n  currencyCode?: string;\r\n  value?: number;\r\n  ownerId: string;\r\n  ownerById?: string;\r\n  documentId: number;\r\n  version: number;\r\n  formId: string;\r\n  stateId: string;\r\n  completed?: boolean;\r\n  model?: T;\r\n  viewed?: Date;\r\n  attachments: Attachment[];\r\n  comments: Comment[];\r\n  unreadComments: number;\r\n  issued?: Date;\r\n  workflow?: WorkflowInfo;\r\n  recipients: Recipient[];\r\n  cubes: CubeEntry[];\r\n  events: ScheduledEvent[];\r\n  locations: MapPin[];\r\n  log: Log[];\r\n  rules?: { [name: string]: boolean };\r\n  parent?: Chain;\r\n  children?: Chain[];\r\n}\r\nexport interface Chain {\r\n  completed: boolean;\r\n  id: number;\r\n  formId: string;\r\n  number?: string;\r\n  subject?: string;\r\n  stateId: string;\r\n  value?: number;\r\n  currencyCode?: string;\r\n  parent?: Chain;\r\n  children?: Chain[];\r\n  recipients?: Recipient[];\r\n  events?: ScheduledEvent[];\r\n  log: Log[];\r\n}\r\nexport interface WorkflowInfo {\r\n  nodes: NodeInfo[];\r\n  connectors: ConnectorInfo[];\r\n}\r\nexport interface RecipientModel<T = any> extends HeaderModel<T>, DocumentModel<T> {\r\n  extra?: any;\r\n  actions?: string[];\r\n  fyi: boolean;\r\n  originId?: number;\r\n  escalated?: boolean;\r\n  tags?: string[];\r\n  byId?: string;\r\n}\r\nexport interface ConnectorInfo {\r\n  // recipient id\r\n  originId?: number;\r\n  estimate: boolean;\r\n  time?: Date;\r\n  sourceId: string;\r\n  targetId: string;\r\n}\r\nexport interface NodeInfo {\r\n  note?: string;\r\n  originId?: number;\r\n  id: string;\r\n  /** node */\r\n  type: string;\r\n  time?: Date;\r\n  estimate: boolean;\r\n  /** seconds */\r\n  standardTime?: number;\r\n  error?: string;\r\n}\r\nexport interface Log {\r\n  recipientId?: number;\r\n  userId: string;\r\n  byId?: string;\r\n  originId?: string;\r\n  time: Date;\r\n  model?: {};\r\n  type: LogType;\r\n  nodeId?: string;\r\n  note?: string;\r\n  state?: string;\r\n  action?: string;\r\n  escalated?: boolean;\r\n  sourceId?: string;\r\n  targetId?: string;\r\n  duration?: number;\r\n  estimate?: boolean;\r\n  fileId?: number;\r\n  error?: string;\r\n}\r\nexport declare type LogType = 'Submit' | 'Download' | 'StateChange' | 'ActionTaken' | 'CheckIn' | 'CheckOut' |\r\n  'ModelChange' | 'Node' | 'VirtualNode' | 'NodeJump' | 'Connector' | 'VirtualConnector' | 'Escalation';\r\n\r\nexport interface Recipient {\r\n  originId?: number;\r\n  substituteId?: string;\r\n  byId?: string;\r\n  nodeId?: string;\r\n  userId: string;\r\n  pending: boolean;\r\n  folderId: string;\r\n  role?: string;\r\n  received: Date;\r\n  replied?: Date;\r\n  estimate?: boolean;\r\n  action?: string;\r\n  fyi?: boolean;\r\n  id: number;\r\n  note?: string;\r\n  escalated?: boolean;\r\n}\r\nexport interface ScheduledEvent {\r\n  id: number;\r\n  documentId: number;\r\n  starting: Date;\r\n  ending?: Date;\r\n  title?: string;\r\n  location?: LatLng;\r\n}\r\nexport interface MapPin {\r\n  location: LatLng;\r\n}\r\n\r\nexport interface LatLng {\r\n  lat: number;\r\n  lng: number;\r\n}\r\n\r\nexport interface CubeEntry {\r\n  cube: string;\r\n  axes: string[];\r\n  value: number;\r\n}\r\n\r\nexport interface Attachment {\r\n  id?: number;\r\n  fileName: string;\r\n  contentType: string;\r\n  userId: string;\r\n  byId?: string;\r\n  time: Date;\r\n  deleted?: boolean;\r\n  checkedOut?: boolean;\r\n  private?: boolean;\r\n  holdingId?: string;\r\n}\r\nexport interface Comment {\r\n  id: number;\r\n  /** base64 */\r\n  image?: string;\r\n  text?: string;\r\n  userId: string;\r\n  time: Date;\r\n  parentId?: number;\r\n  voted?: number;\r\n  votes?: number;\r\n  edited?: Date;\r\n  deleted?: boolean;\r\n  byId?: string;\r\n  resource?: { [key: string]: any };\r\n}\r\nexport interface Vote {\r\n  byId?: string;\r\n  userId: string;\r\n  time: Date;\r\n  voted?: number;\r\n}\r\nexport interface CommentVersion {\r\n  byId?: string;\r\n  userId: string;\r\n  time: Date;\r\n  image?: string;\r\n  text?: string;\r\n  resource?: { [key: string]: any };\r\n}\r\nexport interface Notification {\r\n  muted?: boolean;\r\n  deleted?: boolean;\r\n  id: number;\r\n  type: NotificationType;\r\n  title: string;\r\n  read?: boolean;\r\n  sent: Date;\r\n  recipientId?: number;\r\n}\r\n\r\nexport declare type NotificationType =\r\n  'Commented' |\r\n  'CubeAnomaly' |\r\n  'Escalated' |\r\n  'Liked' |\r\n  'StateChanged' |\r\n  'Nudge' |\r\n  'TextMessage' |\r\n  'UpcomingEvent' |\r\n  'JobProgress' |\r\n  'Tagged';\r\n\r\nexport interface State {\r\n  shape?: string;\r\n  name: string;\r\n  title: string;\r\n  past?: string;\r\n  future?: string;\r\n  color?: string;\r\n  backgroundColor?: string;\r\n}\r\nexport type Gender = 'Male' |\r\n  'Female' | null;\r\n\r\nexport interface View {\r\n  name: string;\r\n  title: string;\r\n  template?: string;\r\n  options?: any;\r\n  guide?: string;\r\n  cubes: string[];\r\n  forms: string[];\r\n}\r\n\r\nexport interface Profile {\r\n  holidays: any;\r\n  utilities: Utility[];\r\n  guides?: Guide[];\r\n  views: View[];\r\n  photo?: string;\r\n  userId: string;\r\n  byId?: string;\r\n  byName?: string;\r\n  name: string;\r\n  impersonating?: string;\r\n  available?: AvailabilityState;\r\n  gender?: Gender;\r\n  byGender?: Gender;\r\n  system: boolean;\r\n  forms: Form[];\r\n  actions: Action[];\r\n  states: State[];\r\n  folders: Folder[];\r\n  reports: Report[];\r\n  types: Type[];\r\n  cubes: Cube[];\r\n  nodes: FlowNode[];\r\n  roles: Role[];\r\n  widgets: Widget[];\r\n  options: Options;\r\n  inbox: HeaderModel[];\r\n  inboxCount?: number;\r\n  notifications: Notification[];\r\n  notificationsCount?: number;\r\n  recents?: HeaderModel[];\r\n  contacts: Contact[];\r\n  conversationsCount: number;\r\n  license?: License;\r\n}\r\nexport interface Type {\r\n  arguments?: FieldInfo[];\r\n  name: string;\r\n  title: string;\r\n  assignable?: boolean;\r\n  columns?: FieldInfo[];\r\n}\r\nexport interface Role {\r\n  name: string;\r\n  title: string;\r\n  dataType: string;\r\n}\r\nexport interface Utility {\r\n  name: string;\r\n  title: string;\r\n  icon?: string;\r\n  guide?: string;\r\n  template?: string;\r\n  arguments?: FieldInfo[];\r\n  options: any;\r\n}\r\nexport interface Contact {\r\n  visited?: Date;\r\n  watermark?: Date;\r\n  id: string;\r\n  text?: string;\r\n  time: Date;\r\n  accepted: boolean;\r\n  image?: string;\r\n  count: number;\r\n  forgotten?: boolean;\r\n  resource?: { [key: string]: any };\r\n}\r\nexport interface Chat {\r\n  date: Date;\r\n  userId: string;\r\n  contactId: string;\r\n  text?: string;\r\n  time: Date;\r\n  /** base64 */\r\n  image?: string;\r\n  resource?: { [key: string]: any };\r\n}\r\nexport interface FieldInfo {\r\n  defaultValue?: any;\r\n  name: string;\r\n  label?: string;\r\n  key?: boolean;\r\n  type?: FieldType;\r\n  validations?: Validation[];\r\n  fields?: FieldInfo[];\r\n  max?: number;\r\n  min?: number;\r\n  source?: string;\r\n  required?: boolean;\r\n  pattern?: string;\r\n  hidden?: boolean;\r\n  placeholder?: string;\r\n  isArray?: boolean;\r\n  isObject?: boolean;\r\n  diagram?: boolean;\r\n  template?: string;\r\n  hint?: string;\r\n  options?: { [key: string]: any };\r\n}\r\nexport interface Validation {\r\n  type: ValidationType;\r\n  message: string;\r\n  min?: number;\r\n  max?: number;\r\n  expression?: any;\r\n}\r\nexport enum ValidationType {\r\n  Required = 'Required',\r\n  Min = 'Min',\r\n  Max = 'Max',\r\n  MinLength = 'MinLength',\r\n  MaxLength = 'MaxLength',\r\n  Pattern = 'Pattern',\r\n  Range = 'Range',\r\n  Email = 'Email'\r\n}\r\nexport enum FieldType {\r\n  String = 'String',\r\n  Number = 'Number',\r\n  Time = 'Time',\r\n  Date = 'Date',\r\n  DateTime = 'DateTime',\r\n  Checkbox = 'Checkbox',\r\n  Currency = 'Currency',\r\n  Select = 'Select',\r\n  EmailAddress = 'EmailAddress',\r\n  Html = 'Html',\r\n  Text = 'Text',\r\n  Password = 'Password',\r\n  PhoneNumber = 'PhoneNumber',\r\n  File = 'File',\r\n  Url = 'Url',\r\n  Switch = 'Switch',\r\n  Address = 'Address',\r\n  Object = 'Object',\r\n  Expression = 'Expression',\r\n  Duration = 'Duration',\r\n  Autocomplete = 'Autocomplete',\r\n  Percent = \"Percent\",\r\n  DateRange = \"DateRange\"\r\n}\r\nexport interface Widget {\r\n  name: string;\r\n  guide?: string;\r\n  title?: string;\r\n  template: string;\r\n  cols?: number;\r\n  rows?: number;\r\n  arguments?: FieldInfo[];\r\n  argumentsTemplate?: string;\r\n  options: any;\r\n}\r\nexport interface License {\r\n  mode: LicenseMode;\r\n  expiration?: Date;\r\n  companyName: string;\r\n}\r\nexport interface Folder {\r\n  filters?: {\r\n    cube?: string;\r\n    axes: string[];\r\n  };\r\n  name: string;\r\n  group?: string;\r\n  icon?: string;\r\n  title: string;\r\n  count?: number;\r\n  columns?: FolderColumn[];\r\n}\r\nexport interface FolderColumn {\r\n  name: string | 'number' | 'subject' | 'value' | 'owner' | 'sender' | 'received' | 'receivedAgo' | 'replied' | 'state' | 'issued' | 'issuedAgo';\r\n  title: string;\r\n  type?: 'Boolean' | 'Date' | 'Decimal' | 'String';\r\n}\r\n\r\nexport type LicenseMode =\r\n  'Evaluation' |\r\n  'Valid' |\r\n  'Grace' |\r\n  'Invalid' |\r\n  'Limit' |\r\n  'Expired';\r\n\r\nexport interface Action {\r\n  name: string;\r\n  title: string;\r\n  verb?: string;\r\n  you?: string;\r\n  youMale?: string;\r\n  youFemale?: string;\r\n  past?: string;\r\n  pastMale?: string;\r\n  pastFemale?: string;\r\n  adjective?: string;\r\n  loggable?: boolean;\r\n  adjectivePlural?: string;\r\n  icon?: string;\r\n  template?: string;\r\n  arguments?: FieldInfo[];\r\n  multiple?: boolean;\r\n  group?: number;\r\n  shape?: string;\r\n  color?: string;\r\n  options?: any;\r\n}\r\nexport interface Options {\r\n  grantAccess?: GrantSettings;\r\n  outOfOffice?: OutOfOfficeSettings;\r\n  notifications?: NotificationsSettings;\r\n  emails?: EmailSettings;\r\n  guides?: string[];\r\n  inboxView?: Date;\r\n  notificationsView?: Date;\r\n  tags?: string[];\r\n}\r\nexport interface GrantSettings {\r\n  active: boolean;\r\n  users?: string[];\r\n}\r\n\r\nexport interface Dimentions {\r\n  width: number;\r\n  height: number;\r\n};\r\n\r\nexport\r\n  interface Report {\r\n  options?: any;\r\n  name: string;\r\n  title: string;\r\n  icon?: string;\r\n  guide?: string;\r\n  template?: string;\r\n  fields?: FieldInfo[];\r\n  itemTemplate?: string;\r\n  columns: FieldInfo[];\r\n  arguments?: FieldInfo[];\r\n  argumentsTemplate?: string;\r\n}\r\nexport interface Form {\r\n  name: string;\r\n  options?: any;\r\n  title: string;\r\n  creatable: boolean;\r\n  icon: string;\r\n  position?: PositionPolicy;\r\n  template?: string;\r\n  structure?: FieldInfo[];\r\n  workflow?: Workflow;\r\n  guide?: string;\r\n}\r\nexport type PositionPolicy = 'Require' | 'Ask' | 'None';\r\nexport interface Workflow {\r\n  version: number;\r\n  connectors: ConnectorModel[];\r\n  nodes: NodeModel[];\r\n}\r\nexport interface UserInfo {\r\n  id: string;\r\n  name: string;\r\n  role?: string;\r\n  gender?: Gender;\r\n  pictureUrl?: string;\r\n  nick?: string;\r\n  phoneNumber?: string;\r\n  email?: string;\r\n  lastActive?: Date;\r\n  mode?: AvailabilityState;\r\n}\r\n\r\nexport interface Guide {\r\n  name: string;\r\n  title?: string;\r\n  mode?: 'Menu' | 'Eager' | 'Private';\r\n  steps: GuideStep[];\r\n}\r\nexport interface GuideStep {\r\n  execute?: boolean;\r\n  selector?: string;\r\n  title?: string;\r\n  content: string;\r\n  navigate?: string;\r\n  position?: 'Above' | 'End' | 'Start' | 'Below';\r\n}\r\n//enum GuideStepPolicy { }\r\nexport interface FlowNode {\r\n  name: string;\r\n  title: string;\r\n  style?: string;\r\n  palette?: string;\r\n  shape: ShapeModel | FlowShapeModel | BasicShapeModel | ImageModel | PathModel | TextModel | BpmnShapeModel | NativeModel;\r\n  template?: string;\r\n  arguments?: FieldInfo[];\r\n}\r\nexport declare type AvailabilityState =\r\n  'Offline' |\r\n  'Online' |\r\n  'OutOfOffice' |\r\n  'Vacation' | 'WorkingHome';\r\n\r\nexport interface Cube {\r\n  name: string;\r\n  title: string;\r\n  icon?: string;\r\n  yAxis?: YAxis;\r\n  template?: string;\r\n  currencyCode?: string;\r\n  views: CubeView[];\r\n  axes: CubeAxis[];\r\n  indices?: CubeIndex[];\r\n}\r\nexport interface YAxis {\r\n  title?: string;\r\n  type?: 'None' | 'Number' | 'Currency';\r\n}\r\nexport interface CubeIndex {\r\n  name: string;\r\n  accumulate?: boolean;\r\n  title: string;\r\n}\r\nexport interface CubeAxis {\r\n  name: string;\r\n  title: string;\r\n  dataType: string;\r\n  hidden?: boolean;\r\n  combination?: boolean;\r\n  selectionMode?: 'Single' | 'Pattern' | 'Multiple' | 'Search' | 'None';\r\n  descendentOf?: string;\r\n}\r\nexport type AxisSelectionMode =\r\n  'None' |\r\n  'Single' |\r\n  'Multiple' |\r\n  'Search' |\r\n  'Pattern';\r\n\r\nexport type AxisType = string | number | Array<string | number>;\r\n\r\nexport interface AxesMap {\r\n  [axis: string]: AxisType;\r\n}\r\nexport interface CubeView {\r\n  xAxis: string[];\r\n  series?: string[];\r\n  filters?: AxesMap;\r\n  indices?: string[];\r\n  icon?: string;\r\n  guide?: string;\r\n  name: string;\r\n  title: string;\r\n  type: ViewType;\r\n  chartType?: ChartType;\r\n  indicesChartType?: ChartType;\r\n}\r\nexport declare type ViewType = 'Spreadsheet' |\r\n  'Chart' | 'Pivot' | 'Grid';\r\nexport declare type ChartType =\r\n  'Pie' |\r\n  /**  Define the line series. */\r\n  'Line' |\r\n  /**  Define the Column series. */\r\n  'Column' |\r\n  /**  Define the Area series. */\r\n  'Area' |\r\n  /**  Define the Bar series. */\r\n  'Bar' |\r\n  /**  Define the StackingColumn series. */\r\n  'StackingColumn' |\r\n  /**  Define the StackingArea series. */\r\n  'StackingArea' |\r\n  /**  Define the StackingLine series. */\r\n  'StackingLine' |\r\n  /**  Define the StackingBar series. */\r\n  'StackingBar' |\r\n  /**  Define the Stepline series. */\r\n  'StepLine' |\r\n  /**  Define the Steparea series. */\r\n  'StepArea' |\r\n  /**  Define the Steparea series. */\r\n  'SplineArea' |\r\n  /**  Define the Scatter series. */\r\n  'Scatter' |\r\n  /**  Define the Spline series. */\r\n  'Spline' |\r\n  /** Define the StackingColumn100 series */\r\n  'StackingColumn100' |\r\n  /** Define the StackingBar100 series */\r\n  'StackingBar100' |\r\n  /** Define the StackingLine100 series */\r\n  'StackingLine100' |\r\n  /** Define the StackingArea100 series */\r\n  'StackingArea100' |\r\n  /** Define the RangeColumn Series */\r\n  'RangeColumn' |\r\n  /** Define the Waterfall Series */\r\n  'Waterfall' |\r\n  /** Define the RangeArea Series */\r\n  'RangeArea' |\r\n  /** Define the Bubble Series */\r\n  'Bubble' |\r\n  /** Define the Candle Series */\r\n  'Polar' |\r\n  /** Define the radar series */\r\n  'Radar' |\r\n  /** Define the Pareto series */\r\n  'Pareto' | 'Doughnut' | 'HalfDoughnut' |\r\n  'Funnel' | 'Pyramid' |\r\n  'StackingStepArea';\r\nexport interface OutOfOfficeSettings {\r\n  from?: Date;\r\n  to?: Date;\r\n  active: boolean;\r\n  substitueId?: string;\r\n}\r\ninterface NotificationsSettings {\r\n  sound?: boolean;\r\n  active?: boolean;\r\n  myStateChanged?: boolean;\r\n  anyStateChanged?: boolean;\r\n  anyComment?: boolean;\r\n  myComment?: boolean;\r\n  liked?: boolean;\r\n  cubeAnomaly?: boolean;\r\n  upcomingEvents?: boolean;\r\n}\r\ninterface EmailSettings {\r\n  active?: boolean;\r\n  mails?: boolean;\r\n  conversations?: boolean;\r\n  notifications?: boolean;\r\n  events?: boolean;\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../../libraries/core/src/lib/core/models.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,KAAK,GAAG,IAAI,EAAE,KAAK,GAAG,IAAI,CAAC;AA8WxC,MAAM,CAAN,IAAY,cASX;AATD,WAAY,cAAc;IACxB,uCAAqB,CAAA;IACrB,6BAAW,CAAA;IACX,6BAAW,CAAA;IACX,yCAAuB,CAAA;IACvB,yCAAuB,CAAA;IACvB,qCAAmB,CAAA;IACnB,iCAAe,CAAA;IACf,iCAAe,CAAA;AACjB,CAAC,EATW,cAAc,KAAd,cAAc,QASzB;AACD,MAAM,CAAN,IAAY,SAwBX;AAxBD,WAAY,SAAS;IACnB,8BAAiB,CAAA;IACjB,8BAAiB,CAAA;IACjB,0BAAa,CAAA;IACb,0BAAa,CAAA;IACb,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,8BAAiB,CAAA;IACjB,0CAA6B,CAAA;IAC7B,0BAAa,CAAA;IACb,0BAAa,CAAA;IACb,kCAAqB,CAAA;IACrB,wCAA2B,CAAA;IAC3B,0BAAa,CAAA;IACb,wBAAW,CAAA;IACX,8BAAiB,CAAA;IACjB,gCAAmB,CAAA;IACnB,8BAAiB,CAAA;IACjB,sCAAyB,CAAA;IACzB,kCAAqB,CAAA;IACrB,0CAA6B,CAAA;IAC7B,gCAAmB,CAAA;IACnB,oCAAuB,CAAA;AACzB,CAAC,EAxBW,SAAS,KAAT,SAAS,QAwBpB;AAmFA,CAAC","sourcesContent":["import { NodeModel, ConnectorModel, ShapeModel, FlowShapeModel, BasicShapeModel, ImageModel, PathModel, TextModel, BpmnShapeModel, NativeModel } from \"@syncfusion/ej2-angular-diagrams\";\r\n\r\nexport const INBOX = 'ib', DRAFT = 'df';\r\n\r\nexport interface HeaderModel<T = any> {\r\n  parentId?: number;\r\n  draft?: boolean;\r\n  issued?: Date;\r\n  documentId: number;\r\n  substituteId?: string;\r\n  ownerId: string;\r\n  action?: string;\r\n  ownerById?: string;\r\n  id: number;\r\n  version: number;\r\n  formId: string;\r\n  number?: string;\r\n  subject?: string;\r\n  value?: number;\r\n  received: Date;\r\n  replied?: Date;\r\n  folderId: string;\r\n  read: boolean;\r\n  note?: string;\r\n  senderId?: string;\r\n  stateId: string;\r\n  currencyCode?: string;\r\n  flag?: boolean;\r\n  summary?: string;\r\n  pending?: boolean;\r\n  model?: T;\r\n}\r\nexport interface DocumentModel<T = any> {\r\n  draft?: boolean;\r\n  extra?: any;\r\n  number?: string;\r\n  subject?: string;\r\n  summary?: string;\r\n  currencyCode?: string;\r\n  value?: number;\r\n  ownerId: string;\r\n  ownerById?: string;\r\n  documentId: number;\r\n  version: number;\r\n  formId: string;\r\n  stateId: string;\r\n  completed?: boolean;\r\n  model?: T;\r\n  viewed?: Date;\r\n  attachments: Attachment[];\r\n  comments: Comment[];\r\n  unreadComments: number;\r\n  issued?: Date;\r\n  workflow?: WorkflowInfo;\r\n  recipients: Recipient[];\r\n  cubes: CubeEntry[];\r\n  events: ScheduledEvent[];\r\n  locations: MapPin[];\r\n  log: Log[];\r\n  rules?: { [name: string]: boolean };\r\n  parent?: Chain;\r\n  children?: Chain[];\r\n}\r\nexport interface Chain {\r\n  completed: boolean;\r\n  id: number;\r\n  formId: string;\r\n  number?: string;\r\n  subject?: string;\r\n  stateId: string;\r\n  value?: number;\r\n  currencyCode?: string;\r\n  parent?: Chain;\r\n  children?: Chain[];\r\n  recipients?: Recipient[];\r\n  events?: ScheduledEvent[];\r\n  log: Log[];\r\n}\r\nexport interface WorkflowInfo {\r\n  nodes: NodeInfo[];\r\n  connectors: ConnectorInfo[];\r\n}\r\nexport interface RecipientModel<T = any> extends HeaderModel<T>, DocumentModel<T> {\r\n  extra?: any;\r\n  actions?: string[];\r\n  fyi: boolean;\r\n  originId?: number;\r\n  escalated?: boolean;\r\n  tags?: string[];\r\n  byId?: string;\r\n}\r\nexport interface ConnectorInfo {\r\n  // recipient id\r\n  originId?: number;\r\n  estimate: boolean;\r\n  time?: Date;\r\n  sourceId: string;\r\n  targetId: string;\r\n}\r\nexport interface NodeInfo {\r\n  note?: string;\r\n  originId?: number;\r\n  id: string;\r\n  /** node */\r\n  type: string;\r\n  time?: Date;\r\n  estimate: boolean;\r\n  /** seconds */\r\n  standardTime?: number;\r\n  error?: string;\r\n}\r\nexport interface Log {\r\n  recipientId?: number;\r\n  userId: string;\r\n  byId?: string;\r\n  originId?: string;\r\n  time: Date;\r\n  model?: {};\r\n  type: LogType;\r\n  nodeId?: string;\r\n  note?: string;\r\n  state?: string;\r\n  action?: string;\r\n  escalated?: boolean;\r\n  sourceId?: string;\r\n  targetId?: string;\r\n  duration?: number;\r\n  estimate?: boolean;\r\n  fileId?: number;\r\n  error?: string;\r\n}\r\nexport declare type LogType = 'Submit' | 'Download' | 'StateChange' | 'ActionTaken' | 'CheckIn' | 'CheckOut' |\r\n  'ModelChange' | 'Node' | 'VirtualNode' | 'NodeJump' | 'Connector' | 'VirtualConnector' | 'Escalation';\r\n\r\nexport interface Recipient {\r\n  originId?: number;\r\n  substituteId?: string;\r\n  byId?: string;\r\n  nodeId?: string;\r\n  userId: string;\r\n  pending: boolean;\r\n  folderId: string;\r\n  role?: string;\r\n  received: Date;\r\n  replied?: Date;\r\n  estimate?: boolean;\r\n  action?: string;\r\n  fyi?: boolean;\r\n  id: number;\r\n  note?: string;\r\n  escalated?: boolean;\r\n}\r\nexport interface ScheduledEvent {\r\n  id: number;\r\n  documentId: number;\r\n  starting: Date;\r\n  ending?: Date;\r\n  title?: string;\r\n  location?: LatLng;\r\n}\r\nexport interface MapPin {\r\n  location: LatLng;\r\n}\r\n\r\nexport interface LatLng {\r\n  lat: number;\r\n  lng: number;\r\n}\r\n\r\nexport interface CubeEntry {\r\n  cube: string;\r\n  axes: string[];\r\n  value: number;\r\n}\r\n\r\nexport interface Attachment {\r\n  id?: number;\r\n  fileName: string;\r\n  contentType: string;\r\n  userId: string;\r\n  byId?: string;\r\n  time: Date;\r\n  deleted?: boolean;\r\n  checkedOut?: boolean;\r\n  private?: boolean;\r\n  holdingId?: string;\r\n}\r\nexport interface Comment {\r\n  id: number;\r\n  /** base64 */\r\n  image?: string;\r\n  text?: string;\r\n  userId: string;\r\n  time: Date;\r\n  parentId?: number;\r\n  voted?: number;\r\n  votes?: number;\r\n  edited?: Date;\r\n  deleted?: boolean;\r\n  byId?: string;\r\n  resource?: { [key: string]: any };\r\n}\r\nexport interface Vote {\r\n  byId?: string;\r\n  userId: string;\r\n  time: Date;\r\n  voted?: number;\r\n}\r\nexport interface CommentVersion {\r\n  byId?: string;\r\n  userId: string;\r\n  time: Date;\r\n  image?: string;\r\n  text?: string;\r\n  resource?: { [key: string]: any };\r\n}\r\nexport interface Notification {\r\n  muted?: boolean;\r\n  deleted?: boolean;\r\n  id: number;\r\n  type: NotificationType;\r\n  title: string;\r\n  read?: boolean;\r\n  sent: Date;\r\n  recipientId?: number;\r\n}\r\n\r\nexport declare type NotificationType =\r\n  'Commented' |\r\n  'CubeAnomaly' |\r\n  'Escalated' |\r\n  'Liked' |\r\n  'StateChanged' |\r\n  'Nudge' |\r\n  'TextMessage' |\r\n  'UpcomingEvent' |\r\n  'JobProgress' |\r\n  'Tagged';\r\n\r\nexport interface State {\r\n  shape?: string;\r\n  name: string;\r\n  title: string;\r\n  past?: string;\r\n  future?: string;\r\n  color?: string;\r\n  backgroundColor?: string;\r\n}\r\nexport type Gender = 'Male' |\r\n  'Female' | null;\r\n\r\nexport interface View {\r\n  name: string;\r\n  title: string;\r\n  template?: string;\r\n  options?: any;\r\n  guide?: string;\r\n  cubes: string[];\r\n  forms: string[];\r\n}\r\n\r\nexport interface Profile {\r\n  holidays: any;\r\n  utilities: Utility[];\r\n  guides?: Guide[];\r\n  views: View[];\r\n  photo?: string;\r\n  userId: string;\r\n  byId?: string;\r\n  byName?: string;\r\n  name: string;\r\n  impersonating?: string;\r\n  available?: AvailabilityState;\r\n  gender?: Gender;\r\n  byGender?: Gender;\r\n  system: boolean;\r\n  forms: Form[];\r\n  actions: Action[];\r\n  states: State[];\r\n  folders: Folder[];\r\n  reports: Report[];\r\n  types: Type[];\r\n  cubes: Cube[];\r\n  nodes: FlowNode[];\r\n  roles: Role[];\r\n  widgets: Widget[];\r\n  options: Options;\r\n  inbox: HeaderModel[];\r\n  inboxCount?: number;\r\n  notifications: Notification[];\r\n  notificationsCount?: number;\r\n  recents?: HeaderModel[];\r\n  contacts: Contact[];\r\n  conversationsCount: number;\r\n  license?: License;\r\n}\r\nexport interface Type {\r\n  arguments?: FieldInfo[];\r\n  name: string;\r\n  title: string;\r\n  assignable?: boolean;\r\n  columns?: FieldInfo[];\r\n}\r\nexport interface Role {\r\n  name: string;\r\n  title: string;\r\n  dataType: string;\r\n}\r\nexport interface Utility {\r\n  name: string;\r\n  title: string;\r\n  icon?: string;\r\n  guide?: string;\r\n  template?: string;\r\n  arguments?: FieldInfo[];\r\n  options: any;\r\n}\r\nexport interface Contact {\r\n  visited?: Date;\r\n  watermark?: Date;\r\n  id: string;\r\n  text?: string;\r\n  time: Date;\r\n  accepted: boolean;\r\n  image?: string;\r\n  count: number;\r\n  forgotten?: boolean;\r\n  resource?: { [key: string]: any };\r\n}\r\nexport interface Chat {\r\n  date: Date;\r\n  userId: string;\r\n  contactId: string;\r\n  text?: string;\r\n  time: Date;\r\n  /** base64 */\r\n  image?: string;\r\n  resource?: { [key: string]: any };\r\n}\r\nexport interface FieldInfo {\r\n  defaultValue?: any;\r\n  name: string;\r\n  label?: string;\r\n  key?: boolean;\r\n  type?: FieldType;\r\n  validations?: Validation[];\r\n  fields?: FieldInfo[];\r\n  max?: number;\r\n  min?: number;\r\n  source?: string;\r\n  required?: boolean;\r\n  pattern?: string;\r\n  hidden?: boolean;\r\n  placeholder?: string;\r\n  isArray?: boolean;\r\n  isObject?: boolean;\r\n  diagram?: boolean;\r\n  template?: string;\r\n  hint?: string;\r\n  options?: { [key: string]: any };\r\n}\r\nexport interface Validation {\r\n  type: ValidationType;\r\n  message: string;\r\n  min?: number;\r\n  max?: number;\r\n  expression?: any;\r\n}\r\nexport enum ValidationType {\r\n  Required = 'Required',\r\n  Min = 'Min',\r\n  Max = 'Max',\r\n  MinLength = 'MinLength',\r\n  MaxLength = 'MaxLength',\r\n  Pattern = 'Pattern',\r\n  Range = 'Range',\r\n  Email = 'Email'\r\n}\r\nexport enum FieldType {\r\n  String = 'String',\r\n  Number = 'Number',\r\n  Time = 'Time',\r\n  Date = 'Date',\r\n  DateTime = 'DateTime',\r\n  Checkbox = 'Checkbox',\r\n  Currency = 'Currency',\r\n  Select = 'Select',\r\n  EmailAddress = 'EmailAddress',\r\n  Html = 'Html',\r\n  Text = 'Text',\r\n  Password = 'Password',\r\n  PhoneNumber = 'PhoneNumber',\r\n  File = 'File',\r\n  Url = 'Url',\r\n  Switch = 'Switch',\r\n  Address = 'Address',\r\n  Object = 'Object',\r\n  Expression = 'Expression',\r\n  Duration = 'Duration',\r\n  Autocomplete = 'Autocomplete',\r\n  Percent = \"Percent\",\r\n  DateRange = \"DateRange\"\r\n}\r\nexport interface Widget {\r\n  name: string;\r\n  guide?: string;\r\n  title?: string;\r\n  template: string;\r\n  cols?: number;\r\n  rows?: number;\r\n  arguments?: FieldInfo[];\r\n  argumentsTemplate?: string;\r\n  options: any;\r\n}\r\nexport interface License {\r\n  mode: LicenseMode;\r\n  expiration?: Date;\r\n  companyName: string;\r\n}\r\nexport interface Folder {\r\n  filters?: {\r\n    cube?: string;\r\n    axes: string[];\r\n  };\r\n  name: string;\r\n  group?: string;\r\n  icon?: string;\r\n  title: string;\r\n  count?: number;\r\n  columns?: FolderColumn[];\r\n}\r\nexport interface FolderColumn {\r\n  name: string | 'number' | 'subject' | 'value' | 'owner' | 'sender' | 'received' | 'receivedAgo' | 'replied' | 'state' | 'issued' | 'issuedAgo';\r\n  title: string;\r\n  type?: 'Boolean' | 'Date' | 'Decimal' | 'String';\r\n}\r\n\r\nexport type LicenseMode =\r\n  'Evaluation' |\r\n  'Valid' |\r\n  'Grace' |\r\n  'Invalid' |\r\n  'Limit' |\r\n  'Expired';\r\n\r\nexport interface Action {\r\n  name: string;\r\n  title: string;\r\n  verb?: string;\r\n  you?: string;\r\n  youMale?: string;\r\n  youFemale?: string;\r\n  past?: string;\r\n  pastMale?: string;\r\n  pastFemale?: string;\r\n  adjective?: string;\r\n  loggable?: boolean;\r\n  adjectivePlural?: string;\r\n  icon?: string;\r\n  template?: string;\r\n  arguments?: FieldInfo[];\r\n  multiple?: boolean;\r\n  group?: number;\r\n  shape?: string;\r\n  color?: string;\r\n  options?: any;\r\n}\r\nexport interface Options {\r\n  grantAccess?: GrantSettings;\r\n  outOfOffice?: OutOfOfficeSettings;\r\n  notifications?: NotificationsSettings;\r\n  emails?: EmailSettings;\r\n  guides?: string[];\r\n  inboxView?: Date;\r\n  notificationsView?: Date;\r\n  tags?: string[];\r\n}\r\nexport interface GrantSettings {\r\n  active: boolean;\r\n  users?: string[];\r\n}\r\n\r\nexport interface Dimentions {\r\n  width: number;\r\n  height: number;\r\n};\r\n\r\nexport\r\n  interface Report {\r\n  options?: any;\r\n  name: string;\r\n  title: string;\r\n  icon?: string;\r\n  guide?: string;\r\n  template?: string;\r\n  fields?: FieldInfo[];\r\n  itemTemplate?: string;\r\n  columns: FieldInfo[];\r\n  arguments?: FieldInfo[];\r\n  argumentsTemplate?: string;\r\n}\r\nexport interface Form {\r\n  name: string;\r\n  options?: any;\r\n  title: string;\r\n  creatable: boolean;\r\n  icon: string;\r\n  position?: PositionPolicy;\r\n  template?: string;\r\n  structure?: FieldInfo[];\r\n  workflow?: Workflow;\r\n  guide?: string;\r\n}\r\nexport type PositionPolicy = 'Require' | 'Ask' | 'None';\r\nexport interface Workflow {\r\n  version: number;\r\n  connectors: ConnectorModel[];\r\n  nodes: NodeModel[];\r\n}\r\nexport interface UserInfo {\r\n  id: string;\r\n  name: string;\r\n  role?: string;\r\n  gender?: Gender;\r\n  pictureUrl?: string;\r\n  nick?: string;\r\n  phoneNumber?: string;\r\n  email?: string;\r\n  lastActive?: Date;\r\n  mode?: AvailabilityState;\r\n}\r\n\r\nexport interface Guide {\r\n  name: string;\r\n  title?: string;\r\n  mode?: 'Menu' | 'Eager' | 'Private';\r\n  steps: GuideStep[];\r\n}\r\nexport interface GuideStep {\r\n  execute?: boolean;\r\n  selector?: string;\r\n  title?: string;\r\n  content: string;\r\n  navigate?: string;\r\n  position?: 'Above' | 'End' | 'Start' | 'Below';\r\n}\r\n//enum GuideStepPolicy { }\r\nexport interface FlowNode {\r\n  name: string;\r\n  title: string;\r\n  style?: string;\r\n  palette?: string;\r\n  shape: ShapeModel | FlowShapeModel | BasicShapeModel | ImageModel | PathModel | TextModel | BpmnShapeModel | NativeModel;\r\n  template?: string;\r\n  arguments?: FieldInfo[];\r\n}\r\nexport declare type AvailabilityState =\r\n  'Offline' |\r\n  'Online' |\r\n  'OutOfOffice' |\r\n  'Vacation' | 'WorkingHome';\r\n\r\nexport interface Cube {\r\n  name: string;\r\n  title: string;\r\n  icon?: string;\r\n  yAxis?: YAxis;\r\n  template?: string;\r\n  currencyCode?: string;\r\n  views: CubeView[];\r\n  axes: CubeAxis[];\r\n  indices?: CubeIndex[];\r\n}\r\nexport interface YAxis {\r\n  title?: string;\r\n  type?: 'None' | 'Number' | 'Currency';\r\n}\r\nexport interface CubeIndex {\r\n  name: string;\r\n  accumulate?: boolean;\r\n  title: string;\r\n}\r\nexport interface CubeAxis {\r\n  name: string;\r\n  title: string;\r\n  dataType: string;\r\n  hidden?: boolean;\r\n  combination?: boolean;\r\n  selectionMode?: 'Single' | 'Pattern' | 'Multiple' | 'Search' | 'None';\r\n  descendentOf?: string;\r\n}\r\nexport type AxisSelectionMode =\r\n  'None' |\r\n  'Single' |\r\n  'Multiple' |\r\n  'Search' |\r\n  'Pattern';\r\n\r\nexport type AxisValue = string | number | Array<string | number>;\r\n\r\nexport interface AxesMap {\r\n  [axis: string]: AxisValue;\r\n}\r\nexport interface CubeView {\r\n  xAxis: string[];\r\n  series?: string[];\r\n  filters?: AxesMap;\r\n  indices?: string[];\r\n  icon?: string;\r\n  guide?: string;\r\n  name: string;\r\n  title: string;\r\n  type: ViewType;\r\n  chartType?: ChartType;\r\n  indicesChartType?: ChartType;\r\n}\r\nexport declare type ViewType = 'Spreadsheet' |\r\n  'Chart' | 'Pivot' | 'Grid';\r\nexport declare type ChartType =\r\n  'Pie' |\r\n  /**  Define the line series. */\r\n  'Line' |\r\n  /**  Define the Column series. */\r\n  'Column' |\r\n  /**  Define the Area series. */\r\n  'Area' |\r\n  /**  Define the Bar series. */\r\n  'Bar' |\r\n  /**  Define the StackingColumn series. */\r\n  'StackingColumn' |\r\n  /**  Define the StackingArea series. */\r\n  'StackingArea' |\r\n  /**  Define the StackingLine series. */\r\n  'StackingLine' |\r\n  /**  Define the StackingBar series. */\r\n  'StackingBar' |\r\n  /**  Define the Stepline series. */\r\n  'StepLine' |\r\n  /**  Define the Steparea series. */\r\n  'StepArea' |\r\n  /**  Define the Steparea series. */\r\n  'SplineArea' |\r\n  /**  Define the Scatter series. */\r\n  'Scatter' |\r\n  /**  Define the Spline series. */\r\n  'Spline' |\r\n  /** Define the StackingColumn100 series */\r\n  'StackingColumn100' |\r\n  /** Define the StackingBar100 series */\r\n  'StackingBar100' |\r\n  /** Define the StackingLine100 series */\r\n  'StackingLine100' |\r\n  /** Define the StackingArea100 series */\r\n  'StackingArea100' |\r\n  /** Define the RangeColumn Series */\r\n  'RangeColumn' |\r\n  /** Define the Waterfall Series */\r\n  'Waterfall' |\r\n  /** Define the RangeArea Series */\r\n  'RangeArea' |\r\n  /** Define the Bubble Series */\r\n  'Bubble' |\r\n  /** Define the Candle Series */\r\n  'Polar' |\r\n  /** Define the radar series */\r\n  'Radar' |\r\n  /** Define the Pareto series */\r\n  'Pareto' | 'Doughnut' | 'HalfDoughnut' |\r\n  'Funnel' | 'Pyramid' |\r\n  'StackingStepArea';\r\nexport interface OutOfOfficeSettings {\r\n  from?: Date;\r\n  to?: Date;\r\n  active: boolean;\r\n  substitueId?: string;\r\n}\r\ninterface NotificationsSettings {\r\n  sound?: boolean;\r\n  active?: boolean;\r\n  myStateChanged?: boolean;\r\n  anyStateChanged?: boolean;\r\n  anyComment?: boolean;\r\n  myComment?: boolean;\r\n  liked?: boolean;\r\n  cubeAnomaly?: boolean;\r\n  upcomingEvents?: boolean;\r\n}\r\ninterface EmailSettings {\r\n  active?: boolean;\r\n  mails?: boolean;\r\n  conversations?: boolean;\r\n  notifications?: boolean;\r\n  events?: boolean;\r\n}\r\n"]}