@gudhub/core 1.0.58 → 1.0.62

package/GUDHUB/GHConstructor/ghconstructor.js

@@ -130,7 +130,11 @@ export class GHConstructor {
         let module = await axios.get(module_url);
         module = module.data;
 
-        eval(module);
+        try {
+            eval(module);
+        } catch(error) {
+            console.error('ERROR WHILE EVAL() IN GHCONSTRUCTOR', error);
+        }
 
         let result = {
             type: module_id,

package/GUDHUB/GHConstructor/interpritate.js

@@ -76,6 +76,9 @@ export class Interpritate {
         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>') {

package/GUDHUB/Utils/ItemsSelection/ItemsSelection.js

@@ -0,0 +1,52 @@
+export default class ItemsSelection {
+    constructor(gudhub) {
+        this.gudhub = gudhub;
+        this.selectedItems = {}
+    }
+
+    async selectItems(appId, items) {
+        if(!this.selectedItems.hasOwnProperty(appId)) {
+            this.selectedItems[appId] = {
+                items: [],
+                app: []
+            }
+
+            let app = await this.gudhub.getApp(appId);
+            this.selectedItems[appId].app = app;
+        }
+
+        let itemObject = this.selectedItems[appId];
+
+        let selectedItemsIds = itemObject.items.map(obj => obj.item_id);
+
+        items.forEach(item => {
+            if(selectedItemsIds.indexOf(item.item_id) != -1) {
+                itemObject.items.splice(selectedItemsIds.indexOf(item.item_id), 1);
+            } else {
+                itemObject.items[itemObject.items.length] = item;
+            }
+        });
+
+    }
+
+    getSelectedItems(appId) {
+        return this.selectedItems[appId] ? this.selectedItems[appId] : { items: [], app: [] };
+    }
+
+    clearSelectedItems(appId) {
+        if(this.selectedItems[appId]) {
+            this.selectedItems[appId].items = [];
+        }
+    }
+
+    isItemSelected(appId, itemId) {
+        let array = this.getSelectedItems(appId);
+        if(array !== null) {
+            array = array.items.map(obj => obj.item_id);
+            return array.indexOf(itemId) != -1;
+        } else {
+            return false;
+        }
+    }
+
+}

package/GUDHUB/Utils/ItemsSelection/ItemsSelection.test.js

@@ -0,0 +1,62 @@
+import should from "should";
+import {GudHub} from '../../gudhub.js';
+
+describe("ITEMS SELECTION", async function() {
+    const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+    const gudhub = new GudHub(auth_key);
+
+    const appId = 16259;
+
+    const items = [
+        {
+            "item_id": 1,
+            "last_update": 1123669745123,
+            "fields": []
+        },
+        {
+            "item_id": 2,
+            "last_update": 1985625103278,
+            "fields": []
+        },
+        {
+            "item_id": 3,
+            "last_update": 1614725478960,
+            "fields": []
+        },
+    ]
+
+    // ORDER OF TEST IS IMPORTANT!
+
+    it('SELECT AND GET SELECTED ITEM', async function() {
+        await gudhub.util.selectItems(appId, [items[0]]);
+
+        let selectedItems = gudhub.util.getSelectedItems(appId);
+        
+        selectedItems.items.length.should.equals(1);
+    });
+
+    it('CHECK IF ITEM SELECTED', async function() {
+        let isItemSelected = gudhub.util.isItemSelected(appId, 1);
+        isItemSelected.should.equals(true);
+
+        isItemSelected = gudhub.util.isItemSelected(appId, 2);
+        isItemSelected.should.equals(false);
+    });
+
+    it('CLEAR SELECTED ITEMS', async function() {
+        gudhub.util.clearSelectedItems(appId);
+
+        let selectedItems = gudhub.util.getSelectedItems(appId);
+        
+        selectedItems.items.length.should.equals(0);
+    });
+
+    it('SELECT MULTIPLE ITEMS', async function() {
+        await gudhub.util.selectItems(appId, items);
+
+        let selectedItems = gudhub.util.getSelectedItems(appId);
+        
+        selectedItems.items.length.should.equals(3);
+    })
+
+});

package/GUDHUB/Utils/MergeFields/MergeFields.js

@@ -0,0 +1,146 @@
+export default class FieldsOperator {
+    constructor(gudhub) {
+        this.gudhub = gudhub;
+    }
+
+    mergeFieldLists(fieldsToView, fieldList) {
+        let fieldsToViewCopy = JSON.parse(JSON.stringify(fieldsToView));
+        let fieldListCopy = JSON.parse(JSON.stringify(fieldList));
+
+        let existingFieldsIds = fieldListCopy.map(field => field.field_id);
+
+        if (!fieldListCopy.length) {
+            return [];
+        }
+
+        return fieldListCopy.reduce((viewArray, currentField) => {
+
+            let positionInViewArray = null;
+            let props = viewArray.find((view, index) => {
+                if (currentField.field_id == view.field_id) {
+                    positionInViewArray = index;
+                    return true;
+                }
+                return false;
+            });
+
+            if (!props) {
+
+                let defaultIntrpr = currentField.data_model && currentField.data_model.interpretation ? currentField.data_model.interpretation.find((intrpr) => {
+                    return intrpr.src == 'table';
+                }) || { settings: { show_field: 1 } } : { settings: { show_field: 1 } };
+
+                if (defaultIntrpr.settings.show_field) {
+                    let firstMerge = this.gudhub.util.mergeObjects({ show: 1 }, defaultIntrpr);
+                    let secondMerge = this.gudhub.util.mergeObjects(firstMerge, currentField);
+                    viewArray.push(secondMerge);
+                }
+
+            } else {
+                viewArray[positionInViewArray] = this.gudhub.util.mergeObjects(viewArray[positionInViewArray], currentField);
+            }
+
+            return viewArray;
+        }, fieldsToViewCopy).filter(function (field) {
+            return field.show && existingFieldsIds.indexOf(field.field_id) != -1;
+        });
+    };
+
+    createFieldsListToView(appId, tableSettingsFieldListToView) {
+        const self = this;
+        return new Promise(async (resolve) => {
+            let fieldList = await this.gudhub.getFieldModels(appId);
+
+            if (tableSettingsFieldListToView.length !== 0) {
+                let correctFieldList = [];
+                tableSettingsFieldListToView.forEach((elementFromTable, index) => {
+                    let fieldOnPipe = fieldList.find((element) => elementFromTable.field_id == element.field_id);
+
+                    if (fieldOnPipe) {
+                        let show_field = fieldOnPipe.data_model.interpretation.find((intrpr) => intrpr.src == 'table');
+                        if (!show_field) {
+                            show_field = { settings: { show_field: 1 } }
+                        }
+                        correctFieldList.push({
+                            field_id: fieldOnPipe.field_id,
+                            show: elementFromTable.show,
+                            width: elementFromTable.width ? elementFromTable.width : "150px"
+                        })
+                    }
+                    if (index + 1 == tableSettingsFieldListToView.length) {
+                        checkFiledFromPipe(correctFieldList)
+                    }
+
+                });
+            } else {
+                checkFiledFromPipe(tableSettingsFieldListToView);
+            }
+
+            function checkFiledFromPipe(correctFieldList) {
+                let counter = 0
+                fieldList.forEach((elemetFromPipe, index) => {
+                    let correctFiel = correctFieldList.find((elemet) => elemetFromPipe.field_id == elemet.field_id)
+                    if (!correctFiel) {
+                        self.gudhub.ghconstructor.getInstance(elemetFromPipe.data_type).then((data) => {
+                            let template = data.getTemplate();
+                            let show_field = template.model.data_model.interpretation.find((intrpr) => intrpr.src == 'table');
+                            if (!show_field) {
+                                show_field = { settings: { show_field: 1 } }
+                            }
+                            correctFieldList.push({
+                                field_id: elemetFromPipe.field_id,
+                                show: show_field.settings.show_field,
+                            });
+
+                            if (counter == fieldList.length - 1) {
+                                resolve(correctFieldList);
+                            }
+                            counter++
+                        }, function errorCallback(result) {
+                            counter++
+                        })
+                    } else {
+                        if (counter == fieldList.length - 1) {
+                            resolve(correctFieldList);
+                        }
+                        counter++
+                    }
+                });
+            }
+        });
+    }
+
+    createFieldsListToViewWithDataType(appId, tableSettingsFieldListToView) {
+        return new Promise(async (resolve) => {
+            let columnsToView = [];
+            let fieldList = await this.gudhub.getFieldModels(appId);
+
+            let actualFieldIds = fieldList.map((field) => +field.field_id);
+
+            columnsToView = fieldList.reduce((viewColumsList, currentField) => {
+                let field = viewColumsList.find((view, index) => {
+                    if (currentField.field_id == view.field_id) {
+                        return true;
+                    }
+                    return false;
+                });
+
+                if (!field) {
+                    this.gudhub.ghconstructor.getInstance(currentField.data_type).then(instance => {
+                        let template = instance.getTemplate();
+                        let defaultIntepretation = template.model.data_model.interpretation.find((intrpr) => intrpr.src == 'table') || { settings: { show_field: 1 } };
+                        viewColumsList.push({
+                            field_id: currentField.field_id,
+                            data_type: currentField.data_type,
+                            show: defaultIntepretation.settings.show_field
+                        });
+                    })
+                }
+
+                return viewColumsList;
+            }, tableSettingsFieldListToView).filter((field) => actualFieldIds.indexOf(field.field_id) != -1);
+
+            resolve(columnsToView);
+        })
+    }
+}

package/GUDHUB/Utils/MergeFields/MergeFields.test.js

@@ -0,0 +1,38 @@
+import should from "should";
+import {GudHub} from '../../gudhub.js';
+
+import table_field_list from './mocks/table_field_list.js';
+import table_fields_to_view from './mocks/table_fields_to_view.js';
+
+import online_inventory_field_list from './mocks/online_inventory_field_list.js';
+import online_inventory_fields_to_view from './mocks/online_inventory_fields_to_view.js';
+
+import table_settings_field_list_to_view from './mocks/table_settings_field_list_to_view.js';
+
+describe("MERGE FIELDS", async function() {
+    const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+    const gudhub = new GudHub(auth_key);
+
+    it("MERGE FIELDS LIST", async function () {
+        let fieldsToView = table_fields_to_view;
+        let fieldList = table_field_list;
+        let result = gudhub.util.mergeFieldLists(fieldsToView, fieldList);
+        result[0].field_id.should.equals(190);
+        result[1].data_model.interpretation.length.should.equals(1);
+
+        fieldsToView = online_inventory_fields_to_view;
+        fieldList = online_inventory_field_list;
+        result = gudhub.util.mergeFieldLists(fieldsToView, fieldList);
+        result[0].field_id.should.equals(192954);
+        result[2].data_model.interpretation.length.should.equals(6);
+    });
+
+    it("CREATES FIELDS LIST TO VIEW", async function () {
+        let tableSettingsFieldListToView = table_settings_field_list_to_view;
+        let appId = 16259;
+        let result = await gudhub.util.createFieldsListToView(appId, tableSettingsFieldListToView);
+        result.length.should.equals(12);
+        result[1].field_id.should.equals(254055);
+    });
+
+});