@gudhub/core 1.0.37

package/GUDHUB/Auth/Auth.js

@@ -0,0 +1,137 @@
+export class Auth {
+  constructor(req, storage) {
+    this.req = req;
+    this.storage = storage;
+  }
+
+  login({ username, password } = {}) {
+    return this.req.simplePost({
+      url: "/auth/login",
+      form: {
+        username,
+        password,
+      },
+    });
+  }
+
+  logout(token) {
+    return this.req.post({
+      url: "/auth/logout",
+      form: {
+        token,
+      },
+    });
+  }
+
+  signup(user) {
+    return this.req.simplePost({
+      url: "/auth/singup",
+      form: { user: JSON.stringify(user) },
+    });
+  }
+
+  getUsersList(keyword) {
+    return this.req.get({
+      url: "/auth/userlist",
+      params: {
+        keyword,
+      },
+    });
+  }
+
+  updateUserApi(userData) {
+    return this.req.post({
+      url: "/auth/updateuser",
+      form: {
+        user: JSON.stringify(userData),
+      },
+    });
+  }
+
+  updateToken(auth_key) {
+    return this.req.simplePost({
+      url: "/auth/login",
+      form: {
+        auth_key,
+      },
+    });
+  }
+
+  avatarUploadApi(image) {
+    return this.req.post({
+      url: "/auth/avatar-upload",
+      form: {
+        image,
+      },
+    });
+  }
+
+  getUserByIdApi(id) {
+    return this.req.get({ url: "/auth/getuserbyid", params: { id } });
+  }
+
+  getVersion() {
+    return this.req.get({ url: "/version" });
+  }
+
+  getUserFromStorage(id) {
+    return this.storage.getUsersList().find((user) => user.user_id == id);
+  }
+
+  saveUserToStorage(saveUser) {
+    const usersList = this.storage.getUsersList();
+    const userInStorage = usersList.find(
+      (user) => user.user_id == saveUser.user_id
+    );
+    if (!userInStorage) {
+      usersList.push(saveUser);
+      return saveUser;
+    }
+    return userInStorage;
+  }
+
+  async getUserById(userId) {
+    let user = this.getUserFromStorage(userId);
+
+    if (!user) {
+      let receivedUser = await this.getUserByIdApi(userId);
+      
+      if(!receivedUser) return null;
+
+      user = this.getUserFromStorage(userId);
+      
+      if (!user) {
+        this.saveUserToStorage(receivedUser);
+        user = receivedUser;
+      }
+    }
+
+    return user;
+  }
+
+  async getToken() {
+    const expiryDate = new Date(this.storage.getUser().expirydate);
+    const currentDate = new Date();
+    let accesstoken = this.storage.getUser().accesstoken;
+
+    /*-- checking if token exists and if it's not expired*/
+    if (expiryDate < currentDate || !accesstoken) {
+      /*-- If token is expired we send request to server to update it*/
+      const user = await this.updateToken(this.storage.getUser().auth_key);
+      this.storage.updateUser(user);
+      accesstoken = user.accesstoken;
+    }
+
+    return accesstoken;
+  }
+
+  async updateUser(userData) {
+    const user = await this.updateUserApi(userData);
+    this.storage.updateUser(user);
+  }
+
+  async updateAvatar(imageData) {
+    const user = await this.avatarUploadApi(imageData);
+    this.storage.updateUser(user);
+  }
+}

package/GUDHUB/Auth/Auth.test.js

@@ -0,0 +1,15 @@
+import should from "should";
+import {GudHub} from './../gudhub.js';
+
+describe("AUTHORIZATION", async function() {
+    const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+    const gudhub = new GudHub(auth_key);
+
+    it("GET USER BY ID / It Should return user with 'Vasya Pupkin' fullname", async function () {
+        this.timeout(5000);
+        var user = await gudhub.auth.getUserById("58");
+    
+        user.fullname.should.equal('Vasya Pupkin');
+    })
+
+});

package/GUDHUB/Managers/ChunksManager/ChunksManager.js

@@ -0,0 +1,80 @@
+
+
+export class ChunksManager {
+  constructor(storage, pipeService, req, util) {
+    this.storage = storage;
+    this.pipeService = pipeService;
+    this.req = req;
+    this.util = util;
+    this.itemListeners();
+  }
+
+  async getChunkApi(app_id, chunk_id) {
+    try {
+      const response = await this.req.simpleGet({
+        url: `/api/get-items-chunk/${app_id}/${chunk_id}`,
+      });
+      return response;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async getLastChunkApi(app_id) {
+    try {
+      const response = await this.req.simpleGet({
+        url: `/api/get-last-items-chunk/${app_id}`,
+      });
+      return response;
+    } 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)));
+    }
+    return chunks;
+  }
+
+
+  async getLastChunk(app_id) {
+    let chunk = await this.getLastChunkApi(app_id);
+    return chunk;
+  }
+
+ 
+  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;
+  }
+  
+  
+}

package/GUDHUB/Managers/ChunksManager/ChunksManager.test.js

@@ -0,0 +1,46 @@
+import should from "should";
+import {GudHub} from './../../gudhub.js';
+
+describe("CHUNKS MANAGER", async function() {
+    const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+    const gudhub = new GudHub(auth_key);
+
+    
+    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]);
+        firstChunk.should.have.property("chunk_number");
+        firstChunk.should.have.property("items_list");
+        firstChunk.items_list[0].fields[0].should.have.property("history");
+    });
+
+
+    it("GET LAST CHUNK : here we should get last chunk", async function () {
+        this.timeout(5000);
+        let firstChunk = await gudhub.chunksManager.getLastChunk(8263);
+
+        firstChunk.should.have.property("chunk_number");
+        firstChunk.should.have.property("items_list");
+        firstChunk.items_list[0].fields[0].should.have.property("history");
+    });
+
+
+    it("GET CHUNKS : here we getting chanks from empty array []", async function () {
+        let chunkedItems = await gudhub.chunksManager.getChunks(8263, []);
+        chunkedItems.length.should.equal(0);
+    });
+
+
+    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);
+
+        chunkedItems[0].items_list[0].should.have.property("fields");
+        chunkedItems[0].items_list[0].should.have.property("item_id");
+        chunkedItems[0].items_list[0].fields[0].should.have.property("history");
+    });
+
+
+});

package/GUDHUB/Managers/DocumentManager/DocumentManager.js

@@ -0,0 +1,48 @@
+/* 
+    Document Template request
+  {
+     app_id: 1,
+     item_id: 1
+     element_id: 1,
+     data: {}
+  }
+
+*/
+
+export class DocumentManager {
+  constructor(req) {
+    this.req = req;
+  }
+
+  createDocumentApi(documentObject) {
+    return this.req.post({
+      url: "/api/new/document/insert-one",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      form: { document: JSON.stringify(documentObject) },
+    });
+  }
+
+  getDocumentApi(documentAddress) {
+    return this.req.post({
+      url: "/api/new/document/find-one",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      form: { document: JSON.stringify(documentAddress) },
+    });
+  }
+
+  getDocumentsApi(documentsAddresses) {
+    return this.req.post({
+      url: "/api/new/document/find",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      form: { document: JSON.stringify(documentsAddresses) },
+    });
+  }
+
+  deleteDocumentApi(documentAddress) {
+    return this.req.post({
+      url: "/api/new/document/remove-one",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      form: { document: JSON.stringify(documentAddress) },
+    });
+  }
+}

package/GUDHUB/Managers/FileManager/FileManager.js

@@ -0,0 +1,208 @@
+export class FileManager {
+  constructor(storage, pipeService, req, appProcessor) {
+    this.storage = storage;
+    this.pipeService = pipeService;
+    this.req = req;
+    this.appProcessor = appProcessor;
+  }
+
+  //********************* UPLOAD FILE *********************//
+
+  async uploadFileApi(fileData, app_id, item_id) {
+    try {
+      const form = {
+        "file-0": fileData,
+        app_id,
+        item_id,
+      };
+      const file = await this.req.post({
+        url: "/file/formupload",
+        form,
+      });
+      return file;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async uploadFileFromStringApi(
+    source,
+    file_name,
+    app_id,
+    item_id,
+    extension,
+    format,
+    element_id
+  ) {
+    try {
+      const fileObj = {
+        app_id,
+        item_id,
+        extension,
+        file_name,
+        format,
+        element_id,
+        source,
+      };
+
+      const file = await this.req.post({
+        url: "/file/upload",
+        form: { file: JSON.stringify(fileObj) },
+      });
+      return file;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async updateFileFromStringApi(data, file_id, file_name, extension, format) {
+    try {
+      const fileObj = {
+        file_name,
+        extension,
+        file_id,
+        format,
+        source: data,
+      };
+
+      const file = await this.req.post({
+        url: "/file/update",
+        form: { file: JSON.stringify(fileObj) },
+      });
+      return file;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async duplicateFile(files) {
+    return this.req.post({
+      url: "/api/new/file/duplicate",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      form: {
+        files: JSON.stringify(files),
+      },
+    });
+  }
+
+  async deleteFileApi(id) {
+    try {
+      const file = await this.req.get({
+        url: `/file/delete?file_id=${id}`,
+      });
+      return file;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  addFileToStorage(app_id, file) {
+    const app = this.storage.getApp(app_id);
+    if (app) {
+      app.file_list.push(file);
+      this.storage.updateApp(app);
+    }
+  }
+
+  addFilesToStorage(app_id, files) {
+    const app = this.storage.getApp(app_id);
+    if (app) {
+      app.file_list.push(...files);
+      this.storage.updateApp(app);
+    }
+  }
+
+  deleteFileFromStorage(fileId, app_id) {
+    const app = this.storage.getApp(app_id);
+    if (app) {
+      app.file_list = app.file_list.filter((file) => file.file_id != fileId);
+      this.storage.updateApp(app);
+      this.pipeService.emit("gh_file_delete", { file_id: fileId }, file);
+    }
+  }
+
+  updateFileInStorage(fileId, app_id, newFile) {
+    const app = this.storage.getApp(app_id);
+    if (app) {
+      app.file_list = app.file_list.map((file) =>
+        file.file_id == fileId ? newFile : file
+      );
+      this.storage.updateApp(app);
+      this.pipeService.emit("gh_file_update", { file_id: fileId });
+    }
+  }
+
+  async getFile(app_id, file_id) {
+    try {
+      const app = await this.appProcessor.getApp(app_id);
+      return app.file_list.find((file) => {
+        return file.file_id == file_id;
+      });
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async getFiles(app_id, filesId = []) {
+    try {
+      const app = await this.appProcessor.getApp(app_id);
+      return app.file_list.filter((file) => {
+        return filesId.some(id => {
+          return id == file.file_id;
+        })});
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async uploadFile(fileData, app_id, item_id) {
+    const file = await this.uploadFileApi(fileData, app_id, item_id);
+    this.addFileToStorage(app_id, file);
+    return file;
+  }
+
+  async uploadFileFromString(
+    source,
+    file_name,
+    app_id,
+    item_id,
+    extension,
+    format,
+    element_id
+  ) {
+    const file = await this.uploadFileFromStringApi(
+      source,
+      file_name,
+      app_id,
+      item_id,
+      extension,
+      format,
+      element_id
+    );
+    this.addFileToStorage(app_id, file);
+    return file;
+  }
+
+  async updateFileFromString(data, file_id, file_name, extension, format) {
+    const file = await this.updateFileFromStringApi(
+      data,
+      file_id,
+      file_name,
+      extension,
+      format
+    );
+    this.updateFileInStorage(file_id, file.app_id, file);
+    return file;
+  }
+
+  deleteFile(app_id, id) {
+    this.deleteFileApi(id);
+    this.deleteFileFromStorage(id, app_id);
+  }
+}

package/GUDHUB/Managers/FileManager/file_manager.test.js

@@ -0,0 +1,17 @@
+import should from "should";
+import { GudHub } from "./../../gudhub.js";
+describe("FILE MANAGER", function () {
+    const gudhub = new GudHub();
+  
+    it("GET FILE URL", async function () {
+      //-- checking if file exist
+      let file = await gudhub.getFile(16259,809199);
+      file.should.have.property("url","https://gudhub.com/userdata/16259/809199.jpg");
+    });
+    it("GET FILES URL's", async function () {
+      //-- checking if file exist
+      let files = await gudhub.getFiles(16259,[809199,811768]);
+      files[0].should.have.property("url","https://gudhub.com/userdata/16259/809199.jpg");
+      files[1].should.have.property("url", "https://gudhub.com/userdata/16259/811768.png");
+    });
+  });

package/GUDHUB/Managers/managers.js

@@ -0,0 +1,5 @@
+import { DocumentManager } from "./DocumentManager/DocumentManager.js";
+import { FileManager } from "./FileManager/FileManager.js";
+import { ChunksManager } from "./ChunksManager/ChunksManager.js";
+
+export { FileManager, DocumentManager, ChunksManager };