feat(connector): [Noon] Add Card Mandates and Webhooks Support

crates/api_models/src/payments.rs

@@ -1559,6 +1559,8 @@ pub struct Metadata {
     #[schema(value_type = Object, example = r#"{ "city": "NY", "unit": "245" }"#)]
     #[serde(flatten)]
     pub data: pii::SecretSerdeValue,
+    /// Information about the order category that merchant wants to specify at connector level. (e.g. In Noon Payments it can take values like "pay", "food", or any other custom string set by the merchant in Noon's Dashboard)
+    pub order_category: Option<String>,
 
     /// Redirection response coming in request as metadata field only for redirection scenarios
     pub redirect_response: Option<RedirectResponse>,

crates/router/src/connector/bluesnap.rs

@@ -1053,7 +1053,7 @@ impl api::IncomingWebhook for Bluesnap {
         let details: bluesnap::BluesnapWebhookObjectResource =
             serde_urlencoded::from_bytes(request.body)
                 .into_report()
-                .change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
+                .change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
         let res_json =
             utils::Encode::<transformers::BluesnapWebhookObjectResource>::encode_to_value(&details)
                 .change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;

crates/router/src/connector/noon.rs

@@ -3,6 +3,7 @@ mod transformers;
 use std::fmt::Debug;
 
 use base64::Engine;
+use common_utils::{crypto, ext_traits::ByteSliceExt};
 use error_stack::{IntoReport, ResultExt};
 use transformers as noon;
 
@@ -14,6 +15,7 @@ use crate::{
         errors::{self, CustomResult},
         payments,
     },
+    db::StorageInterface,
     headers,
     services::{self, ConnectorIntegration},
     types::{
@@ -579,24 +581,112 @@ impl services::ConnectorRedirectResponse for Noon {
 
 #[async_trait::async_trait]
 impl api::IncomingWebhook for Noon {
-    fn get_webhook_object_reference_id(
+    fn get_webhook_source_verification_algorithm(
         &self,
         _request: &api::IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<Box<dyn crypto::VerifySignature + Send>, errors::ConnectorError> {
+        Ok(Box::new(crypto::HmacSha512))
+    }
+
+    fn get_webhook_source_verification_signature(
+        &self,
+        request: &api::IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {
+        let webhook_body: noon::NoonWebhookSignature = request
+            .body
+            .parse_struct("NoonWebhookSignature")
+            .change_context(errors::ConnectorError::WebhookSignatureNotFound)?;
+        let signature = webhook_body.signature;
+        consts::BASE64_ENGINE
+            .decode(signature)
+            .into_report()
+            .change_context(errors::ConnectorError::WebhookSignatureNotFound)
+    }
+
+    fn get_webhook_source_verification_message(
+        &self,
+        request: &api::IncomingWebhookRequestDetails<'_>,
+        _merchant_id: &str,
+        _secret: &[u8],
+    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {
+        let webhook_body: noon::NoonWebhookBody = request
+            .body
+            .parse_struct("NoonWebhookBody")
+            .change_context(errors::ConnectorError::WebhookSignatureNotFound)?;
+        let message = format!(
+            "{},{},{},{},{}",
+            webhook_body.order_id,
+            webhook_body.order_status,
+            webhook_body.event_id,
+            webhook_body.event_type,
+            webhook_body.time_stamp,
+        );
+        Ok(message.into_bytes())
+    }
+
+    async fn get_webhook_source_verification_merchant_secret(
+        &self,
+        db: &dyn StorageInterface,
+        merchant_id: &str,
+    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {
+        let key = format!("whsec_verification_{}_{}", self.id(), merchant_id);
+        let secret = match db.find_config_by_key(&key).await {
+            Ok(config) => Some(config),
+            Err(e) => {
+                crate::logger::warn!("Unable to fetch merchant webhook secret from DB: {:#?}", e);
+                None
+            }
+        };
+        Ok(secret
+            .map(|conf| conf.config.into_bytes())
+            .unwrap_or_default())
+    }
+
+    fn get_webhook_object_reference_id(
+        &self,
+        request: &api::IncomingWebhookRequestDetails<'_>,
     ) -> CustomResult<api::webhooks::ObjectReferenceId, errors::ConnectorError> {
-        Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
+        let details: noon::NoonWebhookOrderId = request
+            .body
+            .parse_struct("NoonWebhookOrderId")
+            .change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;
+        Ok(api_models::webhooks::ObjectReferenceId::PaymentId(
+            api_models::payments::PaymentIdType::ConnectorTransactionId(
+                details.order_id.to_string(),
+            ),
+        ))
     }
 
     fn get_webhook_event_type(
         &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
+        request: &api::IncomingWebhookRequestDetails<'_>,
     ) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
-        Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
+        let details: noon::NoonWebhookEvent = request
+            .body
+            .parse_struct("NoonWebhookEvent")
+            .change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;
+
+        Ok(match &details.event_type {
+            noon::NoonWebhookEventTypes::Sale | noon::NoonWebhookEventTypes::Capture => {
+                match &details.order_status {
+                    noon::NoonPaymentStatus::Captured => {
+                        api::IncomingWebhookEvent::PaymentIntentSuccess
+                    }
+                    _ => Err(errors::ConnectorError::WebhookEventTypeNotFound)?,
+                }
+            }
+            noon::NoonWebhookEventTypes::Fail => api::IncomingWebhookEvent::PaymentIntentFailure,
+            _ => Err(errors::ConnectorError::WebhookEventTypeNotFound)?,
+        })
     }
 
     fn get_webhook_resource_object(
         &self,
-        _request: &api::IncomingWebhookRequestDetails<'_>,
+        request: &api::IncomingWebhookRequestDetails<'_>,
     ) -> CustomResult<serde_json::Value, errors::ConnectorError> {
-        Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
+        let reference_object: serde_json::Value = serde_json::from_slice(request.body)
+            .into_report()
+            .change_context(errors::ConnectorError::WebhookResourceObjectNotFound)?;
+        Ok(reference_object)
     }
 }