@gudhub/core 1.1.13 → 1.1.16

package/GUDHUB/AppProcessor/AppProcessor.js

@@ -105,6 +105,16 @@ export class AppProcessor {
   }
 
   saveAppInStorage(app) {
+
+    app.items_object = {};
+
+    for(let item = 0; item < app.items_list.length; item++) {
+      app.items_object[app.items_list[item].item_id] = {};
+        for(let field = 0; field < app.items_list[item].fields.length; field++) {
+          app.items_object[app.items_list[item].item_id][app.items_list[item].fields[field].field_id] = app.items_list[item].fields[field];
+        }
+    }
+
     const storageApp = this.storage.getApp(app.app_id);
     if (storageApp) {
       app.from_apps_list = storageApp.from_apps_list;
@@ -122,6 +132,7 @@ export class AppProcessor {
     app.items_list = storageApp.items_list;
     app.file_list = storageApp.file_list;
     app.from_apps_list = storageApp.from_apps_list;
+    app.items_object  =storageApp.items_object;
     this.storage.updateApp(app);
     //-- Sending updates for Views Updates
     this.pipeService.emit(
@@ -167,6 +178,15 @@ export class AppProcessor {
         try {
           const app = await this.getAppApi(app_id);
           if (app) {
+            app.items_object = {};
+
+            for(let item = 0; item < app.items_list.length; item++) {
+              app.items_object[app.items_list[item].item_id] = {};
+                for(let field = 0; field < app.items_list[item].fields.length; field++) {
+                  app.items_object[app.items_list[item].item_id][app.items_list[item].fields[field].field_id] = app.items_list[item].fields[field];
+                }
+            }
+
             this.storage.updateApp(app);
           }
         } catch (err) {
@@ -254,7 +274,9 @@ export class AppProcessor {
       }
     }
     
-    return trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
+    // This code for trash must be changed
+    // return trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
+    return app;
   }
 
   async updateApp(app) {
@@ -282,6 +304,7 @@ export class AppProcessor {
 
   async createNewApp(app) {
     const newApp = await this.createNewAppApi(app);
+    newApp.items_object = {};
     this.addNewAppToStorage(newApp);
     return newApp;
   }

package/GUDHUB/FieldProcessor/FieldProcessor.js

@@ -77,11 +77,13 @@ export class FieldProcessor {
         item.fields.forEach((field) => {
           if (field.field_id == field_id) {
             field.field_value = field_value;
+            app.items_object[item.item_id][field.field_id] = field;
           }
         });
       }
     });
     this.storage.updateApp(app);
+    return field_value;
   }
 
   async getField(app_id, field_id) {
@@ -116,16 +118,10 @@ export class FieldProcessor {
     let fieldValue = null;
     const app = await this.appProcessor.getApp(app_id);
     
-    if (app) {
-      const fundedItem = app.items_list.find((item) => item.item_id == item_id);
-      if (fundedItem) {
-        const fundedField = fundedItem.fields.find(
-          (field) => field.field_id == field_id
-        );
-        if (fundedField) {
-          fieldValue = fundedField.field_value;
-        }
-      }
+    try {
+      fieldValue = app.items_object[item_id][field_id].field_value;
+    } catch(err) {
+
     }
 
     return fieldValue;
@@ -136,7 +132,7 @@ export class FieldProcessor {
       return;
     }
     await this.setFieldValueApi(app_id, item_id, field_id, field_value);
-    this.updateFieldValue(app_id, item_id, field_id, field_value);
+    return this.updateFieldValue(app_id, item_id, field_id, field_value);
   }
 
   fieldListeners() {

package/GUDHUB/FieldProcessor/FieldProcessor.test.js

@@ -10,7 +10,36 @@ describe("FIELD PROCESSOR", async function() {
         var fieldModel = await gudhub.getField(16259, 254055);
         fieldModel.data_type.should.equal('text');
         (typeof fieldModel).should.equal('object');
+    });
+
+    it('GET FIELD VALUE / should return a field value', async () => {
+        let value = await gudhub.getFieldValue(16259, 1064673, 254055);
+        value.should.equal('Hall up');
+    });
+
+    it('UPDATE FIELD AND GET NEW VALUE / should return new field value', async () => {
+        await gudhub.setFieldValue(16259, 1064673, 254055, 'Updated value');
+        let value = await gudhub.getFieldValue(16259, 1064673, 254055);
+        value.should.equal('Updated value');
     })
 
+    it('CREATE ITEM AND SET IT VALUE / should return new value of new item', async () => {
+        let items = await gudhub.addNewItems(16259, newItems);
+        let item_id = items[0].item_id;
+
+        await gudhub.setFieldValue(16259, item_id, 254056, 'Big Fish Tank');
+
+        let value = await gudhub.getFieldValue(16259, item_id, 254056);
+
+        value.should.equal('Big Fish Tank');
+    });
+
     
-});
+});
+
+const newItems = [
+    {
+        item_id: 0,
+        fields: []
+    },
+]

package/GUDHUB/GHConstructor/createAngularModuleInstance.js

@@ -73,7 +73,7 @@ let angular = {
 /*** TODO ***/
 // Need to make angular modules instances creation similar to pure js classes.
 
-export default async function createAngularModuleInstance(module_id, module_url, angularInjector, nodeWindow) {
+export default async function createAngularModuleInstance(gudhub, module_id, module_url, angularInjector, nodeWindow) {
 
     try {
 
@@ -106,13 +106,37 @@ export default async function createAngularModuleInstance(module_id, module_url,
 
         } else {
 
+            const proxy = new Proxy(nodeWindow, {
+                get: (target, property) => {
+                    return target[property]
+                },
+                set: (target, property, value) => {
+                    target[property] = value;
+                    global[property] = value;
+                    return true;
+                }
+            })
+
             // If node's global object don't have window and it's methods yet - set it.
             if (!global.hasOwnProperty('window')) {
-                global.window = nodeWindow;
+                global.window = proxy;
                 global.document = nodeWindow.document;
                 global.Element = nodeWindow.Element;
+                global.CharacterData = nodeWindow.CharacterData;
+                global.this = proxy;
+                global.self = proxy;
+                global.Blob = nodeWindow.Blob;
+                global.Node = nodeWindow.Node;
                 global.navigator = nodeWindow.navigator;
                 global.HTMLElement = nodeWindow.HTMLElement;
+                global.XMLHttpRequest = nodeWindow.XMLHttpRequest;
+                global.WebSocket = nodeWindow.WebSocket;
+                global.crypto = nodeWindow.crypto;
+                global.DOMParser = nodeWindow.DOMParser;
+                global.Symbol = nodeWindow.Symbol;
+                global.document.queryCommandSupported = (command) => {
+                    return false;
+                }
                 global.angular = angular;
             }
 
@@ -131,6 +155,7 @@ export default async function createAngularModuleInstance(module_id, module_url,
                 module = await import(/* webpackIgnore: true */encodedCode);
             } catch (err) {
                 console.log(`Error while importing module: ${module_id}`);
+                console.log(err);
             }
 
             // Modules always exports classes as default, so we create new class instance.
@@ -196,7 +221,7 @@ export default async function createAngularModuleInstance(module_id, module_url,
                     let currentDataType = importedClass;
 
                     try {
-                        let interpr_arr = await currentDataType.getInterpretation(value, appId, itemId, field, dataType);
+                        let interpr_arr = await currentDataType.getInterpretation(gudhub, value, appId, itemId, field, dataType);
                         let data = interpr_arr.find((item) => item.id == interpretation_id) || interpr_arr.find((item) => item.id == 'default');
 
                         let result = await data.content()

package/GUDHUB/GHConstructor/createClassInstance.js

@@ -1,187 +1,202 @@
 import axios from 'axios';
 import { IS_WEB } from './../consts.js';
 
-export default async function createClassInstance(module_id, js_url, css_url, nodeWindow) {
+export default async function createClassInstance(gudhub, module_id, js_url, css_url, nodeWindow) {
 
     try {
 
-    // Check if there is url to javascript file of module
+        // Check if there is url to javascript file of module
 
-    if(!js_url) {
-        console.error(`JS link must be provided for this data type - ${module_id}`);
-    }
-
-    // Import module using dynamic import
-
-    let downloadModule = (url) => {
-        if (!IS_WEB && !global.hasOwnProperty('window')) {
-            global.window = nodeWindow;
-            global.document = nodeWindow.document;
-            global.Element = nodeWindow.Element;
-            global.navigator = nodeWindow.navigator;
-            global.HTMLElement = nodeWindow.HTMLElement;
+        if (!js_url) {
+            console.error(`JS link must be provided for this data type - ${module_id}`);
         }
-        return new Promise(async (resolve) => {
-            let moduleData = await axios.get(url).catch(err => {
-                console.log(`Failed to fetch: ${url} in ghconstructor. Module id: ${module_id}`);
-            })
 
-            let encodedJs = encodeURIComponent(moduleData.data);
-    
-            let dataUri = 'data:text/javascript;charset=utf-8,' + encodedJs;
-    
-            resolve(dataUri);
-        })
-    }
+        // Import module using dynamic import
+
+        let downloadModule = (url) => {
+            if (!IS_WEB && !global.hasOwnProperty('window')) {
+                global.window = proxy;
+                global.document = nodeWindow.document;
+                global.Element = nodeWindow.Element;
+                global.CharacterData = nodeWindow.CharacterData;
+                global.this = proxy;
+                global.self = proxy;
+                global.Blob = nodeWindow.Blob;
+                global.Node = nodeWindow.Node;
+                global.navigator = nodeWindow.navigator;
+                global.HTMLElement = nodeWindow.HTMLElement;
+                global.XMLHttpRequest = nodeWindow.XMLHttpRequest;
+                global.WebSocket = nodeWindow.WebSocket;
+                global.crypto = nodeWindow.crypto;
+                global.DOMParser = nodeWindow.DOMParser;
+                global.Symbol = nodeWindow.Symbol;
+                global.document.queryCommandSupported = (command) => {
+                    console.log('QUERY COMMAND SUPPORTED: ', command);
+                    return false;
+                }
+                global.angular = angular;
+            }
+            return new Promise(async (resolve) => {
+                let moduleData = await axios.get(url).catch(err => {
+                    console.log(`Failed to fetch: ${url} in ghconstructor. Module id: ${module_id}`);
+                })
 
-    let moduleData = await downloadModule(js_url);
+                let encodedJs = encodeURIComponent(moduleData.data);
 
-    let module;
+                let dataUri = 'data:text/javascript;charset=utf-8,' + encodedJs;
 
-    try {
-        module = await import(/* webpackIgnore: true */moduleData);
-    } catch (err) {
-        console.log(`Error while importing module: ${module_id}`);
-        console.log(err);
-    }
+                resolve(dataUri);
+            })
+        }
 
-    // Creating class from imported module
+        let moduleData = await downloadModule(js_url);
 
-    let importedClass = new module.default(module_id);
+        let module;
 
-    // Check if there is url to css file of module
-    // If true, and there is no css for this data type, than create link tag to this css in head
+        try {
+            module = await import(/* webpackIgnore: true */moduleData);
+        } catch (err) {
+            console.log(`Error while importing module: ${module_id}`);
+            console.log(err);
+        }
 
-    if(css_url && IS_WEB) {
-        const linkTag = document.createElement('link');
-        linkTag.href = css_url;
-        linkTag.setAttribute('data-module', module_id);
-        linkTag.setAttribute('rel', 'stylesheet');
-        document.getElementsByTagName('head')[0].appendChild(linkTag);
-    }
-    
-    let result = {
-        type: module_id,
+        // Creating class from imported module
 
-        //*************** GET TEMPLATE ****************//
+        let importedClass = new module.default(module_id);
 
-        getTemplate: function (ref, changeFieldName, displayFieldName, field_model, appId, itemId) {
-            let displayFieldNameChecked = displayFieldName === 'false' ? false : true;
-            return importedClass.getTemplate(ref, changeFieldName, displayFieldNameChecked, field_model, appId, itemId);
-        },
+        // Check if there is url to css file of module
+        // If true, and there is no css for this data type, than create link tag to this css in head
 
-        //*************** GET DEFAULT VALUE ****************//
+        if (css_url && IS_WEB) {
+            const linkTag = document.createElement('link');
+            linkTag.href = css_url;
+            linkTag.setAttribute('data-module', module_id);
+            linkTag.setAttribute('rel', 'stylesheet');
+            document.getElementsByTagName('head')[0].appendChild(linkTag);
+        }
 
-        getDefaultValue: function (fieldModel, valuesArray, itemsList, currentAppId) {
-            return new Promise(async (resolve) => {
-                let getValueFunction = importedClass.getDefaultValue;
-                if (getValueFunction) {
-                    let value = await getValueFunction(fieldModel, valuesArray, itemsList, currentAppId);
-                    resolve(value);
-                } else {
-                    resolve(null);
-                }
-            });
-        },
+        let result = {
+            type: module_id,
 
-        //*************** GET SETTINGS ****************//
+            //*************** GET TEMPLATE ****************//
 
-        getSettings: function (scope, settingType, fieldModels) {
-            return importedClass.getSettings(scope, settingType, fieldModels);
-        },
+            getTemplate: function (ref, changeFieldName, displayFieldName, field_model, appId, itemId) {
+                let displayFieldNameChecked = displayFieldName === 'false' ? false : true;
+                return importedClass.getTemplate(ref, changeFieldName, displayFieldNameChecked, field_model, appId, itemId);
+            },
 
-        //*************** FILTER****************//
+            //*************** GET DEFAULT VALUE ****************//
+
+            getDefaultValue: function (fieldModel, valuesArray, itemsList, currentAppId) {
+                return new Promise(async (resolve) => {
+                    let getValueFunction = importedClass.getDefaultValue;
+                    if (getValueFunction) {
+                        let value = await getValueFunction(fieldModel, valuesArray, itemsList, currentAppId);
+                        resolve(value);
+                    } else {
+                        resolve(null);
+                    }
+                });
+            },
 
-        filter: {
-            getSearchOptions: function (fieldModel) {
-                let d_type = importedClass;
-                if (d_type.filter && d_type.filter.getSearchOptions) {
-                    return importedClass.filter.getSearchOptions(fieldModel);
-                }
-                return [];
+            //*************** GET SETTINGS ****************//
+
+            getSettings: function (scope, settingType, fieldModels) {
+                return importedClass.getSettings(scope, settingType, fieldModels);
             },
-            getDropdownValues: function () {
-                let d_type = importedClass;
-                if (d_type.filter && d_type.filter.getDropdownValues) {
-                    return d_type.filter.getDropdownValues();
-                } else {
+
+            //*************** FILTER****************//
+
+            filter: {
+                getSearchOptions: function (fieldModel) {
+                    let d_type = importedClass;
+                    if (d_type.filter && d_type.filter.getSearchOptions) {
+                        return importedClass.filter.getSearchOptions(fieldModel);
+                    }
                     return [];
+                },
+                getDropdownValues: function () {
+                    let d_type = importedClass;
+                    if (d_type.filter && d_type.filter.getDropdownValues) {
+                        return d_type.filter.getDropdownValues();
+                    } else {
+                        return [];
+                    }
                 }
-            }
-        },
-
-        //*************** GET INTERPRETATION ****************//
+            },
 
-        getInterpretation: function (value, interpretation_id, dataType, field, itemId, appId) {
-            return new Promise(async (resolve) => {
-                let currentDataType = importedClass;
+            //*************** GET INTERPRETATION ****************//
 
-                try {
-                    let interpr_arr = await currentDataType.getInterpretation(value, appId, itemId, field, dataType);
-                    let data = interpr_arr.find((item) => item.id == interpretation_id) || interpr_arr.find((item) => item.id == 'default');
+            getInterpretation: function (value, interpretation_id, dataType, field, itemId, appId) {
+                return new Promise(async (resolve) => {
+                    let currentDataType = importedClass;
 
-                    let result = await data.content()
+                    try {
+                        let interpr_arr = await currentDataType.getInterpretation(gudhub, value, appId, itemId, field, dataType);
+                        let data = interpr_arr.find((item) => item.id == interpretation_id) || interpr_arr.find((item) => item.id == 'default');
 
-                    resolve({ html: result });
-                } catch (error) {
-                    console.log(`ERROR IN ${module_id}`, error);
-                    resolve({ html: '<span>no interpretation</span>' })
-                }
-            });
-        },
+                        let result = await data.content()
 
-        //*************** GET INTERPRETATIONS LIST ****************//
+                        resolve({ html: result });
+                    } catch (error) {
+                        console.log(`ERROR IN ${module_id}`, error);
+                        resolve({ html: '<span>no interpretation</span>' })
+                    }
+                });
+            },
 
-        getInterpretationsList: function (field_value, appId, itemId, field) {
-            return importedClass.getInterpretation(field_value, appId, itemId, field);
-        },
+            //*************** GET INTERPRETATIONS LIST ****************//
 
-        //*************** GET INTERPRETATED VALUE ****************//
+            getInterpretationsList: function (field_value, appId, itemId, field) {
+                return importedClass.getInterpretation(field_value, appId, itemId, field);
+            },
 
-        getInterpretatedValue: function (field_value, field_model, appId, itemId) {
-            return new Promise(async (resolve) => {
-                let getInterpretatedValueFunction = importedClass.getInterpretatedValue;
-                if (getInterpretatedValueFunction) {
-                    let value = await getInterpretatedValueFunction(field_value, field_model, appId, itemId);
-                    resolve(value);
-                } else {
-                    resolve(field_value);
-                }
-            });
-        },
+            //*************** GET INTERPRETATED VALUE ****************//
+
+            getInterpretatedValue: function (field_value, field_model, appId, itemId) {
+                return new Promise(async (resolve) => {
+                    let getInterpretatedValueFunction = importedClass.getInterpretatedValue;
+                    if (getInterpretatedValueFunction) {
+                        let value = await getInterpretatedValueFunction(field_value, field_model, appId, itemId);
+                        resolve(value);
+                    } else {
+                        resolve(field_value);
+                    }
+                });
+            },
 
-        //*************** EXTEND CONTROLLER ****************//
+            //*************** EXTEND CONTROLLER ****************//
 
-        extendController: function (actionScope) {
-            importedClass.getActionScope(actionScope);
-        },
+            extendController: function (actionScope) {
+                importedClass.getActionScope(actionScope);
+            },
 
-        //*************** RUN ACTION ****************//
+            //*************** RUN ACTION ****************//
 
-        runAction: function (scope) {
-            try {
-                importedClass.runAction(scope);
-            } catch (e) {
+            runAction: function (scope) {
+                try {
+                    importedClass.runAction(scope);
+                } catch (e) {
 
-            }
-        },
+                }
+            },
 
-        //*************** GET WINDOW SCOPE ****************//
+            //*************** GET WINDOW SCOPE ****************//
 
-        getWindowScope: function (windowScope) {
-            return importedClass.getWindowScope(windowScope);
-        },
+            getWindowScope: function (windowScope) {
+                return importedClass.getWindowScope(windowScope);
+            },
 
-        //*************** GET WINDOW HTML ****************//
+            //*************** GET WINDOW HTML ****************//
 
-        getWindowHTML: function (scope) {
-            return importedClass.getWindowHTML(scope);
-        },
-    }
+            getWindowHTML: function (scope) {
+                return importedClass.getWindowHTML(scope);
+            },
+        }
 
-    return result;
+        return result;
 
-    } catch(err) {
+    } catch (err) {
         console.log(err);
         console.log(`Failed in createClassInstance (ghconstructor). Module id: ${module_id}. JS url: ${js_url}`);
     }

package/GUDHUB/GHConstructor/ghconstructor.js

@@ -69,16 +69,23 @@ export class GHConstructor {
 
     async createInstance(module_id) {
         let module = this.gudhub.storage.getModuleUrl(module_id);
+        
+        if(!module) {
+            console.log(`Cannot find module: ${module_id}`);
+            return;
+        }
 
         let result;
         if (module.type === 'angular') {
-            result = await createAngularModuleInstance(module_id, module.url, this.angularInjector, this.nodeWindow);
+            result = await createAngularModuleInstance(this.gudhub, module_id, module.url, this.angularInjector, this.nodeWindow);
         } else if(module.type === 'class') {
-            result = await createClassInstance(module_id, module.js, module.css, this.nodeWindow);
+            result = await createClassInstance(this.gudhub, module_id, module.js, module.css, this.nodeWindow);
         }
 
-        this.pupToCache(result);
-
+        if(result) {
+            this.pupToCache(result);
+        }
+        
         return result;
     }
 }

package/GUDHUB/GHConstructor/ghconstructor.test.js

@@ -0,0 +1,66 @@
+// import should from "should";
+// import sinon from "sinon";
+// import {GudHub} from './../gudhub.js';
+// import { JSDOM } from 'jsdom';
+
+// describe("GHConstructor", () => {
+
+//     before(() => {
+//         sinon.stub(console, 'info')  // disable console.info
+//         sinon.stub(console, 'warn')  // disable console.warn
+//         sinon.stub(console, 'error')  // disable console.error
+//         // sinon.stub(console, 'log')  // disable console.error
+//     })
+
+//     it('CREATE INSTANCES FOR ALL DATA TYPES', async () => {
+//         const gudhub = new GudHub('o5A10WgXdFpvzJYt0tp6gQaIqF52vPqlbONtjq6yvCSaqr7AtDHGzIS6/9uqJgNhw0Bh5ttE8ft2xQ5xaZ5fHA==', {
+//             server_url: 'https://gudhub.com/GudHub_Test',
+//             async_modules_path: 'build/async_modules_node/',
+//             file_server_url: 'http://localhost:8080'
+//         });
+
+//         const jsdom = new JSDOM('', {
+//             url: 'http://localhost:1234',
+//             runScripts: 'dangerously'
+//         });
+        
+//         const { window } = jsdom;
+
+//         gudhub.ghconstructor.initJsdomWindow(window);
+
+//         let instance = await gudhub.ghconstructor.getInstance('vs_code');
+
+//         if(instance) {
+//             console.log('DONE!');
+//         }
+
+//         // let modulesList = gudhub.storage.modulesList;
+//         // let modulesObj = {};
+
+//         // modulesList.forEach(item => {
+//         //     modulesObj[item.name] = false 
+//         // });
+
+//         // const promises = [];
+
+//         // for(let i = 0; i < modulesList.length; i++) {
+//         //     promises.push(new Promise(async (resolve) => {
+//         //         try {
+//         //             gudhub.ghconstructor.getInstance(modulesList[i].name).then(() => {
+//         //                 modulesObj[modulesList[i].name] = true;
+//         //             })
+//         //             resolve(true);
+//         //         } catch(err) {
+//         //             console.log('ERR!');
+//         //             resolve(false);
+//         //         }
+//         //     }));
+//         // }
+        
+//         // Promise.all(promises).then(() => {
+//         //     console.log('ALL DONE!');
+//         //     console.log('MODULES: ', modulesObj);
+//         // });
+
+//     });
+// });