@gudhub/core 1.0.37

package/GUDHUB/PipeService/PipeService.js

@@ -0,0 +1,167 @@
+/*============================================================================*/
+/*========================     PIPE MODULE     ===============================*/
+/*============================================================================*/
+
+/*
+|    ======================== PIPE EVENTS TYPES =================================
+|
+|
+|    ---------------------------- APP EVENTS -----------------------------------
+|    'gh_app' - send event when element initialised
+|    'gh_app_info_get' - Return app_name, app_id, app_icon
+|    'gh_app_get' -
+|    'gh_app_update' -
+|    'gh_apps_list_get' -
+|    'gh_delete_app' -
+|    'gh_apps_list_update' -
+|
+|    ---------------------------- VIEW EVENTS -----------------------------------
+|    'gh_app_views_update' -
+|    'gh_app_views_get' -
+|    'gh_app_view_get' -
+|    -------------------------- ITEM EVENTS ------------------------------------
+|
+|    'gh_items_get' - get items_list
+|    'gh_items_chunks_get' - get items splitted to chunks with specified chunk size
+|    'gh_items_update' - update items_list
+|
+|    'gh_item_update' - item's any field value update
+|    'gh_item_get' - item fields value get
+|
+|    -------------------------- FIELD EVENTS -----------------------------------
+|
+|    'gh_model_get' - get field model in field_list.
+|    'gh_model_update' - update field model in field_list
+|    'gh_model_delete' - delete field model from field_list and from items
+|
+|
+|
+|    'gh_models_edit' - use in 'edit_template','edit_field' and 'edit_interpretation'
+|                      actions
+|    'gh_models_get' - get field_model list.
+|
+|
+|
+|    'gh_value_update' - update field value in item
+|    'gh_value_get' - get field value
+|    'gh_interpreted_value_get' - get field interpretation
+|    'gh_value_set' - setter of field value
+|
+*/
+
+import { checkParams, createId } from "./utils.js";
+
+export class PipeService {
+  constructor() {
+    this.subscribers = {};
+  }
+
+  //============================== ON PIPE ====================================//
+  /*----------------------------------------------------------------------------
+       |  Params:
+       |    'type' - String (require). type of event ('gh_field_update', ........)
+       |          from event list or maybe 'gh_field_update gh_field_value_update'
+       |    'destination' - Object (require).
+       |      {
+       |        app_id: '',
+       |        item_id: ''
+       |        field_id: ''
+       |      }
+       |    'fn' - Function (require). callback function
+       |    'scope' - Scope
+       |------------------------------------------------------------------------------*/
+
+  on(types, destination, fn) {
+    if (checkParams(types, destination, fn)) {
+      types
+        .split(" ")
+        .map((type) => {
+          return type + ":" + createId(destination);
+        })
+        .forEach((typeWithId) => {
+          if (!this.subscribers[typeWithId]) {
+            this.subscribers[typeWithId] = new Set();
+          }
+
+          this.subscribers[typeWithId].add(fn);
+        });
+    }
+    return this;
+  }
+
+  //============================== EMIT PIPE ====================================//
+  /*------------------------------------------------------------------------------
+       |  Params:
+       |    'type' - String (require). type of event ('gh_field_update', ........)
+       |            from eventlist
+       |    'destination' - Object (require).
+       |        {
+       |          app_id: '',
+       |          item_id: ''
+       |          field_id: ''
+       |        }
+       |    'value' - Any (require). Emiter value to  subscribers
+       |-------------------------------------------------------------------------------*/
+
+  emit(types, destination, address, params) {
+    types.split(" ").forEach((type) => {
+      const listenerName = type + ":" + createId(destination);
+
+      if (this.subscribers[listenerName]) {
+        this.subscribers[listenerName].forEach(function (fn) {
+          fn(null, address, params);
+        });
+      }
+    });
+    return this;
+  }
+
+  //============================== ON ROOT PIPE ====================================//
+  /*---------------------------------------------------------------------------------
+       |  Params:
+       |    'type' - String (require). type of event ('gh_field_update', ........)
+       |          from event list or maybe 'gh_field_update gh_field_value_update'
+       |    'destination' - Object (require).
+       |      {
+       |        app_id: '',
+       |        item_id: ''
+       |        field_id: ''
+       |      }
+       |    'fn' - Function (require). callback function
+       |---------------------------------------------------------------------------------*/
+
+  onRoot(type, destination, fn) {
+    return this.on(type, destination, fn);
+  }
+
+  //=========================== DELETE LISTENER =================================//
+  /*-------------------------------------------------------------------------------
+       |  Params:
+       |    'type' - String (require). type of event ('gh_field_update', ........)
+       |            from eventlist
+       |    'destination' - Object (require).
+       |        {
+       |          app_id: '',
+       |          item_id: ''
+       |          field_id: ''
+       |        }
+       |--------------------------------------------------------------------------------*/
+
+  destroy(types, destination, func) {
+    types.split(" ").forEach((type) => {
+      const listenerName = type + ":" + createId(destination);
+      
+      //if we pass a function then we remove just function in subscriber property
+      if (this.subscribers[listenerName] && func) {
+        this.subscribers[listenerName].delete(func);
+      }
+
+      //if we are not passing a function then we remove a subscriber property
+      if (this.subscribers[listenerName] && !func) {
+        delete this.subscribers[listenerName]
+      }
+    });
+
+    return this;
+  }
+}

package/GUDHUB/PipeService/PipeService.test.js

@@ -0,0 +1,64 @@
+import should from "should";
+import { data } from "../../fake_server/fake_server_data/fake_server_data.js";
+import {GudHub} from './../gudhub.js';
+
+describe("PipeService", () => {
+  var auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+  const gudhub = new GudHub(auth_key);
+
+  it("add new subscriber", () => {
+    gudhub.on("gh_items_get", { app_id: 121 }, () => {});
+    gudhub.pipeService.subscribers.should.have.property("gh_items_get:121");
+    gudhub.pipeService.subscribers["gh_items_get:121"].size.should.equal(1);
+  });
+
+  it("add new subscriber and emit it", () => {
+    gudhub.on("gh_app_get", {}, (event, request) => {
+      const app = data[request.app_id];
+      gudhub.pipeService.emit("gh_app_get", request, app);
+    });
+
+    gudhub
+      .on("gh_app_get", { app_id: 214 }, (event, app) => {
+        app.app_name.should.have.equal("Aqua-Test");
+      })
+      .emit("gh_app_get", {}, { app_id: 214 });
+  });
+
+  it("add new subscriber on App and delete it", () => {
+    function getApp() {}
+
+    gudhub.on("gh_app_get", { app_id: 200 }, getApp);
+    gudhub.pipeService.subscribers["gh_app_get:200"].size.should.have.equal(1);
+    gudhub.destroy("gh_app_get", { app_id: 200 }, getApp);
+    gudhub.pipeService.subscribers["gh_app_get:200"].size.should.have.equal(0);
+  });
+
+  it("add new subscriber on GH-Element value update and delete it", () => {
+    function modelUpdate() {}
+    var model_address = {
+      app_id: 11,
+      field_id: 222
+    };
+    gudhub.on("gh_model_update", model_address, modelUpdate);
+    gudhub.pipeService.subscribers["gh_model_update:11.222"].size.should.have.equal(1);
+    gudhub.destroy("gh_model_update", model_address, modelUpdate);
+    gudhub.pipeService.subscribers["gh_model_update:11.222"].size.should.have.equal(0);
+  });
+
+
+  it("add several subscriber on one GH-Element and delete all of them at one function call", () => {
+    function modelUpdate() {};
+    function modelGet() {};
+    var model_address = {
+      app_id: 22,
+      field_id: 333
+    };
+    gudhub.on("gh_model_update", model_address, modelUpdate);
+    gudhub.on("gh_model_update", model_address, modelGet);
+    gudhub.pipeService.subscribers["gh_model_update:22.333"].size.should.have.equal(2);
+    gudhub.destroy("gh_model_update", model_address);
+    gudhub.pipeService.subscribers.should.not.have.property("gh_model_update:22.333");
+  });
+
+});

package/GUDHUB/PipeService/utils.js

@@ -0,0 +1,32 @@
+
+export function createId(obj) {
+    let stringId = "";
+    for (let key in obj) {
+        if (obj.hasOwnProperty(key) && obj[key]) {
+            stringId += "." + obj[key];
+        }
+    }
+    return stringId ? stringId.substring(1) : "any";
+}
+
+export function checkParams(type, destination, fn) {
+    if (type == undefined || typeof type !== "string") {
+        console.log(
+            "Listener type is \"undefined\" or not have actual 'type' for subscribe"
+        );
+        return false;
+    }
+
+    if (destination == undefined || typeof destination !== "object") {
+        console.log(
+            "Listener destination is \"undefined\" or not have actual 'type' for subscribe"
+        );
+        return false;
+    }
+
+    if (typeof fn !== "function") {
+        console.log("Listener is not a function for subscribe!");
+        return false;
+    }
+    return true;
+}

package/GUDHUB/Processors/AppProcessor/AppProcessor.js

@@ -0,0 +1,433 @@
+import { IS_WEB } from "../../consts.js";
+
+export class AppProcessor {
+  constructor(
+    storage,
+    pipeService,
+    req,
+    websocket,
+    chunksManager,
+    util,
+    activateSW
+  ) {
+    this.storage = storage;
+    this.pipeService = pipeService;
+    this.req = req;
+    this.ws = websocket;
+    this.applistReceived = false;
+    this.activateSW = activateSW; // we use this flag to check if applist was received. The problem is that if you receive an app it also goes to app_list as a result you have the app_list with one app.
+    this.chunksManager = chunksManager;
+    this.util = util;
+    this.appListeners();
+  }
+
+  async createNewAppApi(app) {
+    try {
+      const response = await this.req.post({
+        url: "/api/app/create",
+        form: { app: JSON.stringify(app) },
+      });
+      response.from_apps_list = true;
+      return response;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async updateAppApi(app) {
+    try {
+      const response = await this.req.post({
+        url: "/api/app/update",
+        form: { app: JSON.stringify(app) },
+      });
+      return response;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async deleteAppApi(app_id) {
+    try {
+      const response = await this.req.post({
+        url: "/api/app/delete",
+        form: { app_id },
+      });
+      return response;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async getAppListApi() {
+    try {
+      const response = await this.req.get({
+        url: "/api/applist/get",
+      });
+      return response.apps_list.map((app) => {
+        app.from_apps_list = true;
+        return app;
+      });
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async getAppApi(app_id) {
+    try {
+      const response = await this.req.get({
+        url: "/api/app/get",
+        params: {
+          app_id: app_id,
+        },
+      });
+      return response;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  getAppListFromStorage() {
+    return this.storage.getAppsList();
+  }
+
+  getAppFromStorage(app_id) {
+    const app = this.storage.getApp(app_id);
+    return app && app.field_list.length ? app : null;
+  }
+
+  addNewAppToStorage(app) {
+    return this.storage.getAppsList().push(app);
+  }
+
+  saveAppInStorage(app) {
+    const storageApp = this.storage.getApp(app.app_id);
+    if (storageApp) {
+      app.from_apps_list = storageApp.from_apps_list;
+      app.permission = storageApp.permission;
+      this.storage.updateApp(app);
+    } else {
+      app.from_apps_list = false;
+      this.addNewAppToStorage(app);
+    }
+    return this.getAppFromStorage(app.app_id);
+  }
+
+  updatingAppInStorage(app) {
+    const storageApp = this.getAppFromStorage(app.app_id);
+    app.items_list = storageApp.items_list;
+    app.file_list = storageApp.file_list;
+    app.from_apps_list = storageApp.from_apps_list;
+    this.storage.updateApp(app);
+    //-- Sending updates for Views Updates
+    this.pipeService.emit(
+      "gh_app_views_update",
+      { app_id: app.app_id },
+      app.views_list
+    );
+
+    //-- Sending updates for updating Fields
+    app.field_list.forEach((fieldModel) => {
+      this.pipeService.emit(
+        "gh_model_update",
+        { app_id: app.app_id, field_id: fieldModel.field_id },
+        fieldModel
+      );
+    });
+  }
+
+  deletingAppFromStorage(app_id) {
+    let appList = this.storage.getAppsList();
+    appList.forEach((app, key) => {
+      if (app.app_id == app_id) appList.splice(key);
+    });
+
+    return appList;
+  }
+
+  //-- here we check if app already in storage then we dont update it.
+  //-- the thing is that is posible that we receive app before receiveng an applist
+  updateAppsListInStorage(appsList = []) {
+    for (const app of appsList) {
+      const storageApp = this.storage.getApp(app.app_id);
+      if (storageApp) {
+        storageApp.from_apps_list = app.from_apps_list;
+        storageApp.permission = app.permission;
+      } else this.addNewAppToStorage(app);
+    }
+  }
+
+  async refreshApps(apps_id = []) {
+    for (const app_id of apps_id) {
+      if (app_id != undefined && this.storage.getApp(app_id)) {
+        try {
+          const app = await this.getAppApi(app_id);
+          if (app) {
+            this.storage.updateApp(app);
+          }
+        } catch (err) {
+          console.log(err);
+        }
+      }
+    }
+    console.log("Apps refreshed: ", JSON.stringify(apps_id));
+  }
+
+  async getAppsList() {
+    let app_list = this.getAppListFromStorage();
+    if (!this.applistReceived) {
+      let received_app_list = await this.getAppListApi();
+      if (!received_app_list) return null;
+
+      // for oprimization purpose: in case when there was severals calls at same moment of the getAppLists one call will overwrite app_list of another call with the same app_list,
+      this.updateAppsListInStorage(received_app_list);
+      this.applistReceived = true;
+      app_list = received_app_list;
+    }
+
+    return app_list;
+  }
+
+  //********** GET APP INFO ************/
+  //-- it returs App with Empty fields_list, items_list, file_list, views_list
+  //-- Such simmple data needed to render App Icons, and do some simple updates in App like updating App name icon permisions etc when full app data is not needed
+  async getAppInfo(app_id) {
+    const app_list = await this.getAppsList();
+    return app_list ? app_list.find((app) => app.app_id == app_id) : null;
+  }
+
+  async deleteApp(app_id) {
+    await this.deleteAppApi(app_id);
+    return this.deletingAppFromStorage(app_id);
+  }
+
+  async getApp(app_id) {
+    if (!app_id) return null;
+
+    let app = this.getAppFromStorage(app_id);
+    if (!app) {
+      let receivedApp = await this.getAppApi(app_id);
+      if (!receivedApp) return null;
+
+      //!!! temporary check !!!! if app has chanks property then we start getting it
+      if (receivedApp.chunks && receivedApp.chunks.length) {
+        this.chunksManager
+          .getChunks(app_id, receivedApp.chunks)
+          .then((chunks) => {
+            receivedApp.items_list = this.util.mergeChunks([
+              ...chunks,
+              receivedApp,
+            ]);
+            this.saveAppInStorage(receivedApp);
+            this.pipeService.emit(
+              "gh_items_update",
+              { app_id },
+              receivedApp.items_list
+            );
+          });
+        app = receivedApp
+        this.saveAppInStorage(receivedApp);
+      } else {
+        app = this.getAppFromStorage(app_id);
+        // for oprimization purpose: we check if app was already received in case when there was severals calls at same moment of the getApp one call will overwrite the App from another call with the same App,
+        if (!app) {
+          app = receivedApp;
+          this.saveAppInStorage(receivedApp); //!!! will be saved over several times for each app request
+          this.ws.addSubscription(app_id);
+        }
+      }
+    }
+    
+    return app;
+  }
+
+  async updateApp(app) {
+    if (!app.view_list || !app.view_list.length) {
+      const storageApp = await this.getApp(app.app_id);
+      app.view_list = storageApp.view_list;
+    }
+    const updatedApp = await this.updateAppApi(app);
+    this.updatingAppInStorage(updatedApp);
+    return updatedApp;
+  }
+
+  async updateAppInfo(appInfo = {}) {
+    const app = this.getAppFromStorage(appInfo.app_id);
+    return this.updateApp({ ...app, ...appInfo });
+  }
+
+  async createNewApp(app) {
+    const newApp = await this.createNewAppApi(app);
+    this.addNewAppToStorage(newApp);
+    return newApp;
+  }
+
+  clearAppProcessor() {
+    this.getAppListPromises = null;
+    this.getAppPromises = {};
+    this.applistReceived = false;
+  }
+
+  appListeners() {
+    this.pipeService.onRoot("gh_app_get", {}, async (event, data) => {
+      if (data && data.app_id) {
+        const app = await this.getApp(data.app_id);
+        this.pipeService.emit("gh_app_get", data, app);
+      }
+    });
+
+    this.pipeService.onRoot("gh_apps_list_get", {}, async (event, data) => {
+      const appList = await this.getAppsList();
+      this.pipeService.emit("gh_apps_list_get", data, appList);
+    });
+
+    this.pipeService.onRoot("gh_delete_app", {}, async (event, data) => {
+      const appList = await this.deleteApp(data.app_id);
+      this.pipeService.emit(
+        "gh_apps_list_update",
+        { recipient: "all" },
+        appList
+      );
+    });
+
+    this.pipeService.onRoot("gh_app_update", {}, async (event, data) => {
+      data.app.items_list = [];
+      data.app.file_list = [];
+
+      const newApp = await this.updateApp(data.app);
+
+      this.pipeService.emit(
+        "gh_app_views_update",
+        { app_id: newApp.app_id },
+        newApp.views_list
+      );
+
+      const appsList = await this.getAppsList();
+      this.pipeService.emit(
+        "gh_apps_list_update",
+        { recipient: "all" },
+        appsList
+      );
+
+      newApp.field_list.forEach((fieldModel) => {
+        this.pipeService.emit(
+          "gh_model_update",
+          {
+            app_id: newApp.app_id,
+            field_id: fieldModel.field_id,
+          },
+          fieldModel
+        );
+      });
+    });
+
+    this.pipeService.onRoot("gh_app_view_get", {}, async (event, data) => {
+      if (data && data.app_id) {
+        const app = await this.getApp(data.app_id);
+        app.views_list.forEach((view, key) => {
+          if (view.view_id == data.view_id) {
+            this.pipeService.emit("gh_app_view_get", data, app.views_list[key]);
+          }
+        });
+      }
+    });
+
+    this.pipeService.onRoot("gh_app_views_get", {}, async (event, data) => {
+      if (data && data.app_id) {
+        const app = await this.getApp(data.app_id);
+        this.pipeService.emit("gh_app_views_get", data, app.views_list);
+      }
+    });
+
+    // Return app_name, app_id, app_icon
+    this.pipeService.onRoot("gh_app_info_get", {}, async (event, data) => {
+      const appInfo = await this.getAppInfo(data.app_id);
+      if (appInfo) this.pipeService.emit("gh_app_info_get", data, appInfo);
+    });
+
+    this.pipeService.onRoot("gh_app_info_update", {}, async (event, data) => {
+      if (data && data.app) {
+        const appInfo = await this.updateAppInfo(data.app);
+        this.pipeService.emit(
+          "gh_app_info_update",
+          { app_id: data.app.app_id },
+          appInfo
+        );
+      }
+    });
+
+    this.pipeService.onRoot("gh_app_create", {}, async (event, data) => {
+      await this.createNewApp(data.app);
+      const appsList = await this.getAppsList();
+      this.pipeService.emit(
+        "gh_apps_list_update",
+        { recipient: "all" },
+        appsList
+      );
+    });
+    if (IS_WEB && this.activateSW) {
+      navigator.serviceWorker.addEventListener("message", async (event) => {
+        if (event.data.type === "refresh app") {
+          const app = this.getAppFromStorage(event.data.payload.app_id);
+          if (app && app.items_list.length) {
+            this.util.compareAppsItemsLists(
+              event.data.payload.items_list,
+              app.items_list,
+              ({ diff_fields_items, diff_fields_items_Ids, diff_items }) => {
+                if (diff_items.length) {
+                  this.pipeService.emit(
+                    "gh_items_update",
+                    { app_id: event.data.payload.app_id },
+                    event.data.payload.items_list
+                  );
+                  diff_items.forEach((item) =>
+                    this.pipeService.emit(
+                      "gh_item_update",
+                      { app_id: event.data.payload.app_id, item_id: item.item_id },
+                      item
+                    )
+                  );
+                }
+                diff_fields_items_Ids.forEach((item_id) => {
+                  const item = diff_fields_items[item_id];
+                  if (!item) return;
+                  item.forEach((field) => {
+                    this.pipeService.emit(
+                      "gh_value_update",
+                      {
+                        app_id: event.data.payload.app_id,
+                        item_id,
+                        field_id: field.field_id,
+                      },
+                      field.field_value
+                    );
+                  });
+                });
+              }
+            );
+          }
+          event.data.payload.items_list = this.util.mergeChunks([app, event.data.payload])
+          this.saveAppInStorage(event.data.payload);
+        }
+        // if (event.data.type === "refresh appList") {
+        //   this.storage.unsetApps();
+        //   this.updateAppsListInStorage(
+        //     event.data.payload.apps_list.map((app) => {
+        //       app.from_apps_list = true;
+        //       return app;
+        //     })
+        //   );
+        //   this.pipeService.emit(
+        //     "gh_apps_list_update",
+        //     { recipient: "all" },
+        //     event.data.payload.apps_list
+        //   );
+        // }
+      });
+    }
+  }
+}