@izara_project/izara-core-generate-service-code 1.0.1 → 1.0.2

package/src/TemplateData/EndpointPerService/mainFunction/update/template.ejs

@@ -0,0 +1,446 @@
+/*
+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 />.
+*/
+
+<<<<<<< HEAD
+
+=======
+<<<<<<< HEAD
+
+=======
+>>>>>>> 92addbe (Refactor JavaScript files for improved readability and consistency)
+>>>>>>> 50cbec7 (Refactor JavaScript files for improved readability and consistency)
+// ==================== Shared Core Utilities ====================
+import { objectHash as hash } from '@izara_project/izara-shared-core';
+import { consts as coreConsts } from '@izara_project/izara-core-library-core';
+
+// ==================== Core Service Schemas ====================
+import { getObjectSchema, consts, utils } from '@izara_project/izara-core-library-service-schemas';
+const { createObjType } = utils;
+
+
+// ==================== Market Service Schemas ====================
+import { generateCodeLibs, constsGenerateCodeLibs } from '@izara_project/izara-market-library-service-schemas'
+const {
+  dynamoDbIdentifiersByStorageResource,
+  createUpdateDataDetail,
+} = generateCodeLibs;
+
+const {
+  PREFIX,
+  TOPIC_NAME_GENERATE_CODE,
+  TOPIC_NAME_GRAPH_HANDLER,
+} = constsGenerateCodeLibs;
+
+
+// ==================== Shared Libraries ====================
+import dynamodbSharedLib from '@izara_project/izara-core-library-dynamodb';
+import snsSharedLib from '@izara_project/izara-core-library-sns';
+import asyncFlowSharedLib from '@izara_project/izara-core-library-asynchronous-flow';
+import callingFlowSharedLib from '@izara_project/izara-core-library-calling-flow';
+import lambdaSharedLib from '@izara_project/izara-core-library-lambda';
+
+
+// ==================== External Services ====================
+import { sns } from '@izara_project/izara-core-library-external-request';
+
+
+// ==================== Optional Requires ====================
+// (<optionalRequire>)
+// (</optionalRequire>)
+
+/**
+ *
+ *
+ * description of function.
+ * @param {Object} _izContext
+ * @param {CorrelationIds} _izContext.correlationIds - property of _izContext
+ * @param {Logger} _izContext.logger - property of _izContext
+ * @param {Object} requestParams - request params
+ * @param {Object} requestParams.identifiers - identifiers for get data
+ * @param {Object} requestParams.additionalRequest - additionalRequest
+ *
+ *
+ * @returns {object} description of return value
+ */
+
+export default async function updateMain(
+  _izContext,
+  requestParams,
+  //(<additionalParams>)
+  //(</additionalParams>)
+  callingFlowConfig = {},
+) {
+
+  try {
+    _izContext.logger.debug('function UpdateMain: ', {
+      requestParams,
+      callingFlowConfig
+    });
+
+    let returnSystemFieldsName = false;
+    let returnOldData = false;
+
+    if (requestParams.hasOwnProperty("additionalParams")) {
+      if (requestParams.additionalParams.hasOwnProperty("settings")) {
+        if (requestParams.additionalParams.settings.hasOwnProperty("returnSystemFieldsName") && requestParams.additionalParams.settings.returnSystemFieldsName === true) {
+          returnSystemFieldsName = true;
+        }
+        if (requestParams.additionalParams.settings.hasOwnProperty("returnOldData") && requestParams.additionalParams.settings.returnOldData === true) {
+          returnOldData = true;
+        }
+      };
+    };
+
+
+    let errorsFound = [];
+
+    const objType = createObjType(requestParams.objectType);
+
+    let objectSchema = await getObjectSchema.getObjSchemaS3WithHierarchy(
+      _izContext,
+      objType,
+    );
+    _izContext.logger.debug("objectSchema", objectSchema);
+
+    let userId;
+    let targetId;
+    if (objectSchema.generatedBy === "userGenerated") {
+      userId = _izContext.correlationIds.get(coreConsts.BASE_USER_ID);
+      targetId = _izContext.correlationIds.get(coreConsts.TARGET_ID)
+
+      if (!userId) {
+        errorsFound.push("Not have userId")
+      }
+
+      if (objectSchema.hasOwnProperty("belongTo") && !targetId) {
+        errorsFound.push('not have targetId')
+      }
+    }
+
+    //(<beforeQuery>)
+    //(</beforeQuery>)
+
+    const identifiers = requestParams.objInstanceFull.identifiers;
+    const fields = requestParams.objInstanceFull.fields
+    let versionedDataIds = requestParams.versionedDataIds || {}
+
+    _izContext.logger.debug("explode requestParams", {
+      identifiers: identifiers,
+      fields: fields,
+      versionedDataIds: versionedDataIds
+    })
+
+    let updateDataDetails = await createUpdateDataDetail(
+      _izContext,
+      objectSchema,
+    );
+
+    _izContext.logger.debug("updateDataDetails", updateDataDetails);
+
+    let originTimestamp = Date.now();
+
+    let haveVersionedDataIdsToUpdate = (requestParams.versionedDataIds && Object.keys(requestParams.versionedDataIds).length) ? true : false
+    if (haveVersionedDataIdsToUpdate) {
+
+      let updateMainNodeData = {};
+      let updateVersionedData = {};
+      _izContext.logger.debug("have versionedDataIds to update")
+      for (const fieldProp in requestParams.objInstanceFull.fields) {
+        const fieldSetting = objectSchema.fieldNames[fieldProp];
+        // collect updateData
+        if (fieldSetting.hasOwnProperty("versionedDataLabel")) {
+          if (!updateVersionedData.hasOwnProperty(fieldSetting.versionedDataLabel)) {
+            updateVersionedData[fieldSetting.versionedDataLabel] = {};
+          }
+          Object.assign(updateVersionedData[fieldSetting.versionedDataLabel], {
+            [fieldProp]: requestParams.objInstanceFull.fields[fieldProp]
+          })
+        } else {
+          Object.assign(updateMainNodeData, {
+            [fieldProp]: requestParams.objInstanceFull.fields[fieldProp]
+          })
+        }
+      }
+      _izContext.logger.debug("updateMainNodeData::", updateMainNodeData);
+      _izContext.logger.debug("updateVersionedData::", updateVersionedData);
+
+      const versionedDataIdLabelKeys = Object.keys(requestParams.versionedDataIds);
+      const updateVersionedDataLabelKeys = Object.keys(updateVersionedData);
+
+      _izContext.logger.debug("versionedDataIdLabelKeys:: ", versionedDataIdLabelKeys);
+      _izContext.logger.debug("updateVersionedDataLabelKeys:: ", updateVersionedDataLabelKeys);
+      //check missing versionedDataIds
+      const missingVersionedDataIdLabels = updateVersionedDataLabelKeys.filter(label => !versionedDataIdLabelKeys.includes(label));
+      _izContext.logger.debug("missingVersionedDataIdLabels:: ", missingVersionedDataIdLabels);
+
+      if (missingVersionedDataIdLabels.length) {
+        errorsFound.push(`missing versionedDataIds of versionedDataLabel '${missingVersionedDataIdLabels.join(", ")}'`)
+      }
+
+      // check missing update data of versionedDataLabels
+      const missingDataVersionedDataLabels = versionedDataIdLabelKeys.filter(label => !versionedDataIdLabelKeys.includes(label))
+      if (missingDataVersionedDataLabels.length) {
+        errorsFound.push(`missing data of versionedDataLabels '${missingDataVersionedDataLabels.join(", ")}'`);
+      }
+      // check mainNode Data should not exists
+      if (Object.keys(updateMainNodeData).length) {
+        errorsFound.push("cannot update mainNode if have versionedDataIds");
+      }
+    }
+
+    let messageAttributes
+
+    if (errorsFound.length) {
+      let updateNodeCompleteMessage = {
+        objType: objType,
+        objInstanceFull: {
+          identifiers: identifiers,
+          fields: fields,
+        },
+        versionedDataIds: versionedDataIds,
+        status: 'error',
+        errorsFound: errorsFound
+      };
+
+
+      updateNodeCompleteMessage = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, updateNodeCompleteMessage);
+      messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {})
+
+      let messageParams = {
+        Message: JSON.stringify(updateNodeCompleteMessage),
+        MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+        TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete),
+      };
+
+      _izContext.logger.debug("messageParams OutUpdateNodeComplete ::::::: ", messageParams);
+      await sns.publishAsync(_izContext, messageParams);
+
+      return updateNodeCompleteMessage
+    }
+
+    let awaitingStepIds = [];
+    let updateItem;
+
+    function createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, updateDataDetail) {
+      let fields = {};
+      for (let fieldName of Object.keys(requestParams.objInstanceFull.fields)) {
+        console.log("updateDataDetail[storageTag]", updateDataDetails[storageTag])
+        if ((updateDataDetails[storageTag].fieldNames.includes(fieldName)) &&
+          (updateDataDetail.fieldNames.includes(fieldName))) {
+          if (!identifiers.hasOwnProperty(fieldName)) {
+            if (!fields.hasOwnProperty(fieldName)) {
+              Object.assign(fields, {
+                [fieldName]: requestParams.objInstanceFull.fields[fieldName]
+              })
+            }
+          }
+        }
+      }
+      return fields
+    }
+
+    // start update data
+    await Promise.all(
+      Object.entries(updateDataDetails).map(
+        async ([storageTag, updateDataDetail]) => {
+          if (updateDataDetail.storageType === consts.STORAGE_TYPES.graph) {
+            // let graphServiceName = await getGraphServiceTagWithCache(_izContext, getDataDetail.graphServiceTag)
+
+            //(<beforeUpdateGraph>)
+            //(</beforeUpdateGraph>)
+
+            let updateNodeParams = {
+              objType: objType,
+              objInstanceFull: {
+                identifiers: identifiers,
+                fields: createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, updateDataDetail),
+              },
+              versionedDataIds: versionedDataIds,
+              originTimestamp,
+              settings: {
+                returnSystemFieldsName: returnSystemFieldsName,
+                returnOldData: returnOldData
+              }
+            }
+
+            if (Object.keys(updateNodeParams.objInstanceFull.fields).length === 0) {
+              return
+            } else {
+
+              awaitingStepIds.push( // createAwaitingStepId if updateGraph
+                asyncFlowSharedLib.createAwaitingStepId(
+                  hash({
+                    objectType: objType.objectType,
+                    serviceTag: objType.serviceTag,
+                    identifiers: identifiers,
+                    fields: fields,
+                    // correlationIds: _izContext.correlationIds.get("id")
+                  }),
+                  PREFIX.updateNode
+                ),
+                //(<additionalAttributes>)
+                //(</additionalAttributes>)
+              )
+              _izContext.logger.debug("awaitingStepIds", awaitingStepIds)
+
+              if (awaitingStepIds.length) {
+                let awaitingMultipleStep = await asyncFlowSharedLib.createAwaitingMultipleStepsWithAdditionalAttributes(
+                  _izContext,
+                  awaitingStepIds,
+                  asyncFlowSharedLib.createPendingStepId(
+                    hash(
+                      {
+                        identifiers,
+                        fields,
+                      })
+                  )
+                )
+                _izContext.logger.debug("awaitingMultipleStep", awaitingMultipleStep)
+              }
+
+              updateNodeParams = callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+                updateNodeParams,
+                callingFlowSharedLib.addParentCallingFlowConfig(
+                  callingFlowConfig,
+                  callingFlowSharedLib.createCallingFlowConfig(
+                    //(<callingFlowProperties>)
+                    await lambdaSharedLib.lambdaFunctionName(_izContext, TOPIC_NAME_GENERATE_CODE.updateNodeComplete), {}
+                    //(</callingFlowProperties>)
+                  )
+                )
+              )
+
+              _izContext.logger.debug("messageObject before send message:", updateNodeParams);
+
+
+              let updateNodeMessageBody = {
+                Message: JSON.stringify(updateNodeParams),
+                MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+                TopicArn: await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GRAPH_HANDLER.inUpdateNode, storageTag)
+              }
+
+              _izContext.logger.debug('request param before send to topic InUpdateNode:::', updateNodeMessageBody);
+
+              let resSNS = await sns.publishAsync(_izContext, updateNodeMessageBody)
+              _izContext.logger.debug('resSNS send to topic InUpdateNode finish!', resSNS);
+            }
+          } else if (updateDataDetail.storageType === consts.STORAGE_TYPES.dynamoDB) {
+
+            let identifiersForUpdateData = await dynamoDbIdentifiersByStorageResource(
+              _izContext,
+              objectSchema,
+              updateDataDetail,
+              identifiers
+            )
+
+            // let fieldForUpdateTableDynamo = createFieldForUpdateDynamoDb(_izContext, objectSchema, updateDataDetail, fields)
+
+            _izContext.logger.debug("identifiersForUpdateData", identifiersForUpdateData)
+            // _izContext.logger.debug("fieldForUpdateTableDynamo", fieldForUpdateTableDynamo)
+
+            //(<beforeUpdateDynamoDb>)
+            //(</beforeUpdateDynamoDb>)
+            let fields = createObjInstanceFullFieldsByStorageTag(_izContext, storageTag, updateDataDetail)
+            if (Object.keys(fields).length === 0) {
+              return
+            } else {
+              updateItem = await dynamodbSharedLib.updateItem(
+                _izContext,
+                await dynamodbSharedLib.tableName(_izContext, updateDataDetail.tableName, updateDataDetail.serviceTag),
+                identifiersForUpdateData,
+                fields,
+                {
+                  returnValues: "ALL_NEW"
+                }
+              )
+              _izContext.logger.debug("updateItem:", updateItem);
+            }
+          }
+        }
+      )
+    )
+
+    function createObjInstanceFullFromParams(object, requestParams) {
+      let objInstanceFull = {
+        identifiers: {},
+        fields: {}
+      }
+
+      for (const field in object) {
+        if (requestParams.objInstanceFull.identifiers.hasOwnProperty(field)) {
+          Object.assign(objInstanceFull.identifiers, {
+            [field]: requestParams.objInstanceFull.identifiers[field]
+          })
+        }
+
+        if (requestParams.objInstanceFull.fields.hasOwnProperty(field)) {
+          Object.assign(objInstanceFull.fields, {
+            [field]: requestParams.objInstanceFull.fields[field]
+          })
+        }
+      }
+
+      return objInstanceFull
+    }
+
+    if (awaitingStepIds.length === 0) {
+      let messageObject = {
+        objType: objType,
+        objInstanceFull: createObjInstanceFullFromParams(updateItem, requestParams)
+      }
+
+      //(<additionalProperties>)
+      //(</additionalProperties>)
+
+      if (callingFlowConfig[callingFlowSharedLib.consts.CALLINGFLOWPROPERTIES_PROPERTYNAME]) {
+        _izContext.logger.debug("HAVE CALLING FLOW");
+
+        messageObject = callingFlowSharedLib.addPassBackPropertiesToSnsResponseMessageObject(callingFlowConfig, messageObject);
+        let messageAttributes = callingFlowSharedLib.addCallingFlowToSnsResponseMessageAttributes(callingFlowConfig, {});
+
+        _izContext.logger.debug("after create callingFlow", messageObject)
+        let outUpdateNodeCompleteTopic = await snsSharedLib.snsTopicArnByFlowSchema(_izContext, TOPIC_NAME_GENERATE_CODE.outUpdateNodeComplete);
+        let messageParams = {
+          Message: JSON.stringify(messageObject),
+          MessageAttributes: sns.createStringMessageAttributes(_izContext, messageAttributes),
+          TopicArn: outUpdateNodeCompleteTopic
+        }
+
+        _izContext.logger.debug("message params OutUpdateNodeComplete :::", messageParams);
+        await sns.publishAsync(_izContext, messageParams);
+
+      }
+    }
+
+    return {
+      returnValues: {
+        objType: objType,
+        objInstanceFull: {
+          identifiers: identifiers,
+          fields: fields,
+        },
+        versionedDataIds: versionedDataIds
+      },
+      status: "complete",
+      errorsFound
+    }
+  } catch (err) {
+    _izContext.logger.error('error Update: ', err)
+    throw (err)
+  }
+}