@gudhub/core 1.1.73 → 1.1.75

package/GUDHUB/DocumentManager/DocumentManager.js

@@ -25,7 +25,8 @@ export class DocumentManager {
   }
 
   emitDocumentInsert(data) {
-    this.pipeService.emit("gh_document_insert_one", { app_id: data.app_id, item_id: data.item_id, element_id: data.element_id }, JSON.parse(data.data));
+    const dataToEmit = typeof data.data === "string" ? JSON.parse(data.data) : data.data;
+    this.pipeService.emit("gh_document_insert_one", { app_id: data.app_id, item_id: data.item_id, element_id: data.element_id }, dataToEmit);
   }
 
   getDocument(documentAddress) {

package/GUDHUB/GHConstructor/interpritate.js

@@ -7,9 +7,8 @@ export class Interpritate {
     // In this method we are looking for interpretation in data model according to interpretation src
     // then we merged with default interpretation from defaultFieldDataModel
     // if there are no current interpretation we use default interpretation
-    getInterpretationObj(fieldDataModel, defaultFieldDataModel, src, containerId) {
-        var currentIntrpr = {};
-
+    async getInterpretationObj(fieldDataModel, defaultFieldDataModel, src, containerId, itemId, appId) {
+        var currentIntrpr = [];
         // Creating default interpretation
         var defaultIntrprObj = defaultFieldDataModel.data_model.interpretation.find(function (interpritation) {
             return interpritation.src == src;
@@ -17,15 +16,34 @@ export class Interpritate {
             return interpritation.src == 'table';
         }) || { id: 'default' };
 
+        var interpretation = defaultIntrprObj;
+
         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;
-            });
+            for(var i = 0; i < fieldDataModel.data_model.interpretation.length; i++) {
+                if(fieldDataModel.data_model.interpretation[i].src == src || fieldDataModel.data_model.interpretation[i].src == containerId) {
+                    currentIntrpr.push(fieldDataModel.data_model.interpretation[i]);
+                }
+            }
+
+            for(var i = 0; i < currentIntrpr.length; i++) {
+                if(currentIntrpr[i].settings.condition_filter && currentIntrpr[i].settings.filters_list.length > 0) {
+                    const item = await gudhub.getItem(appId, itemId);
+                    if(item) {
+                        const filteredItems = gudhub.filter([item], currentIntrpr[i].settings.filters_list);
+                        if(filteredItems.length > 0) {
+                            interpretation = currentIntrpr[i];
+                            break;
+                        }
+                    }
+                } else {
+                    interpretation = gudhub.mergeObjects(interpretation, currentIntrpr[i]);
+                }
+            }
+
         }
-        return gudhub.mergeObjects(defaultIntrprObj, currentIntrpr);
+        
+        return interpretation;
     }
 
     /*********************** GET INTERPRETATION ***********************/
@@ -39,9 +57,9 @@ export class Interpritate {
             /*---- 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) {
+                gudhub.ghconstructor.getInstance(data_type).then(async function (data) {
                     if(data) {
-                        var interpretationObj = self.getInterpretationObj(field, data.getTemplate().model, source, containerId);
+                        var interpretationObj = await self.getInterpretationObj(field, data.getTemplate().model, source, containerId, itemId, appId);
                         data.getInterpretation(value, interpretationObj.id, data_type, field, itemId, appId).then(function (result) {
                             // console.log(result, interpretationObj)
 

package/GUDHUB/Storage/ModulesList.js

@@ -1162,11 +1162,25 @@ export default function generateModulesList(async_modules_path, file_server_url,
         },
         {
             data_type: 'TwilioSMS',
-            name: 'Twilio',
+            name: 'Twilio SMS',
             url: file_server_url + '/' + automation_modules_path + 'twilio_sms.js',
             type: 'automation',
             icon: 'automation_twilio'
         },
+        {
+            data_type: 'TwilioAuth',
+            name: 'Twilio Auth',
+            url: file_server_url + '/' + automation_modules_path + 'twilio_auth.js',
+            type: 'automation',
+            icon: 'table'
+        },
+        {
+            data_type: 'TwilioDevice',
+            name: 'Twilio Device',
+            url: file_server_url + '/' + automation_modules_path + 'twilio_device.js',
+            type: 'automation',
+            icon: 'table'
+        },
         {
             data_type: 'UpdateItemsApi',
             name: 'Update Items Api',

package/GUDHUB/Utils/filter/filter.js

@@ -313,6 +313,8 @@ class ItemsFilter {
 
   filter(filters, items) {
 
+    const allFiltersAndStrategy = this.checkIfAllFiltersHaveAndStrategy(filters);
+
     const filteredItems = [];
     const activeFilters = filters.filter(function (filter) {
       return filter.valuesArray.length;
@@ -352,6 +354,12 @@ class ItemsFilter {
               default:
                 result = result && filterChecker.check(filterAggregate);
             }
+
+            // Needed for performance optimization
+            // We don't need to check other filters if we already know that result is false in case of 'and' strategy
+            if(!result && allFiltersAndStrategy) {
+              break;
+            }
             
       }
 
@@ -368,4 +376,14 @@ class ItemsFilter {
     }
     
   }
+
+  checkIfAllFiltersHaveAndStrategy(filters) {
+    return filters.every((filter) => {
+      if(!filter.boolean_strategy || filter.boolean_strategy == 'and') {
+        return true;
+      }
+      return false;
+    });
+  }
+
 }

package/GUDHUB/Utils/filter/filter.test.js

@@ -92,6 +92,49 @@ import { app_8263 } from '../../../fake_server/fake_server_data/app_8263.js';
         filter[0].valuesArray[1].should.equal(true);
 
     });
+
+    it('CHECK FILTER PERFORMANCE / filter with and strategy should run in less than 200ms', async () => {
+
+        const filters = [
+            {
+                "field_id": 96606,
+                "data_type": "text",
+                "valuesArray": [
+                    "Oklahoma"
+                ],
+                "search_type": "contain_or",
+                "boolean_strategy": "and",
+                "selected_search_option_variable": "Value"
+            },
+            
+            {
+                "field_id": 96608,
+                "data_type": "phone",
+                "valuesArray": [
+                    "8453"
+                ],
+                "search_type": "contain_or",
+                "boolean_strategy": "and",
+                "selected_search_option_variable": "Value"
+            }
+        ];
+
+        let totalTime = 0;
+
+        const iterationsCount = 1000;
+
+        for (let i = 0; i < iterationsCount; i++) {
+            const startTime = new Date().getTime();
+            gudhub.filter(app_8263.items_list, filters);
+            totalTime += new Date().getTime() - startTime;
+        }
+
+        // Ideally, on my laptop with i7-9750H 2.60 it takes 60ms
+        totalTime.should.be.below(200);
+
+        console.log('Average time for filter with and strategy: ', totalTime);
+
+    });
     
   });
 

package/GUDHUB/Utils/json_constructor/json_constructor.js

@@ -26,6 +26,20 @@ export function compiler(scheme, item, util, variables, appId) {
       value = await getFieldValue(scheme, item, appId);
     }
 
+    if (typeof scheme === "object" && typeof scheme.type === 'undefined') {
+      const result = {};
+
+      for (const key in scheme) {
+        if (scheme.hasOwnProperty(key)) {
+          const element = scheme[key];
+          const res = await schemeCompiler(element, item, appId);
+          result[key] = res[element.property_name];
+        }
+      }
+
+      return result;
+    }
+
     return { [scheme.property_name]: value };
   }
 

package/package.json

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