@izara_project/izara-market-library-service-schemas 1.0.4 → 1.0.6

package/src/TemplateManager/src/FindData/mainFunction/data.js

@@ -0,0 +1,279 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+'use strict';
+
+const path = require('path');
+
+const { SOURCE_PATH, FUNCTION_NAME } = require("../../libs/Consts");
+const { firstLetterUpperCase: upperCase } = require("../../../../MainLibs/src/Utils")
+
+const serviceSchemas = require('@izara_project/izara-core-library-service-schemas');
+const STORAGE_TYPES = serviceSchemas.consts.STORAGE_TYPES;
+const getObjectSchemas = serviceSchemas.getObjectSchema;
+const { getUsedFieldNamesOfIdentifiers } = serviceSchemas.utils;
+
+const templatePath = path.join(__dirname, "./template.ejs")
+const getByDynamoTemplate = path.join(__dirname, "../GetByStorage/getByDynamo.ejs")
+const getByGraphTemplate = path.join(__dirname, "../GetByStorage/getByGraph.ejs")
+
+const NoRetryError = require("@izara_project/izara-core-library-core/src/NoRetryError");
+
+/**
+ * receive objectSchema
+ * create data for FindDataMain template
+ *
+ * @param {Object} objectSchema
+ * @return {{ templatePath, templateData, setting } }
+ */
+
+async function data(_izContext, srcPath) {
+
+  let datas = [];
+
+  // 1. get objectTypes for check objType param
+  let getObjectTypes = await getObjectSchemas.getAllLocalObjectSchemas(_izContext, srcPath);
+  // console.log(("getObjectTypes: ", getObjectTypes.fieldLookup)
+
+  for (const objectType of Object.keys(getObjectTypes.fieldLookup)) {
+    // console.log(("objectType: ", objectType)
+
+    // 2. get local object schema
+    let objectSchemaRecord = await getObjectSchemas.getLocalObjectSchemasWithHierarchy(
+      _izContext,
+      objectType,
+      srcPath
+    );
+    // console.log(("objectSchemaRecord: ", objectSchemaRecord)
+
+    let objectSchema = objectSchemaRecord.records[0];
+    // console.log(("objectSchema: ", objectSchema)
+
+    const identifiersNames = getUsedFieldNamesOfIdentifiers(_izContext, objectSchema.identifiers);
+    _izContext.logger.debug("identifiersNames: ", identifiersNames);
+
+    let storageResources = objectSchema.storageResources;
+    let fieldNames = objectSchema.fieldNames; // object
+    let fieldNameDatas = [];
+
+    // loop for each main fieldNames
+    Object.entries(fieldNames).map(([field, schemas]) => {
+      // console.log(("field: ", field)
+      // console.log(("schemas: ", schemas)
+
+      let getInIdentifiers = false;
+
+      for (const identifierName of identifiersNames) {
+        if (field === identifierName) {
+          getInIdentifiers = true;
+        }
+      }
+
+      //* set field as key of object
+      //* use schemas for find storageType, graphServiceTag, tableName
+
+      // check type (use only string and number)
+      if (schemas.type === "string" || schemas.type === "number") {
+
+        let collectStorageDetail = {};
+        let storageResourceTags = schemas.storageResourceTags; // array
+
+        for (const storageResourceTag of storageResourceTags) {
+          // console.log(("storageResources: ", storageResources)
+
+          Object.entries(storageResources).map(([storageTag, storageDetail]) => {
+
+            if (storageResourceTag === storageTag) {
+              // console.log(("storageTag: ", storageTag)
+              // console.log(("storageDetail: ", storageDetail)
+
+              if (storageDetail.storageType === STORAGE_TYPES.graph) {
+
+                if (collectStorageDetail.hasOwnProperty(STORAGE_TYPES.graph)) {
+                  // console.log(("collectStorageDetail already have graph storageType")
+                } else {
+                  Object.assign(collectStorageDetail,
+                    {
+                      [storageDetail.storageType]: {
+                        graphServerTag: storageDetail.graphServerTag,
+                        getInIdentifiers: getInIdentifiers
+                      }
+                    })
+                }
+
+              } else if (storageDetail.storageType === STORAGE_TYPES.dynamoDB) {
+
+                if (collectStorageDetail.hasOwnProperty(STORAGE_TYPES.dynamoDB)) {
+                  // console.log(("collectStorageDetail already have dynamoDB storageType")
+                } else {
+                  Object.assign(collectStorageDetail,
+                    {
+                      [storageDetail.storageType]: {
+                        tableName: storageDetail.tableName
+                      }
+                    }
+                  )
+                }
+              }
+            }
+          })
+        }
+
+        // console.log(("collectStorageDetail: ", collectStorageDetail)
+
+        //* Q: chooooooose get data from dynamoDB or graph if this fieldName have both of dynamoDB and graph storageTypes ???
+        //* A: choose dynamoDB
+        // collectStorageDetail: {
+        //   graph: { graphServerTag: 'GraphHandler' },
+        //   dynamoDB: { tableName: 'NotificationHello' }
+        // }
+        if (collectStorageDetail.hasOwnProperty(STORAGE_TYPES.graph) && collectStorageDetail.hasOwnProperty(STORAGE_TYPES.dynamoDB)) {
+          delete collectStorageDetail[STORAGE_TYPES.graph];
+          // console.log(("collectStorageDetail after delete graph: ", collectStorageDetail)
+        }
+
+        fieldNameDatas.push({ [field]: collectStorageDetail })
+        // console.log(("fieldNameDatasMain: ", fieldNameDatas)
+      }
+    })
+
+    // fieldName in versionedData
+    if (objectSchema.hasOwnProperty("addOnDataStructure")) { // array
+      // console.log(("objectSchemas have addOnDataStructure: ", objectSchema.addOnDataStructure)
+
+      for (const versionedData of objectSchema.addOnDataStructure) { // object // loop versionedData
+        // console.log("versionedData: ", versionedData)
+
+        let versionedStorageDetail = {};
+        let versioendStorageResourceTag = versionedData.storageResourceTag;
+        let versionedFieldNames = versionedData.fieldNames; // array
+
+        Object.entries(storageResources).map(([storageTag, storageDetail]) => {
+
+          if (versioendStorageResourceTag === storageTag) {
+            if (storageDetail.storageType === STORAGE_TYPES.graph) {
+              versionedStorageDetail = {
+                [storageDetail.storageType]: {
+                  graphServerTag: storageDetail.graphServerTag,
+                  versionedDataLabel: versionedData.versionedDataLabel
+                }
+              }
+            } else {
+              throw new NoRetryError(`storageType of versionedData isn't graph`)
+            }
+          }
+        })
+        // console.log(("versionedStorageDetail: ", versionedStorageDetail)
+
+        for (const versionedFieldName of versionedFieldNames) { // object // loop versionedFieldNames
+
+          if (versionedFieldName.type === "string" || versionedFieldName.type === "number") {
+            fieldNameDatas.push({ [versionedFieldName.fieldName]: versionedStorageDetail })
+          }
+
+        } // end loop versionedFieldNames
+
+      } // end loop versionedData
+      //fieldNameDatas.push(collectVersionedFieldNames)
+
+    }
+    // console.log(("fieldNameDatas: ", fieldNameDatas)
+
+    let fieldNameDatasPerObjectType = {
+      objectType: objectType,
+      fieldNames: fieldNameDatas
+    };
+    // console.log(("fieldNameDatasPerObjectType: ", fieldNameDatasPerObjectType)
+
+    datas.push(fieldNameDatasPerObjectType)
+  } // end loop objectType
+
+  // console.log(("datas: ", datas)
+
+  // fieldNameDatas:  [
+  //   { notificationId: { graph: [Object], dynamoDB: [Object] } },
+  //   { notificationIdHello: { dynamoDB: {tableName: "NotificationHello"}} },
+  //   { notificationName: { graph: {graphServerTag: 'GraphHandler', versionedDataLabel: 'notificationSettings' }},
+  //   { notificationNameeeeeeeeeee: { graph: {graphServerTag: 'GraphHandler', versionedDataLabel: 'notificationSettingssssssssss'}}
+  // ]
+
+  // fieldNameDatasPerObjectType:  {
+  //   objectType: 'notification',
+  //   fieldNames: [
+  //     { notificationId: [Object] },
+  //     { notificationIdHello: [Object] },
+  //     { notificationName: [Object]},
+  //     { notificationNameeeeeeeeeee: [Object] }
+  //   ]
+  // }
+
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName: upperCase(FUNCTION_NAME.findData),
+      datas: datas,
+      getByDynamoTemplate: getByDynamoTemplate,
+      getByGraphTemplate: getByGraphTemplate,
+      storageDynamo: STORAGE_TYPES.dynamoDB,
+      storageTypeGraph: STORAGE_TYPES.graph,
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.findData),
+      saveFileName: `FindData_Main`,
+      fileExtension: '.js',
+      isAppend: false
+    }
+  }
+
+  // datas:  [
+  //   {
+  //     objectType: 'consolidated',
+  //     fieldNames: [ {notificationGroupId: [Object], time: [Object]}]
+  //   },
+  //   {
+  //     objectType: 'notificationGroup',
+  //     fieldNames: [
+  //       {notificationGroupId: [Object]},
+  //       {notificationGroupName: [Object]},
+  //       {consolidatedType: [Object]},
+  //       {consolidatedFrequency: [Object]},
+  //       {consolidatedNextSendDue: [Object]}
+  //     ]
+  //   },
+  //   {
+  //     objectType: 'notification',
+  //     fieldNames: [
+  //       {notificationId: [Object]},
+  //       {notificationIdHello: [Object]},
+  //       {notificationName: [Object]},
+  //       {notificationNameeeeeeeeeee: [Object]}
+  //     ]
+  //   },
+  //   {
+  //     objectType: 'notificationTrigger',
+  //     fieldNames: [
+  //       {notificationTriggerId: [Object]},
+  //       {propertyName: [Object]},
+  //       {valueType: [Object]},
+  //       {valueString: [Object]},
+  //       {valueNumber: [Object]}
+  //     ]
+  //   }
+  // ]
+}
+
+module.exports = data;

package/src/TemplateManager/src/FindData/mainFunction/template.ejs

@@ -0,0 +1,155 @@
+/*
+Copyright (C) 2020 Sven Mason <http://izara.io>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+'use strict';
+
+const izaraShared = require("@izara_project/izara-shared");
+const findDataSharedLib = izaraShared.findDataSharedLib;
+const graphSharedLib = izaraShared.graphSharedLib;
+const dynamodbSharedLib = izaraShared.dynamodbSharedLib;
+
+const serviceSchemas = require('@izara_project/izara-core-library-service-schemas');
+const serviceConfig = serviceSchemas.serviceConfig;
+const identifierObj = serviceSchemas.identifiersObject
+
+/**
+ * triggered from searchResult for each requiredData field per one identifiers
+ * @param {Object} _izContext
+ * @param {string} fieldName
+ * @param {Object} objType
+ * @param {Object} identifiers
+ * @param {Object} requestProperties
+ *
+ * @returns {object} description of return value
+ */
+
+exports.findData = async (
+  _izContext,
+  fieldName,
+  objType,
+  identifiers,
+  requestProperties,
+  callingFlow,
+  //(<additionalParams>)
+  //(</additionalParams>)
+) => {
+
+  try {
+
+    _izContext.logger.debug('----- findData event params -----', {
+      fieldName: fieldName,
+      objType: objType,
+      identifiers: identifiers,
+      requestProperties: requestProperties,
+      callingFlow: callingFlow
+    });
+
+    // removeAttributes on expired
+    let removeAttributes = [];
+    //(<removeAttributes>)
+    //(</removeAttributes>)
+
+    // Check/create FindDataMain status
+    let [findDataMainStatus, findDataId, findDataMain] = await findDataSharedLib.checkFindDataMainStatus(
+      _izContext,
+      fieldName,
+      objType,
+      identifiers,
+      requestProperties,
+      callingFlow,
+      removeAttributes
+    );
+    _izContext.logger.debug("result after checkFindDataMainStatus is", {
+      findDataMainStatus: findDataMainStatus,
+      findDataId: findDataId,
+      findDataMain: findDataMain
+    })
+
+    if (findDataMainStatus != "process") {
+      _izContext.logger.debug(`findDataMainStatus status isn't process :${findDataMainStatus}`)
+      return; // stop process
+    };
+
+    let identifiersObject = await identifierObj.concatIdentifiersObjectFromIdentifiersObject(
+      _izContext,
+      objType,
+      identifiers
+    );
+    _izContext.logger.debug("create identifiersObject from identifiers: ", identifiersObject) // object
+
+    let errorsFound = [];
+
+    let standardErrorParams = [
+      _izContext,
+      fieldName,
+      objType,
+      identifiers,
+      requestProperties,
+      null,
+      "error"
+    ];
+
+  <% for (let idx = 0; idx < datas.length; idx++) { _%>
+    <% let objectType = datas[idx].objectType _%>
+    if (objType.objectType === <%- JSON.stringify(objectType) %>) {
+      _izContext.logger.debug("objectType: ", objType.objectType)
+
+      <% let fieldNames = datas[idx].fieldNames _%>
+      <% for (let idx = 0; idx < fieldNames.length; idx++) { _%>
+        <% let fieldName = Object.keys(fieldNames[idx])[0] _%>
+        <% let storageDetails = (Object.values(fieldNames[idx])[0]) _%>
+        if (fieldName == <%- JSON.stringify(fieldName) %>) {
+          _izContext.logger.debug("fieldName: ", fieldName)
+
+          <% Object.entries(storageDetails).map(([storage, details]) => { _%>
+            <% let versionedDataLabel = [] _%>
+            <% if (storage === storageTypeGraph && details.hasOwnProperty("versionedDataLabel")){ versionedDataLabel.push(details.versionedDataLabel) } _%>
+            <% if (storage === storageDynamo){ %><%- include(getByDynamoTemplate, {tableName: details.tableName, fieldName: fieldName, objectType: objectType}) %><% } _%>
+            <% if (storage === storageTypeGraph){ %><%- include(getByGraphTemplate, {graphServerTag: details.graphServerTag, versionedDataLabel: versionedDataLabel, fieldName: fieldName, objectType: objectType, getInIdentifiers: details.getInIdentifiers}) %><% } _%>
+          <% }) _%>
+        }<% if (idx + 1 == fieldNames.length) { %>
+        <%- createAdditionalFieldNamesTag(objectType) %>
+        <% } _%>
+          else <% } _%> {
+          errorsFound.push("unrecognised fieldName")
+          standardErrorParams.push(errorsFound)
+          await findDataSharedLib.completeFindDataMain(...standardErrorParams);
+          return;
+        }
+    } <% if (idx + 1 == datas.length) { %>
+      //(<addtionalObjectType>)
+      //(</addtionalObjectType>)
+      <% } _%>
+      else<% } %> {
+      errorsFound.push("unrecognised objectType")
+      standardErrorParams.push(errorsFound)
+      await findDataSharedLib.completeFindDataMain(...standardErrorParams);
+      return;
+    }
+
+    return "Function FindData Finish";
+
+  } catch (err) {
+    _izContext.logger.error('error FindDataMain: ', err)
+    throw (err)
+  }
+}
+
+<%_ function createAdditionalFieldNamesTag(objectType) {
+  return `//(<additional${objectType}FieldNames>)
+          //(</additional${objectType}FieldNames>)`
+} _%>

package/src/TemplateManager/src/GenerateCode(Old).js

@@ -81,7 +81,7 @@ async function generateCodeWithTemplate(_izContext, objSchemaPath) {
 
       // create main resource per relationshipSchema
       const createSourceMainResourcesRelSchema = mainResources.createSourceDataRelSchema(_izContext, { [relTag]: relTagData }, saveFilePath);
-      console.log("createSourceMainResourcesRelSchema: ", createSourceMainResourcesRelSchema);
+      // console.log("createSourceMainResourcesRelSchema: ", createSourceMainResourcesRelSchema);
 
       createSourceParams = createSourceParams.concat(createSourceMainResourcesRelSchema);
     }