@gudhub/core 1.0.37

package/GUDHUB/gudhub-https-service.js

@@ -0,0 +1,193 @@
+//****************** GUDHUB HTTPS SERVICE ***********************//
+//-- This Service decorates each POST and GET request with Token
+//-- This Service take care of toking beeing always valid
+
+import axios from "axios";
+import { convertObjToUrlParams } from "./utils.js";
+import qs from "qs";
+export class GudHubHttpsService {
+  constructor(server_url) {
+    this.root = server_url;
+    this.requestPromises = []; 
+  }
+
+
+  //****************** INITIALISATION **************//
+  // Here we set a function to get token
+  init(getToken) {
+    this.getToken = getToken;
+    this.promiseCollector(5000);
+  }
+
+  
+   //********************* GET ***********************//
+   async get(request) {
+    const accessToken = await this.getToken();
+    const hesh = this.getHashCode(request);
+
+
+    if (this.requestPromises[hesh]) {
+      return this.requestPromises[hesh].promise;
+    }
+
+     const promise = new Promise((resolve, reject) => {
+      const url = this.root + request.url;
+
+      axios.get(
+        `${url}${
+          /\?/.test(url) ? "&" : "?"
+        }token=${accessToken}${convertObjToUrlParams(request.params)}`
+      ).then(function (response) {
+        // handle success
+        resolve(response.data);
+      })
+      .catch(function (err) {
+        console.log("ERROR -> GUDHUB HTTP SERVICE -> GET :", err.message);
+        console.log("Request message: ", request);
+        reject(err);
+      });
+
+    });
+     this.requestPromises[hesh] = {
+       promise,
+       time: Date.now()
+     }
+    return promise;
+  }
+
+
+  //********************* GET ***********************//
+  async simpleGet(request) {
+    const hesh = this.getHashCode(request);
+
+    if (this.requestPromises[hesh]) {
+      return this.requestPromises[hesh].promise;
+    }
+
+    const promise = new Promise((resolve, reject) => {
+      const url = this.root + request.url;
+
+      axios.get(url).then(function (response) {
+        // handle success
+        resolve(response.data);
+      })
+        .catch(function (err) {
+          console.log("ERROR -> GUDHUB HTTP SERVICE -> GET :", err.message);
+          console.log("Request message: ", request);
+          reject(err);
+        });
+
+    });
+    this.requestPromises[hesh] = {
+      promise,
+      time: Date.now()
+    }
+    return promise;
+  }
+
+
+  //********************* POST ***********************//
+  async post(request) {
+    const hesh = this.getHashCode(request);
+    request.form["token"] = await this.getToken();
+
+
+    if (this.requestPromises[hesh]) {
+      return this.requestPromises[hesh].promise;
+    }
+
+    const promise = new Promise((resolve, reject) => {
+      axios.post(
+        this.root + request.url,
+        qs.stringify(request.form),
+        {
+          headers: request.headers || {
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+        }
+      ).then(function (response) {
+        // handle success
+        resolve(response.data);
+      }).catch(function (error) {
+        console.log("ERROR -> GUDHUB HTTP SERVICE -> POST :", error.message);
+        console.log("Request message: ", request);
+        reject(error);
+      });
+    });
+    this.requestPromises[hesh] = {
+      promise,
+      time: Date.now()
+    }
+    return promise;
+  }
+
+
+  //********************* SIMPLE POST ***********************//
+  async simplePost(request) {
+    const hesh = this.getHashCode(request);
+
+    if (this.requestPromises[hesh]) {
+      return this.requestPromises[hesh].promise;
+    }
+
+    const promise = new Promise((resolve, reject) => {
+
+      axios.post(
+        this.root + request.url,
+        qs.stringify(request.form),
+        {
+          headers: request.headers || {
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+        }
+      ).then(function (response) {
+        // handle success
+        resolve(response.data);
+      }).catch(function (error) {
+        console.log("ERROR -> GUDHUB HTTP SERVICE -> SIMPLE POST :", error.message);
+        console.log("Request message: ", request);
+        reject(error);
+      });
+    
+    });
+    this.requestPromises[hesh] = {
+      promise,
+      time: Date.now()
+    }
+    return promise;
+  }
+
+
+  //********************* GET HASH CODE ***********************//
+  // it generates numeric identificator whish is the same for similar requests
+  // HASH CODE is generated based on: request.params, request.url, request.form
+  getHashCode(request){
+    let hash = 0;
+    let str = qs.stringify(request)
+    if (str.length == 0) return hash;
+
+    for (let i = 0; i < str.length; i++) {
+      let char = str.charCodeAt(i);
+      hash = ((hash<<5)-hash)+char;
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    return "h" + hash;
+  }
+
+  
+  //********************* PROMICE COLLECTOR ***********************//
+  // Here we erace all promicess after period of time
+  // !!! Some modifications needed here,  probably erace promicec those were resolved or save start time and erace it in a minute after promice created
+  promiseCollector( interval ) {
+    setInterval(() => {
+      Object.keys(this.requestPromises).forEach(hesh => {
+        if(Date.now() - this.requestPromises[hesh].time > interval ){
+          delete this.requestPromises[hesh];
+        }
+      });
+
+      //console.log("promises:", Object.keys(this.requestPromises).length);
+    }, interval);
+  }
+  
+}

package/GUDHUB/gudhub.js

@@ -0,0 +1,477 @@
+import { GudHubHttpsService } from "./gudhub-https-service.js";
+import { PipeService } from "./PipeService/PipeService.js";
+import { Storage } from "./Storage/Storage.js";
+import { WebSocketApi } from "./WebSocket/WebSocket.js";
+import { wss_url, server_url } from "./config.js";
+import { Utils } from "./Utils/Utils.js";
+import { Auth } from "./Auth/Auth.js";
+import {
+  AppProcessor,
+  FieldProcessor,
+  ItemProcessor,
+} from "./Processors/processors.js";
+import {
+  DocumentManager,
+  FileManager,
+  ChunksManager,
+} from "./Managers/managers.js";
+import { IS_WEB } from "./consts.js";
+
+export class GudHub {
+  constructor(
+    authKey,
+    options = {
+      server_url,
+      wss_url,
+      initWebsocket: false,
+      activateSW: false,
+      swLink: "",
+    }
+  ) {
+    this.pipeService = new PipeService();
+    this.storage = new Storage(this.pipeService);
+    this.util = new Utils(this);
+    this.req = new GudHubHttpsService(options.server_url);
+    this.auth = new Auth(this.req, this.storage);
+    if (authKey) this.storage.setUser({ auth_key: authKey });
+    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
+    );
+    this.appProcessor = new AppProcessor(
+      this.storage,
+      this.pipeService,
+      this.req,
+      this.ws,
+      this.chunksManager,
+      this.util,
+      options.activateSW
+    );
+    this.itemProcessor = new ItemProcessor(
+      this.storage,
+      this.pipeService,
+      this.req,
+      this.appProcessor,
+      this.util
+    );
+    this.fieldProcessor = new FieldProcessor(
+      this.storage,
+      this.req,
+      this.appProcessor,
+      this.itemProcessor
+    );
+    this.fileManager = new FileManager(this.storage, this.req, this.pipeService, this.appProcessor);
+    this.documentManager = new DocumentManager(this.req);
+
+    if (options.initWebsocket) {
+      this.ws.initWebSocket(
+        this.websocketHandler.bind(this),
+        this.appProcessor.refreshApps.bind(this.appProcessor)
+      );
+    }
+    if (options.activateSW) {
+      this.activateSW(options.swLink);
+    }
+  }
+
+  async activateSW(swLink) {
+    if (IS_WEB && "serviceWorker" in window.navigator) {
+      try {
+        const sw = await window.navigator.serviceWorker.register(swLink);
+        sw.update()
+          .then(() =>
+            console.log(
+              "%cSW ->>> Service worker successful updated",
+              "display: inline-block ; background-color: #689f38 ; color: #ffffff ; font-weight: bold ; padding: 3px 7px; border-radius: 3px;"
+            )
+          )
+          .catch(() => console.warn("SW ->>> Service worker is not updated"));
+        console.log(
+          "%cSW ->>> Service worker is registered",
+          "display: inline-block ; background-color: #689f38 ; color: #ffffff ; font-weight: bold ; padding: 3px 7px; border-radius: 3px;",
+          sw
+        );
+      } catch (error) {
+        console.warn(
+          "%cSW ->>> Service worker is not registered",
+          "display: inline-block ; background-color: #d32f2f ; color: #ffffff ; font-weight: bold ; padding: 3px 7px; border-radius: 3px;",
+          error
+        );
+      }
+    } else {
+      console.log(
+        "%cSW ->>> ServiceWorkers not supported",
+        "display: inline-block ; background-color: #d32f2f ; color: #ffffff ; font-weight: bold ; padding: 3px 7px; border-radius: 3px;"
+      );
+    }
+  }
+
+  //************************* PIPESERVICE METHODS  ****************************//
+  //============= ON PIPE ===============//
+  on(types, destination, fn) {
+    this.pipeService.on(types, destination, fn);
+    return this;
+  }
+
+  //============= EMIT PIPE ==============//
+  emit(types, destination, address, params) {
+    this.pipeService.emit(types, destination, address, params);
+    return this;
+  }
+
+  //============ DELETE LISTENER ========//
+  destroy(types, destination, func) {
+    this.pipeService.destroy(types, destination, func);
+    return this;
+  }
+
+  //************************* FILTERATION  ****************************//
+  prefilter(filters_list, element_app_id, app_id, item_id, variables) {
+    return this.util.prefilter(
+      filters_list,
+      element_app_id,
+      app_id,
+      item_id,
+      variables
+    );
+  }
+
+  //============ FILTER ==========//
+  filter(items, filter_list) {
+    return this.util.filter(items, filter_list);
+  }
+
+  //============ GROUP ==========//
+  group(fieldGroup, items) {
+    return this.util.group(fieldGroup, items);
+  }
+
+  //============ GET FILTERED ITEMS ==========//
+  //it returns items with applyed filter
+  getFilteredItems(items, filters_list, options = {}) {
+    return this.util.getFilteredItems(
+      items,
+      filters_list,
+      options.element_app_id,
+      options.app_id,
+      options.item_id,
+      options.field_group,
+      options.search,
+      options.search_params
+    );
+  }
+
+  jsonToItems(json, map) {
+    return this.util.jsonToItems(json, map);
+  }
+
+  getDate(queryKey) {
+    return this.util.getDate(queryKey);
+  }
+
+  populateWithDate(items, model) {
+    return this.util.populateWithDate(items, model);
+  }
+
+  populateItems(items, model, keep_data) {
+    return this.util.populateItems(items, model, keep_data);
+  }
+
+  populateWithItemRef(
+    sourceItemsRef,
+    srcFieldIdToCompare,
+    destinationItems,
+    destFieldIdToCompare,
+    destFieldForRef,
+    app_id
+  ) {
+    return this.util.populateWithItemRef(
+      sourceItemsRef,
+      srcFieldIdToCompare,
+      destinationItems,
+      destFieldIdToCompare,
+      destFieldForRef,
+      app_id
+    );
+  }
+
+  compareItems(sourceItems, destinationItems, fieldToCompare) {
+    return this.util.compareItems(
+      sourceItems,
+      destinationItems,
+      fieldToCompare
+    );
+  }
+
+  mergeItems(sourceItems, destinationItems, mergeByFieldId) {
+    return this.util.mergeItems(sourceItems, destinationItems, mergeByFieldId);
+  }
+
+  mergeObjects(sourceObject, destinationObject) {
+    return this.util.mergeObjects(sourceObject, destinationObject);
+  }
+
+  makeNestedList(arr, id, parent_id, children_property) {
+    return this.util.makeNestedList(arr, id, parent_id, children_property);
+  }
+
+  jsonConstructor(scheme, items, variables){
+    return this.util.jsonConstructor(scheme, items, variables)
+  }
+
+  //************************* APP PROCESSOR ****************************//
+  getAppsList() {
+    return this.appProcessor.getAppsList();
+  }
+
+  getAppInfo(app_id) {
+    return this.appProcessor.getAppInfo(app_id);
+  }
+
+  deleteApp(app_id) {
+    return this.appProcessor.deleteApp(app_id);
+  }
+
+  getApp(app_id) {
+    return this.appProcessor.getApp(app_id);
+  }
+
+  updateApp(app) {
+    return this.appProcessor.updateApp(app);
+  }
+
+  updateAppInfo(appInfo) {
+    return this.appProcessor.updateAppInfo(appInfo);
+  }
+
+  createNewApp(app) {
+    return this.appProcessor.createNewApp(app);
+  }
+
+  getItems(app_id) {
+    return this.itemProcessor.getItems(app_id);
+  }
+
+  async getItem(app_id, item_id) {
+    const items = await this.getItems(app_id);
+    if (items) {
+      return items.find((item) => item.item_id == item_id);
+    }
+  }
+
+  addNewItems(app_id, itemsList) {
+    return this.itemProcessor.addNewItems(app_id, itemsList);
+  }
+
+  updateItems(app_id, itemsList) {
+    return this.itemProcessor.updateItems(app_id, itemsList);
+  }
+
+  deleteItems(app_id, itemsIds) {
+    return this.itemProcessor.deleteItems(app_id, itemsIds);
+  }
+
+  getField(app_id, field_id) {
+    return this.fieldProcessor.getField(app_id, field_id);
+  }
+
+  getFieldModels(app_id) {
+    return this.fieldProcessor.getFieldModels(app_id);
+  }
+
+  updateField(app_id, fieldModel) {
+    return this.fieldProcessor.updateField(app_id, fieldModel);
+  }
+
+  deleteField(app_id, field_id) {
+    return this.fieldProcessor.deleteField(app_id, field_id);
+  }
+
+  getFieldValue(app_id, item_id, field_id) {
+    return this.fieldProcessor.getFieldValue(app_id, item_id, field_id);
+  }
+
+  getInterpretedValue(app_id, item_id, field_id) {
+    return this.util.getInterpretedValue(app_id, item_id, field_id)
+  }
+
+  setFieldValue(app_id, item_id, field_id, field_value) {
+    return this.fieldProcessor.setFieldValue(
+      app_id,
+      item_id,
+      field_id,
+      field_value
+    );
+  }
+
+  getFile(app_id, file_id) {
+    return this.fileManager.getFile(app_id, file_id);
+  }
+
+  getFiles(app_id, filesId) {
+    return this.fileManager.getFiles(app_id, filesId);
+  }
+
+  uploadFile(fileData, app_id, item_id) {
+    return this.fileManager.uploadFile(fileData, app_id, item_id);
+  }
+
+  uploadFileFromString(
+    source,
+    file_name,
+    app_id,
+    item_id,
+    extension,
+    format,
+    element_id
+  ) {
+    return this.fileManager.uploadFileFromString(
+      source,
+      file_name,
+      app_id,
+      item_id,
+      extension,
+      format,
+      element_id
+    );
+  }
+
+  updateFileFromString(data, file_id, file_name, extension, format) {
+    return this.fileManager.updateFileFromString(
+      data,
+      file_id,
+      file_name,
+      extension,
+      format
+    );
+  }
+
+  deleteFile(app_id, id) {
+    return this.fileManager.deleteFile(app_id, id);
+  }
+
+  duplicateFile(files) {
+    return this.fileManager.duplicateFile(files);
+  }
+
+  createDocument(documentObject) {
+    return this.documentManager.createDocumentApi(documentObject);
+  }
+
+  getDocument(documentAddress) {
+    return this.documentManager.getDocumentApi(documentAddress);
+  }
+
+  getDocuments(documentAddress) {
+    return this.documentManager.getDocumentsApi(documentAddress);
+  }
+
+  deleteDocument(documentAddress) {
+    return this.documentManager.deleteDocumentApi(documentAddress);
+  }
+
+  login(data) {
+    return this.auth.login(data);
+  }
+
+  logout(token) {
+    this.appProcessor.clearAppProcessor();
+    return this.auth.logout(token);
+  }
+
+  signup(user) {
+    return this.auth.signup(user);
+  }
+
+  getUsersList(keyword) {
+    return this.auth.getUsersList(keyword);
+  }
+
+  updateToken(auth_key) {
+    return this.auth.updateToken(auth_key);
+  }
+
+  avatarUploadApi(image) {
+    return this.auth.avatarUploadApi(image);
+  }
+
+  getVersion() {
+    return this.auth.getVersion();
+  }
+
+  getUserById(userId) {
+    return this.auth.getUserById(userId);
+  }
+
+  getToken() {
+    return this.auth.getToken();
+  }
+
+  updateUser(userData) {
+    return this.auth.updateUser(userData);
+  }
+
+  updateAvatar(imageData) {
+    return this.auth.updateAvatar(imageData);
+  }
+
+  websocketHandler(message) {
+    switch (message.api) {
+      case "/items/update":
+        console.log("/items/update - ", message);
+        this.itemProcessor.updateItemsInStorage(
+          message.app_id,
+          message.response
+        );
+        break;
+      case "/items/add":
+        console.log("/items/add - ", message);
+        this.itemProcessor.addItemsToStorage(message.app_id, message.response);
+        break;
+      case "/items/delete":
+        console.log("/items/delete - ", message);
+        this.itemProcessor.deleteItemsFromStorage(
+          message.app_id,
+          message.response
+        );
+        break;
+      case "/app/update":
+        console.log("/app/update - ", message);
+        this.appProcessor.updatingAppInStorage(message.response);
+        break;
+      case "/file/delete":
+        console.log("file/delete - ", message);
+        this.fileManager.deleteFileFromStorage(
+          message.response.file_id,
+          message.app_id
+        );
+        break;
+      case "/file/upload":
+        console.log("file/upload - ", message);
+        this.fileManager.addFileToStorage(message.app_id, message.response);
+        break;
+      case "/file/formupload": //I'm not shure if we are using it (probably in contact form)
+        console.log("file/formupload - ", message);
+        break;
+      case "/file/update": //I'm not shure if we are using it (probably in contact form)
+        this.fileManager.updateFileInStorage(
+          message.response.file_id,
+          message.response.app_id,
+          message.response
+        );
+        console.log("file/update - ", message);
+        break;
+      case "/new/file/duplicate": //I'm not shure if we are using it (probably in contact form)
+        this.fileManager.addFilesToStorage(message.app_id, message.response);
+        console.log("new/file/duplicate - ", message);
+        break;
+      default:
+        console.warn("WEBSOCKETS is not process this API:", message.api);
+    }
+  }
+}