@gudhub/core 1.0.50 → 1.0.53

package/GUDHUB/{Processors/AppProcessor → AppProcessor}/AppProcessor.js

@@ -1,4 +1,4 @@
-import { IS_WEB } from "../../consts.js";
+import { IS_WEB } from "../consts.js";
 
 export class AppProcessor {
   constructor(

package/GUDHUB/{Processors/AppProcessor → AppProcessor}/AppProcessor.test.js

@@ -1,5 +1,5 @@
 import should from "should";
-import {GudHub} from './../../gudhub.js';
+import {GudHub} from './../gudhub.js';
 import {appTemplate} from './AppProcessorMocks.js';
 
 describe("APP PROCESSOR", async function() {

package/GUDHUB/{Managers/ChunksManager → ChunksManager}/ChunksManager.test.js

@@ -1,5 +1,5 @@
 import should from "should";
-import {GudHub} from './../../gudhub.js';
+import {GudHub} from './../gudhub.js';
 
 describe("CHUNKS MANAGER", async function() {
     const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';

package/GUDHUB/{Processors/FieldProcessor → FieldProcessor}/FieldProcessor.js

@@ -1,9 +1,11 @@
 export class FieldProcessor {
-  constructor(storage, req, appProcessor, itemProcessor) {
+  constructor(storage, req, appProcessor, itemProcessor, pipeService) {
     this.storage = storage;
     this.req = req;
     this.appProcessor = appProcessor;
     this.itemProcessor = itemProcessor;
+    this.pipeService = pipeService;
+    this.fieldListeners();
   }
 
   deleteFieldApi(field_id) {
@@ -136,4 +138,45 @@ export class FieldProcessor {
     await this.setFieldValueApi(app_id, item_id, field_id, field_value);
     this.updateFieldValue(app_id, item_id, field_id, field_value);
   }
+
+  fieldListeners() {
+    this.pipeService.onRoot('gh_value_get', {}, async (event, data) => {
+      if(data.app_id && data.item_id && data.field_id) {
+        let field_value = await this.getFieldValue(data.app_id, data.item_id, data.field_id);
+        this.pipeService.emit('gh_value_get', data, field_value);
+      }
+    });
+
+    this.pipeService.onRoot('gh_value_set', {}, async (event, data) => {
+      if(data.item_id) {
+        this.setFieldValue(data.app_id, data.item_id, data.field_id, data.new_value);
+        delete data.new_value;
+      }
+    });
+
+    this.pipeService.onRoot('gh_model_get', {}, async (event, data) => {
+      try {
+        let field_model = await this.getField(data.app_id, data.field_id);
+        this.pipeService.emit('gh_model_get', data, field_model)
+      } catch (error) {
+        console.log('Field model: ', error);
+      }
+    });
+
+    this.pipeService.onRoot('gh_model_update', {}, async (event, data) => {
+      let field_model = await this.updateField(data.app_id, data.field_model);
+      this.pipeService.emit('gh_model_update', { app_id: data.app_id, field_id: data.field_id }, field_model);
+    });
+
+    this.pipeService.onRoot('gh_models_get', {}, async (event, data) => {
+      let field_models = await this.getFieldModels(data.app_id);
+      this.pipeService.emit('gh_models_get', data, field_models);
+    });
+
+    this.pipeService.onRoot('gh_model_delete', {}, async (event, data) => {
+      let status = await this.deleteField(data.app_id, data.field_id);
+      this.pipeService.emit('gh_model_delete', data, status);
+    });
+  }
+
 }

package/GUDHUB/{Processors/FieldProcessor → FieldProcessor}/FieldProcessor.test.js

@@ -1,5 +1,5 @@
 import should from "should";
-import {GudHub} from './../../gudhub.js';
+import {GudHub} from './../gudhub.js';
 
 describe("FIELD PROCESSOR", async function() {
     const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';

package/GUDHUB/{Managers/FileManager → FileManager}/file_manager.test.js

@@ -1,5 +1,5 @@
 import should from "should";
-import { GudHub } from "./../../gudhub.js";
+import { GudHub } from "../gudhub.js";
 describe("FILE MANAGER", function () {
     const gudhub = new GudHub();
   

package/GUDHUB/GHConstructor/ghconstructor.js

@@ -0,0 +1,238 @@
+import axios from 'axios';
+
+/*************** FAKE ANGULAR $Q ***************/
+// It's needed when we eval() angular code.
+
+let $q = {
+    when: function (a) {
+        return new Promise(resolve => {
+            resolve(a);
+        })
+    }
+}
+
+export class GHConstructor {
+    constructor() {
+        this.cache = [];
+        this.modulesQueue = {};
+        this.angularInjector;
+    }
+
+    /*************** GET INSTANCE ***************/
+    // Firstly, check if module is loading right now in modules query.
+    // If not, check if module is in cache. If not, create new instance and put loading to modules query.
+    // If yes, return module from cache.
+
+    getInstance(module_id) {
+        return new Promise(async (resolve) => {
+            if (this.modulesQueue[module_id]) {
+                return this.modulesQueue[module_id].then(() => {
+                    resolve(this.getCached(module_id));
+                });
+            } else if (!this.cache.find(module => module.type === module_id)) {
+                this.modulesQueue[module_id] = this.createInstance(module_id);
+                this.modulesQueue[module_id].then(() => {
+                    resolve(this.getCached(module_id));
+                });
+            } else {
+                resolve(this.getCached(module_id));
+            }
+        });
+    }
+
+    /*************** PUT TO CACHE ***************/
+    // Just pushing module to cache.
+
+    pupToCache(module) {
+        this.cache.push(module);
+    }
+
+    /*************** GET CACHED ***************/
+    // Find module in cache and return it.
+
+    getCached(module_id) {
+        return this.cache.find(module => module.type === module_id);
+    }
+
+    /*************** INIT ANGULAR INJECTOR ***************/
+    // Saves angular injector to this.angularInjector.
+    // It's needed to correctly takes module's functions, that uses angular services.
+
+    initAngularInjector(angularInjector) {
+        this.angularInjector = angularInjector;
+    }
+
+    /*************** CREATE INSTANCE ***************/
+    // Get angular module and module's code.
+    // Then parsing module's code.
+    // Finally, creating instance of module, using functions from angular module and parsed code.
+
+    async createInstance(module_id) {
+        let module_url = gudhub.storage.getModuleUrl(module_id);
+        let angularModule = await this.angularInjector.get(module_id);
+        let module = await axios.get(module_url);
+        module = module.data;
+        let returningObject = this.parseModule(module, module_id);
+        if(!returningObject) return false;
+        let obj;
+        eval('obj = ' + returningObject);
+
+        let result = {
+            type: module_id,
+
+            //*************** GET TEMPLATE ****************//
+
+            getTemplate: function (ref, changeFieldName, displayFieldName, field_model, appId, itemId) {
+                let displayFieldNameChecked = displayFieldName === 'false' ? false : true;
+                return obj.getTemplate(ref, changeFieldName, displayFieldNameChecked, field_model, appId, itemId);
+            },
+
+            //*************** GET DEFAULT VALUE ****************//
+
+            getDefaultValue: function (fieldModel, valuesArray, itemsList, currentAppId) {
+                return new Promise(async (resolve) => {
+                    let getValueFunction = obj.getDefaultValue;
+                    if (getValueFunction) {
+                        let value = await getValueFunction(fieldModel, valuesArray, itemsList, currentAppId);
+                        resolve(value);
+                    } else {
+                        resolve(null);
+                    }
+                });
+            },
+
+            //*************** GET SETTINGS ****************//
+
+            getSettings: function (scope, settingType, fieldModels) {
+                return angularModule.getSettings(scope, settingType, fieldModels);
+            },
+
+            //*************** FILTER****************//
+
+            filter: {
+                getSearchOptions: function (fieldModel) {
+                    let d_type = obj;
+                    if (d_type.filter && d_type.filter.getSearchOptions) {
+                        return obj.filter.getSearchOptions(fieldModel);
+                    }
+                    return [];
+                },
+                getDropdownValues: function () {
+                    let d_type = obj;
+                    if (d_type.filter && d_type.filter.getDropdownValues) {
+                        return d_type.filter.getDropdownValues();
+                    } else {
+                        return [];
+                    }
+                }
+            },
+
+            //*************** GET INTERPRETATION ****************//
+
+            getInterpretation: function (value, field, dataType, interpretation_id, itemId, appId) {
+                return new Promise(async (resolve) => {
+                    let currentDataType = obj;
+
+                    let interpr_arr = await currentDataType.getInterpretation(value, field, dataType, interpretation_id, itemId, appId);
+                    if (interpr_arr) {
+                        let data = interpr_arr.find((item) => item.id == interpretation_id) || interpr_arr.find((item) => item.id == 'default');
+
+                        resolve({
+                            html: data.html
+                        })
+                    } else {
+                        resolve({
+                            html: '<span>error(from constructor)</span>'
+                        })
+                    }
+                });
+            },
+
+            //*************** GET INTERPRETATED VALUE ****************//
+
+            getInterpretatedValue: function (field_value, field_model, appId, itemId) {
+                return new Promise(async (resolve) => {
+                    let getInterpretatedValueFunction = obj.getInterpretatedValue;
+                    if (getInterpretatedValueFunction) {
+                        let value = await getInterpretatedValueFunction(field_value, field_model, appId, itemId);
+                        resolve(value);
+                    } else {
+                        let value = await gudhub.getFieldValue(appId, itemId, field_model.id);
+                        resolve(value);
+                    }
+                });
+            },
+
+            //*************** EXTEND CONTROLLER ****************//
+
+            extendController: function (actionScope) {
+                angularModule.getActionScope(actionScope);
+            },
+
+            //*************** RUN ACTION ****************//
+
+            runAction: function (scope) {
+                try {
+                    angularModule.runAction(scope);
+                } catch (e) {
+
+                }
+            },
+
+            //*************** GET WINDOW SCOPE ****************//
+
+            getWindowScope: function (windowScope) {
+                return angularModule.getWindowScope(windowScope);
+            },
+
+            //*************** GET WINDOW HTML ****************//
+
+            getWindowHTML: function (scope) {
+                return angularModule.getWindowHTML(scope);
+            },
+        }
+
+        this.pupToCache(result);
+
+        return result;
+    }
+
+    /*************** PARSE MODULE ***************/
+    // Firstly, it's find factory with provided name.
+    // Then it's parsing factory's code, by counting open and closed brackets.
+    // Then returns object, which originally must be returned by factory.
+
+    parseModule(module, module_id) {
+        let factoryStart = module.indexOf(`.factory('${module_id}',`);
+        if(factoryStart === -1) {
+            factoryStart = module.indexOf(`.factory("${module_id}",`);
+        }
+        if(factoryStart !== -1) {
+            let factory = module.substring(factoryStart, module.length);
+            let returnStart = factory.indexOf('return');
+            let returningObject = factory.substring(returnStart, factory.length);
+            let firstBracket = returningObject.indexOf('{');
+            returningObject = returningObject.substring(firstBracket, returningObject.length);
+            let openBrackets = 0;
+            let closeBrackets = 0;
+            let returnEnd = 0;
+            for (let i = 0; i < returningObject.length; i++) {
+                if (returningObject[i] === '{') {
+                    openBrackets++;
+                }
+                if (returningObject[i] === '}') {
+                    closeBrackets++;
+                }
+                if (openBrackets === closeBrackets && i >= firstBracket) {
+                    returnEnd = i;
+                    break;
+                }
+            }
+            returningObject = returningObject.substring(0, returnEnd + 1);
+            return returningObject;
+        } else {
+            return false;
+        }
+    }
+
+}

package/GUDHUB/{Processors/ItemProcessor → ItemProcessor}/ItemProcessor.js

@@ -1,4 +1,4 @@
-import { filterFields } from "../../utils.js";
+import { filterFields } from "../utils.js";
 
 export class ItemProcessor {
   constructor(storage, pipeService, req, appProcessor, util) {