@gudhub/core 1.1.90 → 1.2.0

package/.vscode/launch.json

@@ -0,0 +1,31 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Program",
+            "program": "${workspaceFolder}/app.js",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "node"
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "runtimeVersion": "16",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/index.js"
+        },
+        {
+            "type": "node-terminal",
+            "name": "Run Script: test",
+            "request": "launch",
+            "command": "npm run test",
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

package/GUDHUB/AppProcessor/AppProcessor.js

@@ -266,42 +266,29 @@ export class AppProcessor {
     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);
-        }
-      }
+    if (app) return app;
+
+    let receivedApp = await this.getAppApi(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,
+      ]);
     }
-    
+
+    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 app;
+    return receivedApp;
   }
 
   async updateApp(app) {

package/GUDHUB/Auth/Auth.js

@@ -10,6 +10,12 @@ export class Auth {
     return user;
   }
 
+  async loginWithToken(token) {
+    const user = await this.loginWithTokenApi(token);
+    this.storage.updateUser(user);
+    return user;
+  }
+
   async logout(token) {
     const response = await this.logoutApi(token);
     return response;
@@ -58,6 +64,18 @@ export class Auth {
     }
   }
 
+  async loginWithTokenApi(token) {
+    try {
+      const user = await this.req.axiosRequest({
+        method: 'POST',
+        url: `${this.req.root}/auth/login?accesstoken=${token}`
+      });
+      return user;
+    } catch (error) {
+      console.log(error);
+    }
+  }
+
   async updateTokenApi(auth_key) {
     try {
       const user = await this.req.axiosRequest({

package/GUDHUB/Auth/Auth.test.js

@@ -1,4 +1,4 @@
-import should from "should";
+
 import {GudHub} from './../gudhub.js';
 
 describe("AUTHORIZATION", async function() {
@@ -22,6 +22,16 @@ describe("AUTHORIZATION", async function() {
         user.fullname.should.equal('Vasya Pupkin');
     })
 
+    it("Authentication with access token", async function () {
+        const gudhub = new GudHub();
+
+        const token = 'accesstoken';
+
+        const user = await gudhub.loginWithToken(token);
+
+        user.hasOwnProperty('fullname').should.equal(true);
+    })
+
     it("Signing up user", async function () {
         const gudhub = new GudHub();
         let credentials =  {

package/GUDHUB/ChunksManager/ChunkApi.js

@@ -0,0 +1,19 @@
+export class ChunkAPI {
+  constructor(req) {
+    this.req = req;
+  }
+
+  async getChunk(app_id, chunk_id) {
+    return this.req.get({
+      url: `${this.req.root}/api/get-items-chunk/${app_id}/${chunk_id}`,
+      method: 'GET'
+    });
+  }
+
+  async getLastChunk(app_id) {
+      return this.req.axiosRequest({
+          url: `${this.req.root}/api/get-last-items-chunk/${app_id}`,
+          method: 'GET'
+      });
+  }
+}

package/GUDHUB/ChunksManager/ChunksManager.js

@@ -1,60 +1,48 @@
+import { ChunkAPI } from "./ChunkApi.js";
 
 
 export class ChunksManager {
-  constructor(storage, pipeService, req, util) {
+  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 getChunkApi(app_id, chunk_id) {
+  async getChunk(app_id, chunk_id) {
     try {
-      const response = await this.req.axiosRequest({
-        url: `${this.req.root}/api/get-items-chunk/${app_id}/${chunk_id}`,
-        method: 'GET'
-      });
-      return response;
+      return this.dataService.getChunk(app_id, chunk_id);
     } catch (err) {
       console.log(err);
       return null;
     }
   }
 
-  async getLastChunkApi(app_id) {
+  async getLastChunk(app_id) {
     try {
-      const response = await this.req.axiosRequest({
-        url: `${this.req.root}/api/get-last-items-chunk/${app_id}`,
-        method: 'GET'
-      });
-      return response;
+      return this.chunkApi.getLastChunk(app_id);
     } catch (err) {
       console.log(err);
       return null;
     }
   }
 
-
-  getChunk(app_id, chunk_id) {
-   return this.getChunkApi(app_id, chunk_id);
-  }
-
-
   async getChunks(app_id, chunk_ids) {
     let chunks = [];
     if(chunk_ids){
-      chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunkApi(app_id, chunk_id)));
+      chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunk(app_id, chunk_id)));
     }
     return chunks;
   }
-
-
-  async getLastChunk(app_id) {
-    let chunk = await this.getLastChunkApi(app_id);
-    return chunk;
-  }
-
  
   itemListeners() {
   }
@@ -76,7 +64,5 @@ export class ChunksManager {
       }
     }
     return app;
-  }
-  
-  
-}
+  }  
+}

package/GUDHUB/ChunksManager/DataService/IndexedDBCacheService.js

@@ -0,0 +1,101 @@
+import { ChunkDataService, HttpDataService } from "./httpDataService.js";
+
+
+//this should be global in project
+// class IndexedDBFacade extends CacheService {
+
+// }
+
+
+
+class ChunkCachedDataService extends ChunkDataService {
+    dataService;
+}
+
+
+export class IndexedDBChunkCacheService extends ChunkCachedDataService {
+    constructor(req) {
+      super();
+  
+      this.dataService = new HttpDataService(req);
+    }
+
+
+    OBJECT_STORE = "v2";
+    DatabaseName = "my-cache-db";
+    DatabaseVersion = 1;
+
+
+    //TODO use IndexedDBFacade here
+    // indexDBAccess = new IndexedDBFacade;
+
+
+    async putChunk(id, data) {
+      try {        
+        const db = await this.openDatabase();
+
+        const transaction = db.transaction(this.OBJECT_STORE, "readwrite");
+        const store = transaction.objectStore(this.OBJECT_STORE);
+
+        store.put(data, id);
+      } catch (error) {
+
+      }
+    }
+
+
+    async getChunk(app_id, id) {
+      try {
+        const db = await this.openDatabase();
+        const transaction = db.transaction(this.OBJECT_STORE, "readonly");
+        const store = transaction.objectStore(this.OBJECT_STORE);
+      
+        const storeRequest = store.get(id);
+      
+        return await new Promise((resolve, reject) => {
+          storeRequest.onsuccess = (e) => {
+      
+            let cachedData = e.target.result;
+      
+            if (
+              !cachedData
+            ) {
+              reject();
+            }
+      
+            if (
+              cachedData
+            ) {
+
+              resolve(cachedData);
+            }
+          };
+      
+          storeRequest.onerror = reject
+        });
+      } catch(e) {
+        let res = await this.dataService.getChunk(app_id, id);
+
+        await this.putChunk(id, res);
+  
+  
+        return res;
+      }
+    }
+
+    async openDatabase() {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.DatabaseName, this.DatabaseVersion);
+        request.onupgradeneeded = event => {
+          const db = event.target.result;
+          db.createObjectStore(this.OBJECT_STORE);
+        };
+        request.onsuccess = event => {
+          resolve(event.target.result);
+        };
+        request.onerror = event => {
+          reject(event.target.error);
+        };
+      });
+    }
+}

package/GUDHUB/ChunksManager/DataService/export.js

@@ -0,0 +1,13 @@
+import { IS_WEB } from "../../consts.js";
+import { IndexedDBChunkCacheService } from "./IndexedDBCacheService.js";
+import { HttpDataService } from "./httpDataService.js";
+
+let exportClass;
+
+if (IS_WEB) {
+    exportClass = IndexedDBChunkCacheService
+} else {
+    exportClass = HttpDataService
+}
+
+export { exportClass as DataService };

package/GUDHUB/ChunksManager/DataService/httpDataService.js

@@ -0,0 +1,21 @@
+import { ChunkAPI } from "../ChunkApi.js";
+
+export class ChunkDataService {}
+
+
+export class HttpDataService extends ChunkDataService {
+  constructor(req) {
+    super();
+
+    this.chunkApi = new ChunkAPI(req);
+  }
+
+  async getChunk(app_id, id) {
+    return this.chunkApi.getChunk(app_id, id);
+  }
+
+
+  putChunk() {
+    //do nothing
+  }
+}

package/GUDHUB/gudhub.js

@@ -18,6 +18,7 @@ import { WebsocketHandler } from './WebSocket/WebsocketHandler.js';
 import { GroupSharing } from './Utils/sharing/GroupSharing.js';
 import { Sharing } from './Utils/sharing/Sharing.js';
 import { WebSocketEmitter } from './WebSocket/WebSocketEmitter.js';
+import { DataService } from "./ChunksManager/DataService/export.js";
 
 export class GudHub {
   constructor(
@@ -31,7 +32,9 @@ export class GudHub {
       swLink: "",
       async_modules_path,
       file_server_url,
-      automation_modules_path
+      automation_modules_path,
+      accesstoken: this.accesstoken,
+      expirydate: this.expirydate
     }
   ) {
     this.config = options;
@@ -44,7 +47,15 @@ export class GudHub {
     this.auth = new Auth(this.req, this.storage);
     this.sharing = new Sharing(this, this.req);
     this.groupSharing = new GroupSharing(this, this.req, this.pipeService);
-    if (authKey) this.storage.setUser({ auth_key: authKey });
+
+    // Login with access token - pass to setUser access token and after it user can  make requests with access token
+    // This method created for optimize GudHub  initialization without auth key
+    if (authKey) {
+      this.storage.setUser({ auth_key: authKey })
+    } else if(options.accesstoken && options.expirydate) {
+      this.storage.setUser({accesstoken: options.accesstoken, expirydate: options.expirydate})
+    }
+
     this.req.init(this.auth.getToken.bind(this.auth));
 
     this.ws = new WebSocketApi(options.wss_url, this.auth);
@@ -52,7 +63,8 @@ export class GudHub {
       this.storage,
       this.pipeService,
       this.req,
-      this.util
+      this.util,
+      new DataService(this.req),
     );
     this.appProcessor = new AppProcessor(
       this.storage,
@@ -442,6 +454,10 @@ export class GudHub {
     return this.auth.login(data);
   }
 
+  loginWithToken(token) {
+    return this.auth.loginWithToken(token);
+  }
+
   logout(token) {
     this.appProcessor.clearAppProcessor();
     return this.auth.logout(token);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gudhub/core",
-  "version": "1.1.90",
+  "version": "1.2.0",
   "description": "",
   "main": "index.js",
   "scripts": {