@sankhyalabs/sankhyablocks 1.0.10 → 1.1.13

package/dist/collection/collection-manifest.json

@@ -0,0 +1,12 @@
+{
+  "entries": [
+    "./components/snk-application/snk-application.js"
+  ],
+  "compiler": {
+    "name": "@stencil/core",
+    "version": "2.15.2",
+    "typescriptVersion": "4.5.4"
+  },
+  "collections": [],
+  "bundles": []
+}

package/dist/collection/components/snk-application/snk-application.css

@@ -0,0 +1,5 @@
+:host {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+}

package/dist/collection/components/snk-application/snk-application.js

@@ -0,0 +1,450 @@
+import { Component, h, Method, Event } from "@stencil/core";
+import DataUnitFetcher from "../../lib/http/data-fetcher/fetchers/dataunit-fetcher";
+import UrlUtils from "../../lib/utils/urlutils";
+import Workspace from "../../lib/workspace/workspace";
+import ParametersFetcher from "../../lib/http/data-fetcher/fetchers/parameters-fecher";
+//FIXME: temporariamente estamos compiando essa classe do ezui pois não conseguimos
+//incluída no pacote. Isso deve ser resolvido nas proximas entregas e então ajustado aqui
+import ApplicationUtils from "../../temp/ApplicationUtils";
+export class SnkApplication {
+  get parameters() {
+    if (!this._parameters) {
+      this._parameters = new ParametersFetcher();
+    }
+    return this._parameters;
+  }
+  get resourceID() {
+    if (!this._resourceID) {
+      this._resourceID = this.urlParams.get("workspaceResourceID") ||
+        this.urlParams.get("resourceID") ||
+        Workspace.resourceID ||
+        "unknown.resource.id";
+    }
+    return this._resourceID;
+  }
+  async getStringParam(name) {
+    return this.parameters.asString(name, this.resourceID);
+  }
+  async getIntParam(name) {
+    return this.parameters.asInteger(name, this.resourceID);
+  }
+  async getFloatParam(name) {
+    return this.parameters.asFloat(name, this.resourceID);
+  }
+  async getBooleanParam(name) {
+    return this.parameters.asBoolean(name, this.resourceID);
+  }
+  async getDateParam(name) {
+    return this.parameters.asDate(name, this.resourceID);
+  }
+  async temOpcional(opcional) {
+    const opts = opcional.split(",");
+    return new Promise((resolve, reject) => {
+      this.getAttributeFromHTMLWrapper("opc0009")
+        .then(value => {
+        if (value === "1") {
+          resolve(true);
+        }
+        else {
+          Promise.all(opts.map(opt => this.getAttributeFromHTMLWrapper("opc" + opt)))
+            .then(result => {
+            resolve(result.includes("1"));
+          })
+            .catch(error => {
+            reject(error);
+          });
+        }
+      })
+        .catch(error => {
+        reject(error);
+      });
+    });
+  }
+  async getAttributeFromHTMLWrapper(attribName) {
+    return Promise.resolve(window[attribName]);
+  }
+  async openApp(resourceId, pkObject) {
+    Workspace.openAppActivity(resourceId, pkObject);
+  }
+  async createDataunit(entityName) {
+    return new Promise(resolve => {
+      const dataUnit = this.dataUnitFetcher.getDataUnit(entityName, this.resourceID);
+      dataUnit.loadMetadata();
+      resolve(dataUnit);
+    });
+  }
+  async getResourceID() {
+    return Promise.resolve(this.resourceID);
+  }
+  alert(title, message, icon) {
+    return ApplicationUtils.alert(title, message, icon);
+  }
+  error(title, message, icon) {
+    return ApplicationUtils.error(title, message, icon);
+  }
+  confirm(title, message, icon, critical) {
+    return ApplicationUtils.confirm(title, message, icon, critical);
+  }
+  info(message) {
+    return ApplicationUtils.info(message);
+  }
+  get urlParams() {
+    if (!this._urlParams) {
+      this._urlParams = UrlUtils.getQueryParams(location.search);
+    }
+    return this._urlParams;
+  }
+  get dataUnitFetcher() {
+    if (!this._dataUnitFetcher) {
+      this._dataUnitFetcher = new DataUnitFetcher();
+    }
+    return this._dataUnitFetcher;
+  }
+  componentDidLoad() {
+    this.applicationLoading.emit(true);
+    window.requestAnimationFrame(() => {
+      this.applicationLoaded.emit(true);
+    });
+  }
+  render() {
+    return (h("div", null));
+  }
+  static get is() { return "snk-application"; }
+  static get encapsulation() { return "scoped"; }
+  static get originalStyleUrls() { return {
+    "$": ["snk-application.css"]
+  }; }
+  static get styleUrls() { return {
+    "$": ["snk-application.css"]
+  }; }
+  static get events() { return [{
+      "method": "applicationLoaded",
+      "name": "applicationLoaded",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "Evento disparado quando a aplica\u00E7\u00E3o for carregada."
+      },
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      }
+    }, {
+      "method": "applicationLoading",
+      "name": "applicationLoading",
+      "bubbles": true,
+      "cancelable": true,
+      "composed": true,
+      "docs": {
+        "tags": [],
+        "text": "Evento"
+      },
+      "complexType": {
+        "original": "boolean",
+        "resolved": "boolean",
+        "references": {}
+      }
+    }]; }
+  static get methods() { return {
+    "getStringParam": {
+      "complexType": {
+        "signature": "(name: string) => Promise<string>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<string>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "getIntParam": {
+      "complexType": {
+        "signature": "(name: string) => Promise<number>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<number>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "getFloatParam": {
+      "complexType": {
+        "signature": "(name: string) => Promise<number>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<number>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "getBooleanParam": {
+      "complexType": {
+        "signature": "(name: string) => Promise<boolean>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<boolean>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "getDateParam": {
+      "complexType": {
+        "signature": "(name: string) => Promise<Date>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "Date": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<Date>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "temOpcional": {
+      "complexType": {
+        "signature": "(opcional: string) => Promise<boolean>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<boolean>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "getAttributeFromHTMLWrapper": {
+      "complexType": {
+        "signature": "(attribName: string) => Promise<string>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<string>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "openApp": {
+      "complexType": {
+        "signature": "(resourceId: string, pkObject: Object) => Promise<void>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }, {
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "Object": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<void>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "createDataunit": {
+      "complexType": {
+        "signature": "(entityName: string) => Promise<DataUnit>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          },
+          "DataUnit": {
+            "location": "import",
+            "path": "@sankhyalabs/core"
+          }
+        },
+        "return": "Promise<DataUnit>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "getResourceID": {
+      "complexType": {
+        "signature": "() => Promise<string>",
+        "parameters": [],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<string>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "alert": {
+      "complexType": {
+        "signature": "(title: string, message: string, icon?: string) => Promise<boolean>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }, {
+            "tags": [],
+            "text": ""
+          }, {
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<boolean>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "error": {
+      "complexType": {
+        "signature": "(title: string, message: string, icon?: string) => Promise<boolean>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }, {
+            "tags": [],
+            "text": ""
+          }, {
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<boolean>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "confirm": {
+      "complexType": {
+        "signature": "(title: string, message: string, icon?: string, critical?: boolean) => Promise<boolean>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }, {
+            "tags": [],
+            "text": ""
+          }, {
+            "tags": [],
+            "text": ""
+          }, {
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<boolean>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    },
+    "info": {
+      "complexType": {
+        "signature": "(message: string) => Promise<void>",
+        "parameters": [{
+            "tags": [],
+            "text": ""
+          }],
+        "references": {
+          "Promise": {
+            "location": "global"
+          }
+        },
+        "return": "Promise<void>"
+      },
+      "docs": {
+        "text": "",
+        "tags": []
+      }
+    }
+  }; }
+}

package/dist/collection/index.js

@@ -0,0 +1 @@
+export {};

package/dist/collection/lib/http/data-fetcher/DataFetcher.js

@@ -0,0 +1,158 @@
+import { batchRequests } from 'graphql-request';
+export class HttpFetcher {
+  constructor() {
+    this.watingRequestsById = new Map();
+  }
+  static get() {
+    if (!HttpFetcher.instance) {
+      HttpFetcher.instance = new HttpFetcher();
+      const application = document.querySelector(this.appTagName);
+      if (application === null) {
+        HttpFetcher.instance.resume();
+      }
+      else {
+        application.addEventListener('applicationLoading', () => HttpFetcher.instance.pause());
+        application.addEventListener('applicationLoaded', () => HttpFetcher.instance.resume());
+      }
+    }
+    return this.instance;
+  }
+  async callGraphQL(req) {
+    var _a;
+    const reqKey = this.getReqKey(req);
+    req.queryID = reqKey;
+    req.values.queryID = reqKey;
+    if (this.ready) {
+      return new Promise(async (resolve, reject) => {
+        let query = this.getQueryTemplate(req);
+        const res = await this.fecthGrapql([{ document: query, variables: req.values }]);
+        if (res.errors.length > 0) {
+          reject(res);
+        }
+        else {
+          //resolve(res);
+          //FIXME: Precisamos trabalhar melhor a resposta, quem chamou 
+          //a API não pode ficar responsavel por desempacotar... fiz uma
+          //gambiarra aqui...
+          resolve(res.data[0][reqKey]);
+        }
+      });
+    }
+    else {
+      if (!this.watingRequestsById.has(reqKey)) {
+        this.watingRequestsById.set(reqKey, new WaitingRequest(req));
+      }
+      return (_a = this.getWatingRequest(reqKey)) === null || _a === void 0 ? void 0 : _a.promise;
+    }
+  }
+  getReqKey(req) {
+    return window.btoa(this.hashCode(`${req.query}${JSON.stringify(req.values || "")}`)).replace(/=/g, "");
+  }
+  getQueryTemplate(re) {
+    return (re.query || "").replaceAll("$queryAlias$", re.queryID);
+  }
+  getWatingRequest(reqID) {
+    return this.watingRequestsById.get(reqID);
+  }
+  pause() {
+    this.ready = false;
+  }
+  async resume() {
+    this.ready = true;
+    if (this.watingRequestsById.size > 0) {
+      const requestsBatch = [];
+      this.watingRequestsById.forEach(async (waitingReq) => {
+        let query = this.getQueryTemplate(waitingReq.request);
+        requestsBatch.push({ document: query, variables: Object.assign({}, waitingReq.request.values) });
+      });
+      let res = undefined;
+      let dataResponse = [];
+      let errorsResponse = [];
+      res = await this.fecthGrapql(requestsBatch);
+      dataResponse = res.data;
+      errorsResponse = res.errors;
+      //Reject promises with errors from query
+      errorsResponse.forEach((errorResponse) => {
+        Object.entries(errorResponse).forEach(([_key, val]) => {
+          var _a;
+          (((_a = this.getWatingRequest(val.request.variables[val.index].queryID)) === null || _a === void 0 ? void 0 : _a.reject) || Promise.reject)(val);
+        });
+      });
+      //Resolve promises with data from query
+      dataResponse.forEach((data) => {
+        Object.entries(data).forEach(([key, val]) => {
+          var _a;
+          (((_a = this.getWatingRequest(key)) === null || _a === void 0 ? void 0 : _a.resolve) || Promise.resolve)(val);
+        });
+      });
+      this.watingRequestsById.clear();
+    }
+  }
+  async fecthGrapql(request) {
+    let res = undefined;
+    let dataResponse = [];
+    let errorsResponse = [];
+    try {
+      res = await batchRequests('http://localhost:8082/', request);
+      res.forEach((resItem) => {
+        dataResponse.push(resItem.data);
+      });
+    }
+    catch (err) {
+      //TODO: Tratar erro quando não existir err.response
+      res = err.response;
+      const req = err.request;
+      Object.entries(res).forEach(([key, val]) => {
+        if (val.errors) {
+          errorsResponse.push(val.errors.map((item) => {
+            item.request = req;
+            item.index = Number(key);
+            return item;
+          }));
+        }
+        else if (val.data) {
+          dataResponse.push(val.data);
+        }
+      });
+    }
+    return { data: dataResponse, errors: errorsResponse };
+  }
+  //TODO: Mover este metodo para o @sankhyalabs/core classe string utils.
+  hashCode(txt) {
+    var hash = 0, i, chr;
+    if (txt.length === 0)
+      return hash.toString();
+    for (i = 0; i < txt.length; i++) {
+      chr = txt.charCodeAt(i);
+      hash = ((hash << 5) - hash) + chr;
+      hash |= 0; // Convert to 32bit integer
+    }
+    return hash.toString();
+  }
+  ;
+}
+HttpFetcher.appTagName = "snk-application";
+class WaitingRequest {
+  constructor(req) {
+    this._resolve = () => { };
+    this._reject = () => { };
+    this._request = undefined;
+    this._request = req;
+    this._promisse = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get resolve() {
+    return this._resolve;
+  }
+  get reject() {
+    return this._reject;
+  }
+  get promise() {
+    return this._promisse;
+  }
+  get request() {
+    return this._request;
+  }
+}

package/dist/collection/lib/http/data-fetcher/fetchers/application-config-fetcher.js

@@ -0,0 +1,23 @@
+import { gql } from "graphql-request";
+import { HttpFetcher } from "../DataFetcher";
+export default class ApplicationConfigFetcher {
+  constructor() {
+    this.templateByQuery = new Map();
+    this.buldTemplates();
+  }
+  buldTemplates() {
+    this.templateByQuery.set("getResource", gql `query($name: String!) {
+            $queryAlias$: getResource(name: $name){
+              name
+              resource
+            }
+        }`);
+  }
+  getResource(name, resourceID) {
+    const completPath = `cfg://app/${resourceID}/${name}`;
+    return HttpFetcher.get().callGraphQL({
+      values: { name: completPath },
+      query: this.templateByQuery.get("getResource"),
+    });
+  }
+}