@gudhub/core 1.1.57 → 1.1.59

package/GUDHUB/FieldProcessor/FieldProcessor.js

@@ -98,6 +98,17 @@ export class FieldProcessor {
     return null;
   }
 
+  async getFieldIdByNameSpace(app_id, name_space) {
+    const app = await this.appProcessor.getApp(app_id);
+    if(!app) return null;
+    for(let i = 0; i < app.field_list.length; i++) {
+      if(app.field_list[i].name_space == name_space) {
+        return app.field_list[i].field_id;
+      }
+    }
+    return null;
+  }
+
   //!!!!! Shou Be Renamed to  getFields() !!!!!!!
   async getFieldModels(app_id) {
     const app = await this.appProcessor.getApp(app_id);

package/GUDHUB/FieldProcessor/FieldProcessor.test.js

@@ -12,6 +12,11 @@ describe("FIELD PROCESSOR", async function() {
         (typeof fieldModel).should.equal('object');
     });
 
+    it("GET FIELD ID BY NAMESPACE / should return a field id", async function() {
+        const fieldId = await gudhub.getFieldIdByNameSpace(16259, 'name');
+        fieldId.should.equal(254056);
+    });
+
     it('GET FIELD VALUE / should return a field value', async () => {
         let value = await gudhub.getFieldValue(16259, 1064673, 254055);
         value.should.equal('Hall up');

package/GUDHUB/PipeService/PipeService.test.js

@@ -68,9 +68,8 @@ describe("PipeService", () => {
     gudhub
       .emit("test",  { app_id: 4, item_id: 3, field_id: 2 }, {"message" : "this is the data"})
       .on("test",  { app_id: 4, item_id: 3, field_id: 2 }, (event, data) => {
-        incomeData = data.message;
+        data.message.should.equal("this is the data");
       });
-      incomeData.should.equal("this is the data");
   });
   
 

package/GUDHUB/Utils/AppsTemplateService/AppsTemplateService.js

@@ -17,26 +17,25 @@ export default class AppsTemplateService {
             let currentStep = 0;
             self.createApps(pack, (status) => {
                 currentStep += 1;
-                progressCallback.call(this, {
+                progressCallback ? progressCallback.call(this, {
                     percent: currentStep * stepPercents,
                     status
-                })
+                }) : null;
             }).then(success => {
                 self.createItems(success, maxNumberOfInsstalledItems, (status) => {
                     if (typeof status === 'string') {
                         currentStep += 1;
-                        progressCallback.call(this, {
+                        progressCallback ? progressCallback.call(this, {
                             percent: currentStep * stepPercents,
                             status
-                        })
+                        }) : null;
                     } else if (typeof status === 'object') {
-                        progressCallback.call(this, {
+                        progressCallback ? progressCallback.call(this, {
                             status: 'Done',
                             apps: status
-                        })
+                        }) : null;
+                        resolve();
                     }
-                }).then(() => {
-                    resolve();
                 })
             })
         });
@@ -61,64 +60,64 @@ export default class AppsTemplateService {
                                 fields: []
                             }
                         }).filter((item, index) => index <= MAX_NUMBER_OF_INSTALLED_ITEMS);
-
                         self.gudhub.addNewItems(app.app_id, items).then(items => {
                             callback ? callback.call(this, `ADD NEW ITEMS: ${result_app.app_name} (Items steps)`) : null;
 
-                            if (items.length === 0) {
-                                callback ? callback.call(this, `NO ITEMS TO REPLACE VALUE: ${result_app.app_name} (Items steps)`) : null;
-                                app_resolve();
-                            }
-
                             app.items_list = items;
                             self._updateMap(app.items_list, source_app.items_list);
                             self._addFieldValue(source_app.items_list, app.items_list, self.appsConnectingMap);
 
                             createsItems.push(app);
 
-                            if (self.appsConnectingMap.apps.length === createsItems.length) {
-                                createsItems.forEach(app => {
-                                    app.items_list.forEach(item => {
-                                        item.fields.forEach(field_item => {
-                                            self.appsConnectingMap.fields.forEach(field_map => {
-                                                if (field_item.field_id === field_map.old_field_id) {
-                                                    field_item.field_id = field_map.new_field_id;
-                                                    field_item.element_id = field_map.new_field_id;
-                                                }
-                                            })
-                                        })
-                                    })
-                                });
-
-                                self.deleteField(createsItems);
-
-                                self.replaceValue(createsItems, self.appsConnectingMap).then(() => {
-                                    callback ? callback.call(this, `REPLACE VALUE: ${result_app.app_name} (Items steps)`) : null;
-                                    createsItems.forEach(created_app => {
-                                        let newItems = created_app.items_list.map(item => {
-                                            item.fields.forEach(field => {
-                                                delete field.data_id;
-                                            });
-                                            return item;
-                                        });
-
-                                        self.gudhub.updateItems(created_app.app_id, newItems).then(() => {
-                                            app_resolve();
-                                        })
-                                    })
-                                });
-                            }
+                            app_resolve();
                         });
                     });
                 }));
             });
 
             Promise.all(promises).then(() => {
-                let apps = create_apps.map(app => {
-                    return app.app_id;
+
+            createsItems.forEach(app => {
+                app.items_list.forEach(item => {
+                    item.fields.forEach(field_item => {
+                        self.appsConnectingMap.fields.forEach(field_map => {
+                            if (field_item.field_id === field_map.old_field_id) {
+                                field_item.field_id = field_map.new_field_id;
+                                field_item.element_id = field_map.new_field_id;
+                            }
+                        })
+                    })
+                })
+            });
+
+            self.deleteField(createsItems);
+
+            self.replaceValue(createsItems, self.appsConnectingMap).then(() => {
+                
+                const promises = [];
+
+                createsItems.forEach(created_app => {
+                    promises.push(new Promise(resolve => {
+                        let newItems = created_app.items_list.map(item => {
+                            item.fields.forEach(field => {
+                                delete field.data_id;
+                            });
+                            return item;
+                        });
+                        
+                        self.gudhub.updateItems(created_app.app_id, newItems).then(() => {
+                            callback ? callback.call(this, `REPLACE VALUE: ${created_app.app_name} (Items steps)`) : null;
+                            resolve();
+                        })
+                    }));
+                });
+                
+                Promise.all(promises).then(() => {
+                    callback.call(this, createsItems);
+                    resolve();
                 });
-                callback.call(this, apps);
-                resolve();
+
+            });
             })
         })
     }
@@ -185,26 +184,30 @@ export default class AppsTemplateService {
     documentInstallerHelper(appId, items, elementId) {
         const self = this;
         return new Promise(async (resolve) => {
-            items.forEach(item => {
+            for(const item of items) {
                 const itemId = item.item_id;
                 const field = item.fields.find(field => field.element_id === elementId);
 
                 if (field && field.field_value && field.field_value.length > 0) {
-                    self.gudhub.getDocument({
+                    const document = await self.gudhub.getDocument({
                         _id: field.field_value
-                    }).then(document => {
-                        self.gudhub.createDocument({
+                    });
+
+                    if(document && document.data) {
+                    
+                        const newDocument = await self.gudhub.createDocument({
                             app_id: appId,
                             item_id: itemId,
                             element_id: elementId,
                             data: document.data
-                        }).then(new_document => {
-                            field.field_value = new_document._id;
-                            resolve();
-                        })
-                    })
+                        });
+
+                        field.field_value = newDocument._id;
+
+                    }
                 }
-            });
+            }
+            resolve();
         });
     }
 

package/GUDHUB/Utils/Utils.js

@@ -21,6 +21,7 @@ import { compiler } from "./json_constructor/json_constructor.js";
 import AppsTemplateService from "./AppsTemplateService/AppsTemplateService.js";
 import { FileHelper } from "./FIleHelper/FileHelper.js";
 import { compareObjects } from "./compareObjects/compareObjects.js";
+import { dynamicPromiseAll } from "./dynamicPromiseAll/dynamicPromiseAll.js";
 
 export class Utils {
   constructor(gudhub) {
@@ -206,4 +207,8 @@ export class Utils {
       callback(diff);
     });
   }
+
+  dynamicPromiseAll(promisesArray) {
+    return dynamicPromiseAll(promisesArray);
+  }
 }

package/GUDHUB/Utils/dynamicPromiseAll/dynamicPromiseAll.js

@@ -0,0 +1,49 @@
+export async function dynamicPromiseAll(promises) {
+
+    await Promise.all(promises);
+
+    let allDone = true;
+
+    for(const promise of promises) {
+        const result = await _checkPromiseStatus(promise);
+        if(result.state === 'pending') {
+            allDone = false;
+            break;
+        }
+        if(result.state === 'rejected') {
+            throw result.reason;
+            break;
+        }
+    }
+
+    if(allDone) {
+        return true;
+    }
+
+    return dynamicPromiseAll(promises);
+
+}
+
+function _checkPromiseStatus(promise) {
+
+    const pending = {
+      state: 'pending',
+    };
+    
+    return Promise.race([promise, pending]).then(
+        (value) => {
+            if (value === pending) {
+                return value;
+            }
+            return {
+                state: 'resolved',
+                value
+                };
+            },
+        (reason) => ({
+            state: 'rejected',
+            reason
+        })
+    );
+}
+  

package/GUDHUB/Utils/json_constructor/json_constructor.js

@@ -114,16 +114,19 @@ export function compiler(scheme, item, util, variables, appId) {
 
       case "function":
         if(typeof scheme.function === 'function') {
-          let result = scheme.function(item, appId, ...scheme.args);
+          let result = scheme.function(item, appId, util.gudhub, ...scheme.args);
           return result;
         } else {
-          const func = new Function('item, appId', 'return (async ' + scheme.function + ')(item, appId)');
-          let result = await func(item, appId);
+          const func = new Function('item, appId, gudhub', 'return (async ' + scheme.function + ')(item, appId, gudhub)');
+          let result = await func(item, appId, util.gudhub);
           return result;
         }
 
       case "field_value":
       default:
+        if(!scheme.field_id && scheme.name_space) {
+          scheme.field_id = await util.gudhub.getFieldIdByNameSpace(appId, scheme.name_space);
+        }
         if (Boolean(Number(scheme.interpretation))) {
           let interpretatedValue = await util.gudhub.getInterpretationById(Number(appId), Number(item.item_id), Number(scheme.field_id), 'value');
           return interpretatedValue;

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

@@ -20,13 +20,14 @@ describe("JSON CONSTRUCTOR", function () {
   gudhub.ghconstructor.initJsdomWindow(window);
 
   it("JSON FROM ONE APP : Here we construct simple json from one App", async function () {
-    this.timeout(4000);
+    this.timeout(5000);
     //-- 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 () {
+    this.timeout(5000);
     //-- 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");
@@ -34,6 +35,7 @@ describe("JSON CONSTRUCTOR", function () {
     json.fishtank[0].should.have.property("notes","https://gudhub.com/userdata/16259/811770.html?timestamp=0");
   });
   it("GET FILTERED ITEMS LENGTH WITH CURRENT ITEM FILTER", async function () {
+    this.timeout(5000);
     let json = await gudhub.jsonConstructor(currentItemScheme);
     let firstLength = json.scheme[0].array.length;
     let secondLength = json.scheme[1].array.length;
@@ -42,6 +44,11 @@ describe("JSON CONSTRUCTOR", function () {
     secondLength.should.equal(4);
    
   });
+  it("WORK WITH NAMESPACE INSTEAD OF FIELD ID", async function () {
+    this.timeout(5000);
+    let json = await gudhub.jsonConstructor(schemeWithNamespace);
+    json.scheme[0].name.should.equal("Big Fish Tank");
+  });
 });
 
 var fishtank_scheme = {
@@ -146,3 +153,20 @@ let currentItemScheme = {
   app_id: "16259",
   filter: [],
 };
+
+let schemeWithNamespace = {
+  type: "array",
+  id: 1,
+  childs: [
+    {
+      type: "property",
+      id: 2,
+      property_name: "name",
+      property_type: "field_value",
+      name_space: "name"
+    }
+  ],
+  property_name: "scheme",
+  app_id: "16259",
+  filter: []
+}

package/GUDHUB/config.js

@@ -3,7 +3,7 @@ export const server_url = "https://gudhub.com/GudHub_Test";
 //export const server_url = "https://integration.gudhub.com/GudHub_Test";
 //export const server_url = "http://localhost:9000";
 export const wss_url = "wss://gudhub.com/GudHub/ws/app/";
-export const async_modules_path = 'build/latest/async_modules/';
+export const async_modules_path = 'build/latest/async_modules_node/';
 export const automation_modules_path = 'build/latest/automation_modules/'
 export const file_server_url = 'https://gudhub.com'
 

package/GUDHUB/gudhub.js

@@ -314,6 +314,10 @@ export class GudHub {
     return this.fieldProcessor.getField(app_id, field_id);
   }
 
+  getFieldIdByNameSpace(app_id, name_space) {
+    return this.fieldProcessor.getFieldIdByNameSpace(app_id, name_space);
+  }
+
   getFieldModels(app_id) {
     return this.fieldProcessor.getFieldModels(app_id);
   }

package/package.json

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