@gudhub/core 1.0.37

package/GUDHUB/Utils/merge_objects/merge_objects.js

@@ -0,0 +1,120 @@
+// Value of properties for source object woun't be changed by target object
+// If source of target hase unique properties they are going to be created in resulted object
+
+export function mergeObjects(target, source, optionsArgument){
+    return deepmerge(target, source, optionsArgument)
+}
+
+
+
+/* Deepmerge - Start */
+// this code was copied from  https://codepen.io/pushpanathank/pen/owjJGG
+// Basicaly I need it to marge field models
+function isMergeableObject(val) {
+    var nonNullObject = val && typeof val === 'object'
+
+    return nonNullObject
+        && Object.prototype.toString.call(val) !== '[object RegExp]'
+        && Object.prototype.toString.call(val) !== '[object Date]'
+}
+
+
+function emptyTarget(val) {
+    return Array.isArray(val) ? [] : {}
+}
+
+
+function cloneIfNecessary(value, optionsArgument) {
+    var clone = optionsArgument && optionsArgument.clone === true
+    return (clone && isMergeableObject(value)) ? deepmerge(emptyTarget(value), value, optionsArgument) : value
+}
+
+
+function defaultArrayMerge(target, source, optionsArgument) {
+    var destination = target.slice()
+    source.forEach(function(e, i) {
+        if (typeof destination[i] === 'undefined') {
+            destination[i] = cloneIfNecessary(e, optionsArgument)
+        } else if (isMergeableObject(e)) {
+            destination[i] = deepmerge(target[i], e, optionsArgument)
+        } else if (target.indexOf(e) === -1) {
+            destination.push(cloneIfNecessary(e, optionsArgument))
+        }
+    })
+    return destination
+}
+
+
+function mergeObject(target, source, optionsArgument) {
+    var destination = {}
+    if (isMergeableObject(target)) {
+        Object.keys(target).forEach(function (key) {
+            destination[key] = cloneIfNecessary(target[key], optionsArgument)
+        })
+    }
+    Object.keys(source).forEach(function (key) {
+        if (!isMergeableObject(source[key]) || !target[key]) {
+            destination[key] = cloneIfNecessary(source[key], optionsArgument)
+        } else {
+            destination[key] = deepmerge(target[key], source[key], optionsArgument)
+        }
+    })
+    return destination
+}
+
+function deepmerge(target, source, optionsArgument) {
+    var array = Array.isArray(source);
+    var options = optionsArgument || { arrayMerge: defaultArrayMerge }
+    var arrayMerge = options.arrayMerge || defaultArrayMerge
+
+    if (array) {
+        return Array.isArray(target) ? arrayMerge(target, source, optionsArgument) : cloneIfNecessary(source, optionsArgument)
+    } else {
+        return mergeObject(target, source, optionsArgument)
+    }
+}
+
+deepmerge.all = function deepmergeAll(array, optionsArgument) {
+    if (!Array.isArray(array) || array.length < 2) {
+        throw new Error('first argument should be an array with at least two elements')
+    }
+
+    // we are sure there are at least 2 values, so it is safe to have no initial value
+    return array.reduce(function(prev, next) {
+        return deepmerge(prev, next, optionsArgument)
+    })
+}
+/* Deepmerge - Ends */
+
+
+// // Sample
+// const defaultPerson = {
+//   name: 'Push',
+//   gender: 'Male',
+//   hair: {
+//     color: 'Black',
+//     cut: 'Short'
+//   },
+//   eyes: 'blue',
+//   family: ['mom', 'dad']
+// };
+
+// const me = {
+//   name: 'Nathan',
+//   gender: 'Male',
+//   hair: {
+//     cut: 'Long'
+//   },
+//   family: ['wife', 'kids', 'dog']
+// };
+
+// const result1 = deepmerge(defaultPerson, me);
+// document.getElementById('result1').innerHTML = JSON.stringify(result1, null, "\t");
+
+// const result2 = deepmerge.all([,
+//   { level1: { level2: { name: 'Push', parts: ['head', 'shoulders'] } } },
+//   { level1: { level2: { face: 'Round', parts: ['knees', 'toes'] } } },
+//   { level1: { level2: { eyes: 'Black', parts: ['eyes'] } } },
+// ]);
+
+// document.getElementById('result2').innerHTML = JSON.stringify(result2, null, "\t");

package/GUDHUB/Utils/merge_objects/merge_objects.test.js

@@ -0,0 +1,137 @@
+import should from "should";
+import {GudHub} from '../../gudhub.js';
+
+describe("MERGE OBJECTS", function () {
+  const gudhub = new GudHub();
+  
+  
+  it("MERGE TWO SIMPLE OBJECTS : data_model should have a new property", function () {
+    gudhub.mergeObjects(simpleTarget, simpleSource).data_model.should.have.property("regular_expresion", "/[0.9]/")
+    gudhub.mergeObjects(simpleTarget, simpleSource).data_model.should.have.property("precision", "1")
+  });
+
+
+  it("MERGE INTERPRETATIONS : table interpretation should be changed", function () {
+    gudhub.mergeObjects(simpleTarget, simpleSource).data_model.should.have.property("regular_expresion", "/[0.9]/");
+
+    let tableInterpretation = gudhub.mergeObjects(interpretationTarget, interpretationSource).data_model.interpretation.find((interp) => interp.src == "table");
+    tableInterpretation.settings.should.have.property("show_field", 1);
+    tableInterpretation.settings.should.have.property("show_field_name", 0);
+    tableInterpretation.settings.should.have.property("editable", 1);
+    
+    let containerInterpretation = gudhub.mergeObjects(interpretationTarget, interpretationSource).data_model.interpretation.find((interp) => interp.src == "31963");
+    tableInterpretation.settings.should.have.property("show_field", 1);
+  });
+});
+
+
+
+
+/*---------------------- MOCKS-----------------------*/
+let simpleTarget = {
+  "field_id": 1446,
+  "element_id": 1446,
+  "name_space": "ph",
+  "field_priority": 0,
+  "field_name": "pH",
+  "data_model": {
+      "precision": "1",
+      "interpretation": []
+  },
+  "data_type": "number"
+};
+
+let simpleSource = {
+  "field_id": 1446,
+  "element_id": 1446,
+  "name_space": "ph",
+  "field_priority": 0,
+  "field_name": "pH",
+  "data_model": {
+      "regular_expresion" : "/[0.9]/",
+      "interpretation": []
+  },
+  "data_type": "number"
+};
+
+
+let interpretationSource = {
+  "field_id": 1446,
+  "element_id": 1446,
+  "name_space": "ph",
+  "field_priority": 0,
+  "field_name": "pH",
+  "data_model": {
+      "precision": "1",
+      "interpretation": [
+          {
+            "src": "table",
+            "id": "default",
+            "settings": {
+                "show_field_name": 0,
+                "editable":1
+            },
+          },{
+            "src": "31963",
+            "id": "default",
+            "settings": {
+              "editable": 1, 
+              "show_field_name": 1, 
+              "show_field": 1
+            }
+          }
+      ]
+  },
+  "data_type": "number"
+};
+
+
+let interpretationTarget = {
+  "field_id": 1449,
+  "element_id": 1449,
+  "name_space": "kh",
+  "field_priority": 0,
+  "field_name": "KH",
+  "data_model": {
+      "precision": "0",
+      "interpretation": [
+          {
+              "src": "table",
+              "id": "default",
+              "settings": {
+                  "show_field": 1,
+                  "editable":0
+              }
+          },
+          {
+              "src": "form",
+              "id": "input_with_name",
+              "settings": {
+                  "show_field": 1
+              }
+          },
+          {
+              "src": "dropdown",
+              "id": "default",
+              "settings": {
+                  "show_field": 1
+              }
+          },
+          {
+              "src": "input",
+              "id": "default",
+              "settings": {
+                  "show_field": 1
+              }
+          },
+          {
+              "src": "input_list",
+              "id": "default",
+              "settings": {
+                  "show_field": 1
+              }
+          }
+      ]
+  },
+  "data_type": "number"
+};

package/GUDHUB/Utils/nested_list/nested_list.js

@@ -0,0 +1,38 @@
+export function makeNestedList(arr, id, parent_id, children_property) {
+  let array = JSON.parse(JSON.stringify(arr));
+  let children = Boolean(children_property) ? children_property : 'children';
+  let i;
+  for (i = 0; i < array.length; i++) {
+    if (array[i][parent_id] && array[i][parent_id] !== 0) {
+      array.forEach((parent) => {
+        if (array[i][parent_id] == parent[id]) {
+          if (!parent[children]) {
+            parent[children] = [];
+          }
+          parent[children].push(array[i]);
+          array.splice(i, 1);
+          i--;
+        } else if (parent[children]) {
+          findIdsOfChildren(parent);
+        }
+      });
+    }
+  }
+
+  function findIdsOfChildren(parent) {
+    parent[children].forEach((child) => {
+      if (child[id] == array[i][parent_id]) {
+        if (!child[children]) {
+          child[children] = [];
+        }
+        child[children].push(array[i]);
+        array.splice(i, 1);
+        i--;
+      } else if (child[children]) {
+        findIdsOfChildren(child);
+      }
+    });
+  }
+
+  return array;
+}

package/GUDHUB/Utils/nested_list/nested_list.test.js

@@ -0,0 +1,70 @@
+import should from "should";
+import { GudHub } from '../../gudhub.js';
+
+describe("NESTED LIST", function () {
+    const gudhub = new GudHub();
+
+    it("Should return right name value of second children", function () {
+        let nestedList = gudhub.makeNestedList(input, 'id', 'parent_id');
+        nestedList[0].children[0].children[0].name.should.equal('Article 4')
+    });
+
+    it('Should return default children property name', function () {
+        let nestedList = gudhub.makeNestedList(input, 'id', 'parent_id');
+        nestedList[0].children[0].should.have.property('children');
+    })
+
+    it('Should return custom children property name', function () {
+        let nestedList = gudhub.makeNestedList(input, 'id', 'parent_id', 'custom_children');
+        nestedList[0].custom_children[0].should.have.property('custom_children');
+    })
+
+});
+
+let input = [
+    {
+        name: "Article 1",
+        id: 1,
+        parent_id: 0
+    },
+    {
+        name: "Article 2",
+        id: 2,
+        parent_id: 0
+    },
+    {
+        name: "Article 3",
+        id: 3,
+        parent_id: 1
+    },
+    {
+        name: "Article 4",
+        id: 4,
+        parent_id: 3
+    },
+    {
+        name: "Article 5",
+        id: 5,
+        parent_id: 3
+    },
+    {
+        name: "Article 6",
+        id: 6,
+        parent_id: 4
+    },
+    {
+        name: "Article 7",
+        id: 7,
+        parent_id: 6
+    },
+    {
+        name: "Article 8",
+        id: 8,
+        parent_id: 3
+    },
+    {
+        name: "Article 9",
+        id: 9,
+        parent_id: 8
+    },
+];

package/GUDHUB/Utils/populate_items/populate_items.js

@@ -0,0 +1,66 @@
+//********************************************//
+//******************* ITEMS ******************//
+//********************************************//
+
+/*
+|====================================== ITEMS UPDATE ================================|
+|===========      updateItems (items, model, eraseOtherValues)           ============|
+|====================================================================================|
+|
+|   items - GudHub items those we are going to be updated
+|   eraseOtherValues - if is 'true' then we erase fields those are not going to be updated
+|   model - by this model we update values. The model format should have folowing format:
+|
+|   
+|   model = [
+|    {
+|       "element_id" : 228464,
+|       "field_value" : 777
+|    }]
+|
+|==================================================================================|
+*/
+
+
+//********************** UPDATE ITEMS ************************/
+export default function populateItems(items, model, keep_data) {
+  var itemsCopy = JSON.parse(JSON.stringify(items));
+  if (keep_data) {
+    return populateItemsAndKeepOtherValues(itemsCopy, model);
+  } else {
+    return populateItemsAndEraseOtherValues(itemsCopy, model);
+  }
+}
+
+
+//---- Update Items And KEEP Other Values ----//
+function populateItemsAndKeepOtherValues(items, model) {
+  items.forEach(item => {
+    model.forEach(modelField => {
+      let field = item.fields.find(sourceField => sourceField.element_id == modelField.element_id);
+
+      if (field) {
+        field.field_value = modelField.field_value;
+      } else {//-- if we didn't find field with item then we add it
+        modelField.field_id = modelField.element_id; //backend send ERROR if don't send field_id
+        item.fields.push(modelField);
+      }
+    });
+  });
+
+  return items;
+}
+
+
+//---- Update Items And ERASE Other Values ----//
+function populateItemsAndEraseOtherValues(items, model) {
+  items.forEach(item => {
+    item.fields = [].concat(model);
+  });
+
+  return items;
+}
+
+
+          
+

package/GUDHUB/WebSocket/WebSocket.js

@@ -0,0 +1,136 @@
+import Websocket from "ws";
+
+export class WebSocketApi {
+  constructor(url, auth) {
+    this.websocket = null;
+    this.connected = false;
+    this.queue = [];
+    this.url = url;
+    this.auth = auth;
+    this.heartBeatTimeStemp = 10000000000000;
+    this.ALLOWED_HEART_BEAT_DELEY = 12000;
+    this.firstHeartBeat = true;
+    this.reload = true;
+    this.isBrowser = ![typeof window, typeof document].includes("undefined");
+  }
+
+  async addSubscription(app_id) {
+    //console.log("Added new subscription: app_id - ", app_id);
+
+    const token = await this.auth.getToken();
+    const subscription = `token=${token}/~/app_id=${app_id}`;
+
+    if (this.connected) {
+      this.websocket.send(subscription);
+    }
+
+    this.queue.push(app_id);
+  }
+
+  async onOpen() {
+    this.reload = true;
+    console.log("websocket opened");
+
+    this.connected = true;
+    const token = await this.auth.getToken();
+
+    this.queue.forEach((queue) => {
+      const subscription = `token=${token}/~/app_id=${queue}`;
+      this.websocket.send(subscription);
+    });
+  }
+
+  onError(error) {
+    console.log("websocket error: ", error);
+
+    this.websocket.close();
+  }
+
+  onClose() {
+    console.log("websocket close");
+
+    this.connected = false;
+    this.initWebSocket();
+  }
+
+  async onMessage(event) {
+    const message = this.isBrowser ? event.data : event
+    if (message.match(/HeartBeat/)) {
+      const hartBeatDelay = new Date().getTime() - this.heartBeatTimeStemp;
+
+      if (this.ALLOWED_HEART_BEAT_DELEY < hartBeatDelay) {
+        await this.onConnectionLost();
+      } else {
+        this.websocket.send("HeartBeat");
+        this.heartBeatTimeStemp = new Date().getTime();
+      }
+    }
+
+    if (this.firstHeartBeat) {
+      this.connectionChecker();
+      this.firstHeartBeat = false;
+    }
+
+    if (message.match(/[{}]/)) {
+      let incomeMessage = JSON.parse(message);
+      const token = await this.auth.getToken();
+
+      //-- We don't want to update storage of user who initieted the update. That is why we check if token from websocket is not the same as users token.
+      if (incomeMessage.token != token) {
+        this.onMassageHandler(incomeMessage);
+      }
+    }
+  }
+
+  initWebSocket(onMassageHandler, refreshAppsHandler) {
+    this.onMassageHandler = onMassageHandler;
+    this.refreshAppsHandler = refreshAppsHandler
+    if (this.isBrowser) {
+      this.websocket = new WebSocket(this.url);
+      this.websocket.onopen = this.onOpen.bind(this);
+
+      this.websocket.onerror = this.onError.bind(this);
+
+      this.websocket.onclose = this.onClose.bind(this);
+
+      this.websocket.onmessage = this.onMessage.bind(this);
+    } else {
+      this.websocket = new Websocket(this.url);
+      this.websocket.on("open", this.onOpen);
+
+      this.websocket.on("error", this.onError);
+
+      this.websocket.on("close", this.onClose);
+
+      this.websocket.on("message", this.onMessage);
+    }
+
+    console.log("websocket initialized");
+  }
+
+  connectionChecker() {
+    setInterval(async () => {
+      let hartBeatDelay = new Date().getTime() - this.heartBeatTimeStemp;
+      // console.log(hartBeatDelay, this.ALLOWED_HEART_BEAT_DELEY, "interval");
+      if (this.ALLOWED_HEART_BEAT_DELEY < hartBeatDelay) {
+        await this.onConnectionLost();
+      }
+    }, 1000);
+  }
+
+  async onConnectionLost() {
+    try {
+      await this.auth.getVersion();
+      if (this.reload) {
+        this.reload = false;
+        console.log("Connected");
+        this.heartBeatTimeStemp = 10000000000000;
+
+        this.websocket.close();
+        this.refreshAppsHandler(this.queue);
+      }
+    } catch (error) {
+      console.log(error);
+    }
+  }
+}

package/GUDHUB/config.js

@@ -0,0 +1,8 @@
+export const server_url = "https://gudhub.com/GudHub";
+//export const server_url = "https://gudhub.com/GudHub_Temp";
+//export const server_url = "https://integration.gudhub.com/GudHub_Test";
+//export const server_url = "http://localhost:9000";
+export const wss_url = "wss://gudhub.com/GudHub/ws/app/";
+
+// FOR TESTS
+export const port = 9000;

package/GUDHUB/consts.js

@@ -0,0 +1 @@
+export const IS_WEB = ![typeof window, typeof document].includes("undefined");