@gofynd/fdk-client-javascript 1.0.0 → 1.0.2

package/sdk/platform/Payment/PaymentPlatformApplicationClient.js

@@ -2,6 +2,8 @@ const Paginator = require("../../common/Paginator");
 const PlatformAPIClient = require("../PlatformAPIClient");
 const { FDKClientValidationError } = require("../../common/FDKError");
 const PaymentValidator = require("./PaymentPlatformApplicationValidator");
+const PaymentModel = require("./PaymentPlatformModel");
+const { Logger } = require("./../../common/Logger");
 
 class Payment {
   constructor(config, applicationId) {
@@ -11,10 +13,11 @@ class Payment {
 
   /**
    * @param {Object} arg - Arg object.
+   * @returns {Promise<PaymentGatewayConfigResponse>} - Success response
    * @summary: Get All Brand Payment Gateway Config Secret
    * @description: Get All Brand Payment Gateway Config Secret
    */
-  getBrandPaymentGatewayConfig({} = {}) {
+  async getBrandPaymentGatewayConfig({} = {}) {
     const { error } = PaymentValidator.getBrandPaymentGatewayConfig().validate(
       {},
       { abortEarly: false, allowUnknown: true }
@@ -23,24 +26,59 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getBrandPaymentGatewayConfig().validate(
+      {},
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getBrandPaymentGatewayConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/aggregator/request`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentGatewayConfigResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getBrandPaymentGatewayConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {PaymentGatewayConfigRequest} arg.body
+   * @returns {Promise<PaymentGatewayToBeReviewed>} - Success response
    * @summary: Save Config Secret For Brand Payment Gateway
    * @description: Save Config Secret For Brand Payment Gateway
    */
-  saveBrandPaymentGatewayConfig({ body } = {}) {
+  async saveBrandPaymentGatewayConfig({ body } = {}) {
     const { error } = PaymentValidator.saveBrandPaymentGatewayConfig().validate(
       {
         body,
@@ -51,24 +89,61 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.saveBrandPaymentGatewayConfig().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for saveBrandPaymentGatewayConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/aggregator/request`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentGatewayToBeReviewed().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for saveBrandPaymentGatewayConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {PaymentGatewayConfigRequest} arg.body
+   * @returns {Promise<PaymentGatewayToBeReviewed>} - Success response
    * @summary: Save Config Secret For Brand Payment Gateway
    * @description: Save Config Secret For Brand Payment Gateway
    */
-  updateBrandPaymentGatewayConfig({ body } = {}) {
+  async updateBrandPaymentGatewayConfig({ body } = {}) {
     const {
       error,
     } = PaymentValidator.updateBrandPaymentGatewayConfig().validate(
@@ -81,25 +156,62 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.updateBrandPaymentGatewayConfig().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for updateBrandPaymentGatewayConfig",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/aggregator/request`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentGatewayToBeReviewed().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for updateBrandPaymentGatewayConfig",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {boolean} arg.refresh -
    * @param {string} arg.requestType -
+   * @returns {Promise<PaymentOptionsResponse>} - Success response
    * @summary: Get All Valid Payment Options
    * @description: Use this API to get Get All Valid Payment Options for making payment
    */
-  getPaymentModeRoutes({ refresh, requestType } = {}) {
+  async getPaymentModeRoutes({ refresh, requestType } = {}) {
     const { error } = PaymentValidator.getPaymentModeRoutes().validate(
       {
         refresh,
@@ -111,27 +223,63 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getPaymentModeRoutes().validate(
+      {
+        refresh,
+        requestType,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getPaymentModeRoutes",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["refresh"] = refresh;
     query_params["request_type"] = requestType;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/options`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentOptionsResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getPaymentModeRoutes",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.orderId -
    * @param {string} [arg.requestHash] -
+   * @returns {Promise<RefundAccountResponse>} - Success response
    * @summary: Get bank details
    * @description: Use this API to get saved bank details for returned/cancelled order using order id.
    */
-  getBankAccountDetailsOpenAPI({ orderId, requestHash } = {}) {
+  async getBankAccountDetailsOpenAPI({ orderId, requestHash } = {}) {
     const { error } = PaymentValidator.getBankAccountDetailsOpenAPI().validate(
       {
         orderId,
@@ -143,26 +291,64 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getBankAccountDetailsOpenAPI().validate(
+      {
+        orderId,
+        requestHash,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for getBankAccountDetailsOpenAPI",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["order_id"] = orderId;
     query_params["request_hash"] = requestHash;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/account`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.RefundAccountResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for getBankAccountDetailsOpenAPI",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {AddBeneficiaryDetailsOTPRequest} arg.body
+   * @returns {Promise<RefundAccountResponse>} - Success response
    * @summary: Save bank details for cancelled/returned order
    * @description: Use this API to save bank details for returned/cancelled order to refund amount in his account.
    */
-  addRefundBankAccountUsingOTP({ body } = {}) {
+  async addRefundBankAccountUsingOTP({ body } = {}) {
     const { error } = PaymentValidator.addRefundBankAccountUsingOTP().validate(
       {
         body,
@@ -173,24 +359,61 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.addRefundBankAccountUsingOTP().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message:
+          "Parameter Validation warrnings for addRefundBankAccountUsingOTP",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/account`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.RefundAccountResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message:
+          "Response Validation Warnnings for addRefundBankAccountUsingOTP",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.orderId -
+   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
    * @summary: List Order Beneficiary
    * @description: Get all active  beneficiary details added by the user for refund
    */
-  getUserOrderBeneficiaries({ orderId } = {}) {
+  async getUserOrderBeneficiaries({ orderId } = {}) {
     const { error } = PaymentValidator.getUserOrderBeneficiaries().validate(
       {
         orderId,
@@ -201,25 +424,60 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getUserOrderBeneficiaries().validate(
+      {
+        orderId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getUserOrderBeneficiaries",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["order_id"] = orderId;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/accounts/order`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.OrderBeneficiaryResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getUserOrderBeneficiaries",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.orderId -
+   * @returns {Promise<OrderBeneficiaryResponse>} - Success response
    * @summary: List User Beneficiary
    * @description: Get all active  beneficiary details added by the user for refund
    */
-  getUserBeneficiaries({ orderId } = {}) {
+  async getUserBeneficiaries({ orderId } = {}) {
     const { error } = PaymentValidator.getUserBeneficiaries().validate(
       {
         orderId,
@@ -230,25 +488,60 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getUserBeneficiaries().validate(
+      {
+        orderId,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getUserBeneficiaries",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["order_id"] = orderId;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/refund/accounts/user`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.OrderBeneficiaryResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getUserBeneficiaries",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {PaymentConfirmationRequest} arg.body
+   * @returns {Promise<PaymentConfirmationResponse>} - Success response
    * @summary: Confirm payment after successful payment from payment gateway
    * @description: Use this API to confirm payment after payment gateway accepted payment.
    */
-  confirmPayment({ body } = {}) {
+  async confirmPayment({ body } = {}) {
     const { error } = PaymentValidator.confirmPayment().validate(
       {
         body,
@@ -259,25 +552,58 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const { error: warrning } = PaymentValidator.confirmPayment().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for confirmPayment",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "post",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/confirm`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.PaymentConfirmationResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for confirmPayment",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {string} arg.merchantUserId -
    * @param {string} arg.mobileNo -
+   * @returns {Promise<GetUserCODLimitResponse>} - Success response
    * @summary: Get COD limit for user
    * @description: Use this API to get user cod limit and reamining limit for the payment
    */
-  getUserCODlimitRoutes({ merchantUserId, mobileNo } = {}) {
+  async getUserCODlimitRoutes({ merchantUserId, mobileNo } = {}) {
     const { error } = PaymentValidator.getUserCODlimitRoutes().validate(
       {
         merchantUserId,
@@ -289,26 +615,62 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.getUserCODlimitRoutes().validate(
+      {
+        merchantUserId,
+        mobileNo,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for getUserCODlimitRoutes",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
     query_params["merchant_user_id"] = merchantUserId;
     query_params["mobile_no"] = mobileNo;
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "get",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/user-cod`,
       query_params,
       undefined
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.GetUserCODLimitResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for getUserCODlimitRoutes",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 
   /**
    * @param {Object} arg - Arg object.
    * @param {SetCODForUserRequest} arg.body
+   * @returns {Promise<SetCODOptionResponse>} - Success response
    * @summary: Set COD option for user for payment
    * @description: Use this API to set cod option as true or false for the payment
    */
-  setUserCODlimitRoutes({ body } = {}) {
+  async setUserCODlimitRoutes({ body } = {}) {
     const { error } = PaymentValidator.setUserCODlimitRoutes().validate(
       {
         body,
@@ -319,15 +681,49 @@ class Payment {
       return Promise.reject(new FDKClientValidationError(error));
     }
 
+    // Showing warrnings if extra unknown parameters are found
+    const {
+      error: warrning,
+    } = PaymentValidator.setUserCODlimitRoutes().validate(
+      {
+        body,
+      },
+      { abortEarly: false, allowUnknown: false }
+    );
+    if (warrning) {
+      Logger({
+        level: "WARN",
+        message: "Parameter Validation warrnings for setUserCODlimitRoutes",
+      });
+      Logger({ level: "WARN", message: warrning });
+    }
+
     const query_params = {};
 
-    return PlatformAPIClient.execute(
+    const response = await PlatformAPIClient.execute(
       this.config,
       "put",
       `/service/platform/payment/v1.0/company/${this.config.companyId}/application/${this.applicationId}/payment/user-cod`,
       query_params,
       body
     );
+
+    const {
+      error: res_error,
+    } = PaymentModel.SetCODOptionResponse().validate(response, {
+      abortEarly: false,
+      allowUnknown: false,
+    });
+
+    if (res_error) {
+      Logger({
+        level: "WARN",
+        message: "Response Validation Warnnings for setUserCODlimitRoutes",
+      });
+      Logger({ level: "WARN", message: res_error });
+    }
+
+    return response;
   }
 }
 module.exports = Payment;