@gudhub/core 1.2.4-beta.0 → 1.2.4-beta.10

package/GUDHUB/AppProcessor/AppProcessor.js

@@ -6,7 +6,7 @@ export class AppProcessor {
     pipeService,
     req,
     websocket,
-    chunksManager,
+    // chunksManager,
     util,
     activateSW,
     dataService,
@@ -17,10 +17,15 @@ export class AppProcessor {
     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.chunksManager = chunksManager;
     this.util = util;
     this.appListeners();
     this.dataService = dataService;
+
+    this.appRequestCache = new Map;
+
+
+    // this.dataServiceRequestedIdSet = new Set;
   }
 
   async createNewAppApi(app) {
@@ -255,27 +260,46 @@ export class AppProcessor {
     let app = this.getAppFromStorage(app_id);
     if (app) return app;
 
-    let receivedApp = await this.dataService.getApp(app_id);
-    if (!receivedApp) return;
-
-    //!!! temporary check !!!! if app has chanks property then we start getting it
-    if (
-      receivedApp.chunks &&
-      receivedApp.chunks.length
-    ) {
-      let chunks = await this.chunksManager.getChunks(app_id, receivedApp.chunks);
-      receivedApp.items_list = this.util.mergeChunks([
-        ...chunks,
-        receivedApp,
-      ]);
-    }
+    if (this.appRequestCache.has(app_id)) return this.appRequestCache.get(app_id);
+
+    let self = this;
+
+    let pr = new Promise(async (resolve, reject) => {
+      try {
+        let app = await self.dataService.getApp(app_id);
+        if (!app) reject();
+    
+        //!!! temporary check !!!! if app has chanks property then we start getting it
+        // if (
+        //   receivedApp.chunks &&
+        //   receivedApp.chunks.length
+        // ) {
+        //   // here should be checked is merge required
+
+
+        //   let chunks = await self.chunksManager.getChunks(app_id, receivedApp.chunks);
+        //   receivedApp.items_list = self.util.mergeChunks([
+        //     ...chunks,
+        //     receivedApp,
+        //   ]);
+        // }
 
-    this.saveAppInStorage(receivedApp);
-    this.ws.addSubscription(app_id);
 
-    // This code for trash must be changed
-    // return trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
-    return receivedApp;
+        // This code for trash must be changed
+        // return trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
+        let filtered =  trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
+        resolve(filtered);
+    
+        self.saveAppInStorage(filtered);
+        self.ws.addSubscription(app_id);
+      } catch (error) {
+        reject();
+      }
+    });
+
+    self.appRequestCache.set(app_id, pr);
+  
+    return pr;
   }
 
   async updateApp(app) {
@@ -319,6 +343,10 @@ export class AppProcessor {
     }
   }
 
+  async handleAppChange(id, prevVersion, nextVersion) {
+    // generate required events etc, do job
+  }
+
   clearAppProcessor() {
     this.getAppListPromises = null;
     this.getAppPromises = {};
@@ -457,7 +485,7 @@ export class AppProcessor {
               }
             );
           }
-          event.data.payload.items_list = this.util.mergeChunks([app, event.data.payload])
+          event.data.payload.items_list = await this.util.mergeChunks([app, event.data.payload]) //here check Ask Andrew
           this.saveAppInStorage(event.data.payload);
         }
         // if (event.data.type === "refresh appList") {

package/GUDHUB/ChunksManager/ChunksManager.js

@@ -1,68 +1,68 @@
-import { ChunkAPI } from "../api/ChunkApi.js";
+// import { ChunkAPI } from "../api/ChunkApi.js";
 
 
-export class ChunksManager {
-  constructor(
-    storage,
-    pipeService,
-    req,
-    util,
-    dataService,
-  ) {
-    this.storage = storage;
-    this.pipeService = pipeService;
-    this.req = req;
-    this.util = util;
-    this.dataService = dataService;
-    this.chunkApi = new ChunkAPI(req);
-    this.itemListeners();
-  }
+// export class ChunksManager {
+//   constructor(
+//     storage,
+//     pipeService,
+//     req,
+//     util,
+//     dataService,
+//   ) {
+//     this.storage = storage;
+//     this.pipeService = pipeService;
+//     this.req = req;
+//     this.util = util;
+//     this.dataService = dataService;
+//     this.chunkApi = new ChunkAPI(req);
+//     this.itemListeners();
+//   }
 
-  async getChunk(app_id, chunk_id) {
-    try {
-      return this.dataService.getChunk(app_id, chunk_id);
-    } catch (err) {
-      console.log(err);
-      return null;
-    }
-  }
+//   async getChunk(app_id, chunk_id) {
+//     try {
+//       return this.dataService.getChunk(app_id, chunk_id);
+//     } catch (err) {
+//       console.log(err);
+//       return null;
+//     }
+//   }
 
-  async getLastChunk(app_id) {
-    try {
-      return this.chunkApi.getLastChunk(app_id);
-    } catch (err) {
-      console.log(err);
-      return null;
-    }
-  }
+//   async getLastChunk(app_id) {
+//     try {
+//       return this.chunkApi.getLastChunk(app_id);
+//     } catch (err) {
+//       console.log(err);
+//       return null;
+//     }
+//   }
 
-  async getChunks(app_id, chunk_ids) {
-    let chunks = [];
-    if(chunk_ids){
-      chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunk(app_id, chunk_id)));
-    }
-    return chunks;
-  }
+//   async getChunks(app_id, chunk_ids) {
+//     let chunks = [];
+//     if(chunk_ids){
+//       chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunk(app_id, chunk_id)));
+//     }
+//     return chunks;
+//   }
  
-  itemListeners() {
-  }
+//   itemListeners() {
+//   }
 
-  async getApp(app_id) {
-    if (!app_id) return null;
-    let app = this.getAppFromStorage(app_id);
-    if (!app) {
-      if (this.getAppPromises[app_id]) {
-        return this.getAppPromises[app_id];
-      }
-      this.getAppPromises[app_id] = this.getAppApi(app_id);
-      app = await this.getAppPromises[app_id];
-      if (app) {
-        this.saveAppInStorage(app);
-        this.ws.addSubscription(app_id);
-      } else {
-        return null;
-      }
-    }
-    return app;
-  }  
-}
+//   async getApp(app_id) {
+//     if (!app_id) return null;
+//     let app = this.getAppFromStorage(app_id);
+//     if (!app) {
+//       if (this.getAppPromises[app_id]) {
+//         return this.getAppPromises[app_id];
+//       }
+//       this.getAppPromises[app_id] = this.getAppApi(app_id);
+//       app = await this.getAppPromises[app_id];
+//       if (app) {
+//         this.saveAppInStorage(app);
+//         this.ws.addSubscription(app_id);
+//       } else {
+//         return null;
+//       }
+//     }
+//     return app;
+//   }  
+// }

package/GUDHUB/ChunksManager/ChunksManager.test.js

@@ -1,5 +1,6 @@
 import should from "should";
 import {GudHub} from './../gudhub.js';
+import { ChunkDataService } from "../DataService/export.js";
 
 describe("CHUNKS MANAGER", async function() {
     const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
@@ -9,7 +10,10 @@ describe("CHUNKS MANAGER", async function() {
     it("GET CHUNK : here we get first chunk from App", async function () {
         this.timeout(10000);
         var app = await gudhub.getApp(8263);
-        let firstChunk = await gudhub.chunksManager.getChunk(8263, app.chunks[0]);
+
+        let chunkDataService = new ChunkDataService(); //TODO args
+
+        let firstChunk = await gudhub.chunksManager.getChunk(8263, app.chunks[0]);// getapp - get firstChunk from it and then load via service or via api, maybe create here chunkDataService instance
         firstChunk.should.have.property("chunk_number");
         firstChunk.should.have.property("items_list");
         firstChunk.items_list[0].fields[0].should.have.property("history");
@@ -18,7 +22,7 @@ describe("CHUNKS MANAGER", async function() {
 
     it("GET LAST CHUNK : here we should get last chunk", async function () {
         this.timeout(5000);
-        let firstChunk = await gudhub.chunksManager.getLastChunk(8263);
+        let firstChunk = await gudhub.chunksManager.getLastChunk(8263);//
 
         firstChunk.should.have.property("chunk_number");
         firstChunk.should.have.property("items_list");
@@ -27,7 +31,7 @@ describe("CHUNKS MANAGER", async function() {
 
 
     it("GET CHUNKS : here we getting chanks from empty array []", async function () {
-        let chunkedItems = await gudhub.chunksManager.getChunks(8263, []);
+        let chunkedItems = await gudhub.chunksManager.getChunks(8263, []);//
         chunkedItems.length.should.equal(0);
     });
 
@@ -35,7 +39,7 @@ describe("CHUNKS MANAGER", async function() {
     it("GET CHUNKS : here we should receive all chunks of app", async function () {
         this.timeout(1000000);
         var app = await gudhub.getApp(8263);
-        let chunkedItems = await gudhub.chunksManager.getChunks(8263, app.chunks);
+        let chunkedItems = await gudhub.chunksManager.getChunks(8263, app.chunks);//
 
         chunkedItems[0].items_list[0].should.have.property("fields");
         chunkedItems[0].items_list[0].should.have.property("item_id");

package/GUDHUB/DataService/AppDataService.js

@@ -1,5 +1,151 @@
 import { DataService } from "./DataService.js";
+import { ChunkDataService, chunkDataServiceConf } from "./export.js";
 
 export class AppDataService extends DataService {
     //interface for indexeddb and http services
+
+    constructor(req, conf, gudhub) {
+        super();
+        this.chunkDataService = new ChunkDataService(req, chunkDataServiceConf, gudhub);
+        this.gudhub = gudhub;
+    }
+
+
+    isWithCache() {
+        return false;
+    }
+
+
+    //here
+    async processRequestedApp(id, sentData) {
+
+
+        
+        
+        if (
+            !this.isWithCache()
+        ) {
+
+//   async getChunks(app_id, chunk_ids) {
+//     let chunks = [];
+//     if(chunk_ids){
+//       chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunk(app_id, chunk_id)));
+//     }
+//     return chunks;
+//   }
+
+            // let res = await this.chunkDataService.getChunks(id, sentData.chunks);
+            let res = await Promise.all(sentData.chunks.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+            if (!res) res = [];
+
+
+
+
+
+            sentData.items_list = await this.gudhub.util.mergeChunks([
+                ...res,
+                sentData,
+            ]);
+
+
+            return sentData;
+  
+        //   this.dataService.putApp(id, nextVersion);
+
+
+            // return this.mergeAndReturnStrategy.handle(sentData, chunks);
+
+
+
+        }
+
+
+
+
+
+
+        try {
+            let cachedVersion = await this.getCached(id);
+
+            if (
+                !cachedVersion
+            ) {
+
+                //TODO maybe dont wait for chunks at first load
+
+                // let res = await this.chunkDataService.getChunks(id, sentData.chunks);
+                let res = await Promise.all(sentData.chunks.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+                if (!res) res = [];
+
+
+
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    ...res,
+                    sentData,
+                ]);
+
+
+                // this.putInCache(id, sentData);
+    
+    
+                return sentData;
+            }
+
+
+            let newHashesList = sentData.chunks.filter(c => !cachedVersion.chunks.includes(c));
+
+
+            // let self = this;
+
+
+            // let res = await this.chunkDataService.getChunks(id, newHashesList);
+            let res = await Promise.all(newHashesList.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+            if (!res) res = [];
+
+
+
+
+            // this.chunkDataService.getChunks(id, newHashesList).then((res) => {
+
+
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    cachedVersion,
+                    ...res,
+                    sentData,
+                ]);
+
+
+                // this.gudhub.triggerAppChange(id, cachedVersion, sentData);
+
+
+                // self.putInCache(id, sentData);
+            // });
+
+
+                return sentData;
+
+
+
+            // return cachedVersion;
+            
+        } catch (error) {
+            // res = await this.chunkDataService.getChunks(id, sentData.chunks);
+            let res = await Promise.all(sentData.chunks.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+            if (!res) res = [];
+
+
+
+
+            sentData.items_list = await this.gudhub.util.mergeChunks([
+                ...res,
+                sentData,
+            ]);
+
+
+            // this.putInCache(id, sentData);
+
+
+            return sentData;
+        }
+    }
 }