Record back

Author: Aniket Burman

crates/hyperswitch_connectors/src/connectors/recurly.rs

@@ -40,7 +40,11 @@ use masking::{ExposeInterface, Mask};
 use transformers as recurly;
 
 use crate::{constants::headers, types::ResponseRouterData, utils};
-
+use hyperswitch_domain_models::types::RevenueRecoveryRecordBackRouterData;
+use hyperswitch_domain_models::router_flow_types::RecoveryRecordBack;
+use hyperswitch_domain_models::router_request_types::revenue_recovery::RevenueRecoveryRecordBackRequest;
+use hyperswitch_domain_models::router_response_types::revenue_recovery::RevenueRecoveryRecordBackResponse;
+use crate::connectors::recurly::transformers::RecurlyRecordStatus;
 #[derive(Clone)]
 pub struct Recurly {
     amount_converter: &'static (dyn AmountConvertor<Output = StringMinorUnit> + Sync),
@@ -66,7 +70,8 @@ impl api::Refund for Recurly {}
 impl api::RefundExecute for Recurly {}
 impl api::RefundSync for Recurly {}
 impl api::PaymentToken for Recurly {}
-
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+impl api::revenue_recovery::RevenueRecoveryRecordBack for Recurly {}
 impl ConnectorIntegration<PaymentMethodToken, PaymentMethodTokenizationData, PaymentsResponseData>
     for Recurly
 {
@@ -541,6 +546,102 @@ impl ConnectorIntegration<RSync, RefundsData, RefundsResponseData> for Recurly {
     }
 }
 
+impl
+    ConnectorIntegration<
+        RecoveryRecordBack,
+        RevenueRecoveryRecordBackRequest,
+        RevenueRecoveryRecordBackResponse,
+    > for Recurly
+{
+    fn get_headers(
+        &self,
+        req: &RevenueRecoveryRecordBackRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+    fn get_url(
+        &self,
+        req: &RevenueRecoveryRecordBackRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        let invoice_id = req
+            .request
+            .merchant_reference_id
+            .get_string_repr()
+            .to_string();
+
+            let status = RecurlyRecordStatus::try_from(req.request.attempt_status)
+            .map_err(|_| errors::ConnectorError::NotSupported {
+                message: "Invalid attempt status for Recurly".to_string(),
+                connector: "recurly",
+            })?;
+    
+        
+        let status_endpoint = match status {
+            RecurlyRecordStatus::Success => "mark_successful",
+            RecurlyRecordStatus::Failure => "mark_failed",
+        }; 
+
+        Ok(format!(
+            "{}/invoices/{}/{}",
+            self.base_url(connectors),
+            invoice_id,
+            status_endpoint
+        ))
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn build_request(
+        &self,
+        req: &RevenueRecoveryRecordBackRouterData,
+        connectors: &Connectors,
+    ) -> CustomResult<Option<Request>, errors::ConnectorError> {
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Put)
+                .url(&types::RevenueRecoveryRecordBackType::get_url(
+                    self, req, connectors,
+                )?)
+                .attach_default_headers()
+                .headers(types::RevenueRecoveryRecordBackType::get_headers(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &RevenueRecoveryRecordBackRouterData,
+        event_builder: Option<&mut ConnectorEvent>,
+        res: Response,
+    ) -> CustomResult<RevenueRecoveryRecordBackRouterData, errors::ConnectorError> {
+        let response: recurly::RecurlyRecordbackResponse = res
+            .response
+            .parse_struct("recurly RecurlyRecordbackResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        event_builder.map(|i| i.set_response_body(&response));
+        router_env::logger::info!(connector_response=?response);
+        RouterData::try_from(ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+        event_builder: Option<&mut ConnectorEvent>,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res, event_builder)
+    }
+}
+
 #[async_trait::async_trait]
 impl webhooks::IncomingWebhook for Recurly {
     fn get_webhook_object_reference_id(

crates/hyperswitch_connectors/src/connectors/recurly/transformers.rs

@@ -16,6 +16,10 @@ use crate::{
     types::{RefundsResponseRouterData, ResponseRouterData},
     utils::PaymentsAuthorizeRequestData,
 };
+use hyperswitch_domain_models::router_flow_types::RecoveryRecordBack;
+use hyperswitch_domain_models::router_request_types::revenue_recovery::RevenueRecoveryRecordBackRequest;
+use hyperswitch_domain_models::router_response_types::revenue_recovery::RevenueRecoveryRecordBackResponse;
+use hyperswitch_domain_models::types::RevenueRecoveryRecordBackRouterData;
 
 //TODO: Fill the struct with respective fields
 pub struct RecurlyRouterData<T> {
@@ -226,3 +230,88 @@ pub struct RecurlyErrorResponse {
     pub message: String,
     pub reason: Option<String>,
 }
+
+#[derive(Debug, Serialize, Clone, Copy)]
+#[serde(rename_all = "snake_case")]
+pub enum RecurlyRecordStatus {
+    Success,
+    Failure,
+}
+
+#[cfg(all(feature = "v2", feature = "revenue_recovery"))]
+impl TryFrom<enums::AttemptStatus> for RecurlyRecordStatus {
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(status: enums::AttemptStatus) -> Result<Self, Self::Error> {
+        match status {
+            enums::AttemptStatus::Charged
+            | enums::AttemptStatus::PartialCharged
+            | enums::AttemptStatus::PartialChargedAndChargeable => Ok(Self::Success),
+            enums::AttemptStatus::Failure
+            | enums::AttemptStatus::CaptureFailed
+            | enums::AttemptStatus::RouterDeclined => Ok(Self::Failure),
+            enums::AttemptStatus::AuthenticationFailed
+            | enums::AttemptStatus::Started
+            | enums::AttemptStatus::AuthenticationPending
+            | enums::AttemptStatus::AuthenticationSuccessful
+            | enums::AttemptStatus::Authorized
+            | enums::AttemptStatus::AuthorizationFailed
+            | enums::AttemptStatus::Authorizing
+            | enums::AttemptStatus::CodInitiated
+            | enums::AttemptStatus::Voided
+            | enums::AttemptStatus::VoidInitiated
+            | enums::AttemptStatus::CaptureInitiated
+            | enums::AttemptStatus::VoidFailed
+            | enums::AttemptStatus::AutoRefunded
+            | enums::AttemptStatus::Unresolved
+            | enums::AttemptStatus::Pending
+            | enums::AttemptStatus::PaymentMethodAwaited
+            | enums::AttemptStatus::ConfirmationAwaited
+            | enums::AttemptStatus::DeviceDataCollectionPending => {
+                Err(errors::ConnectorError::NotSupported {
+                    message: "Record back flow is only supported for terminal status".to_string(),
+                    connector: "recurly",
+                }
+                .into())
+            }
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct RecurlyRecordbackResponse {
+    pub invoice: RecurlyRecordbackInvoice,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct RecurlyRecordbackInvoice {
+    pub id: common_utils::id_type::PaymentReferenceId,
+}
+
+impl
+    TryFrom<
+        ResponseRouterData<
+            RecoveryRecordBack,
+            RecurlyRecordbackResponse,
+            RevenueRecoveryRecordBackRequest,
+            RevenueRecoveryRecordBackResponse,
+        >,
+    > for RevenueRecoveryRecordBackRouterData
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: ResponseRouterData<
+            RecoveryRecordBack,
+            RecurlyRecordbackResponse,
+            RevenueRecoveryRecordBackRequest,
+            RevenueRecoveryRecordBackResponse,
+        >,
+    ) -> Result<Self, Self::Error> {
+        let merchant_reference_id = item.response.invoice.id;
+        Ok(Self {
+            response: Ok(RevenueRecoveryRecordBackResponse {
+                merchant_reference_id,
+            }),
+            ..item.data
+        })
+    }
+}

crates/hyperswitch_connectors/src/default_implementations.rs

@@ -3678,7 +3678,7 @@ default_imp_for_revenue_recovery_record_back!(
     connectors::Placetopay,
     connectors::Rapyd,
     connectors::Razorpay,
-    connectors::Recurly,
+    // connectors::Recurly,
     connectors::Redsys,
     connectors::Shift4,
     connectors::Stax,

crates/hyperswitch_domain_models/src/router_flow_types/revenue_recovery.rs

@@ -1,2 +1,3 @@
 pub struct GetAdditionalRevenueRecoveryDetails;
+#[derive(Clone)]
 pub struct RecoveryRecordBack;