@gudhub/core 1.0.37

package/GUDHUB/Utils/filter/filter.js

@@ -0,0 +1,308 @@
+import { getDate, getDistanceFromLatLonInKm, isSimilarStrings } from "./utils.js";
+
+export default function (items, filters) {
+  const filterAggregate = new Aggregate();
+  const filterChecker = new Checker();
+
+  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);
+      });
+  });
+}
+
+class Checker {
+  changeBehavior(checkOption) {
+    switch (checkOption) {
+      case "contain_or":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) =>
+            data.some((_dataItem) => _dataItem.indexOf(_filter) !== -1)
+          );
+        };
+        break;
+      case "contain_and":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.every((_filter) =>
+            data.some((_dataItem) => _dataItem.indexOf(_filter) !== -1)
+          );
+        };
+        break;
+      case "not_contain_or":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) =>
+            data.every((_dataItem) => _dataItem.indexOf(_filter) === -1)
+          );
+        };
+        break;
+      case "not_contain_and":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.every((_filter) =>
+            data.every((_dataItem) => _dataItem.indexOf(_filter) === -1)
+          );
+        };
+        break;
+      case "equal_or":
+        this._checkFn = function (data, filtersValues) {
+          if (!data.length) return false;
+          return data.some((_dataItem) =>
+            filtersValues.some((_filter) => _dataItem == _filter)
+          );
+        };
+        break;
+      case "equal_and":
+        this._checkFn = function (data, filtersValues) {
+          if (!data.length) return false;
+
+          let filtersValuesSet = new Set(filtersValues);
+          while (data.length && filtersValuesSet.size) {
+            let dataValue = data.pop();
+            if (filtersValuesSet.has(dataValue)) {
+              filtersValuesSet.delete(dataValue);
+            }
+          }
+          return !filtersValuesSet.size;
+        };
+        break;
+      case "not_equal_or":
+        this._checkFn = function (data, filtersValues) {
+          if (!data.length) return true;
+          let filtersValuesSet = new Set(filtersValues);
+          while (data.length && filtersValuesSet.size) {
+            let dataValue = data.pop();
+            if (!filtersValuesSet.has(dataValue)) {
+              return true;
+            }
+          }
+          return false;
+        };
+        break;
+      case "not_equal_and":
+        this._checkFn = function (data, filtersValues) {
+          let filtersValuesSet = new Set(filtersValues);
+          while (data.length && filtersValuesSet.size) {
+            let dataValue = data.pop();
+            if (filtersValuesSet.has(dataValue)) {
+              return false;
+            }
+          }
+          return true;
+        };
+        break;
+      case "bigger":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) =>
+            data.every((_dataItem) => _dataItem > _filter)
+          );
+        };
+        break;
+      case "lower":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) =>
+            data.every((_dataItem) => _dataItem < _filter)
+          );
+        };
+        break;
+      case "range":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) =>
+            data.every(
+              (_dataItem) =>
+                _filter.start <= _dataItem && _dataItem < _filter.end
+            )
+          );
+        };
+        break;
+      case "value":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) =>
+            data.some((_dataItem) => _dataItem == _filter)
+          );
+        };
+        break;
+      case 'search':
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) => isSimilarStrings(_filter, data));
+        };
+        break;
+      case "phone_equal_or":
+        this._checkFn = function (data, filtersValues) {
+          if (!data.length) return false;
+          return filtersValues.some((_filter) =>
+            data.some(
+              (_dataItem) =>
+                _dataItem
+                  .replace(/[^0-9]/g, "")
+                  .indexOf(_filter.replace(/[^0-9]/g, "")) !== -1
+            )
+          );
+        };
+        break;
+      case 'distance':
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) => data.some((_dataItem) => getDistanceFromLatLonInKm(_filter, _dataItem)));
+        };
+        break;
+      case "date_in":
+      case "date_out":
+        this._checkFn = function (data, filtersValues) {
+          return filtersValues.some((_filter) =>
+            data.some((_dataItem) => getDate(_filter, _dataItem))
+          );
+        };
+        break;
+    }
+    return this;
+  }
+
+  check(aggregate) {
+    return this.changeBehavior(aggregate.getCheckOption())._checkFn(
+      aggregate.getEntity(),
+      aggregate.getFilterValues()
+    );
+  }
+}
+
+class NumberFetchStrategy {
+  convert(val) {
+    return [Number(val)];
+  }
+
+  convertFilterValue(val) {
+    return Number(val);
+  }
+}
+
+class RangeFetchStrategy extends NumberFetchStrategy {
+  convertFilterValue(val) {
+    return {
+      start: Number(val.split(":")[0]),
+      end: Number(val.split(":")[1]),
+    };
+  }
+}
+
+class StringFetchStrategy {
+  convert(val) {
+    return String(val != null ? val : "")
+      .toLowerCase()
+      .split(",");
+  }
+
+  convertFilterValue(val) {
+    if (val === 0) return "0";
+    return String(val || "").toLowerCase();
+  }
+}
+
+class dateFetchStrategy extends NumberFetchStrategy {
+  convertFilterValue(val) {
+    const [type, date, match] = val.split(":");
+    return {
+      type,
+      date: Number(date),
+      match: !!Number(match),
+    };
+  }
+}
+
+class BooleanFetchStrategy {
+  convert(val) {
+    return [String(Boolean(val))];
+  }
+
+  convertFilterValue(val) {
+    return String(val);
+  }
+}
+
+class Aggregate {
+  constructor() {
+    this._strategies = {
+      stringStrategy: new StringFetchStrategy(),
+      numberStrategy: new NumberFetchStrategy(),
+      booleanStrategy: new BooleanFetchStrategy(),
+      rangeStrategy: new RangeFetchStrategy(),
+      dateStrategy: new dateFetchStrategy(),
+    };
+  }
+
+  setStrategy(checkOption) {
+    this._checkOption = checkOption;
+    switch (checkOption) {
+      case "contain_or":
+      case "contain_and":
+      case "not_contain_or":
+      case "not_contain_and":
+      case "equal_or":
+      case "equal_and":
+      case "not_equal_or":
+      case "not_equal_and":
+      case "phone_equal_or":
+      case 'distance':
+      case 'search':
+        this._currentStrategy = this._strategies.stringStrategy;
+        break;
+      case "bigger":
+      case "lower":
+        this._currentStrategy = this._strategies.numberStrategy;
+        break;
+      case "range":
+        this._currentStrategy = this._strategies.rangeStrategy;
+        break;
+      case "date_in":
+      case "date_out":
+        this._currentStrategy = this._strategies.dateStrategy;
+        break;
+      case "value":
+        this._currentStrategy = this._strategies.booleanStrategy;
+        break;
+    }
+    return this;
+  }
+
+  setEntity(val) {
+    this._entity = this._currentStrategy.convert(val);
+    return this;
+  }
+
+  getEntity() {
+    return this._entity;
+  }
+
+  setFilterValues(val) {
+    let temp = Array.isArray(val) ? val : [val];
+    this._filterValues = temp.map((curFilterVal) =>
+      this._currentStrategy.convertFilterValue(curFilterVal)
+    );
+    return this;
+  }
+
+  getFilterValues() {
+    return this._filterValues;
+  }
+
+  getCheckOption() {
+    return this._checkOption;
+  }
+}

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

@@ -0,0 +1,94 @@
+import should from 'should';
+import {GudHub} from './../../gudhub.js';
+
+
+
+  describe('Filter', function() {
+    const gudhub = new GudHub();
+
+    it('Should return one Item', function(){
+        gudhub.filter(items, filters).length.should.equal(1);
+    });
+    
+  });
+
+
+  var items = [
+    {
+        "item_id": 987336,
+        "index_number": 7,
+        "last_update": 1584550861000,
+        "fields": [
+            {
+                "field_id": 228464,
+                "element_id": 228464,
+                "field_value": "235613",
+                "data_id": 5680732
+            },
+            {
+                "field_id": 223754,
+                "element_id": 223754,
+                "field_value": "666",
+                "data_id": 5680729
+            },
+            {
+                "field_id": 223714,
+                "element_id": 223714,
+                "field_value": "test",
+                "data_id": 5680730
+            },
+            {
+                "field_id": 223740,
+                "element_id": 223740,
+                "field_value": "1",
+                "data_id": 5680731
+            }
+        ]
+    },
+    {
+        "item_id": 1003970,
+        "index_number": 8,
+        "last_update": 1584707835000,
+        "fields": [
+            {
+                "field_id": 223714,
+                "element_id": 223714,
+                "field_value": "test",
+                "data_id": 5755743
+            },
+            {
+                "field_id": 223740,
+                "element_id": 223740,
+                "field_value": "2",
+                "data_id": 5755745
+            },
+            {
+                "field_id": 223754,
+                "element_id": 223754,
+                "field_value": "666",
+                "data_id": 5755744
+            },
+            {
+                "field_id": 228464,
+                "element_id": 228464,
+                "field_value": "239375",
+                "data_id": 5755746
+            }
+        ]
+    }
+];
+
+var filters = [
+    {
+        "field_id": 223740,
+        "data_type": "radio_button",
+        "valuesArray": [
+            "2"
+        ],
+        "search_type": "equal_or",
+        "selected_search_option_variable": "Value"
+    }
+];
+
+const filterDate = [{"field_id":364453,"data_type":"date","valuesArray":["day:0:1"],"search_type":"date_in","$$hashKey":"object:272","selected_search_option_variable":"Value"}]
+const itemsForFilter = [{"item_id":1612822,"index_number":1,"last_update":1602848634000,"fields":[{"field_id":364453,"element_id":364453,"field_value":"1602810048860","data_id":10023401},{"field_id":363343,"element_id":363343,"field_value":"11","data_id":9801380}]},{"item_id":1612823,"index_number":2,"last_update":1602517283000,"fields":[{"field_id":363343,"element_id":363343,"field_value":"12","data_id":9801381}]},{"item_id":1612824,"index_number":3,"last_update":1602517289000,"fields":[{"field_id":363343,"element_id":363343,"field_value":"21","data_id":9801382}]},{"item_id":1612825,"index_number":4,"last_update":1602516710000,"fields":[{"field_id":363343,"element_id":363343,"field_value":"4","data_id":9801383}]}]

package/GUDHUB/Utils/filter/filterPreparation.js

@@ -0,0 +1,103 @@
+export async function filterPreparation(
+  filters_list,
+  element_app_id,
+  current_app_id,
+  item_id,
+  storage,
+  pipeService,
+  variables = []
+) {
+  const filterArray = [];
+
+  const objectMethod = {
+    variableMethodcurrent_app() {
+      return [current_app_id];
+    },
+    variableMethodelement_app() {
+      return [element_app_id];
+    },
+
+    variableMethodcurrent_item() {
+      const currentValue = `${current_app_id}.${item_id}`;
+      return [currentValue];
+    },
+
+    variableMethoduser_id() {
+      const storage_user = storage.getUser();
+      return [storage_user.user_id];
+    },
+
+    variableMethoduser_email(filter) {
+      const storage_user = storage.getUser();
+      return [storage_user.username];
+    },
+
+    variableMethodtoday(filter) {
+      const date = new Date();
+      const start_date = new Date(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate()
+      );
+      const end_date = new Date(
+        date.getFullYear(),
+        date.getMonth(),
+        date.getDate() + 1
+      );
+      const result =
+        start_date.valueOf().toString() + ":" + end_date.valueOf().toString();
+      return [result];
+    },
+    variableMethodvariable() {
+      return variables;
+    },
+  };
+  if (filters_list) {
+    for (const filter of filters_list) {
+      if (filter) {
+        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();
+            }
+            filterArray.push(filter);
+            break;
+          case "field":
+            const field_value = await fieldMethod({
+              app_id: current_app_id,
+              item_id: item_id,
+              field_id: filter.input_value,
+            });
+            if(field_value != null){
+              filter.valuesArray.push(field_value)
+            }
+            filterArray.push(filter);
+            break;
+          default:
+            filterArray.push(filter);
+            break;
+        }
+      } else {
+        filterArray.push(filter);
+      }
+    }
+  }
+
+  function fieldMethod(address) {
+    return new Promise((resolve) => {
+      pipeService
+        .on("gh_value_get", address, function ghValueGet(event, field_value) {
+          pipeService.destroy("gh_value_get", address, ghValueGet);
+          resolve(field_value);
+        })
+        .emit("gh_value_get", {}, address);
+    });
+  }
+
+  return filterArray;
+}

package/GUDHUB/Utils/filter/group.js

@@ -0,0 +1,41 @@
+export function group(fieldGroup, items) {
+  let groupItemList = [];
+  let arrayGroupField;
+  if (!fieldGroup) {
+    groupItemList = items;
+  } else {
+    arrayGroupField = fieldGroup.split(",");
+  }
+
+  let arrayValue = new Set();
+
+  if (fieldGroup) {
+    items.forEach((item) => {
+      let valueField = "";
+      arrayGroupField.forEach((fieldToGroup, index) => {
+        const findField = item.fields.find((field) => field.field_id == fieldToGroup);
+        if (findField) {
+          valueField += findField.field_value;
+        }
+        if (arrayGroupField.length - 1 == index) {
+          let itemUnics = findUniqItem(valueField);
+          if (itemUnics) {
+            groupItemList.push(item);
+          }
+        }
+      });
+    });
+  }
+
+  // send field value and check if it's unique
+  function findUniqItem(value) {
+    const uniqValue = !arrayValue.has(value);
+    if (uniqValue) {
+      arrayValue.add(value);
+    }
+    return uniqValue;
+  }
+
+  return groupItemList
+  
+}

package/GUDHUB/Utils/filter/utils.js

@@ -0,0 +1,119 @@
+import Fuse from "fuse.js";
+
+export function getDistanceFromLatLonInKm(coordsFrom, coordsTo) {
+  const [lat1, lon1, distance] = coordsFrom.split(':');
+  const [lat2, lon2] = coordsTo.split(':');
+  const R = 6371; // Radius of the earth in km
+  const dLat = deg2rad(lat2 - lat1); // deg2rad below
+  const dLon = deg2rad(lon2 - lon1);
+  const a =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+  const distanceBetween = R * c; // Distance in km
+
+  return Number(distance) >= distanceBetween;
+}
+
+function deg2rad(deg) {
+  return deg * (Math.PI / 180);
+}
+
+export function getDate({ type, date = 0, match = true } = {}, itemTime) {
+  if (!itemTime && type) return false;
+  const newDate = new Date();
+  let result = true;
+  switch (type) {
+    case "day":
+      const filterDayStart = getDateInMs(date);
+      const filterDayEnd = getDateInMs(date + 1);
+
+      result = filterDayStart <= itemTime && itemTime < filterDayEnd;
+      break;
+
+    case "days":
+      if (date < 0) {
+        const currentDayEnd = getDateInMs(1);
+        const startPast7Days = getDateInMs(-6);
+
+        result = startPast7Days <= itemTime && itemTime < currentDayEnd;
+      } else {
+        const currentDay = getDateInMs();
+        const startNext7Days = getDateInMs(7);
+
+        result = currentDay <= itemTime && itemTime < startNext7Days;
+      }
+      break;
+
+    case "day_week":
+      result = date === new Date(itemTime).getDay();
+      break;
+
+    case "week":
+      const weekStart = newDate.getDate() - newDate.getDay();
+      const weekEnd = weekStart + 6;
+      const weekDayStart = newDate.setDate(weekStart + date * 7);
+      const weekDayEnd = newDate.setDate(weekEnd + date * 7);
+
+      const [sunday, saturday] = getWeek(weekDayStart, weekDayEnd);
+
+      result = sunday <= itemTime && itemTime <= saturday;
+      break;
+
+    case "month":
+      if (newDate.getFullYear() !== new Date(itemTime).getFullYear())
+        return false;
+
+      const month = newDate.getMonth() + date;
+
+      result = month === new Date(itemTime).getMonth();
+      break;
+
+    case "year":
+      const year = newDate.getFullYear() + date;
+
+      result = year === new Date(itemTime).getFullYear();
+      break;
+
+    default:
+      return true;
+  }
+  return match ? result : !result;
+}
+
+function getWeek(start, end) {
+  return [new Date(start), new Date(end)];
+}
+
+function getDateInMs(date = 0) {
+  const currentDay = new Date();
+  return new Date(
+    currentDay.getFullYear(),
+    currentDay.getMonth(),
+    currentDay.getDate() + date
+  ).valueOf();
+}
+
+export function searchValue(items, filter) {
+  if (!items || !items.length) return;
+
+  if (filter) {
+    return items.filter((item) =>
+      item.fields.find(
+        (field) =>
+          field.index_value &&
+          field.index_value.toLowerCase().indexOf(filter.toLowerCase()) !== -1
+      )
+    );
+  }
+  return items;
+}
+
+const fuse = new Fuse([]);
+
+export function isSimilarStrings(str1, strArray) {
+  fuse.setCollection(strArray);
+  return Boolean(fuse.search(str1).length);
+}