aeremmiddleware 1.0.1

package/Finance/idfy.ts

@@ -0,0 +1,205 @@
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+
+
+export default class IdfyAPIWrapper {
+
+    private bodyTaskIdGroupId = {
+        task_id: '74f4c926-250c-43ca-9c53-453e87ceacd1',
+        group_id: '8e16424a-58fc-4ba4-ab20-5bc8e7c3c41e',
+    }
+    private defaultHeaderIdfyApi = {
+        "account-id": "e0d2add9d3c1/86e1d197-adb5-4f8f-af82-2728599a3615",
+        "api-key": "7fad350f-5519-4ec7-b977-d8c8b131b8e4"
+    }
+    private baseUrl: string = "https://eve.idfy.com/";
+    private gstVerificationEndPoint = 'v3/tasks/sync/verify_with_source/ind_gst_certificate'
+    private panIndividualVerificationEndPoint = 'v3/tasks/async/verify_with_source/ind_pan'
+    private cinCompanyVerificationEndPoint = 'v3/tasks/async/verify_with_source/ind_mca'
+    private taskUrl = 'v3/tasks?request_id='
+    private syncIndividualAadharScanInfoEndpoint = 'v3/tasks/sync/extract/ind_aadhaar_plus'
+    private syncIndividualPANScanInfoEndpoint = 'v3/tasks/sync/extract/ind_pan'
+    private syncIndividualLiveFaceLivenessEndpoint = 'v3/tasks/sync/check_photo_liveness/face'
+
+   
+
+
+    constructor() { }
+
+    private async makeRequest<T>(
+        method: string,
+        endpoint: string,
+        data?: any
+    ): Promise<T> {
+        const requestConfig: AxiosRequestConfig = {
+            method,
+            url: this.baseUrl + endpoint,
+            headers: this.defaultHeaderIdfyApi,
+            data,
+        };
+
+        try {
+            const response: AxiosResponse<T> = await axios(requestConfig);
+            return response.data;
+        } catch (error) {
+            console.error("Error while making Idfy Axios API request:", error);
+            throw error;
+        }
+    }
+
+    private async getTask(requestId: string): Promise<any> {
+        try {
+            //   const data = {}
+            const urlEndPoint = this.taskUrl + requestId
+            const response = await this.makeRequest<any>("get", urlEndPoint);
+            return response;
+        } catch (error) {
+            console.error("Error while fetching Idfy getTask API data:", error);
+            throw error;
+        }
+    }
+
+    private async pingTaskUntilSuccess(requestId: string): Promise<any> {
+        try {
+
+            let res: any = null
+            const checkTaskAfter1sec = (requestId:string) => {
+                return new Promise<any>((resolve, reject) => {
+                    try{
+                        setTimeout(async () => {
+                            const data = await this.getTask(requestId)
+                            if(res?.[0].status == 'failed'){
+                                reject(res)
+                            }
+                            resolve(data)
+                        }, 1000)
+                        
+                    }catch(e){
+                        reject(e)
+                    }
+                })
+            }
+            do {
+                res = await checkTaskAfter1sec(requestId)
+                
+                console.log( "### res ",res) ;
+            } while (res?.[0].status !== 'completed')
+
+            return res;
+
+        } catch (error) {
+            console.error("Error while fetching Idfy getTask API data:", error);
+            throw error;
+        }
+    }
+    async getCompanyGstInfo({ gstNo }: { gstNo: string }): Promise<any> {
+        try {
+            const data = {
+                ...(this.bodyTaskIdGroupId),
+                data: {
+                    gstin: gstNo,
+                }
+            }
+            const response = await this.makeRequest<any>("post", this.gstVerificationEndPoint, data);
+            return response;
+        } catch (error) {
+            console.error("Error while fetching Idfy API data:", error);
+            throw error;
+        }
+    }
+    async getCompanyCINInfo({ cinNo }: { cinNo: string }): Promise<any> {
+        try {
+            const data = {
+                ...(this.bodyTaskIdGroupId),
+                data: {
+                    "cin": cinNo,
+                }
+            }
+            const response = await this.makeRequest<any>("post", this.cinCompanyVerificationEndPoint, data);
+            const successData =  await this.pingTaskUntilSuccess(response.request_id)
+
+            return successData?.[0]?.result?.source_output;
+        } catch (error) {
+            console.error("Error while fetching Idfy CIN API data:", error);
+            throw error;
+        }
+    }
+    async getIndividualPANInfo({ panNo }: { panNo: string }): Promise<any> {
+        try {
+            const data = {
+                ...(this.bodyTaskIdGroupId),
+                data: {
+                    "id_number": panNo,
+                }
+            }
+            const response = await this.makeRequest<any>("post", this.panIndividualVerificationEndPoint, data);
+            const successData =  await this.pingTaskUntilSuccess(response.request_id)
+
+            return successData?.[0]?.result?.source_output;
+        } catch (error) {
+            console.error("Error while fetching Idfy PAN API data:", error);
+            throw error;
+        }
+    }
+
+    async getSyncIndividualAadharScanInfo({ frontScanBase64,backScanBase64 }: { frontScanBase64: string,backScanBase64:string }): Promise<any> {
+        try {
+            const data = {
+                ...(this.bodyTaskIdGroupId),
+                data: {
+                    "document1":frontScanBase64,
+                    "document2":backScanBase64,
+                    "consent":"yes",
+                    "advanced_details": { 
+                        "extract_qr_info": true, 
+                        "extract_last_4_digit":false 
+                    }
+                }
+            }
+            const response = await this.makeRequest<any>("post", this.syncIndividualAadharScanInfoEndpoint, data);
+         
+            return response?.result;
+        } catch (error) {
+            console.error("Error while fetching Idfy PAN API data:", error);
+            throw error;
+        }
+    }
+
+    async getSyncIndividualPANScanInfo({ frontScanBase64 }: { frontScanBase64: string }): Promise<any> {
+        try {
+            const data = {
+                ...(this.bodyTaskIdGroupId),
+                data: {
+                    "document1":frontScanBase64,
+                    "consent":"yes",
+                }
+            }
+            const response = await this.makeRequest<any>("post", this.syncIndividualPANScanInfoEndpoint, data);
+         
+            return response?.result;
+        } catch (error) {
+            console.error("Error while fetching Idfy PAN API data:", error);
+            throw error;
+        }
+    }
+
+    async getSyncIndividualLivenessSelfyScanInfo({ faceScanBase64 }: { faceScanBase64: string }): Promise<any> {
+        try {
+            const data = {
+                ...(this.bodyTaskIdGroupId),
+                data: {
+                    "document1":faceScanBase64,
+                    "consent":"yes",
+                }
+            }
+            const response = await this.makeRequest<any>("post", this.syncIndividualLiveFaceLivenessEndpoint, data);
+         
+            return response?.result;
+        } catch (error) {
+            console.error("Error while fetching Idfy PAN API data:", error);
+            throw error;
+        }
+    }
+
+
+
+}

package/Finance/index.ts

@@ -0,0 +1,5 @@
+import IdfyAPIWrapper from './idfy'
+
+export const finance = {
+idFy : IdfyAPIWrapper
+}

package/Socials/Whatsapp.types.ts

@@ -0,0 +1,95 @@
+interface WhatsAppMessageData {
+    from: string;
+    to: string;
+    body?: string;
+    content?: WhatsappContentType;
+  }
+
+interface Templatetype {
+    name: string;
+    language: {
+      policy: string;
+      code: string;
+    };
+    components: Array<{
+      type: string;
+      parameters: Array<{
+        type: string;
+        text: string;
+      }>;
+    }>;
+  }
+  interface WhatsappContentType {
+    type: string; //"text",  "document",  "image",  "video",  "template";
+    text?: { preview_url: string; body: string };
+    document?: any;
+    image?: any;
+    video?: any;
+    recipient_type: any;
+    template?: Templatetype;
+  }
+  
+  export interface DemoBody {
+    whatsapp: {
+      messages: Array<WhatsAppMessageData>;
+    };
+  }
+  
+  interface WhatsAppTemplateMessage {
+    from: string;
+    to: string;
+    content: {
+      type: string;
+      template: {
+        name: string;
+        language: {
+          policy?: string;
+          code: string;
+        };
+        components: Array<{
+          type: string;
+          parameters: Array<{
+            type: string;
+            text: string;
+          }>;
+        }>;
+      };
+    };
+  }
+  
+  export interface WhatsAppTemplateDemoBody {
+    whatsapp: {
+      messages: Array<WhatsAppTemplateMessage>;
+    };
+  }
+  
+  export interface EmiReminderAug2023 {
+    code: number;
+    error_data: null;
+    status: string;
+    data: {
+      waba_id: string;
+      name: string;
+      components: Array<HeaderComponent | BodyComponent>;
+    };
+  }
+  
+  interface HeaderComponent {
+    type: string;
+    format: string;
+    text: string;
+    example: {
+      header_text: Array<string>;
+    };
+  }
+ interface BodyComponent {
+    type: string;
+    text: string;
+    example: {
+      body_text: Array<Array<string>>;
+    };
+  }
+  export enum Provider {
+    EXOTEL = "EXOTEL",
+    GUPSHUP = "GUPSHUP",
+  }

package/Socials/index.ts

@@ -0,0 +1,5 @@
+import Socials from './message'
+
+export const socials = {
+message : Socials
+}

package/Socials/message.ts

@@ -0,0 +1,188 @@
+import axios from "axios";
+import { DemoBody, EmiReminderAug2023, Provider, WhatsAppTemplateDemoBody } from "./Whatsapp.types";
+
+class ExotelWhatsAppSender {
+  private exotelSid: string;
+  private exotelToken: string;
+  private exotelApiKey: string;
+  private whatsappApiUrl!: string;
+  private provider: string;
+
+  constructor(payload: {
+    exotelSid: string;
+    exotelToken: string;
+    exotelApiKey: string;
+    provider: string;
+  }) {
+    const { exotelSid, exotelToken, exotelApiKey, provider } = payload;
+    this.exotelSid = exotelSid;
+    this.exotelToken = exotelToken;
+    this.exotelApiKey = exotelApiKey;
+    this.provider = provider;
+
+    if (this.provider === Provider.EXOTEL) {
+      this.whatsappApiUrl = `https://${exotelApiKey}:${exotelToken}@api.exotel.com/v2/accounts/${exotelSid}/messages`;
+    } else if (this.provider === Provider.GUPSHUP) {
+      // Define the URL for Gupshup API
+      // this.gupshupApiUrl = ...;
+    }
+  }
+
+  async getTemplates() {
+    const request = await axios.get(
+      `https://${this.exotelApiKey}:${this.exotelToken}@api.exotel.com/v2/accounts/${this.exotelSid}/templates?waba_id=114033855070320`
+    );
+
+    return request.data.response.whatsapp.templates;
+  }
+  getUniquePlaceholderCount(str: string) {
+    const arr:Array<string> = [];
+    str.split("{{").map((s) => arr.push(...s.split("}}")));
+    const placeholders: Array<string> = arr.filter(
+      (i) => i.match(/[0-9]+/) && !isNaN(Number(i))
+    );
+    return [...new Set(placeholders)].length;
+  }
+
+  validateTemplatePayload(template:EmiReminderAug2023, payload:any) {
+    const templateComponents = template.data.components;
+    if (templateComponents.length != 2) {
+      return;
+    }
+
+    const [headerTemplate, bodyTemplate] = templateComponents;
+  //this checks if placeholder is correct or not
+    for (let index = 0; index < payload.whatsapp.messages.length; index++) {
+      const message = payload.whatsapp.messages[index];
+      const payloadComponents = message.content.template.components;
+      for (let index2 = 0; index2 < payloadComponents.length; index2++) {
+        const payloadComponent = payloadComponents[index2];
+        // validate template header
+        if (payloadComponent.type === headerTemplate.type.toLowerCase()) {
+          const headerPlaceholdersCount = this.getUniquePlaceholderCount(
+            headerTemplate.text
+          );
+          if (payloadComponent.parameters.length != headerPlaceholdersCount) {
+            console.log("invalid header");
+            throw new Error("header count mismatch");
+          } else {
+            // header validated
+            // TODO: add more validations if required
+          }
+        } else if (payloadComponent.type === bodyTemplate.type.toLowerCase()) {
+          const bodyPlaceholdersCount = this.getUniquePlaceholderCount(
+            bodyTemplate.text
+          );
+          if (payloadComponent.parameters.length != bodyPlaceholdersCount) {
+            console.log("invalid body");
+            throw new Error("body count mismatch");
+          } else {
+            // validate template body
+            // body validated
+            // TODO: add more validations if required
+          }
+        }
+        else
+          throw new Error("type mismatch or incorrect")
+        
+      }
+      return true;
+    }
+  }
+  testType(obj: DemoBody) {
+    let returnValue = true;
+    obj.whatsapp.messages.every((message, index) => {
+      returnValue =
+        Boolean(message?.content?.type === "text" && message.content.text) ||
+        Boolean(
+          message?.content?.type === "document" && message.content.document
+        ) ||
+        Boolean(message?.content?.type === "image" && message.content.image) ||
+        Boolean(message?.content?.type === "video" && message.content.video) ||
+        Boolean(
+          message?.content?.type === "template" && message.content.template
+        );
+      return returnValue;
+    });
+    return returnValue;
+  }
+
+  private async sendMessage(messageData: DemoBody): Promise<boolean> {
+    try {
+      let config = {
+        method: "post",
+        maxBodyLength: Infinity,
+        url: this.whatsappApiUrl,
+        headers: {
+          "Content-Type": "application/json",
+        },
+
+        data: JSON.stringify(messageData),
+      };
+
+      const response = await axios.request(config);
+      if (response.data.metadata && response.data.metadata.success != 0) {
+        console.log("WhatsApp message sent successfully:", response.data);
+        return true;
+      } else {
+        console.error("Error sending WhatsApp message:", response.data);
+        return false;
+      }
+    } catch (error) {
+      console.error("Error sending WhatsApp message:", error);
+      return false;
+    }
+  }
+
+  private async sendTemplateMessage(
+    messageData: WhatsAppTemplateDemoBody
+  ): Promise<boolean> {
+    try {
+      const config = {
+        method: "post",
+        maxBodyLength: Infinity,
+        url: this.whatsappApiUrl,
+        headers: {
+          "Content-Type": "application/json",
+        },
+        data: JSON.stringify(messageData),
+      };
+
+      const response = await axios.request(config);
+      if (response.data.metadata && response.data.metadata.success !== 0) {
+        console.log(
+          "WhatsApp template message sent successfully:",
+          response.data
+        );
+        return true;
+      } else {
+        console.error(
+          "Error sending WhatsApp template message:",
+          response.data
+        );
+        return false;
+      }
+    } catch (error) {
+      console.error("Error sending WhatsApp template message:", error);
+      return false;
+    }
+  }
+
+  async sendWhatsAppMessage(obj: DemoBody): Promise<boolean> {
+    if (this.testType(obj)) return this.sendMessage(obj);
+    else return false;
+  }
+
+  async sendWhatsappTemplateMessage(
+    obj: WhatsAppTemplateDemoBody
+  ): Promise<boolean> {
+    let templatevalue=await this.getTemplates();
+    let tempVariable=obj.whatsapp.messages[0].content.template.name;
+    let template = templatevalue.find((e:any)=>e.data.name==tempVariable)
+    if(this.validateTemplatePayload(template,obj)){
+      return this.sendTemplateMessage(obj)
+    }
+    else return false;
+  }
+}
+export default ExotelWhatsAppSender;

package/index.ts

@@ -0,0 +1,8 @@
+import { finance } from "./Finance";
+import { socials } from "./Socials";
+
+
+export  const AeremMiddleware = {
+    finance,socials
+
+} 

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "aeremmiddleware",
+  "version": "1.0.1",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "rm -rf build && tsc ",
+    "prod": "node ./build/src/index.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.4.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    
+    "target": "ES2017",                                  
+    "module": "commonjs",                                 
+    "esModuleInterop": true,                             
+    "forceConsistentCasingInFileNames": true,            
+    "strict": true,                                     
+    "skipLibCheck": true,
+    "rootDir": "./",
+    "outDir": "build"                                
+  }
+}