active-connect-ng2 0.2.40 → 0.2.41

package/src/lib/websocket/decorators/websocket/outbound.ts

@@ -0,0 +1,212 @@
+import { WebsocketClient } from '../../client';
+
+export function Outbound(
+  method: string,
+  requestingRequired?: boolean,
+  cached?: boolean,
+  sortBy?: (a: any, b: any) => number
+) {
+  return function _Outbound(target: any, propertyKey: string): any {
+    target.loading = new Map<string, boolean>();
+    // property annotation
+    WebsocketClient.expectOutbound(
+      method,
+      function setOutbound(
+        data: any,
+        specificHash: number | null,
+        inserted: any[] | null,
+        updated: any[] | null,
+        deleted: any[] | null,
+        length: number | null,
+        _this: WebsocketClient
+      ) {
+        if (!target.___received) target.___received = {};
+        if (!target.___data) target.___data = {};
+        if (!target.___received) target.___received = {};
+        if (!target.___requested) target.___requested = {};
+        if (!cached) {
+          if (_this.dbService) {
+            try {
+              _this.dbService
+                .deleteByKey('outbound', method)
+                .subscribe(() => {});
+            } catch (e) {
+              console.error(
+                'ActiveConnect: could not delete indexdb cache entry'
+              );
+            }
+          }
+        }
+
+        if (data == 'cache_restore') {
+          if (_this.dbService) {
+            try {
+              _this.dbService
+                .getByKey('outbound', method)
+                .subscribe((result: any) => {
+                  target.___received[propertyKey] = true;
+                  target.___data[propertyKey] = result.data;
+                  target.loading.set(propertyKey, 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 (_this.dbService) {
+            try {
+              _this.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'
+            );
+          }
+          target.___received[propertyKey] = false;
+          target.___data[propertyKey] = undefined;
+          target.loading.set(propertyKey, false);
+        } else if (data == 'data_delete') {
+          target.___data[propertyKey] = undefined;
+          target.loading.set(propertyKey, false);
+          target.___received[propertyKey] = false;
+          target.___requested[propertyKey] = false;
+        } else if (data == 'data_diff') {
+          var data = target.___data[propertyKey] || [];
+          inserted?.forEach((e) => {
+            const matching = data.filter((d: any) => d.id == e.id);
+            if (matching.length > 0) {
+              data[data.indexOf(matching[0])] = e;
+            } else {
+              data.push(e);
+            }
+          });
+          updated?.forEach((e) => {
+            const matching = data.filter((d: any) => d.id == e.id);
+            if (matching.length > 0) {
+              data[data.indexOf(matching[0])] = e;
+            } else {
+              data.push(e);
+            }
+          });
+          deleted?.forEach((e) => {
+            data = data.filter((d: any) => d.id != e.id);
+          });
+          if (sortBy && data) data = data.sort(sortBy);
+          target.___data[propertyKey] = data;
+          target.loading.set(propertyKey, false);
+
+          if (cached && specificHash) {
+            if (_this.dbService) {
+              if (data && data?.length > 0) {
+                try {
+                  _this.dbService
+                    .update('outbound', {
+                      method,
+                      data,
+                      specificHash,
+                    })
+                    .subscribe(() => {});
+                } catch (e) {
+                  console.error('ActiveConnect: Unable to update cached data');
+                  console.error(e);
+                }
+              } else {
+                try {
+                  _this.dbService
+                    .deleteByKey('outbound', method)
+                    .subscribe(() => {});
+                } catch (e) {
+                  console.error('ActiveConnect: Unable to delete cached data');
+                  console.error(e);
+                }
+              }
+            } else {
+              console.error(
+                'ActiveConnect: Caching not possible as the indexedDB has not been initialized'
+              );
+            }
+          }
+        } else {
+          if (sortBy && data) data = data.sort(sortBy);
+          target.___received[propertyKey] = true;
+          target.___data[propertyKey] = data;
+          target.loading.set(propertyKey, false);
+          if (cached && specificHash) {
+            if (_this.dbService) {
+              if (data && data?.length > 0) {
+                try {
+                  _this.dbService
+                    .update('outbound', {
+                      method,
+                      data,
+                      specificHash,
+                    })
+                    .subscribe(() => {});
+                } catch (e) {
+                  console.error('ActiveConnect: Unable to update cached data');
+                  console.error(e);
+                }
+              } else {
+                try {
+                  _this.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 (requestingRequired) {
+      WebsocketClient.addResetRequestingStateCallback(function callback() {
+        if (target.___requested) {
+          target.___requested[propertyKey] = false;
+        }
+      });
+    }
+
+    const obj = {
+      configurable: true,
+      get() {
+        if (!target.___requested) target.___requested = {};
+        if (requestingRequired && !target.___requested[propertyKey]) {
+          target.___requested[propertyKey] = true;
+          (this as any).send('request.' + method, null).then();
+        }
+        if (!target.___data) target.___data = {};
+        if (!target.___data[propertyKey]) {
+          target.loading.set(propertyKey, true);
+        } else if (target.loading[propertyKey]) {
+          target.loading.set(propertyKey, false);
+        }
+        return target.___data[propertyKey];
+      },
+      set(val: any) {
+        if (!target.___data) target.___data = {};
+        target.loading.set(propertyKey, false);
+        if (sortBy && val) val = val.sort(sortBy);
+        return (target.___data[propertyKey] = val);
+      },
+    };
+    target[propertyKey] = obj;
+    return obj;
+  };
+}

package/src/lib/websocket/decorators/websocket/route.ts

@@ -0,0 +1,32 @@
+export function Route(
+  method: string,
+  loadingKey?: string,
+  dontEnsureTransmission?: boolean
+) {
+  return function _Route(target: any, propertyKey: string): any {
+    // method annotation
+    const original = target[propertyKey];
+    target[propertyKey] = async function execRoute(...data: any): Promise<any> {
+      if (loadingKey) {
+        if (!this.loadingElements[loadingKey]) {
+          this.loadingElements[loadingKey] = 0;
+        }
+        this.loadingElements[loadingKey]++;
+      }
+      const promise = original.bind(this)(...data);
+      let res = null;
+      if (this.client) {
+        res = await this.client
+          .send(method, data[0], dontEnsureTransmission)
+          ?.catch((err: any) => {
+            if (loadingKey) this.loadingElements[loadingKey]--;
+            throw err;
+          });
+      }
+      await promise;
+      if (loadingKey) this.loadingElements[loadingKey]--;
+      return res;
+    };
+    return target;
+  };
+}

package/src/lib/websocket/decorators/websocket/shared.ts

@@ -0,0 +1,11 @@
+/**
+ * @deprecated
+ */
+export function Shared<T>(defaultValue?: T) {
+  if (defaultValue) {
+    throw Error(
+      "Active-Connect/@Shared: defaultValue is no longer supported, please assign the value to the variable itself."
+    );
+  }
+  return function _Shared(target: any, propertyKey: string) {};
+}

package/{lib/websocket/decorators/websocket/websocket-route-service.d.ts → src/lib/websocket/decorators/websocket/websocket-route-service.ts}

@@ -1,5 +1,6 @@
 import { WebsocketClient } from '../../client';
+
 export interface WebsocketRouteService {
-    loadingElements: any;
-    client: WebsocketClient;
+  loadingElements: any;
+  client: WebsocketClient;
 }

package/src/lib/websocket/json/json-parser.ts

@@ -0,0 +1,26 @@
+export class JsonParser {
+  static stringify(obj: any) {
+    return JSON.stringify(obj);
+  }
+
+  static parsingFunction(key: any, value: any) {
+    var a;
+    if (typeof value === "string") {
+      a =
+        /^[0-9]{4}\-[0-9]{2}\-[0-9]{2}T[0-9]{2}\:[0-9]{2}\:[0-9]{2}\.[0-9]{3}Z$/.exec(
+          value
+        );
+      if (a) {
+        return new Date(a as any);
+      }
+    }
+    return value;
+  }
+
+  static parse(str: string) {
+    if (str && str != "undefined") {
+      return JSON.parse(str, JsonParser.parsingFunction);
+    }
+    return str;
+  }
+}

package/src/lib/websocket/lifecycle/loading-status.ts

@@ -0,0 +1,32 @@
+import { WebsocketClient } from '../client';
+
+export class LoadingStatus extends WebsocketClient {
+  private __proto__: any;
+  static loading: Map<string, boolean>;
+  get isLoading(): boolean {
+    // return general loading
+    let anyTrue = false;
+    this.__proto__.loading.forEach((e: boolean) => {
+      anyTrue ||= e;
+    });
+    if (!anyTrue) this.__proto__.loading.clear();
+    return this.__proto__.loading.size > 0;
+  }
+  getLoadingMap(): Map<string, boolean> {
+    return this.__proto__.loading;
+  }
+
+  get getCurrent(): number {
+    let count = 0;
+    this.__proto__.loading.forEach((e: boolean) => {
+      if (e) count++;
+    });
+    if (count == 0) {
+      this.__proto__.loading.clear();
+    }
+    return count;
+  }
+  get getTotal(): number {
+    return this.__proto__.loading.size;
+  }
+}