@gudhub/core 1.2.4-beta.1 → 1.2.4-beta.11

package/GUDHUB/DataService/IndexedDB/appRequestWorker.js

@@ -0,0 +1,71 @@
+
+import { appDataServiceConf } from "../export.js";
+import { GudHub } from "../../gudhub.js";
+import { IndexedDBAppServiceForWorker } from "../IndexedDB/IndexedDBAppService.js";
+import { appsConf } from "../IndexedDB/appDataConf.js";
+
+
+
+let gudhub = {};
+let appDataService = {};
+
+
+
+//TODO also ChunkDataService !!!!!!!!!!!!!!!!!!!!!!!
+
+
+self.onmessage = async function(e) {
+  if (e.data.type === 'init') {
+
+    gudhub = new GudHub(e.data.gudhubSerialized.authKey, e.data.gudhubSerialized.options);
+    appDataService = new IndexedDBAppServiceForWorker(gudhub.req, appsConf, gudhub);
+
+  }
+
+  if (e.data.type === 'processData') {
+
+
+
+        //todo cached could not exist !!!!!!!!!!!!!!!!!!!
+
+    let cached = await appDataService.getCached(e.data.id);
+
+    let newVersion = await appDataService.getApp(e.data.id);
+
+
+
+
+
+    // let comparison = gudhub.compareItems(cached.items_list, newVersion.items_list);
+    let comparison = gudhub.compareItems(newVersion.items_list, cached.items_list);
+
+
+
+    this.postMessage({id: e.data.id, compareRes: comparison, newVersion, type: e.data.type});
+
+
+
+
+    /// todo process data merge and then call merge and compare and then return from here for example event to update
+
+
+
+    // also dont forget that main thread also uses AppDataService !!!!!!!!!!!!!!!!!! make temporarile a separate class for it maybe
+
+}
+
+
+  if (
+    e.data.type === 'requestApp'
+  ) {
+
+    let data = await appDataService.getApp(e.data.id);
+
+
+    this.postMessage({id: e.data.id, type: e.data.type, data});
+
+  }
+
+
+  // this.appRequestAndProcessWorker.postMessage({ type: 'requestApp', id: id });
+};

package/GUDHUB/DataService/httpService/AppHttpService.js

@@ -1,26 +1,44 @@
 import { AppAPI } from "../../api/AppApi.js";
 import { AppDataService } from "../AppDataService.js";
+import { ChunkDataService } from "../export.js";
 import { objectAssignWithOverride } from "../utils.js";
 import { HttpService } from "./HttpService.js";
 
 export class AppHttpService extends AppDataService {
-    constructor(req, conf) {
-      super();
+    constructor(req, conf, gudhub) {
+      super(req, conf, gudhub);
   
       this.appApi = new AppAPI(req);
 
       let indexDBService = new HttpService(conf);
+
+
+    //   this.chunkDataService = new ChunkDataService; //TODO move to 
     
       objectAssignWithOverride(this, indexDBService);
     }
 
 
     async getApp(id) {
+        let sentData = await this.appApi.getApp(id);
+        return this.processRequestedApp(id, sentData);// here is a problem. IndexedDB App service has Data service AppHttpService
+    }
+
+    //TODO should be getApp and getAppAndProcessData - refactor whole code to use them
+
+
+
+
+    //TODO андрей говорил про то что там надо фильтровать айтемы удаленные, я так и не доделал
+
+
+
+    async getAppWithoutProcessing(id) {
         return this.appApi.getApp(id);
     }
 
     async putApp(id, app) {
-
+        // do nothing
     }
   
     static [Symbol.hasInstance](instance) {
@@ -32,4 +50,4 @@ export class AppHttpService extends AppDataService {
             return false;
         }
     }
-}
+};

package/GUDHUB/DataService/httpService/ChunkHttpService.js

@@ -9,9 +9,9 @@ export class ChunkHttpService extends ChunkDataService {
   
       this.chunkApi = new ChunkAPI(req);
 
-      let indexDBService = new HttpService(conf);
+      let httpService = new HttpService(conf);
     
-      objectAssignWithOverride(this, indexDBService);
+      objectAssignWithOverride(this, httpService);
     }
   
     async getChunk(app_id, id) {

package/GUDHUB/ItemProcessor/ItemProcessor.js

@@ -118,6 +118,25 @@ export class ItemProcessor {
     return items;
   }
 
+  //here
+  handleItemsChange(id, prevVersion, nextVersion) {
+    let compareRes = this.util.compareItems(prevVersion.items_list, nextVersion.items_list);
+
+    this.updateItemsInStorage(id, compareRes.diff_src_items);
+    this.addItemsToStorage(id, compareRes.new_src_items);
+  }
+
+  triggerItemsChange(id, compareRes) {
+    this.updateItemsInStorage(id, compareRes.diff_src_items);
+    this.addItemsToStorage(id, compareRes.new_src_items);
+  }
+
+  handleDiff(id, compare) {
+    this.updateItemsInStorage(id, compare.diff_src_items);
+    this.addItemsToStorage(id, compare.new_src_items);
+    this.deleteItemsFromStorage(id, compare.trash_src_items);
+  }
+
   async deleteItemsFromStorage(app_id, itemsForDelete = []) {
     const app = await this.appProcessor.getApp(app_id);
     if (app) {

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) {

package/GUDHUB/Utils/merge_chunks/merge_chunks.js

@@ -1,31 +1,35 @@
+import { mergeChunks as mergeChunksByMainThread, mergeChunksWorker } from "./merge_chunks.worker.js";
+
+
+// const mergeChunksWorkerSingletone = new Worker('mergeWorker.js'); //TODO
+
+
 export function mergeChunks(chunks) {
-  const result = {};
+  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/gudhub.js

@@ -10,7 +10,7 @@ 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";
@@ -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,
@@ -234,6 +242,17 @@ 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);
   }