aeremmiddleware 1.0.3 → 1.0.5

package/src/Finance/idfy.ts

@@ -1,292 +1,534 @@
 import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+interface ObjectTypes {
+  IDFY_TASK_ID: string;
+  IDFY_GROUP_ID: string;
+  IDFY_ACCOUNT_ID: string;
+  IDFY_API_KEY: string;
+  IDFY_COMPANY_SEARCH_API_KEY: string;
+}
+export default class IdfyAPIWrapper {
+  private bodyTaskIdGroupId = {
+    task_id: "",
+    group_id: "",
+  };
+  private defaultHeaderIdfyApi = {
+    "account-id": "",
+    "api-key": "",
+  };
+  private standardErrorThrowFormat = {
+    statusCode: 400,
+    message: ["bad request"],
+  };
+  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_plus";
+  private cinCompanyVerificationEndPoint =
+    "v3/tasks/async/verify_with_source/ind_mca";
+  private taskUrl = "v3/tasks?request_id=";
+  private asyncIndividualAadhaarLiteInfoEndPoint =
+    "v3/tasks/async/verify_with_source/aadhaar_lite";
+  private syncIndividualAadharScanInfoEndpoint =
+    "v3/tasks/sync/extract/ind_aadhaar_plus";
+  private syncIndividualPANScanInfoEndpoint = "v3/tasks/sync/extract/ind_pan";
+  private syncIndividualGSTScanInfoEndpoint =
+    "v3/tasks/sync/extract/ind_gst_certificate";
+  private syncIndividualLiveFaceLivenessEndpoint =
+    "v3/tasks/sync/check_photo_liveness/face";
 
+  private idfyCompanySearch = {
+    defaultHeader: {
+      "api-key": "",
+      "Content-Type": "application/json",
+    },
+    version: "v1",
+    companySearchUrl: "https://riskai.idfystaging.com/api/v1/company/search",
+    taskBaseUrl: "https://riskai.idfystaging.com/api/v1/task/",
+    cinllpinUrl: "https://riskai.idfystaging.com/api/v1/company/basic",
+  };
 
-export default class IdfyAPIWrapper {
+  private idfyError = {
+    INVALID_IMAGE: {
+      idfyErrorCode: "IDFY_ERR_100",
+      message: "Please scan correct document",
+    },
+    INSUFFICIENT_CREDITS: {
+      idfyErrorCode: "IDFY_ERR_101",
+      message: "Please renew credit",
+    },
+  };
+
+  constructor({
+    IDFY_TASK_ID,
+    IDFY_GROUP_ID,
+    IDFY_ACCOUNT_ID,
+    IDFY_API_KEY,
+    IDFY_COMPANY_SEARCH_API_KEY,
+  }: ObjectTypes) {
+    this.bodyTaskIdGroupId.task_id = IDFY_TASK_ID;
+    this.bodyTaskIdGroupId.group_id = IDFY_GROUP_ID;
+    this.defaultHeaderIdfyApi["account-id"] = IDFY_ACCOUNT_ID;
+    this.defaultHeaderIdfyApi["api-key"] = IDFY_API_KEY;
+    this.idfyCompanySearch.defaultHeader["api-key"] =
+      IDFY_COMPANY_SEARCH_API_KEY;
+  }
+
+  private async makeRequest<T>(
+    method: string,
+    endpoint: string,
+    data?: any
+  ): Promise<T> {
+    const requestConfig: AxiosRequestConfig = {
+      method,
+      url: this.baseUrl + endpoint,
+      headers: this.defaultHeaderIdfyApi,
+      data,
+    };
 
-    private bodyTaskIdGroupId = {
-        task_id: '74f4c926-250c-43ca-9c53-453e87ceacd1',
-        group_id: '8e16424a-58fc-4ba4-ab20-5bc8e7c3c41e',
+    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 defaultHeaderIdfyApi = {
-        "account-id": "e0d2add9d3c1/86e1d197-adb5-4f8f-af82-2728599a3615",
-        "api-key": "7fad350f-5519-4ec7-b977-d8c8b131b8e4"
+  }
+
+  private async makeAxiosRequest<T>({
+    method,
+    url,
+    data,
+    headers,
+  }: {
+    method: string;
+    url: string;
+    data?: any;
+    headers: any;
+  }): Promise<T> {
+    const requestConfig: AxiosRequestConfig = {
+      method,
+      url,
+      headers,
+      data,
+    };
+
+    try {
+      const response: AxiosResponse<T> = await axios(requestConfig);
+      return response.data;
+    } catch (error) {
+      console.error(
+        "Error while making Idfy makeAxiosRequest API request:",
+        error
+      );
+      throw error;
     }
-    private standardErrorThrowFormat = {
-        statusCode: 400,
-        message: ["bad request"]
+  }
+
+  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 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_plus'
-    private cinCompanyVerificationEndPoint = 'v3/tasks/async/verify_with_source/ind_mca'
-    private taskUrl = 'v3/tasks?request_id='
-    private asyncIndividualAadhaarLiteInfoEndPoint='v3/tasks/async/verify_with_source/aadhaar_lite'
-    private syncIndividualAadharScanInfoEndpoint = 'v3/tasks/sync/extract/ind_aadhaar_plus'
-    private syncIndividualPANScanInfoEndpoint = 'v3/tasks/sync/extract/ind_pan'
-    private syncIndividualGSTScanInfoEndpoint = 'v3/tasks/sync/extract/ind_gst_certificate'
-    private syncIndividualLiveFaceLivenessEndpoint = 'v3/tasks/sync/check_photo_liveness/face'
+  }
 
-    private idfyError = {
-        "INVALID_IMAGE":{
-            idfyErrorCode :"IDFY_ERR_100" ,
-            message:"Please scan correct document" 
-        },
-        "INSUFFICIENT_CREDITS":{
-            idfyErrorCode :"IDFY_ERR_101" ,
-            message:"Please renew credit" 
-        }
-    }          
+  private async getCompanySearchTask({
+    requestId,
+  }: {
+    requestId: string;
+  }): Promise<any> {
+    try {
+      const taskBaseUrl = this.idfyCompanySearch.taskBaseUrl + requestId;
+      const response = await this.makeAxiosRequest({
+        method: "get",
+        url: taskBaseUrl,
+        headers: this.idfyCompanySearch.defaultHeader,
+      });
+      return response;
+    } catch (error) {
+      console.error(
+        "Error while fetching Idfy getCompanySearchTask API data:",
+        error
+      );
+      throw error;
+    }
+  }
 
-   
+  private async pingTaskUntilSuccess(requestId: string): Promise<any> {
+    try {
+      let res: any = null;
+      const checkTaskAfter1sec = (requestId: any) => {
+        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");
 
-    constructor() { }
+      return res;
+    } catch (error) {
+      console.error("Error while fetching Idfy getTask API data:", error);
+      throw error;
+    }
+  }
 
-    private async makeRequest<T>(
-        method: string,
-        endpoint: string,
-        data?: any
-    ): Promise<T> {
-        const requestConfig: AxiosRequestConfig = {
-            method,
-            url: this.baseUrl + endpoint,
-            headers: this.defaultHeaderIdfyApi,
-            data,
-        };
+  private async pingCompanySearchTaskUntilSuccess(
+    requestId: string
+  ): Promise<any> {
+    try {
+      console.log(" ## requestId ", requestId);
+      let res: any = null;
+      const checkTaskAfter1sec = (requestId: string) => {
+        return new Promise<any>((resolve, reject) => {
+          try {
+            setTimeout(async () => {
+              const data = await this.getCompanySearchTask({ requestId });
+              if (data.status != "failed") {
+                resolve(data);
+              } else {
+                reject(res);
+              }
+            }, 1000);
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+      do {
+        res = await checkTaskAfter1sec(requestId);
+        console.log("### res ", res);
+      } while (res?.status !== "completed");
 
-        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;
-        }
+      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: any) {
+      if (error?.response?.data?.error) {
+        const errorObj = this.idfyError[error?.response?.data?.error];
+        if (errorObj)
+          throw {
+            ...this.standardErrorThrowFormat,
+            message: this.idfyError[errorKey],
+          };
+      }
 
-    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;
-        }
+      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);
 
-    private async pingTaskUntilSuccess(requestId: string): Promise<any> {
-        try {
+      return successData?.[0]?.result?.source_output;
+    } catch (error) {
+      if (error?.response?.data?.error) {
+        const errorObj = this.idfyError[error?.response?.data?.error];
+        if (errorObj)
+          throw {
+            ...this.standardErrorThrowFormat,
+            message: [errorObj.message],
+          };
+      }
+      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);
 
-            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 successData;
+    } catch (error) {
+      if (error?.response?.data?.error) {
+        const errorObj = this.idfyError[error?.response?.data?.error];
+        if (errorObj)
+          throw {
+            ...this.standardErrorThrowFormat,
+            message: [errorObj.message],
+          };
+      }
+      throw error;
+    }
+  }
 
-            return res;
+  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
+      );
 
-        } catch (error) {
-            console.error("Error while fetching Idfy getTask API data:", error);
-            throw error;
-        }
+      return response?.result;
+    } catch (error) {
+      if (error?.response?.data?.error) {
+        const errorObj = this.idfyError[error?.response?.data?.error];
+        if (errorObj)
+          throw {
+            ...this.standardErrorThrowFormat,
+            message: [errorObj.message],
+          };
+      }
+      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) {
-            
-            // if(error?.response?.data?.error){
-            //     const errorObj = this.idfyError[error?.response?.data?.error]
-            //     if(errorObj)
-            //      throw ({ ...this.standardErrorThrowFormat, message: [errorObj.message] })
-            //  }
+  }
 
-            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)
+  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 successData?.[0]?.result?.source_output;
-        } catch (error) {
-            // if(error?.response?.data?.error){
-            //     const errorObj = this.idfyError[error?.response?.data?.error]
-            //     if(errorObj)
-            //      throw ({ ...this.standardErrorThrowFormat, message: [errorObj.message] })
-            //  }
-            throw error;
-        }
+      return response?.result;
+    } catch (error) {
+      if (error?.response?.data?.error) {
+        const errorObj = this.idfyError[error?.response?.data?.error];
+        if (errorObj)
+          throw {
+            ...this.standardErrorThrowFormat,
+            message: [errorObj.message],
+          };
+      }
+      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;
-        } catch (error) {
-            // if(error?.response?.data?.error){
-            //     const errorObj = this.idfyError[error?.response?.data?.error]
-            //     if(errorObj)
-            //      throw ({ ...this.standardErrorThrowFormat, message: [errorObj.message] })
-            //  }
-            throw error;
-        }
-    }
+  async getSyncCompanyGSTScanInfo({
+    frontScanBase64,
+  }: {
+    frontScanBase64: string;
+  }): Promise<any> {
+    try {
+      const data = {
+        ...this.bodyTaskIdGroupId,
+        data: {
+          document1: frontScanBase64,
+        },
+      };
+      const response = await this.makeRequest<any>(
+        "post",
+        this.syncIndividualGSTScanInfoEndpoint,
+        data
+      );
 
-    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) {
-            // if(error?.response?.data?.error){
-            //     const errorObj = this.idfyError[error?.response?.data?.error]
-            //     if(errorObj)
-            //      throw ({ ...this.standardErrorThrowFormat, message: [errorObj.message] })
-            //  }
-            throw error;
-        }
+      return response?.result;
+    } catch (error) {
+      if (error?.response?.data?.error) {
+        const errorObj = this.idfyError[error?.response?.data?.error];
+        if (errorObj)
+          throw {
+            ...this.standardErrorThrowFormat,
+            message: [errorObj.message],
+          };
+      }
+      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) {
-            // if(error?.response?.data?.error){
-            //     const errorObj = this.idfyError[error?.response?.data?.error]
-            //     if(errorObj)
-            //      throw ({ ...this.standardErrorThrowFormat, message: [errorObj.message] })
-            //  }
-            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) {
+      if (error?.response?.data?.error) {
+        const errorObj = this.idfyError[error?.response?.data?.error];
+        if (errorObj)
+          throw {
+            ...this.standardErrorThrowFormat,
+            message: [errorObj.message],
+          };
+      }
+      throw error;
     }
+  }
 
+  async getAsyncAadhaarLiteInfo({
+    aadhaarNo,
+  }: {
+    aadhaarNo: string;
+  }): Promise<any> {
+    try {
+      const data = {
+        ...this.bodyTaskIdGroupId,
+        data: {
+          aadhaar_number: aadhaarNo,
+        },
+      };
+      const response = await this.makeRequest<any>(
+        "post",
+        this.asyncIndividualAadhaarLiteInfoEndPoint,
+        data
+      );
+      const successData = await this.pingTaskUntilSuccess(response.request_id);
 
-    async getSyncCompanyGSTScanInfo({ frontScanBase64 }: { frontScanBase64: string }): Promise<any> {
-        try {
-            const data = {
-                ...(this.bodyTaskIdGroupId),
-                data: {
-                    "document1":frontScanBase64
-                }
-            }
-            const response = await this.makeRequest<any>("post", this.syncIndividualGSTScanInfoEndpoint, data);
-         
-            return response?.result;
-        } catch (error) {
-            // if(error?.response?.data?.error){
-            //    const errorObj = this.idfyError[error?.response?.data?.error]
-            //    if(errorObj)
-            //     throw ({ ...this.standardErrorThrowFormat, message: [errorObj.message] })
-            // }
-            throw error;
-        }
+      return successData;
+    } catch (error) {
+      if (error?.response?.data?.error) {
+        const errorObj = this.idfyError[error?.response?.data?.error];
+        if (errorObj)
+          throw {
+            ...this.standardErrorThrowFormat,
+            message: [errorObj.message],
+          };
+      }
+      throw error;
     }
+  }
 
+  async getCompanyDetailsByName({
+    legalName,
+  }: {
+    legalName: string;
+  }): Promise<any> {
+    try {
+      const data = {
+        version: this.idfyCompanySearch.version,
+        ...this.bodyTaskIdGroupId,
+        data: {
+          name: legalName,
+        },
+      };
+      const response = await this.makeAxiosRequest<any>({
+        method: "post",
+        url: this.idfyCompanySearch.companySearchUrl,
+        data,
+        headers: this.idfyCompanySearch.defaultHeader,
+      });
+      const successData = await this.pingCompanySearchTaskUntilSuccess(
+        response.request_id
+      );
 
-    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) {
-            // if(error?.response?.data?.error){
-            //     const errorObj = this.idfyError[error?.response?.data?.error]
-            //     if(errorObj)
-            //      throw ({ ...this.standardErrorThrowFormat, message: [errorObj.message] })
-            //  }
-            throw error;
-        }
+      return { request_id: response, successData: successData };
+    } catch (error) {
+      throw error;
     }
+  }
 
-    
-    async getAsyncAadhaarLiteInfo({ aadhaarNo }: { aadhaarNo: string }): Promise<any> {
-        try {
-            const data = {
-                ...(this.bodyTaskIdGroupId),
-                data: {
-                    "aadhaar_number": aadhaarNo
-                }
-            }
-            const response = await this.makeRequest<any>("post", this.asyncIndividualAadhaarLiteInfoEndPoint, data);
-            const successData =  await this.pingTaskUntilSuccess(response.request_id)
-         
-            return successData;
-        } catch (error) {
-            // if(error?.response?.data?.error){
-            //     const errorObj = this.idfyError[error?.response?.data?.error]
-            //     if(errorObj)
-            //      throw ({ ...this.standardErrorThrowFormat, message: [errorObj.message] })
-            //  }
-            throw error;
-        }
+  async getCompanyDetailsByLlpinOrCin({
+    cinOrLlpin,
+  }: {
+    cinOrLlpin: string;
+  }): Promise<any> {
+    try {
+      const data = {
+        version: this.idfyCompanySearch.version,
+        ...this.bodyTaskIdGroupId,
+        data: {
+          cin_llpin: cinOrLlpin,
+        },
+      };
+      const response = await this.makeAxiosRequest<any>({
+        method: "post",
+        url: this.idfyCompanySearch.cinllpinUrl,
+        data,
+        headers: this.idfyCompanySearch.defaultHeader,
+      });
+      return { response: response };
+    } catch (error) {
+      throw error;
     }
-
-}
+  }
+}