@gudhub/core 1.0.37

package/GUDHUB/Processors/AppProcessor/AppProcessor.test.js

@@ -0,0 +1,38 @@
+import should from "should";
+import {GudHub} from './../../gudhub.js';
+import {appTemplate} from './AppProcessorMocks.js';
+
+describe("APP PROCESSOR", async function() {
+    const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+    const gudhub = new GudHub(auth_key);
+    let newAppID = 0; 
+
+
+    it("GET APP / App name should be 'Aqua-Test'", async function () {
+        var app = await gudhub.getApp("16259");
+        app.app_name.should.equal('Fish Tank');
+        gudhub.storage.getAppsList().length.should.equal(1);
+    })
+
+
+    // it("CREATE APP / App name should be 'My Application'", async function () {
+    //     var newApp = await gudhub.createNewApp(appTemplate);
+    //     newApp.app_name.should.equal('My Application');
+    //     newAppID = newApp.app_id;
+    //     gudhub.storage.getAppsList().length.should.equal(2);
+    // })
+
+
+    // it("DELETE APP / We should receive messege like 'delete application with id=[app_id]'", async function () {
+    //     var currentApplist = await gudhub.deleteApp(newAppID);
+    //     currentApplist.length.should.equal(1);
+    //     gudhub.storage.getAppsList().length.should.equal(1);
+    // })
+
+
+    // it("GET APP LIST / Should return arey with two apps", async function () {
+    //     var appList = await gudhub.getAppsList();
+    //     appList.length.should.equal(2);
+    //     gudhub.storage.getAppsList().length.should.equal(2);
+    // })
+});

package/GUDHUB/Processors/AppProcessor/AppProcessorMocks.js

@@ -0,0 +1,83 @@
+export const appTemplate = {
+    app_name: "My Application",
+    icon: {
+        "icon_id": "box",
+        "icon_color": "ffffff",
+        "gradient_up": "00CCF8",
+        "gradient_down": "00F8B2"
+    },
+    privacy: 1,
+    views_list: [{
+        content: [],
+        name:	"Main"
+    }, {
+        content: [],
+        name:	"Form"
+    }],
+    items_list: [{
+        "item_id": "123",
+        "fields": [{
+            "field_id": 1,
+            "create_field": "newfield1",
+            "field_value": "John",
+        }, {
+            "field_id": 2,
+            "create_field": "newfield2",
+            "field_value": "Dow",
+        }, {
+            "field_id": 3,
+            "create_field": "newfield3",
+            "field_value": "0674346135",
+        }, {
+            "field_id": 4,
+            "create_field": "newfield4",
+            "field_value": "",
+        }]
+    }],
+    field_list: [{
+        "field_id": 1,
+        "create_field": "newfield1",
+        "field_name": "First Name",
+        "data_id": 0,
+        "data_type": "text",
+        "file_name": "0"
+    }, {
+        "field_id": 2,
+        "create_field": "newfield2",
+        "field_name": "Last Name",
+        "data_id": 0,
+        "data_type": "text",
+        "file_name": "0"
+    }, {
+        "field_id": 3,
+        "create_field": "newfield3",
+        "field_name": "Phone",
+        "data_id": 0,
+        "data_type": "number",
+        "file_name": "0"
+    }, {
+        "field_id": 4,
+        "create_field": "newfield4",
+        "data_model": {
+            "search":"",
+            "filter_list": [],
+            "table_settings": {
+                "columns_to_view": [], /* Array of column settings, wich view in table,*/
+                "table_height": '', /* Height of table*/
+                "action": "open_item",
+                "selected_item": "1"
+            },
+            "item_update_settings": {
+                "show_updating_input": false,
+                "field_to_view": 0
+            },
+            "itself_filter": {
+                "active": false,
+            }
+        },
+        "data_type": "table",
+        "field_name": "App",
+        "data_id": 0,
+        "file_name": "0"
+    }]
+};

package/GUDHUB/Processors/FieldProcessor/FieldProcessor.js

@@ -0,0 +1,139 @@
+export class FieldProcessor {
+  constructor(storage, req, appProcessor, itemProcessor) {
+    this.storage = storage;
+    this.req = req;
+    this.appProcessor = appProcessor;
+    this.itemProcessor = itemProcessor;
+  }
+
+  deleteFieldApi(field_id) {
+    return this.req.post({ url: "/api/app/delete-field", form: { field_id } });
+  }
+
+  async updatedFieldApi(app_id, fieldModel = {}) {
+    const app = await this.appProcessor.getApp(app_id);
+    const appToUpdate = {
+      app_id,
+      app_name: app.app_name,
+      group_id: app.group_id,
+      icon: app.icon,
+      field_list: app.field_list.map((field) =>
+        field.field_id == fieldModel.field_id
+          ? { ...field, ...fieldModel }
+          : field
+      ),
+      views_list: app.views_list,
+    };
+    return this.appProcessor.updateApp(appToUpdate);
+  }
+
+  setFieldValueApi(app_id, item_id, field_id, field_value) {
+    const itemToUpdate = [
+      {
+        item_id,
+        fields: [
+          {
+            field_id,
+            field_value,
+          },
+        ],
+      },
+    ];
+    return this.itemProcessor.updateItems(app_id, itemToUpdate);
+  }
+
+  deleteFieldInStorage(app_id, field_id) {
+    const app = this.storage.getApp(app_id);
+    app.field_list = app.field_list.filter(
+      (field) => field.file_id != field_id
+    );
+    app.items_list = app.items_list.map((item) => {
+      item.fields = item.fields.filter((field) => field.field_id != field_id);
+      return item;
+    });
+    this.storage.updateApp(app);
+  }
+
+  updateFieldInStorage(app_id, fieldModel) {
+    const app = this.storage.getApp(app_id);
+    app.field_list = app.field_list.map((field) =>
+      field.field_id == fieldModel.field_id
+        ? { ...field, ...fieldModel }
+        : field
+    );
+    this.storage.updateApp(app);
+    return fieldModel;
+  }
+
+  //This method was created for setFieldValue()
+  //!!!!! 1) Change for each to for
+  //!!!!! 2) Stop iteration after value has been found
+  updateFieldValue(app_id, item_id, field_id, field_value) {
+    const app = this.storage.getApp(app_id);
+    app.items_list.forEach((item) => {
+      if (item.item_id == item_id) {
+        item.fields.forEach((field) => {
+          if (field.field_id == field_id) {
+            field.field_value = field_value;
+          }
+        });
+      }
+    });
+    this.storage.updateApp(app);
+  }
+
+  async getField(app_id, field_id) {
+    const app = await this.appProcessor.getApp(app_id);
+    if(!app) return null
+    return app.field_list.find((field) => field.field_id == field_id);
+  }
+
+  //!!!!! Shou Be Renamed to  getFields() !!!!!!!
+  async getFieldModels(app_id) {
+    const app = await this.appProcessor.getApp(app_id);
+    if(!app) return null
+    return app.field_list;
+  }
+
+  //!!!!! Shou Be added fieldID argument !!!!!!!
+  async updateField(app_id, fieldModel) {
+    if (!app_id || !fieldModel) {
+      return;
+    }
+    const newModel = await this.updatedFieldApi(app_id, fieldModel);
+    return this.updateFieldInStorage(app_id, newModel);
+  }
+
+  async deleteField(app_id, field_id) {
+    await this.deleteFieldApi(field_id);
+    return this.deleteFieldInStorage(app_id, field_id);
+  }
+
+  //this method should alwaise return value if no value we return null
+  async getFieldValue(app_id, item_id, field_id) {
+    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;
+        }
+      }
+    }
+
+    return fieldValue;
+  }
+
+  async setFieldValue(app_id, item_id, field_id, field_value) {
+    if (!app_id || !item_id || !field_id) {
+      return;
+    }
+    await this.setFieldValueApi(app_id, item_id, field_id, field_value);
+    this.updateFieldValue(app_id, item_id, field_id, field_value);
+  }
+}

package/GUDHUB/Processors/FieldProcessor/FieldProcessor.test.js

@@ -0,0 +1,16 @@
+import should from "should";
+import {GudHub} from './../../gudhub.js';
+
+describe("FIELD PROCESSOR", async function() {
+    const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
+    const gudhub = new GudHub(auth_key);
+
+
+    it("GET FIELD / should return a field model", async function () {
+        var fieldModel = await gudhub.getField(16259, 254055);
+        fieldModel.data_type.should.equal('text');
+        (typeof fieldModel).should.equal('object');
+    })
+
+    
+});

package/GUDHUB/Processors/FieldProcessor/Untitled-1.json

@@ -0,0 +1,17 @@
+{
+    "field_id": 505247,
+    "data_type": "image",
+    "name_space": "thumbnail",
+    "field_priority": 0,
+    "field_name": "Thumbnail",
+    "data_model": {
+        "show_field_name": true,
+        "image_preview_selected_size": 128,
+        "display_mode": "single",
+        "image_editor": false,
+        "compress": false,
+        "quality": "1",
+        "table_display_mode": "image",
+        "interpretation": []
+    }
+}

package/GUDHUB/Processors/FieldProcessor/field_processor.md

@@ -0,0 +1,85 @@
+# Field Processor
+
+Field processor is responcible for receiving, updating fields models. Also with field processor you can get and update field values.
+
+## getField(app_id, field_id)
+
+Method Returns field model from specific App.
+
+```js
+import {GudHub} from '@gudhub/gudhub';
+const gudhub = new GudHub(authkey);
+gudhub.getField(app_id, field_id, fieldToCompare);
+```
+
+Argument Name|Type|Description
+------------ | ------------- | -------------
+*app_id* | `number` | Application ID where we want to get the field model
+*field_id* | `number` | field ID that we want to receive
+
+The Method returns field model:
+
+```json
+{
+    "field_id": 505247,
+    "data_type": "image",
+    "name_space": "thumbnail",
+    "field_priority": 0,
+    "field_name": "Thumbnail",
+    "data_model": {
+        "show_field_name": true,
+        "display_mode": "single",
+        "image_editor": false,
+        "compress": false,
+        "quality": "1",
+        "table_display_mode": "image",
+        "interpretation": []
+    }
+}
+```
+
+## updateField(app_id, fieldModel)
+
+With this method you can update field model of specific App
+
+```js
+import {GudHub} from '@gudhub/gudhub';
+const gudhub = new GudHub(authkey);
+gudhub.updateField(app_id, fieldModel);
+```
+
+Argument Name|Type|Description
+------------ | ------------- | -------------
+*app_id* | `number` | Application ID where we want to update the field model
+*fieldModel* | `json` | field model object in json format that you want to update.
+
+The Method returns updated field model:
+
+```json
+{
+    "field_id": 505247,
+    "data_type": "image",
+    "name_space": "thumbnail",
+    "field_priority": 0,
+    "field_name": "Thumbnail",
+    "data_model": {
+        "show_field_name": true,
+        "display_mode": "single",
+        "image_editor": false,
+        "compress": false,
+        "quality": "1",
+        "table_display_mode": "image",
+        "interpretation": []
+    }
+}
+```
+
+## deleteField(app_id, field_id)
+
+## getFieldModels(app_id)
+
+## getFieldValue(app_id, item_id, field_id)
+
+## getInterpretedValue(app_id, item_id, field_id)
+
+## setFieldValue(app_id, item_id, field_id, field_value)

package/GUDHUB/Processors/ItemProcessor/ItemProcessor.js

@@ -0,0 +1,247 @@
+import { filterFields } from "../../utils.js";
+
+export class ItemProcessor {
+  constructor(storage, pipeService, req, appProcessor, util) {
+    this.storage = storage;
+    this.pipeService = pipeService;
+    this.req = req;
+    this.appProcessor = appProcessor;
+    this.util = util;
+    this.itemListeners();
+  }
+
+  async addItemsApi(app_id, itemsList) {
+    try {
+      const response = await this.req.post({
+        url: "/api/items/add",
+        form: { items: JSON.stringify(itemsList), app_id },
+      });
+      return response;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  async updateItemsApi(app_id, itemsList) {
+    try {
+      const response = await this.req.post({
+        url: "/api/items/update",
+        form: { items: JSON.stringify(itemsList), app_id },
+      });
+      return response;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  deleteItemsApi(items_ids) {
+    try {
+      const response = this.req.post({
+        url: "/api/items/delete",
+        form: { items_ids: JSON.stringify(items_ids)},
+      });
+      response.from_apps_list = true;
+      return response;
+    } catch (err) {
+      console.log(err);
+      return null;
+    }
+  }
+
+  addItemsToStorage(app_id, items) {
+    const app = this.storage.getApp(app_id);
+    if (app) {
+      items.forEach((item) => {
+        app.items_list.push(item);
+        this.pipeService.emit("gh_item_update", { app_id }, [item]);
+      });
+      this.pipeService.emit("gh_items_update", { app_id }, app.items_list);
+      this.storage.updateApp(app);
+    }
+    return app;
+  }
+
+  updateItemsInStorage(app_id, items) {
+    this.pipeService.emit("gh_items_update", { app_id }, items);
+    //-- getting app from storage
+    const app = this.storage.getApp(app_id);
+    if (app && items) {
+      items.forEach((item) => {
+        const addressToEmit = { app_id };
+        this.pipeService.emit("gh_item_update", addressToEmit, [item]);
+        addressToEmit.item_id = item.item_id;
+        this.pipeService.emit("gh_item_update", addressToEmit, item);
+        //-- Looking for updated item in the main storage according to 'item_id'
+        const fundedItem = app.items_list.find(
+          (storageItem) => storageItem.item_id == item.item_id
+        );
+        if (fundedItem) {
+          //-- Updating value in existing fields
+          item.fields.forEach((field) => {
+            const fundedField = fundedItem.fields.find(
+              (storageField) => storageField.field_id == field.field_id
+            );
+            addressToEmit.field_id = field.field_id;
+            if (fundedField) {
+              //-- Checking if value of existing fields were updated, because we are not sending updates if value didn't changed
+              if (fundedField.field_value != field.field_value) {
+                fundedField.field_value = field.field_value;
+                this.pipeService.emit(
+                  "gh_value_update",
+                  addressToEmit,
+                  field.field_value
+                );
+              }
+            } else {
+              //-- Pushing new fields to the storage (it's when user enters new value)
+              fundedItem.fields.push(field);
+              this.pipeService.emit(
+                "gh_value_update",
+                addressToEmit,
+                field.field_value
+              );
+            }
+          });
+        }
+      });
+    }
+    return items;
+  }
+
+  deleteItemsFromStorage(app_id, itemsForDelete = []) {
+    const app = this.storage.getApp(app_id);
+    if (app) {
+      app.items_list = app.items_list.filter(
+        (item) => !itemsForDelete.includes(item.item_id)
+      );
+      this.pipeService.emit("gh_items_update", { app_id }, app.items_list);
+      this.storage.updateApp(app);
+    }
+  }
+
+  async getItems(app_id, trash = false) {
+    const app = await this.appProcessor.getApp(app_id)
+    if(!app) return null;
+    return trash ? app.items_list : app.items_list.filter(item => !item.trash);
+  }
+
+  async addNewItems(app_id, itemsList) {
+    const preparedItemsList = itemsList.map((item) => ({
+      ...item,
+      fields: filterFields(item.fields),
+    }));
+    const newItems = await this.addItemsApi(app_id, preparedItemsList);
+    this.addItemsToStorage(app_id, newItems);
+    this.pipeService.emit("gh_items_add", { app_id }, newItems);
+    return newItems;
+  }
+
+  async updateItems(app_id, itemsList) {
+    const preparedItemsList = itemsList.map((item) => ({
+      ...item,
+      fields: filterFields(item.fields),
+    }));
+    const updatedItems = await this.updateItemsApi(app_id, preparedItemsList);
+    return this.updateItemsInStorage(app_id, updatedItems);
+  }
+
+  async deleteItems(app_id, itemsIds) {
+    return this.deleteItemsApi(itemsIds).then(() =>
+      this.deleteItemsFromStorage(app_id, itemsIds)
+    );
+  }
+
+  itemListeners() {
+    this.pipeService.onRoot("gh_items_get", {}, async (event, data) => {
+      if(data && data.app_id) {
+        const items = await this.getItems(data.app_id);
+        if (items) {
+          this.pipeService.emit("gh_items_get", data, items);
+        } else {
+          this.pipeService.emit("gh_items_get", data, []);
+        }
+      }
+    });
+
+    this.pipeService.onRoot("gh_items_add", {}, async (event, data) => {
+      if(data && data.app_id && data.items) {
+        const items = await this.addNewItems(data.app_id, data.items);
+        if (items) {
+          this.pipeService.emit("gh_items_add", data, items);
+        } else {
+          this.pipeService.emit("gh_items_add", data, []);
+        }
+      }
+    });
+
+    this.pipeService.onRoot("gh_items_update", {}, async (event, data) => {
+      if(data && data.app_id && data.items) {
+        const items = await this.updateItems(data.app_id, data.items);
+        if (items) {
+          this.pipeService.emit("gh_items_update", data, items);
+        } else {
+          this.pipeService.emit("gh_items_update", data, []);
+        }
+      }
+    });
+
+    /* ---- FIELD VALUE GET LISTENING ---- */
+    this.pipeService.onRoot("gh_item_get", {}, async (event, data) => {
+      if(data && data.app_id){
+        const items = await this.getItems(data.app_id);
+        const item = items.find((item) => item.item_id == data.item_id);
+        this.pipeService.emit("gh_item_get", data, item);
+      }
+    });
+
+    // GETTING FILTERED ITEM
+    /* data = {
+                                      app_id: current appId,
+                                      element_app_id: for reference appId,
+                                      itemsId: current itemId,
+                                      filters_list: filters list,
+                                      field_groupe ?: field group,
+                                      search?: search value,
+                                    }
+                                 */
+    this.pipeService.onRoot(
+      "gh_filtered_items_get",
+      {},
+
+      async (event, data) => {
+        if(data && data.element_app_id) {
+          const items = await this.getItems(data.element_app_id);
+          const filteredItems = await this.util.getFilteredItems(
+            items,
+            data.filters_list,
+            data.element_app_id,
+            data.app_id,
+            data.item_id,
+            data.field_groupe,
+            data.search,
+            data.search_params
+          );
+          this.pipeService.emit("gh_filtered_items_get", data, filteredItems);
+        }
+      }
+    );
+
+    this.pipeService.onRoot("gh_filter_items", {}, async (event, data) => {
+      if(data && data.items) {
+        const filteredItems = await this.util.getFilteredItems(
+          data.items,
+          data.filters_list,
+          data.element_app_id,
+          data.app_id,
+          data.item_id,
+          data.field_groupe,
+          data.search,
+          data.search_params
+        );
+        this.pipeService.emit("gh_filter_items", data, filteredItems);
+      }
+    });
+  }
+}

package/GUDHUB/Processors/ItemProcessor/item_processor.md

@@ -0,0 +1,50 @@
+# Item Processor
+
+Item Processor is responcible for creating, receiving, updating and deleting items. Please note that you can not delete items from an appliucation. When you delete the items they just murked as deleted. 
+
+## getItems(app_id, trash)
+
+Method Returns items from the app
+
+```js
+import {GudHub} from '@gudhub/gudhub';
+const gudhub = new GudHub(authkey);
+gudhub.getItems(app_id, false);
+```
+
+Argument Name|Type|Description
+------------ | ------------- | -------------
+*app_id* | `number` | Application ID where we want to get the field model
+*trash* | `boolean` | If it's true then it returns deleted items only
+
+The Method returns items:
+
+
+```json
+[
+    {   
+        index_number: 1,
+        item_id: 137,
+        last_update: 16777296000,
+        fields: [
+            {field_id: 199, element_id: 199, field_value: "John", data_id: 580},
+            {field_id: 199, element_id: 199, field_value: "Dow", data_id: 580}
+        ]
+    },
+    {
+        index_number: 2,
+        item_id: 140,
+        last_update: 16777312000,
+        fields: [
+            {field_id: 199, element_id: 199, field_value: "Michael", data_id: 580},
+            {field_id: 199, element_id: 199, field_value: "Jeckson", data_id: 580}
+        ]
+    }
+]
+```
+
+## addNewItems(app_id, itemsList)
+
+## updateItems(app_id, itemsList)
+
+## deleteItems(app_id, itemsIds)

package/GUDHUB/Processors/processors.js

@@ -0,0 +1,5 @@
+import { AppProcessor } from "./AppProcessor/AppProcessor.js";
+import { ItemProcessor } from "./ItemProcessor/ItemProcessor.js";
+import { FieldProcessor } from "./FieldProcessor/FieldProcessor.js";
+
+export { AppProcessor, ItemProcessor, FieldProcessor };