@gudhub/core 1.0.56 → 1.0.59

package/GUDHUB/GHConstructor/ghconstructor.js

@@ -11,6 +11,57 @@ let $q = {
     }
 }
 
+/*************** FAKE ANGULAR ***************/
+// It's needed when we eval() angular code.
+
+let factoryReturns = {};
+
+let angular = {
+    module() {
+        return angular;
+    },
+    directive() {
+        return angular;
+    },
+    factory(name, args) {
+        try {
+            if(typeof args === 'object') {
+                factoryReturns[name] = args[args.length - 1]($q);
+            } else {
+                factoryReturns[name] = args($q);
+            }
+        } catch(error) {
+            console.log('Errror in data type: ', name);
+            console.log(error);
+        }
+        return angular;
+    },
+    service() {
+        return angular;
+    },
+    run() {
+        return angular;
+    },
+    filter() {
+        return angular;
+    },
+    controller() {
+        return angular;
+    },
+    value() {
+        return angular;
+    },
+    element() {
+        return angular;
+    },
+    injector() {
+        return angular;
+    },
+    invoke() {
+        return angular;
+    }
+}
+
 export class GHConstructor {
     constructor() {
         this.cache = [];
@@ -23,7 +74,7 @@ export class GHConstructor {
     // 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) {
+    async getInstance(module_id) {
         return new Promise(async (resolve) => {
             if (this.modulesQueue[module_id]) {
                 return this.modulesQueue[module_id].then(() => {
@@ -64,21 +115,25 @@ export class GHConstructor {
 
     /*************** 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.
+    // Then eval() module's code.
+    // Finally, creating instance of module, using functions from angular module and evaled code.
 
     async createInstance(module_id) {
         let module_url = gudhub.storage.getModuleUrl(module_id);
+
+        if(!this.angularInjector.has(module_id)) {
+            await this.angularInjector.get('$ocLazyLoad').load(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;
+
         try {
-            eval('obj = ' + returningObject);
+            eval(module);
         } catch(error) {
-            console.log(`Error in ghconstructor (${module_id})`, error);
+            console.error('ERROR WHILE EVAL() IN GHCONSTRUCTOR', error);
         }
 
         let result = {
@@ -135,7 +190,7 @@ export class GHConstructor {
 
             getInterpretation: function (value, field, dataType, interpretation_id, itemId, appId) {
                 return new Promise(async (resolve) => {
-                    let currentDataType = obj;
+                    let currentDataType = angularModule;
 
                     let interpr_arr = await currentDataType.getInterpretation(value, field, dataType, interpretation_id, itemId, appId);
                     if (interpr_arr) {
@@ -152,17 +207,36 @@ export class GHConstructor {
                 });
             },
 
+            //*************** GET INTERPRETATION V2 ****************//
+
+            getInterpretationNew: function(value, interpretation_id, dataType, field, itemId, appId) {
+                return new Promise(async (resolve) => {
+                    let currentDataType = factoryReturns[module_id];
+
+                    try {
+                        let interpr_arr = await currentDataType.getInterpretationNew(value, appId, itemId, field, dataType);
+                        let data = interpr_arr.find((item) => item.id == interpretation_id) || interpr_arr.find((item) => item.id == 'default');
+
+                        let result = await data.content()
+
+                        resolve({ html: result });
+                    } catch(error) {
+                        console.log(`ERROR IN ${module_id}`, error);
+                        resolve({ html: '<span>no interpretation</span>' })
+                    }
+                });
+            },
+
             //*************** GET INTERPRETATED VALUE ****************//
 
             getInterpretatedValue: function (field_value, field_model, appId, itemId) {
                 return new Promise(async (resolve) => {
-                    let getInterpretatedValueFunction = angularModule.getInterpretatedValue;
+                    let getInterpretatedValueFunction = factoryReturns[module_id].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);
+                        resolve(field_value);
                     }
                 });
             },
@@ -200,43 +274,4 @@ export class GHConstructor {
 
         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/GHConstructor/interpritate.js

@@ -0,0 +1,93 @@
+export class Interpritate {
+    constructor(gudhub) {
+        this.gudhub = gudhub;
+    }
+
+    /*********************** GET INTERPRETATION OBJ ***********************/
+
+    getInterpretationObj(fieldDataModel, defaultFieldDataModel, src, containerId) {
+        var currentIntrpr = {};
+
+        var defaultIntrprObj = defaultFieldDataModel.data_model.interpretation.find(function (interpritation) {
+            return interpritation.src == src;
+        }) || defaultFieldDataModel.data_model.interpretation.find(function (interpritation) {
+            return interpritation.src == 'table';
+        }) || { id: 'default' };
+
+        if (fieldDataModel.data_model && fieldDataModel.data_model.interpretation) {
+            // To detect interpretation we use (container_id), if there is not (container_id) we use (src)
+            currentIntrpr = fieldDataModel.data_model.interpretation.find(function (interpritation) {
+                return interpritation.src == containerId;
+            }) || fieldDataModel.data_model.interpretation.find(function (interpritation) {
+                return interpritation.src == src;
+            });
+        }
+        return gudhub.mergeObjects(defaultIntrprObj, currentIntrpr);
+    }
+
+    /*********************** GET INTERPRETATION ***********************/
+
+    getInterpretation(value, field, dataType, source, itemId, appId, containerId) {
+        const self = this;
+        return new Promise(async (resolve, reject) => {
+            /*-- By default we use 'data_type' from field but in case if field is undefined we use 'dataType' from attribute*/
+            var data_type = field && field.data_type ? field.data_type : dataType;
+
+            /*---- Constructing Data Object ----*/
+            if (data_type) {
+                /*-- if we have data_type then we construct new data object to interpritate value*/
+                gudhub.ghconstructor.getInstance(data_type).then(function (data) {
+                    var interpretationObj = self.getInterpretationObj(field, data.getTemplate().model, source, containerId);
+                    data.getInterpretationNew(value, interpretationObj.id, data_type, field, itemId, appId).then(function (result) {
+                        // console.log(result, interpretationObj)
+
+                        resolve(gudhub.mergeObjects(result, interpretationObj));
+                    }, function (error) {
+                        reject();
+                    });
+                }, function (error) { });
+
+            } else {
+                /*-- if we don't have data_type then we run defaultInterpretation function*/
+                resolve(this.getDefaultInterpretation(value, field));
+            }
+        });
+    }
+
+    /*********************** GET DEFAULT INTERPRETATION ***********************/
+
+    getDefaultInterpretation(value, options) {
+        var result = value;
+  
+        if (options) {
+          /*-- Iterating through options from data_model to find a nave for selected*/
+          options.forEach(item => {
+              if(item.value == value && value != '') {
+                  result = item.name;
+              }
+          })
+        }
+        return result;
+      }
+
+    /********************* GET INTERPRETATION BY ID *********************/
+
+    getInterpretationById(appId, itemId, fieldId, interpretationId) {
+        return new Promise(async (resolve) => {
+            let fieldValue = await this.gudhub.getFieldValue(appId, itemId, fieldId);
+            let fieldModel = await this.gudhub.getField(appId, fieldId);
+            if(fieldModel == null) {
+                resolve('');
+            }
+            this.gudhub.ghconstructor.getInstance(fieldModel.data_type).then(async (instance) => {
+                let interpretatedValue = await instance.getInterpretationNew(fieldValue, interpretationId, fieldModel.data_type, fieldModel, itemId, appId);
+                if(interpretatedValue.html == '<span>no interpretation</span>') {
+                    resolve(fieldValue);
+                } else {
+                    resolve(interpretatedValue.html);
+                }
+            });
+        });
+    }
+
+}

package/GUDHUB/Storage/ModulesList.js

@@ -136,14 +136,6 @@ export default function generateModulesList(async_modules_path, file_server_url)
             name: "signature",
             url: file_server_url + '/' + async_modules_path + "signature_data.js"
         },
-        {
-            name: "schedule",
-            url: file_server_url + '/' + async_modules_path + "schedule_data.js"
-        },
-        {
-            name: "auto_schedule",
-            url: file_server_url + '/' + async_modules_path + "auto_schedule_data.js"
-        },
         {
             name: "sendEmail",
             url: file_server_url + '/' + async_modules_path + "send_email_data.js"
@@ -413,5 +405,9 @@ export default function generateModulesList(async_modules_path, file_server_url)
             name: "vs_code",
             url: file_server_url + '/' + async_modules_path + "vs_code_data.js"
         },
+        {
+            name: "nested_list",
+            url: file_server_url + '/' + async_modules_path + "nested_list_data.js"
+        },
     ]
 }

package/GUDHUB/Storage/Storage.js

@@ -6,6 +6,7 @@ export class Storage {
     this.users_list = [];
     this.user = {};
     this.modulesList = generateModulesList(async_modules_path, file_server_url);
+    this.ghComponentsPromises = [];
   }
 
   getMainStorage() {

package/GUDHUB/Utils/Utils.js

@@ -139,8 +139,8 @@ export class Utils {
     return mergeChunks(chunks);
   }
 
-  jsonConstructor(scheme, items, variables){
-    return compiler(scheme, items, this, variables)
+  jsonConstructor(scheme, item, variables){
+    return compiler(scheme, item, this, variables)
   }
   
   compareAppsItemsLists(items_list1, items_list2, callback) {

package/GUDHUB/Utils/get_date/get_date.test.js

@@ -1,5 +1,7 @@
 import should from "should";
+// import add from "date-fns/subYears/index.js";
 import {GudHub} from '../../gudhub.js';
+import { subYears } from "date-fns";
 
 describe("GET DATE", function () {
   const gudhub = new GudHub();
@@ -73,6 +75,15 @@ describe("GET DATE", function () {
     result.should.equal(false);
   });
 
+  it('CHECK IF DATE IN THIS WEEK / Compare this wednesday with wednesday two years ago', function(){
+    let day = gudhub.getDate('this_wednesday');
+    let dayTwoYearsBefore = subYears(day, 2);
+
+    // console.log(dayTwoYearsBefore);
+    let result = gudhub.checkRecurringDate(dayTwoYearsBefore, 'week');
+    result.should.equal(true);
+  });
+
   it("CHECK IF DATE IN THIS MONTH", function() {
     let today = new Date();
     let result = gudhub.checkRecurringDate(today, 'month');
@@ -83,4 +94,5 @@ describe("GET DATE", function () {
     result = gudhub.checkRecurringDate(twoMonthsLater, 'month');
     result.should.equal(false);
   });
+
 });

package/GUDHUB/Utils/merge_objects/merge_objects.js

@@ -63,6 +63,8 @@ function mergeObject(target, source, optionsArgument) {
 }
 
 function deepmerge(target, source, optionsArgument) {
+    target = target !== undefined ? target : {};
+    source = source !== undefined ? source : {};
     var array = Array.isArray(source);
     var options = optionsArgument || { arrayMerge: defaultArrayMerge }
     var arrayMerge = options.arrayMerge || defaultArrayMerge

package/GUDHUB/Utils/nested_list/nested_list.js

@@ -36,16 +36,12 @@ export function makeNestedList(arr, id, parent_id, children_property, priority_p
   }
 
   function sortChildrensByPriority(unsorted_array) {
-    unsorted_array.forEach(item => {
-      if(item[children]) {
-        item[children].sort((a, b) => a[priority] - b[priority]);
-        item[children].forEach(child => {
-          if(child[children]) {
-            sortChildrensByPriority(child[children]);
-        }
-      })
-    }
-    });
+    unsorted_array.sort( (a, b) => a[priority] - b[priority])
+    unsorted_array.forEach(element => {
+      if(element[children]) {
+        sortChildrensByPriority(element[children])
+      }
+    })
   }
 
   if(priority) {

package/GUDHUB/Utils/nested_list/nested_list.test.js

@@ -24,6 +24,11 @@ describe("NESTED LIST", function () {
         nestedList[0].custom_children_array_name[1].title.should.equal('Child 1');
     })
 
+    it('Should sort nested list parents by priority', function () {
+        let nestedList = gudhub.makeNestedList(parentInput, 'id', 'parent_id', 'children', 'priority');
+        nestedList[0].title.should.equal('Nineth');
+    })
+
 });
 
 let input = [
@@ -145,4 +150,36 @@ let complicatedInput = [
         parent_id: "26553.2884361",
         title: "Child of second parent"
     }
+]
+let parentInput = [
+    {
+        "id": "27026.2937695",
+        "parent_id": "",
+        "title": "First",
+        "priority": "1"
+    },
+    {
+        "id": "27026.2937708",
+        "parent_id": "",
+        "title": "Second",
+        "priority": "4"
+    },
+    {
+        "id": "27026.3009942",
+        "parent_id": "",
+        "title": "Eighth",
+        "priority": "3"
+    },
+    {
+        "id": "27026.3009943",
+        "parent_id": "",
+        "title": "Tenth",
+        "priority": "2"
+    },
+    {
+        "id": "27026.3108354",
+        "parent_id": "",
+        "title": "Nineth",
+        "priority": "0"
+    }
 ]

package/GUDHUB/gudhub.js

@@ -12,6 +12,7 @@ import { FieldProcessor } from "./FieldProcessor/FieldProcessor.js";
 import { FileManager } from "./FileManager/FileManager.js";
 import { ChunksManager } from "./ChunksManager/ChunksManager.js";
 import { DocumentManager } from "./DocumentManager/DocumentManager.js";
+import { Interpritate } from './GHConstructor/interpritate.js'
 import { IS_WEB } from "./consts.js";
 
 export class GudHub {
@@ -28,6 +29,7 @@ export class GudHub {
     }
   ) {
     this.ghconstructor = new GHConstructor();
+    this.interpritate = new Interpritate(this);
     this.pipeService = new PipeService();
     this.storage = new Storage(options.async_modules_path, options.file_server_url);
     this.util = new Utils(this);
@@ -148,6 +150,26 @@ export class GudHub {
     return this.ghconstructor.initAngularInjector(injector);
   }
 
+  /******************* INTERPRITATE *******************/
+
+  getInterpretation(value, field, dataType, source, itemId, appId, containerId) {
+    return this.interpritate.getInterpretation(
+      value,
+      field,
+      dataType,
+      source,
+      itemId,
+      appId,
+      containerId
+    );
+  }
+
+  /******************* GET INTERPRETATION BY ID *******************/
+
+  getInterpretationById(appId, itemId, fieldId, interpretationId) {
+    return this.interpritate.getInterpretationById(appId, itemId, fieldId, interpretationId);
+  }
+
   //============ FILTER ==========//
   filter(items, filter_list) {
     return this.util.filter(items, filter_list);

package/package.json

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