@gudhub/core 1.0.37

package/GUDHUB/Utils/get_date/get_date.js

@@ -0,0 +1,90 @@
+/*
+|====================================== GETTING DATE ================================|
+|===========================      getDate (queryKey)           ======================|
+|====================================================================================|
+|   Arguments:
+|    - queryKey - according to 'queryKey' we decide with date should be returned to user
+|
+|   Return:
+|   - date in miliseconds
+|   
+|==================================================================================|
+*/
+import add from "date-fns/add/index.js";
+import setDay from "date-fns/setDay/index.js";
+
+//********************** POPULATE WITH DATE ************************//
+export function populateWithDate(items, model) {
+  items.forEach((item) => {
+    model.forEach((modelField) => {
+      let field = item.fields.find(
+        (sourceField) => sourceField.element_id == modelField.element_id
+      );
+      if (field) {
+        field.field_value = getDate(modelField.date_type);
+      } else {
+        //-- if we didn't find field in item then we add it
+        item.fields.push({
+          field_id: modelField.element_id,
+          element_id: modelField.element_id,
+          field_value: getDate(modelField.date_type),
+        });
+      }
+    });
+  });
+
+  return items;
+}
+
+//********************** GET DATE ************************//
+export function getDate(queryKey) {
+  const date = new Date();
+  switch (queryKey) {
+    
+    case "next_day":
+      return add(date, {days: 1}).getTime();
+
+    case "two_days_after":
+      return add(date, {days: 2}).getTime();
+
+    case "three_days_after":
+      return add(date, {days: 3}).getTime();
+
+    case "four_days_after":
+      return add(date, {days: 4}).getTime();
+
+    case "next_week":
+      return add(date, {weeks: 1}).getTime();
+
+    case "two_weeks_after":
+      return add(date, {weeks: 2}).getTime();
+
+    case "three_weeks_after":
+      return add(date, {weeks: 3}).getTime();
+    
+    case "this_sunday":
+        return setDay(date, 0, {weekStartsOn: 1});
+    
+    case "this_monday":
+        return setDay(date, 1, {weekStartsOn: 1});
+    
+    case "this_tuesday":
+        return setDay(date, 2, {weekStartsOn: 1});
+    
+    case "this_wednesday":
+        return setDay(date, 3, {weekStartsOn: 1});
+      
+    case "this_thursday":
+        return setDay(date, 4, {weekStartsOn: 1});
+      
+    case "this_friday":
+        return setDay(date, 5, {weekStartsOn: 1});
+
+    case "this_saturday":
+        return setDay(date, 6, {weekStartsOn: 1});
+
+    case "now":
+    default:
+      return date.getTime();
+  }
+}

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

@@ -0,0 +1,53 @@
+import should from "should";
+import {GudHub} from '../../gudhub.js';
+
+describe("GET DATE", function () {
+  const gudhub = new GudHub();
+  
+
+  it("NOW : should return current time", function () {
+    const timeDiff = Math.round( (new Date().getTime())/60 - gudhub.getDate('now')/60 );
+    timeDiff.should.equal(0);
+  });
+
+
+  it("NEXT DAY : should return current day + 24hours", function () {
+    const timeDiff = Math.round( (gudhub.getDate('next_day') - (new Date().getTime()))/3600000 );
+    timeDiff.should.equal(24);
+  });
+
+  it("THIS SUNDAY : should return sunday", function () {
+    let day = gudhub.getDate('this_sunday');
+    day.getDay().should.equal(0);
+  });
+
+  it("THIS MONDAY : should return monday", function () {
+    let day = gudhub.getDate('this_monday');
+    day.getDay().should.equal(1);
+  });
+
+  it("THIS Tuesday : should return Tuesday", function () {
+    let day = gudhub.getDate('this_tuesday');
+    day.getDay().should.equal(2);
+  });
+
+  it("THIS Wednesday : should return wednesday", function () {
+    let day = gudhub.getDate('this_wednesday');
+    day.getDay().should.equal(3);
+  });
+
+  it("THIS Thursday : should return thursday", function () {
+    let day = gudhub.getDate('this_thursday');
+    day.getDay().should.equal(4);
+  });
+
+  it("THIS Friday : should return friday", function () {
+    let day = gudhub.getDate('this_friday');
+    day.getDay().should.equal(5);
+  });
+
+  it("THIS Saturday : should return saturday", function () {
+    let day = gudhub.getDate('this_saturday');
+    day.getDay().should.equal(6);
+  });
+});

package/GUDHUB/Utils/interpretation/interpretation.js

@@ -0,0 +1,100 @@
+export async function getInterpretedValue(gudhub, app_id, item_id, field_id) {
+    const fieldModel = await gudhub.getField(app_id, field_id);
+    const fieldValue = await gudhub.getFieldValue(app_id, item_id, field_id);
+
+    if (!fieldModel || !fieldModel.data_type || !fieldValue) return "";
+
+    const fieldsValueArray = fieldValue.split(",");
+
+    switch (fieldModel.data_type) {
+      case "radio_button":
+      case "text_opt":
+      case "tag":
+        const fieldNames = fieldsValueArray
+          .map((value) => {
+            const option = fieldModel.data_model.options.find(
+              (modelOption) => modelOption.value == value
+            );
+            return option ? option.name : "";
+          })
+          .join(" ");
+        return fieldNames;
+
+      case 'file':
+      case "image":
+        let fileUrl = '';
+        if(fieldModel.data_model.display_mode == 'multiple') {
+          await gudhub.getFiles(app_id, fieldsValueArray).then(
+            files => 
+            {
+              files.forEach(file => {
+                return fileUrl += file.url + ',';
+              });
+            },
+            err => {return 'no img'}
+          )
+          fileUrl = fileUrl.slice(0,-1)
+        } 
+        else {
+          fileUrl = await gudhub.getFile(app_id, fieldValue).then(
+            file => {
+            return file.url;
+            },
+            err => {return 'no img'}
+          )
+        }
+        return fileUrl;
+
+      case "text_editor":
+      case 'tinymse':
+      case 'code_editor':
+      case 'grapes_html_editor':
+        let htmlUrl = await gudhub.getFile(app_id, fieldValue).then(
+          file => {
+            return file.url + '?timestamp=' + file.last_update;
+          },
+          err => {return 'no text'}
+        )
+        return htmlUrl;
+
+      case "item_ref":
+        const interpretedValue = [];
+        for (const field of fieldsValueArray) {
+          for (const ref of fieldModel.data_model.refs) {
+            const [appId, itemId] = field.split(".");
+            const value = await this.getInterpretedValue(
+              appId,
+              itemId,
+              ref.field_id
+            );
+            interpretedValue.push(value);
+          }
+        }
+        return interpretedValue.join(", ");
+
+      case "data_ref":
+        for (const caseItem of fieldModel.data_model.cases) {
+          const [appId, itemId] = fieldValue.split(".");
+          if (caseItem.app_id == appId) {
+            const value = await this.getInterpretedValue(
+              appId,
+              itemId,
+              caseItem.field_id
+            );
+            return value;
+          }
+        }
+        return "";
+      case "field":
+        const fieldsName = [];
+        for (const value of fieldsValueArray) {
+          const model = await gudhub.getField(app_id, value);
+          if (model.field_name != undefined) {
+            fieldsName.push(model.field_name);
+          }
+        }
+        return fieldsName.join(" ");
+      default:
+        return fieldValue;
+    }
+  }

package/GUDHUB/Utils/json_constructor/json_constructor.js

@@ -0,0 +1,130 @@
+
+export function compiler(scheme, item, util, variables) {
+  async function schemeCompiler(scheme, item, app) {
+    let value = null;
+    if (scheme.type === "array") {
+      // get properties value for array childs for each application item
+      if (Number(scheme.is_static)) {
+        value = new Array(
+          await getChildsPropertiesObject(scheme.childs, item, app)
+        );
+      } else {
+        value = await getArrayOfItemsWithProperties(scheme, item, app);
+      }
+    }
+
+    if (scheme.type === "object") {
+      // get properties value for object childs
+      if (Number(scheme.current_item)) {
+        value = await getItemWithProperties(scheme, item);
+      } else {
+        value = await getChildsPropertiesObject(scheme.childs, item, app);
+      }
+    }
+    if (scheme.type === "property") {
+      // get properties value
+      value = await getFieldValue(scheme, item, app);
+    }
+
+    return { [scheme.property_name]: value };
+  }
+
+  /* Get properties value for array childs in scheme, for each application filtered item. */
+  async function getArrayOfItemsWithProperties(scheme, item, recievedApp) {
+    const app = await util.gudhub.getApp(Number(scheme.app_id));
+    const filteredItems = await filterItems(
+      scheme.filter,
+      app.items_list,
+      recievedApp,
+      item
+    );
+
+    const arrayOfItemsWithProperties =  filteredItems.map(async (item) => {
+      return getChildsPropertiesObject(scheme.childs, item, app);
+    });
+    return Promise.all(arrayOfItemsWithProperties);
+  }
+
+  async function getItemWithProperties(scheme, item) {
+    const app = await util.gudhub.getApp(scheme.app_id);
+    const items = app.items_list || [];
+
+    return getChildsPropertiesObject(scheme.childs, item || items[0], app);
+  }
+
+  /* Get properties value for object childs in scheme. */
+  async function getChildsPropertiesObject(properties, item, app) {
+    const propertiesArray = await properties.map(async (child) => {
+      return schemeCompiler(child, item, app);
+    });
+    const resolvedPropertiesArray = await Promise.all(propertiesArray);
+    return resolvedPropertiesArray.reduce((acc, object) => {
+      return { ...acc, ...object };
+    }, {});
+  }
+
+  /* Get property value based on interpretation value */
+  async function getFieldValue(scheme, item, app) {
+    switch (scheme.property_type) {
+      case "static":
+        return scheme.static_field_value;
+      case "variable":
+        switch (scheme.variable_type) {
+          case "app_id":
+            return app.app_id;
+          // case "user_id":
+          //   resolve(storage.getUser().user_id);
+          //   break;
+          case "current_item":
+          default:
+            return `${app.app_id}.${item.item_id}`;
+        }
+
+      case "field_id":
+        return scheme.field_id;
+
+      case "field_value":
+      default:
+        if (Boolean(Number(scheme.interpretation))) {
+          return util.gudhub.getInterpretedValue(
+            Number(app.app_id),
+            Number(item.item_id),
+            Number(scheme.field_id)
+          );
+        } else {
+          return util.gudhub.getFieldValue(
+            Number(app.app_id),
+            Number(item.item_id),
+            Number(scheme.field_id)
+          );
+        }
+    }
+  }
+
+  async function getFilteredItems(filtersList, app_id, item_id, itemsList) {
+    const modified_filters_list = await util.gudhub.prefilter(
+      filtersList,
+      app_id,
+      item_id,
+      variables
+    );
+    return util.gudhub.filter(itemsList, [...modified_filters_list, ...filtersList]);
+  }
+
+  /* Filter items by scheme filter */
+  async function filterItems(
+    filtersList = [],
+    itemsList = [],
+    app = {},
+    item = {}
+  ) {
+    return filtersList.length ? getFilteredItems(
+      filtersList,
+      app.app_id,
+      item.item_id,
+      itemsList
+    ) : [...itemsList ];
+  }
+
+  return schemeCompiler(scheme, item);
+}

package/GUDHUB/Utils/json_constructor/json_constructor.test.js

@@ -0,0 +1,70 @@
+import should from "should";
+import { GudHub } from "./../../gudhub.js";
+
+describe("JSON CONSTRUCTOR", function () {
+  const gudhub = new GudHub();
+
+  it("JSON FROM ONE APP : Here we construct simple json from one App", async function () {
+    //-- checking if json was generated properly
+    let json = await gudhub.jsonConstructor(fishtank_scheme);
+    json.fishtank[0].should.have.property("name", "Big Fish Tank");
+    json.fishtank[0].should.have.property("state", "Normal");
+  });
+  it("CHECK INTERPRETATION VALUE FOR FILES: output: we should get url's", async function () {
+    //-- checking interpretation mode
+    let json = await gudhub.jsonConstructor(fishtank_scheme);
+    json.fishtank[0].should.have.property("image","https://gudhub.com/userdata/16259/809199.jpg,https://gudhub.com/userdata/16259/811768.png");
+    json.fishtank[0].should.have.property("url","https://google.com,https://test.com");
+    json.fishtank[0].should.have.property("notes","https://gudhub.com/userdata/16259/811770.html?timestamp=0");
+  });
+});
+
+var fishtank_scheme = {
+  type: "array",
+  id: 1,
+  childs: [
+    {
+      type: "property",
+      id: 5,
+      property_name: "name",
+      property_type: "field_value",
+      field_id: "254056",
+      interpretation: 1,
+    },
+    {
+      type: "property",
+      id: 6,
+      property_name: "state",
+      property_type: "field_value",
+      field_id: "270607",
+      interpretation: 1,
+    },
+    {
+      type: "property",
+      id: 7,
+      property_name: "image",
+      property_type: "field_value",
+      field_id: "551380",
+      interpretation: 1,
+    },
+    {
+      type: "property",
+      id: 3,
+      property_name: "url",
+      property_type: "field_value",
+      field_id: "551381",
+      interpretation: 1,
+    },
+    {
+      type: "property",
+      id: 4,
+      property_name: "notes",
+      property_type: "field_value",
+      field_id: "551382",
+      interpretation: 1,
+    },
+  ],
+  property_name: "fishtank",
+  app_id: "16259",
+  filter: [],
+};

package/GUDHUB/Utils/json_to_items/json_to_items.js

@@ -0,0 +1,161 @@
+import jsonpath from 'jsonpath';
+
+/*
+|==================================== JSON TO ITEMS ==================================|
+|======================      jsonToItems (json, fieldsMap)           =================|
+|=====================================================================================|
+|   Arguments:
+|       - json - is an object that is going to be converted to items
+|
+|
+|       - fieldsMap - this map is an object array that contains field_id and jsonPath to get data from  
+|       [
+|           {
+|               field_id: 431,
+|               json_path : "$..item_id"
+|           }
+|       ]
+|
+|
+|       - Returns items_list:
+|      [
+|          fields: {
+|            field_id: 12356,
+|            field_value: "test value"
+|          }
+|       ]
+|
+|=====================================================================================|
+*/
+
+export function jsonToItems(json, fieldsMap){
+    let proccessedMap = [];
+    let itemsPath = [];
+   
+    //-- Step 1 --// 
+    // iterating through map and generating list of paths for each field_id
+    fieldsMap.forEach( fieldMap =>{
+        let json_paths = [];
+        try {
+            json_paths = jsonpath.paths(json, fieldMap.json_path)
+            proccessedMap.push({
+                field_id: fieldMap.field_id,
+                json_paths: json_paths,
+                json_paths_length: json_paths.length,
+            });
+        } catch (err){
+            console.log(err)
+        }
+
+    });
+  
+    //-- Step 2 --//
+    // we are sorrting by json_paths_length to find a field with biggest number of json_paths
+    // we are going to use the first element of the proccessedMap array as a main iterator
+    proccessedMap.sort((b, a) => {
+      return a.json_paths_length - b.json_paths_length;
+    });
+  
+  
+    //-- Step 3 --//
+    // creating items array based on proccessedMap
+    let items =  getPathForItems(proccessedMap).map(itemPath => {
+      return {  fields : 
+             itemPath.fields.map(field => {
+              return {
+                field_id :  field.field_id,
+                field_value : jsonpath.value(json, field.json_path)
+              }
+            })
+      }
+    });
+  
+  
+    return items;
+  }
+
+
+
+  
+
+
+
+//**************** BEST MATCH ****************//
+// it looks for jsonPath in the pathsToCompare that is mutching the best
+function bestMatch(targetPath, pathsToCompare){
+    let matchedPaths = [];
+    
+  
+    //-- Creating matchedPaths for compearing targetPath with pathsToCompare
+    pathsToCompare.forEach(path =>{
+      matchedPaths.push({
+        path_to_compare : path,
+        match_coefficient : 0
+      })
+    })
+  
+  
+    //-- Assigning match_coefficient to each path from matchedPaths arrey to determine which path match the best
+    // Bigger coefficient means better munch  
+    targetPath.forEach( (trgElem, key) => {
+      
+      for(var i=0; i<matchedPaths.length; i++){
+        if(matchedPaths[i].path_to_compare[key] == trgElem){
+          matchedPaths[i].match_coefficient += 1/(key+1);
+        }
+      }
+    });
+  
+  
+    //-- Sorting matchedPaths by match_coefficient in order to return puth that match the best
+    matchedPaths.sort((b, a) => {
+      return a.match_coefficient - b.match_coefficient;
+    });
+  
+    
+    //-- Returning first element of matchedPaths[] with biggest match_coefficient with is a best match result
+    return matchedPaths[0].path_to_compare;
+  }
+  
+  
+
+
+
+
+
+
+  
+//*************** GET PATH FOR ITEMS ****************//
+/* Here we create array of items those are contains jsonePaths 
+/* at the next step we are going to create field_value from json_path
+|      [
+|            fields:
+|            {
+|                field_id : 123,
+|                json_path : $..test_path
+|            }
+|        ]
+|*/
+  function getPathForItems( proccessedMap ){
+    let itemsPath = [];
+
+      proccessedMap.length && proccessedMap[0].json_paths.forEach( jsonPath =>{
+      let itemPath = {
+          fields  : []
+      }
+  
+      proccessedMap.forEach(pMap => {
+        itemPath.fields.push({
+          field_id : pMap.field_id,
+          json_path : bestMatch(jsonPath, pMap.json_paths),
+        })
+  
+      });
+      itemsPath.push(itemPath);
+    });
+  
+    return itemsPath;
+  }
+  
+  
+  

package/GUDHUB/Utils/json_to_items/json_to_items.test.js

@@ -0,0 +1,85 @@
+import should from "should";
+import { jsonToItems } from "./json_to_items.js";
+
+describe("JSON TO ITEMS", function () {
+  it("Creats items list from jsone based on map", function () {
+    let items = jsonToItems(json, fieldsMap);
+    items.length.should.equal(5);
+
+    items[0].fields.forEach((field) => {
+      if (field.field_id == 431) field.should.have.property("field_value", 1);
+      if (field.field_id == 421) field.should.have.property("field_value", 111);
+    });
+
+    items[3].fields.forEach((field) => {
+      if (field.field_id == 431) field.should.have.property("field_value", 2);
+      if (field.field_id == 421) field.should.have.property("field_value", 222);
+    });
+  });
+});
+
+//----------------------------------- MOCKS ---------------------------------//
+
+var fieldsMap = [
+  {
+    field_id: 431,
+    json_path: "$..item_id",
+  },
+  {
+    field_id: 432,
+    json_path: "$..tax",
+  },
+  {
+    field_id: 421,
+    json_path: "$..quote_id",
+  },
+  {
+    field_id: 422,
+    json_path: "$..quote_date",
+  },
+];
+
+var json = [
+  {
+    quote_id: 111,
+    quote_date: "11/21/2020",
+    quote_items: [
+      {
+        item_id: 1,
+        quanity: 1,
+        tax: 1.1,
+        price: 15,
+      },
+      {
+        item_id: 2,
+        quanity: 2,
+        tax: 1.1,
+        price: 10,
+      },
+    ],
+  },
+  {
+    quote_id: 222,
+    quote_date: "12/22/2020",
+    quote_items: [
+      {
+        item_id: 1,
+        quanity: 3,
+        tax: 2.2,
+        price: 15,
+      },
+      {
+        item_id: 2,
+        tax: 2.2,
+        quanity: 1,
+        price: 10,
+      },
+      {
+        tax: 2.2,
+        item_id: 3,
+        quanity: 4,
+        price: 11,
+      },
+    ],
+  },
+];