@gudhub/core 1.1.70 → 1.1.72

package/GUDHUB/FieldProcessor/FieldProcessor.test.js

@@ -29,12 +29,12 @@ describe("FIELD PROCESSOR", async function() {
     })
 
     it('CREATE ITEM AND SET IT VALUE / should return new value of new item', async () => {
-        let items = await gudhub.addNewItems(16259, newItems);
+        let items = await gudhub.addNewItems(214, newItems);
         let item_id = items[0].item_id;
 
-        await gudhub.setFieldValue(16259, item_id, 254056, 'Big Fish Tank');
+        await gudhub.setFieldValue(214, item_id, 254056, 'Big Fish Tank');
 
-        let value = await gudhub.getFieldValue(16259, item_id, 254056);
+        let value = await gudhub.getFieldValue(214, item_id, 254056);
 
         value.should.equal('Big Fish Tank');
     });

package/GUDHUB/ItemProcessor/ItemProcessor.test.js

@@ -7,52 +7,52 @@ describe("ITEM PROCESSOR", async function () {
 
 
     it("GET ITEM / should return an item", async () => {
-        let item = await gudhub.getItem(16259, 1064673);
-        item.item_id.should.equal(1064673)
+        let item = await gudhub.getItem(214, 1175);
+        item.item_id.should.equal(1175)
         let itemType = typeof item;
         itemType.should.equal('object');
     });
 
     it("ADD ITEM AND GET IT / should return new item twice", async () => {
-        let items = await gudhub.addNewItems(16259, newItems);
+        let items = await gudhub.addNewItems(214, newItems);
 
         let isItemsArray = Array.isArray(items);
 
         isItemsArray.should.equal(true);
         items[0].fields[0].field_value.should.equal('Big Fish Tank');
 
-        let item = await gudhub.getItem(16259, items[0].item_id);
+        let item = await gudhub.getItem(214, items[0].item_id);
 
         item.fields[0].field_value.should.equal('Big Fish Tank');
     });
 
     it("ADD NEW ITEM AND GET ITS VALUE / should return new item's value", async () => {
-        let items = await gudhub.addNewItems(16259, newItems);
+        let items = await gudhub.addNewItems(214, newItems);
         let item_id = items[0].item_id;
 
-        let value = await gudhub.getFieldValue(16259, item_id, 254056);
+        let value = await gudhub.getFieldValue(214, item_id, 254056);
 
         value.should.equal('Big Fish Tank');
     });
 
     it("ADD NEW ITEM, UPDATE ITS VALUE AND GET IT / should return updated value of new item", async () => {
-        let items = await gudhub.addNewItems(16259, newItems);
+        let items = await gudhub.addNewItems(214, newItems);
         let item_id = items[0].item_id;
 
-        await gudhub.setFieldValue(16259, item_id, 254056, 'Updated value');
+        await gudhub.setFieldValue(214, item_id, 254056, 'Updated value');
 
-        let value = await gudhub.getFieldValue(16259, item_id, 254056);
+        let value = await gudhub.getFieldValue(214, item_id, 254056);
 
         value.should.equal('Updated value');
     });
 
     it("ADD NEW ITEM, THEN DELETE IT / should return null", async () => {
-        let items = await gudhub.addNewItems(16259, newItems);
+        let items = await gudhub.addNewItems(214, newItems);
         let item_id = items[0].item_id;
 
-        await gudhub.deleteItems(16259, [item_id]);
+        await gudhub.deleteItems(214, [item_id]);
 
-        let value = await gudhub.getFieldValue(16259, item_id, 254056);
+        let value = await gudhub.getFieldValue(214, item_id, 254056);
 
         let isValueNull = value === null ? true : false;
 

package/GUDHUB/Storage/ModulesList.js

@@ -911,10 +911,10 @@ export default function generateModulesList(async_modules_path, file_server_url,
         },
         {
             data_type: 'static_nested_list',
-            name: 'Static Nested List',
+            name: 'Nested Filter',
             icon: 'scheduling',
-            js: 'https://gudhub.com/modules/nested-filter/dist/main.js',
-            css: 'https://gudhub.com/modules/nested-filter/dist/style.css',
+            js: 'https://gudhub.com/modules/nested-filter/dist/main.js?t=1',
+            css: 'https://gudhub.com/modules/nested-filter/dist/style.css?t=1',
             type: 'gh_element',
             technology: 'class'
         },

package/GUDHUB/Utils/Utils.js

@@ -1,5 +1,6 @@
 import { filterPreparation } from "./filter/filterPreparation.js";
 import filter from "./filter/filter.js";
+import { mergeFilters } from "./filter/mergeFilters.js";
 import { jsonToItems } from "./json_to_items/json_to_items.js";
 import {
   mergeItems,
@@ -32,12 +33,9 @@ export class Utils {
     this.FileHelper = new FileHelper(gudhub);
   }
 
-  prefilter(filters_list, element_app_id, app_id, item_id, variables = []) {
+  prefilter(filters_list, variables = {}) {
     return filterPreparation(
       filters_list,
-      element_app_id,
-      app_id,
-      item_id,
       this.gudhub.storage,
       this.gudhub.pipeService,
       variables
@@ -48,6 +46,10 @@ export class Utils {
     return filter(items, filter_list);
   }
 
+  mergeFilters(src, dest) {
+    return mergeFilters(src, dest);
+  }
+
   group(fieldGroup, items) {
     return group(fieldGroup, items);
   }
@@ -64,14 +66,13 @@ export class Utils {
   ) {
     const modified_filters_list = await this.prefilter(
       filters_list,
-      element_app_id,
-      app_id,
-      item_id
+      {
+        element_app_id,
+        app_id,
+        item_id
+      }
     );
-    const itemsList = this.filter(items, [
-      ...filters_list,
-      ...modified_filters_list,
-    ]);
+    const itemsList = this.filter(items, modified_filters_list);
     const newItems = this.group(field_group, itemsList);
     return newItems
       .filter((newItem) => {

package/GUDHUB/Utils/filter/filter.js

@@ -1,34 +1,13 @@
 import { getDate, getDistanceFromLatLonInKm, isSimilarStrings } from "./utils.js";
 
 export default function (items, filters) {
-  const filterAggregate = new Aggregate();
-  const filterChecker = new Checker();
+  const itemsFilter = new ItemsFilter();
 
   if (!items || !items.length) {
     return [];
   }
 
-  return items.filter(function (item) {
-    return filters
-      .filter(function (filter) {
-        return filter.valuesArray.length;
-      })
-      .every(function (filter) {
-        var currField = item.fields.find(function (itemField) {
-          return filter.field_id == itemField.field_id;
-        });
-
-        filterAggregate
-          .setStrategy(filter.search_type)
-          .setEntity(
-            currField && currField.field_value != undefined
-              ? currField.field_value
-              : null
-          )
-          .setFilterValues(filter.valuesArray);
-        return filterChecker.check(filterAggregate);
-      });
-  });
+  return itemsFilter.filter(filters, items);
 }
 
 class Checker {
@@ -326,3 +305,67 @@ class Aggregate {
     return this._checkOption;
   }
 }
+
+class ItemsFilter {
+  constructor() {
+
+  }
+
+  filter(filters, items) {
+
+    const filteredItems = [];
+    const activeFilters = filters.filter(function (filter) {
+      return filter.valuesArray.length;
+    });
+    
+    for(let item of items) {
+      let result = true;
+
+      for(let i = 0; i < activeFilters.length; i++) {
+        const filter = activeFilters[i];
+  
+        const currField = item.fields.find(function (itemField) {
+          return filter.field_id == itemField.field_id;
+        });
+  
+        const filterAggregate = new Aggregate();
+        const filterChecker = new Checker();
+  
+        filterAggregate
+            .setStrategy(filter.search_type)
+            .setEntity(
+              currField && currField.field_value != undefined
+                ? currField.field_value
+                : null
+            )
+            .setFilterValues(filter.valuesArray);
+           
+            switch(filter.boolean_strategy) {
+              case 'and':
+                result = result && filterChecker.check(filterAggregate);
+              break;
+
+              case 'or':
+                result = result || filterChecker.check(filterAggregate);
+              break;
+
+              default:
+                result = result && filterChecker.check(filterAggregate);
+            }
+            
+      }
+
+      if(result) {
+        filteredItems.push(item);
+      }
+    }
+
+    if(filteredItems.length || filters.length && !filteredItems.length) {
+      return filteredItems;
+    } 
+     else {
+      return items;
+    }
+    
+  }
+}

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

@@ -1,6 +1,8 @@
 import should from 'should';
 import {GudHub} from './../../gudhub.js';
 
+import { app_8263 } from '../../../fake_server/fake_server_data/app_8263.js';
+
 
 
   describe('Filter', function() {
@@ -9,6 +11,87 @@ import {GudHub} from './../../gudhub.js';
     it('Should return one Item', function(){
         gudhub.filter(items, filters).length.should.equal(1);
     });
+
+    it('FILTER AND / should return items matching first AND second filter', function() {
+        const filters = [
+            {
+                "field_id": 96606,
+                "data_type": "text",
+                "valuesArray": [
+                    "Dothan"
+                ],
+                "search_type": "contain_or",
+                "boolean_strategy": "and",
+                "selected_search_option_variable": "Value"
+            },
+            
+            {
+                "field_id": 96608,
+                "data_type": "phone",
+                "valuesArray": [
+                    "677"
+                ],
+                "search_type": "contain_or",
+                "boolean_strategy": "and",
+                "selected_search_option_variable": "Value"
+            }
+        ];
+
+        const filteredItems = gudhub.filter(app_8263.items_list, filters);
+        filteredItems.length.should.equal(1);
+    });
+
+    it('FILTER OR / should return items matching first OR second filter', function() {
+        const filters = [
+            {
+                "field_id": 96606,
+                "data_type": "text",
+                "valuesArray": [
+                    "Distributors"
+                ],
+                "search_type": "contain_or",
+                "boolean_strategy": "and",
+                "selected_search_option_variable": "Value"
+            },
+            
+            {
+                "field_id": 96608,
+                "data_type": "phone",
+                "valuesArray": [
+                    "353"
+                ],
+                "search_type": "contain_or",
+                "boolean_strategy": "or",
+                "selected_search_option_variable": "Value"
+            }
+        ];
+
+        const filteredItems = gudhub.filter(app_8263.items_list, filters);
+        filteredItems.length.should.equal(8);
+    });
+
+    it('PREFILTER WITH VARIABLES / should return variables values instead of names', async () => {
+        const filters = [
+            {
+                "field_id": 96606,
+                "data_type": "text",
+                "input_type": "variable",
+                "input_value": "current_app,boolean",
+                "search_type": "contain_or"
+            }
+        ]
+
+        const variables = {
+            current_app_id: 1,
+            boolean: true
+        }
+
+        const filter = await gudhub.prefilter(filters, variables);
+
+        filter[0].valuesArray[0].should.equal(1);
+        filter[0].valuesArray[1].should.equal(true);
+
+    });
     
   });
 

package/GUDHUB/Utils/filter/filterPreparation.js

@@ -1,24 +1,21 @@
 export async function filterPreparation(
   filters_list,
-  element_app_id,
-  current_app_id,
-  item_id,
   storage,
   pipeService,
-  variables = []
+  variables = {}
 ) {
   const filterArray = [];
 
   const objectMethod = {
     variableMethodcurrent_app() {
-      return [current_app_id];
+      return [variables.current_app_id];
     },
     variableMethodelement_app() {
-      return [element_app_id];
+      return [variables.element_app_id];
     },
 
     variableMethodcurrent_item() {
-      const currentValue = `${current_app_id}.${item_id}`;
+      const currentValue = `${variables.current_app_id || variables.app_id}.${variables.item_id}`;
       return [currentValue];
     },
 
@@ -48,29 +45,41 @@ export async function filterPreparation(
         start_date.valueOf().toString() + ":" + end_date.valueOf().toString();
       return [result];
     },
-    variableMethodvariable() {
-      return variables;
+    variableMethodvariable(property) {
+      return [variables[property]];
     },
   };
   if (filters_list) {
     for (const filter of filters_list) {
       if (filter) {
+        // ---------------------- WARNING !!! -------------------------------
+        // Should be fixed: modification of filters_list valuesArray
         switch (filter.input_type) {
           case "variable":
-            const functionName =
-              filter.input_type + "Method" + filter.input_value;
-            const func = objectMethod[functionName];
-            if (typeof func === "function") {
-              filter.valuesArray = func();
-            } else {
-              filter.valuesArray = objectMethod.variableMethodvariable();
+            for(const filterValue of filter?.input_value.split(',')) {
+              const functionName =
+                filter.input_type + "Method" + filterValue;
+              const func = objectMethod[functionName];
+              if (typeof func === "function") {
+                if(!filter.valuesArray) {
+                  filter.valuesArray = func();
+                } else {
+                  filter.valuesArray.push(...func());
+                }
+              } else {
+                if(!filter.valuesArray) {
+                  filter.valuesArray = objectMethod.variableMethodvariable(filterValue);
+                } else {
+                  filter.valuesArray.push(...objectMethod.variableMethodvariable(filterValue));
+                }
+              }
             }
             filterArray.push(filter);
             break;
           case "field":
             const field_value = await fieldMethod({
-              app_id: current_app_id,
-              item_id: item_id,
+              app_id: variables.current_app_id,
+              item_id: variables.item_id,
               field_id: filter.input_value,
             });
             if(field_value != null){

package/GUDHUB/Utils/filter/mergeFilters.js

@@ -0,0 +1,32 @@
+export function mergeFilters(srcFilters, destFilters) {
+  const mergedFieldIds = [];
+  let filters = [];
+
+  if(srcFilters.length > 0) {
+    srcFilters.forEach(filter => {
+      filters.push(filter);
+    });
+  } else {
+    filters = destFilters;
+  }
+
+  if(filters.length > 0) {
+    
+    filters.forEach((filter, index) => {
+      for(let i = 0; i < destFilters.length; i++) {
+          if(filter.field_id == destFilters[i].field_id) {
+            mergedFieldIds.push(filter.field_id);
+            filters[index] = gudhub.mergeObjects(destFilters[i], filter);
+          }
+      }
+    });
+
+    for(let k = 0; k < destFilters.length; k++) {
+      if(!mergedFieldIds.includes(destFilters[k].field_id)) {
+        filters.push(destFilters[k]);
+      }
+    }
+
+  }
+  return filters;
+}

package/GUDHUB/Utils/json_constructor/json_constructor.js

@@ -68,6 +68,28 @@ export function compiler(scheme, item, util, variables, appId) {
 
     }
 
+    if(scheme.offset) {
+      let offset;
+      if(scheme.use_variables_for_limit_and_offset && variables) {
+        offset = variables[scheme.offset];
+      } else {
+        offset = /^[0-9]+$/.test(scheme.offset) ? scheme.offset : 0;
+      }
+      filteredItems = filteredItems.slice(offset);
+    }
+
+    if(scheme.limit) {
+      let limit;
+      if(scheme.use_variables_for_limit_and_offset && variables) {
+        limit = variables[scheme.limit];
+      } else {
+        limit = /^[0-9]+$/.test(scheme.limit) || 0;
+      }
+      if(limit !== 0) {
+        filteredItems = filteredItems.slice(0, limit);
+      }
+    }
+
     const arrayOfItemsWithProperties =  filteredItems.map(async (item) => {
       return getChildsPropertiesObject(scheme.childs, item, app.app_id);
     });
@@ -140,10 +162,12 @@ export function compiler(scheme, item, util, variables, appId) {
   async function getFilteredItems(filtersList, element_app_id, app_id, item_id, itemsList) {
     const modified_filters_list = await util.gudhub.prefilter(
       JSON.parse(JSON.stringify(filtersList)),
-      element_app_id,
-      app_id,
-      item_id,
-      variables
+      {
+        element_app_id,
+        app_id,
+        item_id,
+        ...variables
+      }
     );
     return util.gudhub.filter(itemsList, [...modified_filters_list, ...filtersList]);
   }
@@ -164,5 +188,5 @@ export function compiler(scheme, item, util, variables, appId) {
     ) : [...itemsList ];
   }
 
-  return schemeCompiler(scheme, item, appId);
+  return schemeCompiler(scheme, item, appId, variables);
 }

package/GUDHUB/gudhub-https-service.js

@@ -39,13 +39,19 @@ export class GudHubHttpsService {
          /\?/.test(url) ? "&" : "?"
        }token=${accessToken}${convertObjToUrlParams(request.params)}`;
       }
-
-      axios.get(url).then(function (response) {
+      axios.get(url, {
+        validateStatus: function (status) {
+            return status < 400; // Resolve only if the status code is less than 400
+        }
+      }).then(function (response) {
+        if(response.status != 200) {
+          console.error(`GUDHUB HTTP SERVICE: GET ERROR: ${response.status}`, response);
+        }
         // handle success
         resolve(response.data);
       })
       .catch(function (err) {
-        console.log("ERROR -> GUDHUB HTTP SERVICE -> GET :", err.message);
+        console.error(`GUDHUB HTTP SERVICE: GET ERROR: ${err.response.status}\n`, err);
         console.log("Request message: ", request);
         if(err.response && err.response.data) {
           console.log('Error response data: ', err.response.data);
@@ -79,12 +85,18 @@ export class GudHubHttpsService {
           headers: request.headers || {
             "Content-Type": "application/x-www-form-urlencoded",
           },
+          validateStatus: function (status) {
+            return status < 400; // Resolve only if the status code is less than 400
+          }
         }
       ).then(function (response) {
+        if(response.status != 200) {
+          console.error(`GUDHUB HTTP SERVICE: POST ERROR: ${response.status}`, response);
+        }
         // handle success
         resolve(response.data);
       }).catch(function (error) {
-        console.log("ERROR -> GUDHUB HTTP SERVICE -> POST :", error.message);
+        console.error(`GUDHUB HTTP SERVICE: POST ERROR: ${error.response.status}\n`, error);
         console.log("Request message: ", request);
         reject(error);
       });

package/GUDHUB/gudhub.js

@@ -141,12 +141,9 @@ export class GudHub {
   }
 
   //************************* FILTERATION  ****************************//
-  prefilter(filters_list, element_app_id, app_id, item_id, variables) {
+  prefilter(filters_list, variables) {
     return this.util.prefilter(
       filters_list,
-      element_app_id,
-      app_id,
-      item_id,
       variables
     );
   }
@@ -176,6 +173,11 @@ export class GudHub {
     return this.util.filter(items, filter_list);
   }
 
+  //============ MERGE FILTERS ==========//
+  mergeFilters(source, destination) {
+    return this.util.mergeFilters(source, destination);
+  }
+
   //============ GROUP ==========//
   group(fieldGroup, items) {
     return this.util.group(fieldGroup, items);

package/package.json

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