@gudhub/core 1.2.1 → 1.2.3

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/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 = "chunks";
+    DatabaseName = "gudhubapi-data";
+    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/DataService/IndexedDB/IndexedDBAppService.js

@@ -1,5 +1,5 @@
 import { AppDataService } from "../AppDataService.js";
-import { ChunkCacheDataService, ChunkDataService } from "../ChunkDataService.js";
+import { ChunkDataService } from "../ChunkDataService.js"; // removed "ChunkCacheDataService" from imported because it was causing an error "{ ChunkCacheDataService } not found in exported names" in "gudhub-node-server"
 import { AppHttpService } from "../httpService/AppHttpService.js";
 import { objectAssignWithOverride } from "../utils.js";
 import { IndexedDBService } from "./IndexedDBService.js";

package/GUDHUB/DataService/IndexedDB/IndexedDBChunkService.js

@@ -1,4 +1,4 @@
-import { ChunkCacheDataService, ChunkDataService } from "../ChunkDataService.js";
+import { ChunkDataService } from "../ChunkDataService.js"; // removed "ChunkCacheDataService" from imported because it was causing an error "{ ChunkCacheDataService } not found in exported names" in "gudhub-node-server"
 import { ChunkHttpService } from "../httpService/ChunkHttpService.js";
 import { objectAssignWithOverride } from "../utils.js";
 import { IndexedDBService } from "./IndexedDBService.js";

package/GUDHUB/gudhub.js

@@ -32,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;
@@ -45,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);
@@ -445,6 +455,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.2.1",
+  "version": "1.2.3",
   "description": "",
   "main": "index.js",
   "scripts": {