active-connect-ng2 0.2.40 → 0.2.41

package/src/lib/websocket/objects/outbound-object.ts

@@ -0,0 +1,430 @@
+import { Observable, Observer } from 'rxjs';
+import { WebsocketClient } from '../client';
+
+export interface IdObject {
+  id: number | null | undefined;
+}
+
+export class OutboundObject<T extends IdObject> {
+  private previouslyCachedCount: number | undefined;
+  constructor(
+    private client: WebsocketClient,
+    private method: string,
+    private lazyLoaded?: boolean,
+    public readonly cached?: boolean,
+    private initialLoadingCount?: number,
+    private sortBy?: (a: T, b: T) => number
+  ) {
+    this.target.loading = new Map<string, boolean>();
+
+    if (this.client.dbService) {
+      try {
+        this.client.dbService
+          .getByKey('outbound', method)
+          .subscribe((result: any) => {
+            if (result) {
+              this.previouslyCachedCount = result.data?.length || null;
+            }
+          });
+      } catch (e) {
+        console.error('ActiveConnect: Unable to read cached data');
+        console.error(e);
+      }
+    }
+
+    const _this = this;
+    WebsocketClient.expectOutbound(
+      method,
+      function setOutbound(
+        data: any,
+        specificHash: number | null,
+        insertedOrGroupData: any[] | null,
+        updatedOrGroupId: any[] | null,
+        deleted: any[] | null,
+        length: number | null,
+        _client: WebsocketClient
+      ) {
+        if (!cached) {
+          if (_client.dbService) {
+            try {
+              _client.dbService
+                .deleteByKey('outbound', method)
+                .subscribe(() => {});
+            } catch (e) {
+              console.error('ActiveConnect: Unable to delete cached data');
+              console.error(e);
+            }
+          }
+        }
+
+        if (data == 'cache_restore') {
+          if (_client.dbService) {
+            try {
+              _client.dbService
+                .getByKey('outbound', method)
+                .subscribe((result: any) => {
+                  _this.setData(result.data);
+                  if (result.length) _this._length = result.length;
+                  _this.loading = false;
+                });
+            } catch (e) {
+              console.error('ActiveConnect: Unable to restore cached data');
+              console.error(e);
+            }
+          } else {
+            console.error(
+              'ActiveConnect: Caching / restore not possible as the indexedDB is not accessible'
+            );
+          }
+        } else if (data == 'cache_delete') {
+          if (_client.dbService) {
+            try {
+              _client.dbService
+                .deleteByKey('outbound', method)
+                .subscribe(() => {});
+            } catch (e) {
+              console.error('ActiveConnect: Unable to delete cached data');
+              console.error(e);
+            }
+          } else {
+            console.error(
+              'ActiveConnect: Caching / restore not possible as the indexedDB is not accessible'
+            );
+          }
+          _this.loading = false;
+          _this.requested = false;
+        } else if (data == 'data_delete') {
+          _this.data = undefined;
+          _this.dataMap = new Map();
+          _this.requested = false;
+          _this.loadedGroupData = null;
+          _this.loadedGroupId = null;
+          _this._length = undefined;
+          _this.loading = false;
+        } else if (data == 'data_group') {
+          if (
+            _this.requestedGroupId ==
+            (updatedOrGroupId ? updatedOrGroupId[0] : 0)
+          ) {
+            _this.loadedGroupData = insertedOrGroupData;
+            _this.loadedGroupId = updatedOrGroupId ? updatedOrGroupId[0] : 0;
+            _this.loadedGroupChanged?.next(insertedOrGroupData as T[]);
+            _this.loading = false;
+          }
+        } else if (data == 'data_id') {
+          if (
+            _this.requestedId == (updatedOrGroupId ? updatedOrGroupId[0] : 0)
+          ) {
+            _this.loadedIdData =
+              (insertedOrGroupData?.length || 0) > 0
+                ? (insertedOrGroupData as any[])[0]
+                : null;
+            _this.loadedId = updatedOrGroupId ? updatedOrGroupId[0] : 0;
+            _this.loadedIdChanged?.next(_this.loadedIdData as T);
+            _this.loading = false;
+          }
+        } else if (data == 'data_diff') {
+          insertedOrGroupData?.forEach((e) => {
+            _this.dataMap.set(e.id, e);
+            if (e.id == _this.loadedId) {
+              _this.loadedIdChanged?.next(e);
+            }
+          });
+          updatedOrGroupId?.forEach((e) => {
+            _this.dataMap.set(e.id, e);
+            if (e.id == _this.loadedId) {
+              _this.loadedIdChanged?.next(e);
+            }
+          });
+          deleted?.forEach((e) => {
+            _this.dataMap.delete(e.id);
+            if (e.id == _this.loadedId) {
+              _this.loadedIdChanged?.next(null as any);
+            }
+          });
+          _this.data = Array.from(_this.dataMap.values());
+          if (_this.data && _this.sortBy)
+            _this.data = _this.data.sort(_this.sortBy);
+          _this.loading = false;
+
+          if (cached && specificHash) {
+            if (_client.dbService) {
+              try {
+                if (_this.data && _this.data?.length > 0) {
+                  _client.dbService
+                    .update('outbound', {
+                      method,
+                      data: _this.data,
+                      specificHash,
+                      length,
+                    })
+                    .subscribe(() => {});
+                } else {
+                  _client.dbService
+                    .deleteByKey('outbound', method)
+                    .subscribe(() => {});
+                }
+              } catch (e) {
+                console.error('ActiveConnect: Unable to update cached data.');
+                console.error(e);
+              }
+            } else {
+              console.error(
+                'ActiveConnect: Caching not possible as the indexedDB has not been initialized'
+              );
+            }
+          }
+        } else {
+          _this.setData(data);
+          if (_this.loadedId) {
+            const loadedValue = _this.dataMap.get(_this.loadedId);
+            if (loadedValue) {
+              _this.loadedIdData = loadedValue;
+              _this.loadedIdChanged?.next(_this.loadedIdData);
+            }
+          }
+          _this.loading = false;
+          if (cached && specificHash) {
+            if (_client.dbService) {
+              try {
+                if (data && data?.length > 0) {
+                  _client.dbService
+                    .update('outbound', {
+                      method,
+                      data,
+                      specificHash,
+                      length,
+                    })
+                    .subscribe(() => {});
+                } else {
+                  _client.dbService
+                    .deleteByKey('outbound', method)
+                    .subscribe(() => {});
+                }
+              } catch (e) {
+                console.error('ActiveConnect: Unable to update cached data.');
+                console.error(e);
+              }
+            } else {
+              console.error(
+                'ActiveConnect: Caching not possible as the indexedDB has not been initialized'
+              );
+            }
+          }
+        }
+        if (length) _this._length = length;
+      }
+    );
+
+    WebsocketClient.addResetRequestingStateCallback(() => {
+      this.afterServerReconnected();
+    });
+  }
+
+  get target(): any {
+    return (this.client as any).__proto__;
+  }
+
+  private dataMap: Map<number | null | undefined, T> = new Map();
+  private data: T[] | undefined = undefined;
+
+  public get(id: number): Observable<T> {
+    if (this.requestedId == id && this.loadedObservable && this.loadedIdData) {
+      if (this.loadedIdData)
+        setTimeout(() => {
+          if (this.loadedIdData) this.loadedIdChanged?.next(this.loadedIdData);
+        }, 50);
+      return this.loadedObservable;
+    }
+
+    let observablePromise: Promise<any> | undefined;
+    if (this.requestedId != id || !this.loadedObservable) {
+      observablePromise = new Promise<void>((resolve) => {
+        this.loadedObservable = new Observable<T>((observer: Observer<T>) => {
+          this.loadedIdChanged = observer;
+          resolve();
+        });
+      });
+    }
+
+    Promise.all([observablePromise]).then(() => {
+      new Promise<void>(async (resolve) => {
+        if (!this.requested && this.lazyLoaded) {
+          this.load().then();
+        }
+        if (this.data) {
+          const res = this.dataMap.get(id);
+          if (res) {
+            this.loadedIdChanged?.next(res);
+            resolve();
+            return;
+          }
+        }
+        if (this.loadedId == id) {
+          this.loadedIdChanged?.next(this.loadedIdData as T);
+        } else {
+          await this.requestById(id);
+        }
+        resolve();
+      }).then();
+    });
+    return this.loadedObservable as Observable<T>;
+  }
+
+  public getForGroup(groupId: number): Observable<T[]> {
+    if (
+      this.requestedGroupId == groupId &&
+      this.loadedGroupObservable &&
+      this.loadedGroupData
+    ) {
+      setTimeout(() => {
+        if (this.loadedGroupData)
+          this.loadedGroupChanged?.next(this.loadedGroupData);
+      }, 50);
+      return this.loadedGroupObservable;
+    }
+
+    let observablePromise: Promise<any> | undefined;
+    if (this.requestedGroupId != groupId || !this.loadedGroupObservable) {
+      observablePromise = new Promise<void>((resolve) => {
+        this.loadedGroupObservable = new Observable<T[]>(
+          (observer: Observer<T[]>) => {
+            this.loadedGroupChanged = observer;
+            resolve();
+          }
+        );
+      });
+    }
+
+    Promise.all([observablePromise]).then(() => {
+      new Promise<void>(async (resolve) => {
+        if (!this.requested && this.lazyLoaded) {
+          this.load().then();
+        }
+        if (this.loadedGroupId == groupId && this.loadedGroupData) {
+          this.loadedGroupChanged?.next(this.loadedGroupData as T[]);
+        } else {
+          await this.requestForGroup(groupId);
+        }
+        resolve();
+      }).then();
+    });
+    return this.loadedGroupObservable as Observable<T[]>;
+  }
+
+  public get all(): T[] | undefined {
+    if (!this.requested && this.lazyLoaded) {
+      this.load().then();
+    }
+    return this.data;
+  }
+
+  private requested: boolean = false;
+  public async load(count?: number): Promise<void> {
+    if (this.lazyLoaded) {
+      const hasBeenRequestedBefore = this.requested;
+      this._loading = true;
+      if (!this.requested) {
+        this.loading = true;
+      }
+      this.requested = true;
+      await this.client.send('request.' + this.method, {
+        count: hasBeenRequestedBefore
+          ? this.data
+            ? count || this.initialLoadingCount
+              ? (count || (this.initialLoadingCount as number)) +
+                this.loadedLength
+              : undefined
+            : undefined
+          : this.previouslyCachedCount || (this.initialLoadingCount as number),
+        loaded: this.loadedLength,
+      });
+    } else {
+      throw Error(
+        'Active-Connect: Cannot run loading request as this outbound is not lazy-loaded.'
+      );
+    }
+  }
+
+  private _loading = false;
+  private set loading(value: boolean) {
+    this._loading = value;
+    this.target.loading.set(this.method, value);
+  }
+  public get loading(): boolean {
+    return this._loading;
+  }
+  public get loadedLength(): number {
+    return this.data?.length || 0;
+  }
+  private _length: number | undefined = undefined;
+  public get length(): number | undefined {
+    return this._length;
+  }
+
+  private requestedId: number | null = null;
+  private loadedObservable: Observable<T> | null = null;
+  private loadedId: number | null = null;
+  private loadedIdData: T | null = null;
+  private loadedIdChanged: Observer<T> | null = null;
+  private requestById(id: number): Promise<any> {
+    this.loading = true;
+    this.requestedId = id;
+    return this.client.send('request.' + this.method, { id }) as Promise<any>;
+  }
+
+  private requestedGroupId: number | null = null;
+  private loadedGroupObservable: Observable<T[]> | null = null;
+  private loadedGroupId: number | null = null;
+  private loadedGroupData: T[] | null = null;
+  private loadedGroupChanged: Observer<T[]> | null = null;
+  private requestForGroup(groupId: number): Promise<T[]> {
+    this.loading = true;
+    this.requestedGroupId = groupId;
+    return this.client.send('request.' + this.method, { groupId });
+  }
+
+  private setData(data: T[] | { added: T[] | undefined; length: number }) {
+    this.data = data as T[];
+    if (this.data && this.sortBy) this.data = this.data.sort(this.sortBy);
+    this._length = data.length;
+    this.dataMap = new Map();
+    this.data.forEach((d) => {
+      this.dataMap.set(d.id, d);
+    });
+  }
+
+  get isEmpty() {
+    return this.data == undefined;
+  }
+
+  /**
+   * The contained data can be modified within the callback method
+   */
+  public update(callback: (data: T[]) => void) {
+    if (this.data) {
+      const updateLengthVariable = this.data.length == this._length;
+      const length = this.length;
+      callback(this.data);
+      this.setData(this.data);
+      if (!updateLengthVariable) {
+        this._length = length;
+      }
+    }
+  }
+
+  private afterServerReconnected() {
+    if (this.requested && this.lazyLoaded) {
+      this.requested = false;
+      this.load(1).then();
+    }
+    if (this.loadedId) {
+      this.loadedIdData = null;
+      this.get(this.loadedId);
+    }
+    if (this.loadedGroupId) {
+      this.loadedGroupData = null;
+      this.getForGroup(this.loadedGroupId);
+    }
+  }
+}

package/{public-api.d.ts → src/public-api.ts}

@@ -1,3 +1,7 @@
+/*
+ * Public API Surface of active-connect-ng2
+ */
+
 export * from './lib/active-connect-ng2.module';
 export * from './lib/websocket';
 export { NgxIndexedDBService } from 'ngx-indexed-db';

package/tsconfig.lib.json

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,14 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/esm2020/active-connect-ng2.mjs

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZlLWNvbm5lY3QtbmcyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvYWN0aXZlLWNvbm5lY3QtbmcyL3NyYy9hY3RpdmUtY29ubmVjdC1uZzIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2020/lib/active-connect-ng2.module.mjs

@@ -1,42 +0,0 @@
-import { NgModule } from '@angular/core';
-import { NgxIndexedDBModule } from 'ngx-indexed-db';
-import * as i0 from "@angular/core";
-import * as i1 from "ngx-indexed-db";
-const dbConfig = {
-    name: 'activeconnect_cache',
-    version: 2,
-    objectStoresMeta: [
-        {
-            store: 'outbound',
-            storeConfig: { keyPath: 'method', autoIncrement: false },
-            storeSchema: [
-                { name: 'method', keypath: 'method', options: { unique: true } },
-                { name: 'data', keypath: 'data', options: { unique: false } },
-                {
-                    name: 'specificHash',
-                    keypath: 'specificHash',
-                    options: { unique: false },
-                },
-                {
-                    name: 'length',
-                    keypath: 'length',
-                    options: { unique: false },
-                },
-            ],
-        },
-    ],
-};
-export class ActiveConnectNg2Module {
-}
-ActiveConnectNg2Module.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ActiveConnectNg2Module, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-ActiveConnectNg2Module.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: ActiveConnectNg2Module, imports: [i1.NgxIndexedDBModule], exports: [NgxIndexedDBModule] });
-ActiveConnectNg2Module.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ActiveConnectNg2Module, imports: [NgxIndexedDBModule.forRoot(dbConfig), NgxIndexedDBModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ActiveConnectNg2Module, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [],
-                    imports: [NgxIndexedDBModule.forRoot(dbConfig)],
-                    exports: [NgxIndexedDBModule],
-                }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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