@gudhub/core 1.2.4-beta.3 → 1.2.4-beta.30

package/GUDHUB/Storage/ModulesList.js

@@ -931,7 +931,7 @@ export default function generateModulesList(async_modules_path, file_server_url,
             data_type: 'study_journal',
             name: 'Study Journal',
             icon: 'timeline',
-            js: 'https://gudhub.com/modules/Study-Journal/dist/main.js',
+            js: 'https://gudhub.com/modules/Study-Journal/dist/main.js?t=1',
             css: 'https://gudhub.com/modules/Study-Journal/dist/style.css',
             type: 'gh_element',
             technology: 'class'
@@ -958,11 +958,27 @@ export default function generateModulesList(async_modules_path, file_server_url,
             data_type: "text_area",
             name: "Text Area",
             icon: "text_icon",
-            js: "https://gudhub.com/modules/text-area-ghe/dist/main.js?t=1",
+            js: "https://gudhub.com/modules/text-area-ghe/dist/main.js?t=3",
             css: "https://gudhub.com/modules/text-area-ghe/dist/style.css",
             type: "gh_element",
             technology: "class",
         },
+        {
+            data_type: "resource_calendar",
+            name: "Resource Сalendar",
+            icon: "calendar",
+            url: file_server_url + '/' + async_modules_path + "resource_calendar_data.js",
+            type: 'gh_element',
+            technology: 'angular'
+        },
+        {
+            data_type: "visualizer_with_control_panel",
+            name: "Visualizer With Control Panel",
+            icon: 'visualizer',
+            url: file_server_url + '/' + async_modules_path + "visualizer_with_control_panel_data.js",
+            type: 'gh_element',
+            technology: 'angular'
+        },
         /* AUTOMATION MODULES */
         /*
             We have next types for automations:

package/GUDHUB/Utils/AppsTemplateService/AppsTemplateService.js

@@ -195,6 +195,8 @@ export default class AppsTemplateService {
 
     documentInstallerHelper(appId, items, elementId) {
         const self = this;
+        const itemsWithClonedDocument = [];
+
         return new Promise(async (resolve) => {
             for(const item of items) {
                 const itemId = item.item_id;
@@ -216,10 +218,11 @@ export default class AppsTemplateService {
 
                         field.field_value = newDocument._id;
 
+                        itemsWithClonedDocument.push(item);
                     }
                 }
             }
-            resolve();
+            resolve(itemsWithClonedDocument);
         });
     }
 
@@ -480,6 +483,39 @@ export default class AppsTemplateService {
                     parent[prop] = `${self.getValueByPath(app.views_list, path, pron_name)}`;
                 }
 
+                if (prop.indexOf("trigger") !== -1 && value.model && value.model.nodes) {
+                    const nodes = value.model.nodes;
+                    const nodeProperties = ["inputs", "outputs"];
+
+                    for (const index in nodes) {
+                        nodeProperties.forEach((property) => {
+                            const node = nodes[index];
+                            const numericProperties = Object.keys(node[property]).filter(prop => prop !== '' && !isNaN(prop)); // field_id as keys
+
+                            numericProperties.forEach((old_field_id) => {
+                                const correspondFieldOfConnectingMap = appsConnectingMap.fields.filter((field) => field.old_field_id == old_field_id);
+
+                                if (correspondFieldOfConnectingMap.length !== 0 && correspondFieldOfConnectingMap[0].new_field_id) {
+                                    const new_field_id = correspondFieldOfConnectingMap[0].new_field_id.toString();
+
+                                    const connectionObjectCopy = node[property][old_field_id];
+                                    connectionObjectCopy.connections.forEach((connection) => {
+                                        if (connection.input == old_field_id) {
+                                            connection.input = new_field_id;
+                                        }
+                                        if (connection.output == old_field_id) {
+                                            connection.output = new_field_id;
+                                        }
+                                    });
+
+                                    delete node[property][old_field_id];
+
+                                    node[property][new_field_id] = connectionObjectCopy;
+                                }
+                            });
+                        });
+                    };
+                }
             })
         })
 

package/GUDHUB/Utils/Utils.js

@@ -24,6 +24,7 @@ import { FileHelper } from "./FIleHelper/FileHelper.js";
 import { compareObjects } from "./compareObjects/compareObjects.js";
 import { dynamicPromiseAll } from "./dynamicPromiseAll/dynamicPromiseAll.js";
 import { sortItems } from './filter/sortItems.js';
+import { mergeChunksWorker } from "./merge_chunks/merge_chunks.worker.js";
 
 export class Utils {
   constructor(gudhub) {
@@ -126,6 +127,7 @@ export class Utils {
     );
   }
 
+  //here
   compareItems(sourceItems, destinationItems, fieldToCompare) {
     return compareItems(sourceItems, destinationItems, fieldToCompare);
   }
@@ -142,8 +144,19 @@ export class Utils {
     return makeNestedList(arr, id, parent_id, children_property, priority_property);
   }
 
-  mergeChunks(chunks) {
+  async mergeChunks(chunks) {
     return mergeChunks(chunks);
+
+
+    // const chunkWorkerBlob = new Blob([mergeChunksWorker()], {
+    //   type: "application/javascript",
+    // });
+    // this.worker = new Worker(URL.createObjectURL(chunkWorkerBlob));
+    // this.worker.postMessage(chunks);
+    // this.worker.addEventListener("message", (event) => {
+    //   const { diff } = event.data;
+    //   callback(event.data);
+    // });
   }
 
   mergeFieldLists(fieldsToView, fieldList) {
@@ -194,10 +207,25 @@ export class Utils {
     return this.AppsTemplateService.createItems(create_apps, maxNumberOfInsstalledItems);
   }
 
+  areViewListsEqual(list1, list2) {
+    let sortedList1 = list1.sort((e1, e2) => e1.view_id - e2.view_id);
+    let sortedList2 = list2.sort((e1, e2) => e1.view_id - e2.view_id);
+
+    return this.compareObjects(sortedList1, sortedList2);
+  }
+
+  areFieldListsEqual(list1, list2) {
+    let sortedList1 = list1.sort((e1, e2) => e1.field_id - e2.field_id);
+    let sortedList2 = list2.sort((e1, e2) => e1.field_id - e2.field_id);
+
+    return this.compareObjects(sortedList1, sortedList2);
+  }
+
   compareObjects(obj1, obj2) {
     return compareObjects(obj1, obj2);
   }
   
+  //
   compareAppsItemsLists(items_list1, items_list2, callback) {
     const chunkWorkerBlob = new Blob([compare_items_lists_Worker()], {
       type: "application/javascript",

package/GUDHUB/Utils/merge_chunks/merge_chunks.js

@@ -1,31 +1,39 @@
+import { mergeChunks as mergeChunksByMainThread, mergeChunksWorker } from "./merge_chunks.worker.js";
+
+
+// const mergeChunksWorkerSingletone = new Worker('mergeWorker.js'); //TODO
+
+
 export function mergeChunks(chunks) {
-  const result = {};
+  //dont launch new thread because already used in worker.
+  // Main reason is that renderer process allocates memory for structured clones for communication between trheads
+  return mergeChunksByMainThread(chunks);
+
+  if (
+    typeof Worker !== 'undefined'
+  ) {
+    return new Promise((resolve, reject) => {
+      const chunkWorkerBlob = new Blob([mergeChunksWorker()], {
+        type: "application/javascript",
+      });
+  
+      let worker = new Worker(URL.createObjectURL(chunkWorkerBlob));
+  
+      worker.postMessage(chunks);  
 
-  chunks.forEach((chunk) => {
-    chunk.items_list.forEach((item) => {
-      const dstItem = result[item.item_id];
-      if (dstItem) {
-        dstItem.trash = item.trash;
-        return item.fields.forEach((srcField) => {
-          let isFieldNonExist = true;
-          dstItem.fields = dstItem.fields.map((dstField) => {
-            if (Number(dstField.field_id) === Number(srcField.field_id)) {
-              isFieldNonExist = false;
-              if (dstField.field_value != srcField.field_value) {
-                return {
-                  ...srcField,
-                  history: srcField.history.concat(dstField.history),
-                };
-              }
-              return dstField;
-            }
-            return dstField;
-          });
-          if (isFieldNonExist) dstItem.fields.push(srcField);
-        });
-      }
-      return (result[item.item_id] = item);
+      worker.onmessage = function(e) {
+        resolve(e.data);
+        worker.terminate();
+      };
+    
+      worker.onerror = function(e) {
+        reject();
+        worker.terminate();
+      };
+    
+      worker.postMessage(chunks);
     });
-  });
-  return Object.values(result);
-}
+  } else {
+    return mergeChunksByMainThread(chunks);
+  }
+}

package/GUDHUB/Utils/merge_chunks/merge_chunks.worker.js

@@ -0,0 +1,78 @@
+export function mergeChunks(chunks) {
+    const result = {};
+  
+    chunks.forEach((chunk) => {
+      chunk.items_list.forEach((item) => {
+        const dstItem = result[item.item_id];
+        if (dstItem) {
+          dstItem.trash = item.trash;
+          return item.fields.forEach((srcField) => {
+            let isFieldNonExist = true;
+            dstItem.fields = dstItem.fields.map((dstField) => {
+              if (Number(dstField.field_id) === Number(srcField.field_id)) {
+                isFieldNonExist = false;
+                if (dstField.field_value != srcField.field_value) {
+                  return {
+                    ...srcField,
+                    history: srcField.history.concat(dstField.history),
+                  };
+                }
+                return dstField;
+              }
+              return dstField;
+            });
+            if (isFieldNonExist) dstItem.fields.push(srcField);
+          });
+        }
+        return (result[item.item_id] = item);
+      });
+    });
+    return Object.values(result);
+  }
+
+
+self.onmessage = function(e) {      
+    const mergedChunks = mergeChunks(e.data);
+    self.postMessage(mergedChunks);
+}
+
+
+export function mergeChunksWorker() {
+  return `function mergeChunks(chunks) {
+    const result = {};
+  
+    chunks.forEach((chunk) => {
+      chunk.items_list.forEach((item) => {
+        const dstItem = result[item.item_id];
+        if (dstItem) {
+          dstItem.trash = item.trash;
+          return item.fields.forEach((srcField) => {
+            let isFieldNonExist = true;
+            dstItem.fields = dstItem.fields.map((dstField) => {
+              if (Number(dstField.field_id) === Number(srcField.field_id)) {
+                isFieldNonExist = false;
+                if (dstField.field_value != srcField.field_value) {
+                  return {
+                    ...srcField,
+                    history: srcField.history.concat(dstField.history),
+                  };
+                }
+                return dstField;
+              }
+              return dstField;
+            });
+            if (isFieldNonExist) dstItem.fields.push(srcField);
+          });
+        }
+        return (result[item.item_id] = item);
+      });
+    });
+    return Object.values(result);
+  }
+
+
+  self.onmessage = function(e) {      
+    const mergedChunks = mergeChunks(e.data);
+    self.postMessage(mergedChunks);
+  }`;
+}

package/GUDHUB/Utils/merge_compare_items/merge_compare_items.js

@@ -140,7 +140,8 @@
                 is_items_diff: false,
                 new_src_items:[],
                 diff_src_items:[],
-                same_items:[]
+                same_items:[],
+                trash_src_items: [],
             };
 
             const differentSrcItemFn = function(item){
@@ -155,11 +156,32 @@
                 result.new_src_items.push(item);
             }
 
+            const trashSrcItemFn = function(item){
+                result.trash_src_items.push(item);
+            }
+
             
             //---------  Compearing Src & Dst Items by item_id  ---------//
-            if(fieldToCompare){
+            if (
+                fieldToCompare
+            ) {
+                //TODO trashSrcItemFn
                 compareItemsByFieldId(src, dst, fieldToCompare, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn)
-            }else compareItemsByItemId(src, dst, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn)
+            }
+
+            if (
+                !fieldToCompare
+            ) {
+                compareItemsByItemId(
+                    src, 
+                    dst, 
+                    differentSrcItemFn, 
+                    theSameSrcItemFn, 
+                    newSrcItemFn, 
+                    null, 
+                    trashSrcItemFn,
+                );
+            } 
 
 
             //--------- Final Report ---------//
@@ -214,16 +236,17 @@
 
 
 
-        function compareItemsByItemId(src, dst, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn, uniqDestItemFn){
+        function compareItemsByItemId(src, dst, differentSrcItemFn, theSameSrcItemFn, newSrcItemFn, uniqDestItemFn, trashSrcItemFn){
             let dstItemsMap = new ItemsMapper(dst);
 
             src.forEach(srcItem => {
                 let destIndex = dstItemsMap.pullItemIndex(srcItem.item_id);
 
                 if(destIndex != undefined){
-                    compareTwoItems(srcItem, dst[destIndex], differentSrcItemFn, theSameSrcItemFn);
+                    compareTwoItems(srcItem, dst[destIndex], differentSrcItemFn, theSameSrcItemFn, trashSrcItemFn);
                 }else{
-                    newSrcItemFn(srcItem);
+                    if (srcItem.trash) trashSrcItemFn(srcItem);
+                    if (!srcItem.trash) newSrcItemFn(srcItem);
                 };
             });
             
@@ -236,7 +259,7 @@
 
 
 
-        function compareTwoItems (src, dst, differentSrcItemFn, theSameSrcItemFn ){
+        function compareTwoItems (src, dst, differentSrcItemFn, theSameSrcItemFn, trashSrcItemFn){
             let sameItem = true;
 
             for(let i=0; i<src.fields.length; i++){
@@ -254,8 +277,16 @@
             
             //-- Sending Compearing Result
             if (sameItem){
-                theSameSrcItemFn(src, dst);
-            }else differentSrcItemFn(src, dst);
+                if (src.trash) trashSrcItemFn(src, dst);
+                if (!src.trash) theSameSrcItemFn(src, dst);
+            }
+
+            if (
+                !sameItem
+            ) {
+                if (src.trash) trashSrcItemFn(src, dst);
+                if (!src.trash) differentSrcItemFn(src, dst);
+            }
         }
 
 

package/GUDHUB/WebSocket/WebSocket.js

@@ -1,4 +1,5 @@
 import Websocket from "ws";
+import { IS_BROWSER } from "../consts.js";
 
 export class WebSocketApi {
   constructor(url, auth) {
@@ -11,7 +12,7 @@ export class WebSocketApi {
     this.ALLOWED_HEART_BEAT_DELEY = 12000;
     this.firstHeartBeat = true;
     this.reload = true;
-    this.isBrowser = ![typeof window, typeof document].includes("undefined");
+    this.isBrowser = IS_BROWSER;
   }
 
   async addSubscription(app_id) {

package/GUDHUB/consts.js

@@ -1 +1,21 @@
-export const IS_WEB = ![typeof window, typeof document].includes("undefined");
+export const IS_BROWSER_MAIN_THREAD = ![typeof window, typeof document].includes("undefined");
+
+export const IS_BROWSER_WORKER =
+    typeof self === "object" &&
+    typeof WorkerGlobalScope != 'undefined'
+
+
+export const IS_BROWSER = IS_BROWSER_MAIN_THREAD || IS_BROWSER_WORKER;
+
+export const IS_NODE =
+  // @ts-expect-error
+  typeof process !== "undefined" &&
+  // @ts-expect-error
+  process.versions != null &&
+  // @ts-expect-error
+  process.versions.node != null;
+
+
+
+
+//   IS_WEB

package/GUDHUB/gudhub.js

@@ -10,10 +10,10 @@ import { AppProcessor } from "./AppProcessor/AppProcessor.js";
 import { ItemProcessor } from "./ItemProcessor/ItemProcessor.js";
 import { FieldProcessor } from "./FieldProcessor/FieldProcessor.js";
 import { FileManager } from "./FileManager/FileManager.js";
-import { ChunksManager } from "./ChunksManager/ChunksManager.js";
+// import { ChunksManager } from "./ChunksManager/ChunksManager.js";
 import { DocumentManager } from "./DocumentManager/DocumentManager.js";
 import { Interpritate } from './GHConstructor/interpritate.js'
-import { IS_WEB } from "./consts.js";
+import { IS_BROWSER, IS_BROWSER_MAIN_THREAD, IS_WEB } from "./consts.js";
 import { WebsocketHandler } from './WebSocket/WebsocketHandler.js';
 import { GroupSharing } from './Utils/sharing/GroupSharing.js';
 import { Sharing } from './Utils/sharing/Sharing.js';
@@ -37,6 +37,12 @@ export class GudHub {
       expirydate: this.expirydate
     }
   ) {
+
+    this.serialized = {
+      authKey,
+      options,
+    }
+
     this.config = options;
     this.ghconstructor = new GHConstructor(this);
     this.interpritate = new Interpritate(this);
@@ -59,22 +65,24 @@ export class GudHub {
     this.req.init(this.auth.getToken.bind(this.auth));
 
     this.ws = new WebSocketApi(options.wss_url, this.auth);
-    this.chunksManager = new ChunksManager(
-      this.storage,
-      this.pipeService,
-      this.req,
-      this.util,
-      new ChunkDataService(this.req, chunkDataServiceConf),
-    );
+
+    //todo
+    // this.chunksManager = new ChunksManager(
+    //   this.storage,
+    //   this.pipeService,
+    //   this.req,
+    //   this.util,
+    //   new ChunkDataService(this.req, chunkDataServiceConf, this),
+    // );
     this.appProcessor = new AppProcessor(
       this.storage,
       this.pipeService,
       this.req,
       this.ws,
-      this.chunksManager,
+      // this.chunksManager,
       this.util,
       options.activateSW,
-      new AppDataService(this.req, appDataServiceConf),
+      new AppDataService(this.req, appDataServiceConf, this),
     );
     this.itemProcessor = new ItemProcessor(
       this.storage,
@@ -107,7 +115,7 @@ export class GudHub {
   }
 
   async activateSW(swLink) {
-    if (IS_WEB && "serviceWorker" in window.navigator) {
+    if (IS_BROWSER_MAIN_THREAD && "serviceWorker" in window.navigator) {
       try {
         const sw = await window.navigator.serviceWorker.register(swLink);
         sw.update()
@@ -234,6 +242,21 @@ export class GudHub {
     return this.util.sortItems(items, options);
   }
 
+
+  //
+  //here
+  triggerAppChange(id, prevVersion, newVersion) {
+    this.itemProcessor.handleItemsChange(id, prevVersion, newVersion);
+    this.appProcessor.handleAppChange(id, prevVersion, newVersion);
+  }
+
+
+  //
+  //TODO handleAppChange
+  triggerIemsChange(id, compareRes) {
+    this.itemProcessor.triggerItemsChange(id, compareRes);
+  }
+
   jsonToItems(json, map) {
     return this.util.jsonToItems(json, map);
   }
@@ -413,13 +436,15 @@ export class GudHub {
     );
   }
 
-  updateFileFromString(data, file_id, file_name, extension, format) {
+  updateFileFromString(data, file_id, file_name, extension, format, alt, title) {
     return this.fileManager.updateFileFromString(
       data,
       file_id,
       file_name,
       extension,
-      format
+      format,
+      alt,
+      title
     );
   }