feat(core): ✨ communication history store in database

communication history store in database

Ref: #191

package/communication/communicate.communicator.ts

@@ -1,5 +1,7 @@
+import { v4 as uuidv4 } from "uuid";
 import { constant } from "../constants/server.constant";
 import { databaseActions } from "../database/actions.database";
+import { coreConstant } from "../index";
 import { WrappidLogger } from "../logging/wrappid.logger";
 import * as communicationUtils from "../utils/communication.utils";
 import { checkIfCommunicationEnabled } from "../utils/communication.utils";
@@ -53,27 +55,61 @@ export const communicate = async ({
       });
       //create
       //  FunctionsRegistry.createCommunicationHistory();
+      const defaultProvider = await communicationUtils.getDefaultCommunicationConfig(commType);
+      const senderData = await mapCommunicationConfig(defaultProvider, commType);
+      // with status new give entry
+      const newCreatedData = await databaseActions.create(
+        "application",
+        "CommunicationHistories",
+        {
+          type: commType,
+          from: senderData?.sender,
+          to: commRecipients.to[0],
+          retryCount: 0,
+          commId: uuidv4(),
+          extraInfo: {},
+          variable: {otp: commData?.otp},
+          _status: "new",
+          templateId: communicationTemplate?.id,
+        }
+      );
+      let resData:any = {status: false, data: {}};
       if (directFlag) {
         switch (commType) {
           case constant.commType.EMAIL:
-            return communicateEmail({ ...commRecipients, ...messageObject });
+            resData = await communicateEmail({ ...commRecipients, ...messageObject });
+            break;
           case constant.commType.SMS:
-            return communicateSMS({
+            resData = await communicateSMS({
               phone: commRecipients.to[0],
               ...messageObject,
               dlttemplateid: communicationTemplate.externalTemplateId,
             });
+            break;
           case constant.commType.WHATSAPP:
-            return communicateWhatsApp({
+            resData = await communicateWhatsApp({
               phone: commRecipients.to[0],
               messageObject,
             });
+            break;
           default:
             WrappidLogger.error("Communication type is invalid.");
             throw new Error("Communication type is invalid.");
         }
-      //check communcation status
-      ///update
+        //check communcation status
+        ///update status sent
+        if(resData?.status){
+          databaseActions.update(
+            "application",
+            "CommunicationHistories",
+            { _status: "sent",
+              extraInfo: {response: resData?.data}
+            },
+            { where: { id: newCreatedData?.id } }
+          );
+          return {success:true};
+        }
+
       } else {
       // db entry
       }
@@ -82,6 +118,15 @@ export const communicate = async ({
       throw new Error("Communcation Disabled!!");
     }
   } catch (error:any) {
+    //db entry with status sent faild
+    databaseActions.update(
+      "application",
+      "CommunicationHistories",
+      { _status: "faild" },
+      { where: {  to: commRecipients[0],
+        variable: {otp: commData?.otp},
+        _status: "new", } }
+    );
     // console.error(error);
     WrappidLogger.error(error);
     if (errorFlag) {
@@ -91,3 +136,36 @@ export const communicate = async ({
     WrappidLogger.logFunctionEnd("whatsapp.communicate");
   }
 };
+
+/**
+ *  This function help us to map communication config
+ * @param configData config data
+ * @param commType communication type
+ * @returns 
+ */
+async function mapCommunicationConfig(configData:any, commType:string){
+  try {
+    WrappidLogger.logFunctionStart("mapCommunicationConfig");
+    const returndata:any = {sender: ""};
+    switch (commType) {
+      case coreConstant.commType.EMAIL:
+        returndata.sender = configData?.fromEmail;
+        break;
+
+      case coreConstant.commType.SMS:
+        returndata.sender = configData?.sender;
+        break;
+
+      case coreConstant.commType.WHATSAPP:
+        returndata.sender = configData?.api_url;
+        break;
+
+      default:
+        break;
+    }
+    return returndata;
+  } catch (error:any) {
+    WrappidLogger.error(error);
+    throw error;
+  } 
+}

package/communication/email/email.communication.ts

@@ -44,7 +44,8 @@ const communicate = async (mailOptions: any) => {
             WrappidLogger.info("Email sent.................");
             WrappidLogger.info(<string>res);
             // console.log(res);
-            return true;
+            return {status: true, data:res};
+            // return true;
           })
           .catch((error) => {
             WrappidLogger.info("Email sent failed.................");

package/communication/sms/sms.communication.ts

@@ -45,7 +45,8 @@ const communicate = async (smsOptions: any) => {
             .then((data: any) => {
               console.log(data);
               if (data.includes("Sent.c")) {
-                return true;
+                return { status: true, data: data };
+                // return true;
               } else {
                 WrappidLogger.error("SMS sent failed");
                 throw new Error("SMS sent failed");

package/communication/whatsapp/whatsapp.communication.ts

@@ -58,9 +58,7 @@ async function communicate(whatsappOptions: any) {
             throw data.error;
           } else
             return {
-              status: 200,
-              success: true,
-              error: null,
+              status: true,
               data: data,
             };
         })