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

package/src/TemplateData/flowSchema/components/upload/preSignUrl/reservedLimit/sqs/data.js

@@ -0,0 +1,68 @@
+/*
+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/>.
+*/
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import {
+  consts as mainLibsConsts,
+  utils
+} from '../../../../../../../../MainLibs/index.js';
+const { firstLetterUpperCase: upperCase } = utils;
+const { SOURCE_PATH, SAVE_FILE_NAME, FUNCTION_NAME, HANDLER } = mainLibsConsts;
+const templatePath = path.join(__dirname, 'template.ejs');
+
+/**
+ * create data for dynamoDbYaml tempalte from objectSchema
+ * return array of dynamoDb data
+ * because one objectSchema can create multiple dynamoDb table
+ *
+ * @param {Object} _izContext
+ * @param {Object} objectSchema
+ * @returns {Object[]}              - data of multiple dynamoDb template
+ */
+
+function data(_izContext, srcPath) {
+  let resultForCreateSqs = [];
+  const WebSocketSqsQueueNames = [];
+  const setting = {
+    initialData: 'Resources:\n',
+    savePath: path.join(srcPath, SOURCE_PATH.resourceYaml),
+    saveFileName: SAVE_FILE_NAME.snsInSqsYaml,
+    fileExtension: '.yml',
+    isAppend: true
+  };
+
+  WebSocketSqsQueueNames.push({
+    queueName:
+      upperCase(FUNCTION_NAME.reservedLimit) + upperCase(HANDLER.hdrSqs),
+    queueNameSubscription: upperCase(FUNCTION_NAME.createObjectComplete)
+  });
+
+  for (let WebSocketSqsQueueName of WebSocketSqsQueueNames) {
+    resultForCreateSqs.push({
+      templatePath: templatePath,
+      templateData: WebSocketSqsQueueName,
+      setting: setting
+    });
+  }
+  return resultForCreateSqs;
+}
+
+export default data;

package/src/TemplateData/flowSchema/components/upload/preSignUrl/reservedLimit/sqs/template.ejs

@@ -0,0 +1,53 @@
+##===== SNS Subscription
+  SubscriptionOut<%- queueNameSubscription %>:
+    Type: AWS::SNS::Subscription
+    Properties:
+      TopicArn: !Ref Out<%- queueNameSubscription %>
+      Endpoint: "arn:aws:sqs:${self:custom.iz_region}:${self:custom.iz_accountId}:${self:custom.iz_resourcePrefix}<%- queueName %>"
+      Protocol: "sqs"
+##===== [Queue]
+  <%- queueName %>:
+    Type: "AWS::SQS::Queue"
+    Properties:
+      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>
+      RedrivePolicy:
+        deadLetterTargetArn:
+        # !GetAtt
+          Fn::GetAtt:
+            - <%- queueName %>DLQ
+            - Arn
+        maxReceiveCount: 3
+      VisibilityTimeout: 120
+##==== [QueueDLQ]
+  <%- queueName %>DLQ:
+    Type: AWS::SQS::Queue
+    Properties:
+      QueueName: ${self:custom.iz_resourcePrefix}<%- queueName %>DLQ
+##==== [QueuePolicy]
+  <%- queueName %>Policy:
+    Type: AWS::SQS::QueuePolicy
+    Properties:
+      PolicyDocument:
+        Version: "2012-10-17"
+        Statement:
+          - Sid: "allow-sns-messages"
+            Effect: Allow
+            Principal: "*"
+            Resource:
+            # !GetAtt
+              Fn::GetAtt:
+                - <%- queueName %>
+                - Arn
+            Action: "SQS:SendMessage"
+      Queues:
+        - Ref: <%- queueName %>
+  #<#<%- firstLetterUpperCase(queueName) %>QueueSetting#>
+  #<#/<%- firstLetterUpperCase(queueName) %>QueueSetting#>
+
+
+  <%_ function firstLetterUpperCase(text){
+    return text.charAt(0).toUpperCase() + text.slice(1)
+  } _%>
+  <%_ function firstLetterLowerCase(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1)
+  } _%>

package/src/TemplateData/flowSchema/components/upload/processFile/functionYml/HdrS3/data.js

@@ -0,0 +1,139 @@
+/*
+Copyright (C) 2021 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/>.
+*/
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import { consts, utils } from '../../../../../../../../MainLibs/index.js';
+
+const {
+  SOURCE_PATH,
+  SAVE_FILE_NAME,
+  defaultIamRolePerAction,
+  createIamRole,
+  RESOURCE_CLASSES,
+  S3_RESOURCE,
+  resourceNames,
+  DYNAMO_RESOURCE,
+  SQS_RESOURCE,
+  SNS_RESOURCE,
+  shortNameHandler,
+  FUNCTION_NAME,
+  LAMBDA_RESOURCE,
+  SOURCE_GENERATE_IAM_ROLE,
+  ACTIONS,
+  HANDLER
+} = consts;
+
+const { firstLetterUpperCase: upperCase } = utils;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+function data(_izContext, flowSchema, srcPath) {
+  return [createSourceParam(_izContext, flowSchema, srcPath)];
+}
+
+function createSourceParam(_izContext, flowSchema, srcPath) {
+  let functionName = upperCase(FUNCTION_NAME.processAfterUploadS3);
+  let handlerType = 'HdrS3';
+  let additionalResourcePermission = defaultIamRolePerAction();
+  let bucketName = flowSchema.bucketName;
+  additionalResourcePermission.push(
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.s3]: [
+          S3_RESOURCE.getObject,
+          S3_RESOURCE.getObjectTagging,
+          S3_RESOURCE.putObject,
+          S3_RESOURCE.putObjectTagging,
+          S3_RESOURCE.deleteObject,
+          S3_RESOURCE.deleteObjectTagging
+        ]
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.s3, bucketName),
+        resourceNames(RESOURCE_CLASSES.s3, bucketName + '/*')
+      ]
+    ),
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sqs]: [
+          SQS_RESOURCE.sendMessage,
+          SQS_RESOURCE.receiveMessage,
+          SQS_RESOURCE.deleteMessage,
+          SQS_RESOURCE.getQueueAttributes
+        ]
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.sqs, functionName),
+        resourceNames(RESOURCE_CLASSES.sqs, functionName + 'DLQ')
+      ]
+    ),
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish]
+      },
+      [resourceNames(RESOURCE_CLASSES.sns, functionName + '_In')]
+    ),
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.sns]: [SNS_RESOURCE.publish],
+        [RESOURCE_CLASSES.lambda]: [LAMBDA_RESOURCE.invokeFunction]
+      },
+      [
+        resourceNames(RESOURCE_CLASSES.sns, upperCase(ACTIONS.update) + '_In'),
+        resourceNames(
+          RESOURCE_CLASSES.lambda,
+          upperCase(ACTIONS.get) + upperCase(HANDLER.hdrInv)
+        )
+      ]
+    ),
+    createIamRole(
+      {
+        [RESOURCE_CLASSES.dynamoDbTable]: [DYNAMO_RESOURCE.getItem]
+      },
+      [resourceNames(RESOURCE_CLASSES.dynamoDbTable, 'ReservedDataMain')]
+    )
+  );
+  return {
+    templatePath: templatePath,
+    templateData: {
+      functionName,
+      handlerType,
+      additionalResourcePermission,
+      resourceLocation: path.join(
+        SOURCE_PATH.resourceLocationWebSocket,
+        flowSchema.flowTag,
+        'source/'
+      ),
+      bucketName,
+      functionNameConfig:
+        upperCase(functionName) + upperCase(shortNameHandler(handlerType)),
+      roleName: SOURCE_GENERATE_IAM_ROLE.FlowSchemaUploadS3Role
+    },
+    setting: {
+      savePath: path.join(srcPath, SOURCE_PATH.appYaml),
+      saveFileName: upperCase(SAVE_FILE_NAME.flowSchema),
+      isAppend: true,
+      fileExtension: '.yml'
+    }
+  };
+}
+
+export default data;

package/src/TemplateData/flowSchema/components/upload/processFile/functionYml/HdrS3/template.ejs

@@ -0,0 +1,25 @@
+<%_ const join = require('path').join; _%>
+<%- firstLetterUpperCase(functionNameConfig) %>:
+  handler: <%- join(resourceLocation, `${firstLetterUpperCase(functionName)}_${firstLetterUpperCase(handlerType)}.main`)%>
+  name: ${self:custom.iz_resourcePrefix}<%- firstLetterUpperCase(functionName) %><%- firstLetterUpperCase(handlerType) %>
+  role: <%- roleName %>Role
+  #<#<%- functionName %><%- handlerType %>FunctionSetting#>
+  #<#/<%- functionName %><%- handlerType %>FunctionSetting#>
+  events:
+    - s3:
+        bucket: <%- bucketName %>
+        event: s3:ObjectCreated:*
+        existing: true
+        rules:
+        #<#<%- functionName %><%- handlerType %>rules#>
+        #<#/<%- functionName %><%- handlerType %>rules#>
+            - prefix: uploads/
+            - suffix: .csv
+        forceDeploy: true
+
+<%_ function firstLetterUpperCase(text){
+  return text.charAt(0).toUpperCase() + text.slice(1)
+} _%>
+<%_ function firstLetterLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1)
+} _%>

package/src/TemplateData/flowSchema/components/upload/processFile/handler/handlerS3/data.js

@@ -0,0 +1,52 @@
+/*
+Copyright (C) 2021 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/>.
+*/
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import { consts, utils } from '../../../../../../../../MainLibs/index.js';
+
+const { SOURCE_PATH, FUNCTION_NAME } = consts;
+
+const { firstLetterUpperCase: upperCase } = utils;
+const templatePath = path.join(__dirname, 'template.ejs');
+
+function data(_izContext, flowSchema, srcPath) {
+  return [createSourceData(_izContext, flowSchema, srcPath)];
+}
+
+function createSourceData(_izContext, flowSchema, srcPath) {
+  let functionName = FUNCTION_NAME.processAfterUploadS3;
+  let handlerType = 'HdrS3';
+  return {
+    templatePath: templatePath,
+    templateData: {},
+    setting: {
+      savePath: path.join(
+        srcPath,
+        SOURCE_PATH.webSocket,
+        flowSchema.flowTag,
+        'source/'
+      ),
+      saveFileName: `${upperCase(functionName)}_${upperCase(handlerType)}`,
+      fileExtension: '.js'
+    }
+  };
+}
+export default data;

package/src/TemplateData/flowSchema/components/upload/processFile/handler/handlerS3/template.ejs

@@ -0,0 +1,50 @@
+/*
+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/>.
+*/
+
+
+import { middlewareHandler as middleware } from "@izara_project/izara-middleware";
+import Logger from '@izara_project/izara-core-library-logger';
+import recordHandlerS3SharedLib from '@izara_project/izara-core-library-record-handler';
+
+import processAfterUpload from './ProcessAfterUploadS3_Main.js';
+//--------------------------------------------------------------------------
+middleware.setValidatorSchema(recordHandlerS3SharedLib.baseValidatorSchemaS3());
+
+export const main = middleware.wrap(async (event, context) => {
+  try {
+    Logger.debug("event is:", event)
+    Logger.debug("event.Records[0] is:", event.Records[0])
+
+    let processImageResponse = await processAfterUpload(
+      event._izContext,       // correlationId/logger/integrationTestDetail/uniqueRequestId/userId
+      event.Records[0].s3.bucket,
+      event.Records[0].s3.object,
+      //(<additionalProperties>)
+      //(</additionalProperties>)
+    );
+
+    if (processImageResponse instanceof Error) {
+      return (izara.response.failure(processImageResponse));
+    };
+
+    return (izara.response.success(processImageResponse));
+
+  } catch (err) {
+    event._izContext.logger.error('Error, processAfterUploadHdrS3: ', err);
+    return (izara.response.failure(err));
+  }
+});

package/src/TemplateData/flowSchema/components/upload/processFile/mainFunction/ProcessCsvtemplate.ejs

@@ -0,0 +1,182 @@
+/* Copyright (C) 2021 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/>. */
+const callingFlowSharedLib =
+require('@izara_project/izara-core-library-calling-flow'); const snsSharedLib =
+require('@izara_project/izara-core-library-sns'); const dynamodbSharedLib =
+require('@izara_project/izara-core-library-dynamodb'); const lambdaSharedLib =
+require('@izara_project/izara-core-library-lambda'); const externalRequest =
+require('@izara_project/izara-core-library-external-request') const lambda =
+externalRequest.lambda; const sns = externalRequest.sns; const NoRetryError =
+require('@izara_project/izara-core-library-core').NoRetryError; const utils =
+require('@izara_project/izara-market-library-service-schemas/src/MainLibs/src/Utils');
+const { S3Client, GetObjectCommand, DeleteObjectCommand, PutObjectCommand,
+CopyObjectCommand } = require('@aws-sdk/client-s3'); const s3 = new S3Client({
+region: 'us-east-2' }); const hash =
+require('@izara_project/izara-shared-core').objectHash; const Readable =
+require('stream'); const { isValidCsv, getNestObject } =
+require('../../../../libs/source/GenerateCodeLibs/index.js'); const consts =
+require('@izara_project/izara-market-library-service-schemas/src/GenerateCodeLibs/src/Consts')
+const coreConsts = require('@izara_project/izara-core-library-core/src/Consts');
+/** * description of function. * @param {Object} _izContext * @param
+{CorrelationIds} _izContext.correlationIds - property of _izContext * @param
+{Logger} _izContext.logger - property of _izContext * @param {Logger}
+_izContext.logger.debug - property of _izContext * @param {Object} bucket -
+bucket's data * @param {Array} field - image's data * @param {Array} importBy -
+'webSocket' || 'importData' * @param {Array} imageImportId - from importData *
+@param {Array} realImageSize - from importData * @param {Array}
+passBackProperties - from importData * * @returns {object} returnResponse */
+module.exports.processAfterUpload = async ( _izContext, bucket, field, importBy
+= '', importBatchId = '', realImageSize = 0, passBackProperties = {} ) => { try
+{ _izContext.logger.debug('----- processImageFile event params ----- ', {
+bucket: bucket, field: field, importBy: importBy, importBatchId: importBatchId,
+realImageSize: realImageSize, passBackProperties: passBackProperties }) let
+errorsFound = []; const objectS3Param = { Bucket: bucket.name, Key: field.key }
+_izContext.logger.debug("params before getObjectParam::", objectS3Param) const
+fileObjectS3 = await s3.send(new GetObjectCommand(objectS3Param));
+_izContext.logger.debug("get fileObjectS3", fileObjectS3); importBatchId =
+fileObjectS3.Metadata.importbatchid let getImportBatchMain = await
+lambda.invokeSync(_izContext, await
+lambdaSharedLib.lambdaFunctionName(_izContext, "ImportBatchMainGetHdrInv"), {
+identifiers: { importBatchId: importBatchId } } )
+_izContext.logger.debug("getImportBatchMain", getImportBatchMain)
+_izContext.correlationIds.set(coreConsts.BASE_USER_ID,
+getImportBatchMain.fields.userId);
+_izContext.correlationIds.set(coreConsts.TARGET_ID,
+getImportBatchMain.fields.submittedByUserId); let userId =
+_izContext.correlationIds.get(coreConsts.BASE_USER_ID); let targetId =
+_izContext.correlationIds.get(coreConsts.TARGET_ID); if (Date.now() >
+getImportBatchMain.fields.expiryTimestamp) { errorsFound.push("url expired can't
+upload") let sendMessageUpdateUrlExpired = { objInstanceFull: { identifiers: {
+importBatchId: importBatchId }, fields: { importBatchStatus: "urlExpired",
+errorsFound: "url expired can't upload", processingError: true } } } let
+sendMessageToInImportBatchUpdate = { Message:
+JSON.stringify(sendMessageUpdateUrlExpired), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, "InImportBatchMainUpdate") };
+_izContext.logger.debug("message param before send to updateImportBatchMain",
+sendMessageToInImportBatchUpdate); await sns.publishAsync(_izContext,
+sendMessageToInImportBatchUpdate); let deleteFileObjectS3 = await s3.send(new
+DeleteObjectCommand(objectS3Param)); _izContext.logger.debug("Delete object
+response: ", deleteFileObjectS3) return } if (fileObjectS3) { if
+(!importBatchId) { errorsFound.push("cant't get importBatchId from S3 uploaded
+file"); } } else { errorsFound.push("cant't get fileObjectS3 from S3 uploaded
+file"); }; let fileS3Body = fileObjectS3.Body;
+_izContext.logger.debug("fileS3Body", fileS3Body); let fileS3Buffer = null; if
+(fileS3Body instanceof Readable) { fileS3Buffer = Buffer.concat(await
+fileS3Body.toArray()); _izContext.logger.debug("fileS3Buffer", fileS3Buffer) }
+else { errorsFound.push('unknown object stream type'); } // check file type //
+can be strict in function.yml that only trigger if it specific type of file
+const srcKey = field.key; const importFieldType = srcKey.match(/\.([^.]*)$/);
+_izContext.logger.debug("importFieldType", importFieldType); if
+(!importFieldType) { throw new NoRetryError("error fileType") }; const
+importKeyType = utils.firstLetterLowerCase(importFieldType[1]);
+_izContext.logger.debug("importKeyType", importKeyType); if (importKeyType ===
+"csv") { // check valid CSV file let [validCsv, errorCheckCsv] = await
+isValidCsv(_izContext, fileObjectS3) _izContext.logger.debug("validCsv check::",
+{ validCsv, errorsFound }) if (errorCheckCsv.length) {
+errorsFound.push(errorCheckCsv[0]) } // check file size let reservedFileSize =
+getImportBatchMain.fields.fileSize; _izContext.logger.debug("initialFileSize::",
+reservedFileSize) let s3FileSize = fileObjectS3.ContentLength / 1048576 //
+convert back to byte unit _izContext.logger.debug("s3FileSize in MiB::",
+s3FileSize) if (s3FileSize < 0.5) { // round up to 1 s3FileSize = 1 } let
+reservedData = await dynamodbSharedLib.getItem(_izContext, await
+dynamodbSharedLib.tableName(_izContext, "ReservedDataMain"), { servicePendingId:
+importBatchId, reservedDataId:
+`${consts.ACCOUNTLIMIT_TAG.reservedDynamic}_${getImportBatchMain.fields.userId}_${consts.LIMIT_TAG.uploadData}`
+} ) _izContext.logger.debug("reservedData::", reservedData); let sizeDiff; if
+(s3FileSize > reservedFileSize) { sizeDiff = s3FileSize - reservedFileSize; if
+(sizeDiff < 1) { // send message to confirmUsage let confirmUsageMessage = {
+userId: userId, limitTag: consts.LIMIT_TAG.uploadData, uniqueIdentify:
+reservedData.uniqueIdentify, } let sendMessageToConfirmUsage = { Message:
+JSON.stringify(confirmUsageMessage), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, 'InConfirmUsage',
+consts.EXTERNAL_SERVICE_NAME.accountLimits) };
+_izContext.logger.debug("sendMessageToConfirmUsage", sendMessageToConfirmUsage);
+await sns.publishAsync(_izContext, sendMessageToConfirmUsage); let
+sendMessageToUpdateImportBatchStatus = { objInstanceFull: { identifiers: {
+importBatchId: servicePendingId }, fields: { importBatchStatus: 'uploadComplete'
+} } } let sendMessageToUpdateImportBatch = { Message:
+JSON.stringify(sendMessageToUpdateImportBatchStatus), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, `InImportBatchMainUpdate`) };
+_izContext.logger.debug("sendMessageToUpdateImportBatch",
+sendMessageToUpdateImportBatch); await sns.publishAsync(_izContext,
+sendMessageToUpdateImportBatch); } } else if (s3FileSize < reservedFileSize) {
+sizeDiff = reservedFileSize - s3FileSize; if (sizeDiff < 1) { let
+confirmUsageMessage = { userId: userId, limitTag: consts.LIMIT_TAG.uploadData,
+uniqueIdentify: reservedData.uniqueIdentify, } let sendMessageToConfirmUsage = {
+Message: JSON.stringify(confirmUsageMessage), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, 'InConfirmUsage',
+consts.EXTERNAL_SERVICE_NAME.accountLimits) };
+_izContext.logger.debug("sendMessageToConfirmUsage", sendMessageToConfirmUsage);
+await sns.publishAsync(_izContext, sendMessageToConfirmUsage); let
+sendMessageToUpdateImportBatchStatus = { objInstanceFull: { identifiers: {
+importBatchId: servicePendingId }, fields: { importBatchStatus: 'uploadComplete'
+} } } let sendMessageToUpdateImportBatch = { Message:
+JSON.stringify(sendMessageToUpdateImportBatchStatus), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, `InImportBatchMainUpdate`) };
+_izContext.logger.debug("sendMessageToUpdateImportBatch",
+sendMessageToUpdateImportBatch); await sns.publishAsync(_izContext,
+sendMessageToUpdateImportBatch); } else { let realFileSize =
+Math.round(s3FileSize); // cancel reserved -> new reserved -> confirm // cancel
+let sendMessageToCancelReserved = { Message: JSON.stringify({ userId: userId,
+limitTag: consts.LIMIT_TAG.uploadData, uniqueIdentify:
+reservedData.uniqueIdentify }), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, 'InCancelUsage',
+consts.EXTERNAL_SERVICE_NAME.accountLimits) };
+_izContext.logger.debug("sendMessageToCancelReserved",
+sendMessageToCancelReserved); await sns.publishAsync(_izContext,
+sendMessageToCancelReserved); // new reserved let originTimestamp = Date.now();
+let messageObjReserved = { userId: userId, limitTag:
+consts.LIMIT_TAG.uploadData, value: realFileSize, rbacType:
+consts.RBAC_TYPE.appLevel, usedTimestamp: originTimestamp, targetUserId:
+targetId } let callingFlowProperties = { identifier: { servicePendingId:
+importBatchId, reservedDataId:
+`${consts.ACCOUNTLIMIT_TAG.reservedDynamic}_${getImportBatchMain.fields.userId}_${consts.LIMIT_TAG.uploadData}`,
+userId: getImportBatchMain.fields.userId, realSize: realFileSize } }
+messageObjReserved =
+callingFlowSharedLib.addCallingFlowToSnsRequestMessageObject(
+messageObjReserved, callingFlowSharedLib.createCallingFlowConfig( await
+lambdaSharedLib.lambdaFunctionName(_izContext, "ConfirmNewReservedHdrSqs"),
+callingFlowProperties ) ) _izContext.logger.debug('after add callingFlow: ',
+messageObjReserved) let sendMessageToReservedDynamic = { Message:
+JSON.stringify(messageObjReserved), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, 'InReservedDynamicUsage',
+consts.EXTERNAL_SERVICE_NAME.accountLimits) };
+_izContext.logger.debug("sendMessageToReservedDynamic",
+sendMessageToReservedDynamic); await sns.publishAsync(_izContext,
+sendMessageToReservedDynamic); }; } else if (s3FileSize === reservedFileSize) {
+let confirmUsageMessage = { userId: getImportBatchMain.fields.userId, limitTag:
+consts.LIMIT_TAG.uploadData, uniqueIdentify: reservedData.uniqueIdentify, } let
+sendMessageToConfirmUsage = { Message: JSON.stringify(confirmUsageMessage),
+TopicArn: await snsSharedLib.snsTopicArn(_izContext, 'InConfirmUsage',
+consts.EXTERNAL_SERVICE_NAME.accountLimits) };
+_izContext.logger.debug("sendMessageToConfirmUsage", sendMessageToConfirmUsage);
+await sns.publishAsync(_izContext, sendMessageToConfirmUsage); let
+sendMessageToUpdateImportBatchStatus = { objInstanceFull: { identifiers: {
+importBatchId: servicePendingId }, fields: { importBatchStatus: 'uploadComplete'
+} } } let sendMessageToUpdateImportBatch = { Message:
+JSON.stringify(sendMessageToUpdateImportBatchStatus), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, `InImportBatchMainUpdate`) };
+_izContext.logger.debug("sendMessageToUpdateImportBatch",
+sendMessageToUpdateImportBatch); await sns.publishAsync(_izContext,
+sendMessageToUpdateImportBatch); } } else { errorsFound.push("error
+importKeyType") } if (errorsFound.length) { // if error send message to update
+error in importBatchMain let updateImportBatchMainError = { objInstanceFull: {
+identifiers: { importBatchId: importBatchId }, fields: { importBatchStatus:
+"errorToUpload", errorsFound: errorsFound, processingError: true } } } let
+sendMessageToUpdateImportBatchMain = { Message:
+JSON.stringify(updateImportBatchMainError), TopicArn: await
+snsSharedLib.snsTopicArn(_izContext, "InImportBatchMainUpdate") };
+_izContext.logger.debug('sendMessageToUpdateImportBatchMain::',
+sendMessageToUpdateImportBatchMain); await sns.publishAsync(_izContext,
+sendMessageToUpdateImportBatchMain); let deleteFileObjectS3 = await s3.send(new
+DeleteObjectCommand(objectS3Param)); _izContext.logger.debug("Delete object
+response: ", deleteFileObjectS3) } } catch (err) {
+_izContext.logger.error('error ProcessImageAfterUploadMain: ', err) throw (err)
+} }

package/src/TemplateData/flowSchema/components/upload/processFile/mainFunction/data.js

@@ -0,0 +1,51 @@
+/*
+Copyright (C) 2021 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/>.
+*/
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+import { consts, utils } from '../../../../../../../MainLibs/index.js';
+const { SOURCE_PATH, FUNCTION_NAME } = consts;
+const { firstLetterUpperCase: upperCase } = utils;
+
+const templatePath = path.join(__dirname, 'template.ejs');
+
+function data(_izContext, flowSchema, srcPath) {
+  return [createSourceParams(_izContext, flowSchema, srcPath)];
+}
+
+function createSourceParams(_izContext, flowSchema, srcPath) {
+  let functionName = upperCase(FUNCTION_NAME.processAfterUploadS3);
+  return {
+    templatePath: templatePath,
+    templateData: {},
+    setting: {
+      saveFileName: `${functionName}_Main`,
+      savePath: path.join(
+        srcPath,
+        SOURCE_PATH.webSocket,
+        flowSchema.flowTag,
+        'source/'
+      ),
+      fileExtension: '.js'
+    }
+  };
+}
+
+export default data;