Add files using upload-large-folder tool

diffs/pr_10051/fb23500/diff.json

@@ -0,0 +1,125 @@
+{
+  "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca",
+  "pr_number": 10051,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/novalnet.rs",
+    "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::function::get_incoming_webhook_event",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_incoming_webhook_event(\n    status: WebhookEventType,\n    transaction_status: NovalnetTransactionStatus,\n) -> IncomingWebhookEvent {\n    match status {\n        WebhookEventType::Payment => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::PaymentIntentSuccess\n            }\n            NovalnetTransactionStatus::OnHold => {\n                IncomingWebhookEvent::PaymentIntentAuthorizationSuccess\n            }\n            NovalnetTransactionStatus::Pending => IncomingWebhookEvent::PaymentIntentProcessing,\n            NovalnetTransactionStatus::Progress => IncomingWebhookEvent::EventNotSupported,\n            _ => IncomingWebhookEvent::PaymentIntentFailure,\n        },\n        WebhookEventType::TransactionCapture => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::PaymentIntentCaptureSuccess\n            }\n            _ => IncomingWebhookEvent::PaymentIntentCaptureFailure,\n        },\n        WebhookEventType::TransactionCancel => match transaction_status {\n            NovalnetTransactionStatus::Deactivated => IncomingWebhookEvent::PaymentIntentCancelled,\n            _ => IncomingWebhookEvent::PaymentIntentCancelFailure,\n        },\n        WebhookEventType::TransactionRefund => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::RefundSuccess\n            }\n            _ => IncomingWebhookEvent::RefundFailure,\n        },\n        WebhookEventType::Chargeback => IncomingWebhookEvent::DisputeOpened,\n        WebhookEventType::Credit => IncomingWebhookEvent::DisputeWon,\n    }\n}",
+      "after_code": "pub fn get_incoming_webhook_event(\n    status: WebhookEventType,\n    transaction_status: NovalnetTransactionStatus,\n    payment_type: Option<NovalNetPaymentTypes>,\n) -> IncomingWebhookEvent {\n    match status {\n        WebhookEventType::Payment => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::PaymentIntentSuccess\n            }\n            NovalnetTransactionStatus::OnHold => {\n                IncomingWebhookEvent::PaymentIntentAuthorizationSuccess\n            }\n            NovalnetTransactionStatus::Pending => IncomingWebhookEvent::PaymentIntentProcessing,\n            NovalnetTransactionStatus::Progress => IncomingWebhookEvent::EventNotSupported,\n            _ => IncomingWebhookEvent::PaymentIntentFailure,\n        },\n        WebhookEventType::TransactionCapture => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::PaymentIntentCaptureSuccess\n            }\n            _ => IncomingWebhookEvent::PaymentIntentCaptureFailure,\n        },\n        WebhookEventType::TransactionCancel => match transaction_status {\n            NovalnetTransactionStatus::Deactivated => IncomingWebhookEvent::PaymentIntentCancelled,\n            _ => IncomingWebhookEvent::PaymentIntentCancelFailure,\n        },\n        WebhookEventType::TransactionRefund => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::RefundSuccess\n            }\n            _ => IncomingWebhookEvent::RefundFailure,\n        },\n        WebhookEventType::Chargeback => {\n            if matches!(transaction_status, NovalnetTransactionStatus::Confirmed)\n                && matches!(payment_type, Some(NovalNetPaymentTypes::ReturnDebitSepa))\n            {\n                IncomingWebhookEvent::DisputeLost\n            } else {\n                IncomingWebhookEvent::EventNotSupported\n            }\n        }\n        WebhookEventType::Credit => IncomingWebhookEvent::DisputeWon,\n    }\n}",
+      "diff_span": {
+        "before": "            _ => IncomingWebhookEvent::RefundFailure,\n        },\n        WebhookEventType::Chargeback => IncomingWebhookEvent::DisputeOpened,\n        WebhookEventType::Credit => IncomingWebhookEvent::DisputeWon,\n    }",
+        "after": "    status: WebhookEventType,\n    transaction_status: NovalnetTransactionStatus,\n    payment_type: Option<NovalNetPaymentTypes>,\n) -> IncomingWebhookEvent {\n    match status {\n        WebhookEventType::Payment => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::PaymentIntentSuccess\n            }\n            NovalnetTransactionStatus::OnHold => {\n                IncomingWebhookEvent::PaymentIntentAuthorizationSuccess\n            }\n            NovalnetTransactionStatus::Pending => IncomingWebhookEvent::PaymentIntentProcessing,\n            NovalnetTransactionStatus::Progress => IncomingWebhookEvent::EventNotSupported,\n            _ => IncomingWebhookEvent::PaymentIntentFailure,\n        },\n        WebhookEventType::TransactionCapture => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::PaymentIntentCaptureSuccess\n            }\n            _ => IncomingWebhookEvent::PaymentIntentCaptureFailure,\n        },\n        WebhookEventType::TransactionCancel => match transaction_status {\n            NovalnetTransactionStatus::Deactivated => IncomingWebhookEvent::PaymentIntentCancelled,\n            _ => IncomingWebhookEvent::PaymentIntentCancelFailure,\n        },\n        WebhookEventType::TransactionRefund => match transaction_status {\n            NovalnetTransactionStatus::Confirmed | NovalnetTransactionStatus::Success => {\n                IncomingWebhookEvent::RefundSuccess\n            }\n            _ => IncomingWebhookEvent::RefundFailure,\n        },\n        WebhookEventType::Chargeback => {\n            if matches!(transaction_status, NovalnetTransactionStatus::Confirmed)\n                && matches!(payment_type, Some(NovalNetPaymentTypes::ReturnDebitSepa))\n            {\n                IncomingWebhookEvent::DisputeLost\n            } else {\n                IncomingWebhookEvent::EventNotSupported\n            }\n        }\n        WebhookEventType::Credit => IncomingWebhookEvent::DisputeWon,\n    }"
+      },
+      "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::enum::NovalnetWebhookTransactionData",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "enum_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub enum NovalnetWebhookTransactionData {\n    SyncTransactionData(NovalnetSyncResponseTransactionData),\n    CaptureTransactionData(NovalnetCaptureTransactionData),\n    CancelTransactionData(NovalnetPaymentsResponseTransactionData),\n    RefundsTransactionData(NovalnetRefundsTransactionData),\n}",
+      "after_code": "pub enum NovalnetWebhookTransactionData {\n    ChargebackTransactionData(NovalnetChargebackTransactionData),\n    SyncTransactionData(NovalnetSyncResponseTransactionData),\n    CaptureTransactionData(NovalnetCaptureTransactionData),\n    CancelTransactionData(NovalnetPaymentsResponseTransactionData),\n    RefundsTransactionData(NovalnetRefundsTransactionData),\n}",
+      "diff_span": {
+        "before": "",
+        "after": "pub enum NovalnetWebhookTransactionData {\n    ChargebackTransactionData(NovalnetChargebackTransactionData),\n    SyncTransactionData(NovalnetSyncResponseTransactionData),\n    CaptureTransactionData(NovalnetCaptureTransactionData),"
+      },
+      "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet.rs::Novalnet::function::get_dispute_details",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_dispute_details(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<disputes::DisputePayload, errors::ConnectorError> {\n        let notif: transformers::NovalnetWebhookNotificationResponse =\n            get_webhook_object_from_body(request.body)\n                .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;\n        let (amount, currency, reason, reason_code) = match notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => {\n                (data.amount, data.currency, None, None)\n            }\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => {\n                (data.amount, data.currency, None, None)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {\n                (data.amount, data.currency, None, None)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                (data.amount, data.currency, data.reason, data.reason_code)\n            }\n        };\n\n        let dispute_status =\n            novalnet::get_novalnet_dispute_status(notif.event.event_type).to_string();\n        Ok(disputes::DisputePayload {\n            amount: utils::convert_amount(\n                self.amount_converter,\n                amount.ok_or(errors::ConnectorError::AmountConversionFailed)?,\n                novalnet::option_to_result(currency)?,\n            )?,\n            currency: novalnet::option_to_result(currency)?,\n            dispute_stage: api_models::enums::DisputeStage::Dispute,\n            connector_dispute_id: notif.event.tid.to_string(),\n            connector_reason: reason,\n            connector_reason_code: reason_code,\n            challenge_required_by: None,\n            connector_status: dispute_status,\n            created_at: None,\n            updated_at: None,\n        })\n    }",
+      "after_code": "fn get_dispute_details(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<disputes::DisputePayload, errors::ConnectorError> {\n        let notif: transformers::NovalnetWebhookNotificationResponse =\n            get_webhook_object_from_body(request.body)\n                .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;\n        let (amount, currency, reason, reason_code) = match notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => {\n                (data.amount, data.currency, None, None)\n            }\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => {\n                (data.amount, data.currency, None, None)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {\n                (data.amount, data.currency, None, None)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                (data.amount, data.currency, data.reason, data.reason_code)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(data) => {\n                (data.amount, data.currency, data.reason, data.reason_code)\n            }\n        };\n\n        let dispute_status =\n            novalnet::get_novalnet_dispute_status(notif.event.event_type).to_string();\n        Ok(disputes::DisputePayload {\n            amount: utils::convert_amount(\n                self.amount_converter,\n                amount.ok_or(errors::ConnectorError::AmountConversionFailed)?,\n                novalnet::option_to_result(currency)?,\n            )?,\n            currency: novalnet::option_to_result(currency)?,\n            dispute_stage: api_models::enums::DisputeStage::Dispute,\n            connector_dispute_id: notif.event.tid.to_string(),\n            connector_reason: reason,\n            connector_reason_code: reason_code,\n            challenge_required_by: None,\n            connector_status: dispute_status,\n            created_at: None,\n            updated_at: None,\n        })\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                (data.amount, data.currency, data.reason, data.reason_code)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(data) => {\n                (data.amount, data.currency, data.reason, data.reason_code)\n            }"
+      },
+      "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::enum::NovalNetPaymentTypes",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "enum_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub enum NovalNetPaymentTypes {\n    CREDITCARD,\n    PAYPAL,\n    GOOGLEPAY,\n    APPLEPAY,\n    #[serde(rename = \"DIRECT_DEBIT_SEPA\")]\n    DirectDebitSepa,\n    #[serde(rename = \"GUARANTEED_DIRECT_DEBIT_SEPA\")]\n    GuaranteedDirectDebitSepa,\n}",
+      "after_code": "pub enum NovalNetPaymentTypes {\n    CREDITCARD,\n    PAYPAL,\n    GOOGLEPAY,\n    APPLEPAY,\n    #[serde(rename = \"DIRECT_DEBIT_SEPA\")]\n    DirectDebitSepa,\n    #[serde(rename = \"GUARANTEED_DIRECT_DEBIT_SEPA\")]\n    GuaranteedDirectDebitSepa,\n    #[serde(rename = \"RETURN_DEBIT_SEPA\")]\n    ReturnDebitSepa,\n}",
+      "diff_span": {
+        "before": "",
+        "after": "    #[serde(rename = \"GUARANTEED_DIRECT_DEBIT_SEPA\")]\n    GuaranteedDirectDebitSepa,\n    #[serde(rename = \"RETURN_DEBIT_SEPA\")]\n    ReturnDebitSepa,\n}"
+      },
+      "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet.rs::Novalnet::function::get_webhook_object_reference_id",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_webhook_object_reference_id(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {\n        let notif = get_webhook_object_from_body(request.body)\n            .change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;\n        let transaction_order_no = match notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => data.order_no,\n        };\n\n        if novalnet::is_refund_event(&notif.event.event_type) {\n            Ok(api_models::webhooks::ObjectReferenceId::RefundId(\n                api_models::webhooks::RefundIdType::ConnectorRefundId(notif.event.tid.to_string()),\n            ))\n        } else {\n            match transaction_order_no {\n                Some(order_no) => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(\n                    api_models::payments::PaymentIdType::PaymentAttemptId(order_no),\n                )),\n                None => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(\n                    api_models::payments::PaymentIdType::ConnectorTransactionId(\n                        notif.event.tid.to_string(),\n                    ),\n                )),\n            }\n        }\n    }",
+      "after_code": "fn get_webhook_object_reference_id(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::ObjectReferenceId, errors::ConnectorError> {\n        let notif = get_webhook_object_from_body(request.body)\n            .change_context(errors::ConnectorError::WebhookReferenceIdNotFound)?;\n        let transaction_order_no = match notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(data) => {\n                data.order_no\n            }\n        };\n\n        if novalnet::is_refund_event(&notif.event.event_type) {\n            Ok(api_models::webhooks::ObjectReferenceId::RefundId(\n                api_models::webhooks::RefundIdType::ConnectorRefundId(notif.event.tid.to_string()),\n            ))\n        } else {\n            match transaction_order_no {\n                Some(order_no) => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(\n                    api_models::payments::PaymentIdType::PaymentAttemptId(order_no),\n                )),\n                None => Ok(api_models::webhooks::ObjectReferenceId::PaymentId(\n                    api_models::payments::PaymentIdType::ConnectorTransactionId(\n                        notif.event.tid.to_string(),\n                    ),\n                )),\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => data.order_no,\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(data) => {\n                data.order_no\n            }\n        };\n"
+      },
+      "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet.rs::Novalnet::function::get_webhook_event_type",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_webhook_event_type(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {\n        let notif = get_webhook_object_from_body(request.body)\n            .change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;\n\n        let optional_transaction_status = match notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => data.status,\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.status,\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {\n                Some(data.status)\n            }\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                Some(data.status)\n            }\n        };\n\n        let transaction_status =\n            optional_transaction_status.ok_or(errors::ConnectorError::MissingRequiredField {\n                field_name: \"transaction_status\",\n            })?;\n        // NOTE: transaction_status will always be present for Webhooks\n        // But we are handling optional type here, since we are reusing TransactionData Struct from NovalnetPaymentsResponseTransactionData for Webhooks response too\n        // In NovalnetPaymentsResponseTransactionData, transaction_status is optional\n\n        let incoming_webhook_event =\n            novalnet::get_incoming_webhook_event(notif.event.event_type, transaction_status);\n        Ok(incoming_webhook_event)\n    }",
+      "after_code": "fn get_webhook_event_type(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n    ) -> CustomResult<api_models::webhooks::IncomingWebhookEvent, errors::ConnectorError> {\n        let notif = get_webhook_object_from_body(request.body)\n            .change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;\n\n        let optional_transaction_status = match &notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => data.status,\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.status,\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {\n                Some(data.status)\n            }\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                Some(data.status)\n            }\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(data) => {\n                Some(data.status)\n            }\n        };\n\n        let transaction_status =\n            optional_transaction_status.ok_or(errors::ConnectorError::MissingRequiredField {\n                field_name: \"transaction_status\",\n            })?;\n        // NOTE: transaction_status will always be present for Webhooks\n        // But we are handling optional type here, since we are reusing TransactionData Struct from NovalnetPaymentsResponseTransactionData for Webhooks response too\n        // In NovalnetPaymentsResponseTransactionData, transaction_status is optional\n\n        let payment_type = match notif.transaction.clone() {\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(_) => {\n                Some(novalnet::NovalNetPaymentTypes::ReturnDebitSepa)\n            }\n            _ => None,\n        };\n\n        let incoming_webhook_event = novalnet::get_incoming_webhook_event(\n            notif.event.event_type,\n            transaction_status,\n            payment_type,\n        );\n        Ok(incoming_webhook_event)\n    }",
+      "diff_span": {
+        "before": "            .change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;\n\n        let optional_transaction_status = match notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => data.status,\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.status,\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {\n                Some(data.status)\n            }\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                Some(data.status)\n            }\n        };\n\n        let transaction_status =\n            optional_transaction_status.ok_or(errors::ConnectorError::MissingRequiredField {\n                field_name: \"transaction_status\",\n            })?;\n        // NOTE: transaction_status will always be present for Webhooks\n        // But we are handling optional type here, since we are reusing TransactionData Struct from NovalnetPaymentsResponseTransactionData for Webhooks response too\n        // In NovalnetPaymentsResponseTransactionData, transaction_status is optional\n\n        let incoming_webhook_event =\n            novalnet::get_incoming_webhook_event(notif.event.event_type, transaction_status);\n        Ok(incoming_webhook_event)\n    }",
+        "after": "            .change_context(errors::ConnectorError::WebhookEventTypeNotFound)?;\n\n        let optional_transaction_status = match &notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => data.status,\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => data.status,\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {\n                Some(data.status)\n            }\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                Some(data.status)\n            }\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(data) => {\n                Some(data.status)\n            }\n        };\n\n        let transaction_status =\n            optional_transaction_status.ok_or(errors::ConnectorError::MissingRequiredField {\n                field_name: \"transaction_status\",\n            })?;\n        // NOTE: transaction_status will always be present for Webhooks\n        // But we are handling optional type here, since we are reusing TransactionData Struct from NovalnetPaymentsResponseTransactionData for Webhooks response too\n        // In NovalnetPaymentsResponseTransactionData, transaction_status is optional\n\n        let payment_type = match notif.transaction.clone() {\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(_) => {\n                Some(novalnet::NovalNetPaymentTypes::ReturnDebitSepa)\n            }\n            _ => None,\n        };\n\n        let incoming_webhook_event = novalnet::get_incoming_webhook_event(\n            notif.event.event_type,\n            transaction_status,\n            payment_type,\n        );\n        Ok(incoming_webhook_event)\n    }"
+      },
+      "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet.rs::Novalnet::function::get_webhook_source_verification_message",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_webhook_source_verification_message(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        let notif = get_webhook_object_from_body(request.body)\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n        let (amount, currency) = match notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n        };\n        let amount = amount\n            .map(|amount| amount.to_string())\n            .unwrap_or(\"\".to_string());\n        let currency = currency\n            .map(|amount| amount.to_string())\n            .unwrap_or(\"\".to_string());\n\n        let secret_auth = String::from_utf8(connector_webhook_secrets.secret.to_vec())\n            .change_context(errors::ConnectorError::WebhookVerificationSecretInvalid)\n            .attach_printable(\"Could not convert webhook secret auth to UTF-8\")?;\n        let reversed_secret_auth = novalnet::reverse_string(&secret_auth);\n\n        let message = format!(\n            \"{}{}{}{}{}{}\",\n            notif.event.tid,\n            notif.event.event_type,\n            notif.result.status,\n            amount,\n            currency,\n            reversed_secret_auth\n        );\n\n        Ok(message.into_bytes())\n    }",
+      "after_code": "fn get_webhook_source_verification_message(\n        &self,\n        request: &webhooks::IncomingWebhookRequestDetails<'_>,\n        _merchant_id: &common_utils::id_type::MerchantId,\n        connector_webhook_secrets: &api_models::webhooks::ConnectorWebhookSecrets,\n    ) -> CustomResult<Vec<u8>, errors::ConnectorError> {\n        let notif = get_webhook_object_from_body(request.body)\n            .change_context(errors::ConnectorError::WebhookSourceVerificationFailed)?;\n        let (amount, currency) = match notif.transaction {\n            novalnet::NovalnetWebhookTransactionData::CaptureTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n            novalnet::NovalnetWebhookTransactionData::CancelTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::RefundsTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n        };\n        let amount = amount\n            .map(|amount| amount.to_string())\n            .unwrap_or(\"\".to_string());\n        let currency = currency\n            .map(|amount| amount.to_string())\n            .unwrap_or(\"\".to_string());\n\n        let secret_auth = String::from_utf8(connector_webhook_secrets.secret.to_vec())\n            .change_context(errors::ConnectorError::WebhookVerificationSecretInvalid)\n            .attach_printable(\"Could not convert webhook secret auth to UTF-8\")?;\n        let reversed_secret_auth = novalnet::reverse_string(&secret_auth);\n\n        let message = format!(\n            \"{}{}{}{}{}{}\",\n            notif.event.tid,\n            notif.event.event_type,\n            notif.result.status,\n            amount,\n            currency,\n            reversed_secret_auth\n        );\n\n        Ok(message.into_bytes())\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "\n            novalnet::NovalnetWebhookTransactionData::SyncTransactionData(data) => {\n                (data.amount, data.currency)\n            }\n\n            novalnet::NovalnetWebhookTransactionData::ChargebackTransactionData(data) => {\n                (data.amount, data.currency)\n            }"
+      },
+      "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::struct::NovalnetChargebackTransactionData",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct NovalnetChargebackTransactionData {\n    pub amount: Option<MinorUnit>,\n    pub currency: Option<common_enums::Currency>,\n    pub order_no: Option<String>,\n    pub payment_type: NovalNetPaymentTypes,\n    pub status: NovalnetTransactionStatus,\n    pub status_code: u64,\n    pub test_mode: u8,\n    pub tid: Option<Secret<i64>>,\n    pub reason: Option<String>,\n    pub reason_code: Option<String>,\n}",
+      "diff_span": null,
+      "commit_sha": "fb23500dab93b9430846222f7c5fb60b5ebb52ca"
+    }
+  ]
+}

diffs/pr_10059/d34460b/diff.json

@@ -0,0 +1,9 @@
+{
+  "commit_sha": "d34460bfdb98b07667b12e2230c81053bebc5a6e",
+  "pr_number": 10059,
+  "rust_files": [
+    "crates/api_models/src/authentication.rs",
+    "crates/router/src/services/authentication.rs"
+  ],
+  "diffs": []
+}

diffs/pr_10112/036c679/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "036c679caef1809920803da22767698dd54e1925",
+  "pr_number": 10112,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10112/07a3026/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "07a3026e88cb6e5824975682c1d7ea44b3371455",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::impl::RefundsRouterData<Execute>",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<RefundsResponseRouterData<Execute, TesouroRefundResponse>>\n    for RefundsRouterData<Execute>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(refund_previous_payment_response) = response\n                    .data\n                    .refund_previous_payment\n                    .refund_previous_payment_response\n                {\n                    let transaction_id = refund_previous_payment_response.transaction_id;\n                    match refund_previous_payment_response.type_name {\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {\n                            Ok(Self {\n                                response: Ok(RefundsResponseData {\n                                    connector_refund_id: transaction_id,\n                                    refund_status: enums::RefundStatus::Success,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {\n                            Ok(Self {\n                                response: Err(ErrorResponse {\n                                    code: refund_previous_payment_response\n                                        .decline_type\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_CODE.to_string()),\n                                    message: refund_previous_payment_response\n                                        .message\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                                    reason: refund_previous_payment_response.message.clone(),\n                                    status_code: item.http_code,\n                                    attempt_status: None,\n                                    connector_transaction_id: None,\n                                    network_advice_code: None,\n                                    network_decline_code: None,\n                                    network_error_message: None,\n                                    connector_metadata: None,\n                                    mandate_reference: None,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        None => Ok(Self {\n                            response: Ok(RefundsResponseData {\n                                connector_refund_id: transaction_id,\n                                refund_status: enums::RefundStatus::Pending,\n                            }),\n                            ..item.data\n                        }),\n                    }\n                } else if let Some(errors) = response.data.refund_previous_payment.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or refund_previous_payment_response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "after_code": "impl TryFrom<RefundsResponseRouterData<Execute, TesouroRefundResponse>>\n    for RefundsRouterData<Execute>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(refund_previous_payment_response) = response\n                    .data\n                    .refund_previous_payment\n                    .refund_previous_payment_response\n                {\n                    let transaction_id = refund_previous_payment_response.transaction_id;\n                    match refund_previous_payment_response.type_name {\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {\n                            Ok(Self {\n                                response: Ok(RefundsResponseData {\n                                    connector_refund_id: transaction_id,\n                                    refund_status: enums::RefundStatus::Success,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {\n                            Ok(Self {\n                                response: Err(ErrorResponse {\n                                    code: refund_previous_payment_response\n                                        .decline_type\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_CODE.to_string()),\n                                    message: refund_previous_payment_response\n                                        .message\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                                    reason: refund_previous_payment_response.message.clone(),\n                                    status_code: item.http_code,\n                                    attempt_status: None,\n                                    connector_transaction_id: None,\n                                    network_advice_code: None,\n                                    network_decline_code: None,\n                                    network_error_message: None,\n                                    connector_metadata: None,\n                                    mandate_reference: None,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        None => Ok(Self {\n                            response: Ok(RefundsResponseData {\n                                connector_refund_id: transaction_id,\n                                refund_status: enums::RefundStatus::Pending,\n                            }),\n                            ..item.data\n                        }),\n                    }\n                } else if let Some(errors) = response.data.refund_previous_payment.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or refund_previous_payment_response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data",
+        "after": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "07a3026e88cb6e5824975682c1d7ea44b3371455"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::RefundsRouterData<Execute>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(refund_previous_payment_response) = response\n                    .data\n                    .refund_previous_payment\n                    .refund_previous_payment_response\n                {\n                    let transaction_id = refund_previous_payment_response.transaction_id;\n                    match refund_previous_payment_response.type_name {\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {\n                            Ok(Self {\n                                response: Ok(RefundsResponseData {\n                                    connector_refund_id: transaction_id,\n                                    refund_status: enums::RefundStatus::Success,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {\n                            Ok(Self {\n                                response: Err(ErrorResponse {\n                                    code: refund_previous_payment_response\n                                        .decline_type\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_CODE.to_string()),\n                                    message: refund_previous_payment_response\n                                        .message\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                                    reason: refund_previous_payment_response.message.clone(),\n                                    status_code: item.http_code,\n                                    attempt_status: None,\n                                    connector_transaction_id: None,\n                                    network_advice_code: None,\n                                    network_decline_code: None,\n                                    network_error_message: None,\n                                    connector_metadata: None,\n                                    mandate_reference: None,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        None => Ok(Self {\n                            response: Ok(RefundsResponseData {\n                                connector_refund_id: transaction_id,\n                                refund_status: enums::RefundStatus::Pending,\n                            }),\n                            ..item.data\n                        }),\n                    }\n                } else if let Some(errors) = response.data.refund_previous_payment.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or refund_previous_payment_response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "after_code": "fn try_from(\n        item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(refund_previous_payment_response) = response\n                    .data\n                    .refund_previous_payment\n                    .refund_previous_payment_response\n                {\n                    let transaction_id = refund_previous_payment_response.transaction_id;\n                    match refund_previous_payment_response.type_name {\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {\n                            Ok(Self {\n                                response: Ok(RefundsResponseData {\n                                    connector_refund_id: transaction_id,\n                                    refund_status: enums::RefundStatus::Success,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {\n                            Ok(Self {\n                                response: Err(ErrorResponse {\n                                    code: refund_previous_payment_response\n                                        .decline_type\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_CODE.to_string()),\n                                    message: refund_previous_payment_response\n                                        .message\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                                    reason: refund_previous_payment_response.message.clone(),\n                                    status_code: item.http_code,\n                                    attempt_status: None,\n                                    connector_transaction_id: None,\n                                    network_advice_code: None,\n                                    network_decline_code: None,\n                                    network_error_message: None,\n                                    connector_metadata: None,\n                                    mandate_reference: None,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        None => Ok(Self {\n                            response: Ok(RefundsResponseData {\n                                connector_refund_id: transaction_id,\n                                refund_status: enums::RefundStatus::Pending,\n                            }),\n                            ..item.data\n                        }),\n                    }\n                } else if let Some(errors) = response.data.refund_previous_payment.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or refund_previous_payment_response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data",
+        "after": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "07a3026e88cb6e5824975682c1d7ea44b3371455"
+    }
+  ]
+}

diffs/pr_10112/2463d0e/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "2463d0e89e9a5a85dd829288980bc6d606e57b25",
+  "pr_number": 10112,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10112/2fe4bcc/diff.json

@@ -0,0 +1,85 @@
+{
+  "commit_sha": "2fe4bcc0af2e8220eaf06a49c511cd94f78f8887",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+    "crates/router/src/types/storage/revenue_recovery_redis_operation.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs::struct::AccountUpdateHistoryRecord",
+      "file": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct AccountUpdateHistoryRecord {\n    pub old_token : String,\n    pub new_token : String,\n    pub updated_at : PrimitiveDateTime,\n    pub old_token_info : Option<api_models::payments::AdditionalCardInfo>,\n    pub new_token_info : Option<api_models::payments::AdditionalCardInfo>,\n}",
+      "after_code": "pub struct AccountUpdateHistoryRecord {\n    /// Old token by the account updater\n    pub old_token : String,\n    /// New token by the account updater\n    pub new_token : String,\n    /// The time at which the token was updated\n    pub updated_at : PrimitiveDateTime,\n    /// Metadata of the old token \n    pub old_token_info : Option<api_models::payments::AdditionalCardInfo>,\n    /// Metadata of the new token\n    pub new_token_info : Option<api_models::payments::AdditionalCardInfo>,\n}",
+      "diff_span": {
+        "before": "",
+        "after": "pub struct AccountUpdateHistoryRecord {\n    /// Old token by the account updater\n    pub old_token : String,\n    /// New token by the account updater\n    pub new_token : String,\n    /// The time at which the token was updated\n    pub updated_at : PrimitiveDateTime,\n    /// Metadata of the old token \n    pub old_token_info : Option<api_models::payments::AdditionalCardInfo>,\n    /// Metadata of the new token\n    pub new_token_info : Option<api_models::payments::AdditionalCardInfo>,\n}"
+      },
+      "commit_sha": "2fe4bcc0af2e8220eaf06a49c511cd94f78f8887"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::struct::PaymentResponse",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct PaymentResponse {\n    #[serde(rename = \"@id\")]\n    pub id: String,\n    #[serde(rename = \"@reportGroup\")]\n    pub report_group: String,\n    #[serde(rename = \"@customerId\", skip_serializing_if = \"Option::is_none\")]\n    pub customer_id: Option<String>,\n    pub cnp_txn_id: String,\n    pub order_id: String,\n    pub response: WorldpayvantivResponseCode,\n    pub message: String,\n    pub response_time: String,\n    pub auth_code: Option<Secret<String>>,\n    pub fraud_result: Option<FraudResult>,\n    pub token_response: Option<TokenResponse>,\n    pub network_transaction_id: Option<Secret<String>>,\n    pub approved_amount: Option<MinorUnit>,\n    pub enhanced_auth_response: Option<EnhancedAuthResponse>,\n}",
+      "after_code": "pub struct PaymentResponse {\n    #[serde(rename = \"@id\")]\n    pub id: String,\n    #[serde(rename = \"@reportGroup\")]\n    pub report_group: String,\n    #[serde(rename = \"@customerId\", skip_serializing_if = \"Option::is_none\")]\n    pub customer_id: Option<String>,\n    pub cnp_txn_id: String,\n    pub order_id: String,\n    pub response: WorldpayvantivResponseCode,\n    pub message: String,\n    pub response_time: String,\n    pub auth_code: Option<Secret<String>>,\n    pub fraud_result: Option<FraudResult>,\n    pub token_response: Option<TokenResponse>,\n    pub network_transaction_id: Option<Secret<String>>,\n    pub approved_amount: Option<MinorUnit>,\n    pub enhanced_auth_response: Option<EnhancedAuthResponse>,\n    pub account_updater : Option<AccountUpdater>\n}",
+      "diff_span": {
+        "before": "",
+        "after": "    pub approved_amount: Option<MinorUnit>,\n    pub enhanced_auth_response: Option<EnhancedAuthResponse>,\n    pub account_updater : Option<AccountUpdater>\n}"
+      },
+      "commit_sha": "2fe4bcc0af2e8220eaf06a49c511cd94f78f8887"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::function::get_vantiv_card_data",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_vantiv_card_data(\n    payment_method_data: &PaymentMethodData,\n    payment_method_token: Option<hyperswitch_domain_models::router_data::PaymentMethodToken>,\n) -> Result<\n    (\n        Option<WorldpayvantivCardData>,\n        Option<CardholderAuthentication>,\n    ),\n    error_stack::Report<errors::ConnectorError>,\n> {\n    match payment_method_data {\n        PaymentMethodData::Card(card) => {\n            let card_type = match card.card_network.clone() {\n                Some(card_type) => WorldpayvativCardType::try_from(card_type)?,\n                None => WorldpayvativCardType::try_from(&card.get_card_issuer()?)?,\n            };\n\n            let exp_date = card.get_expiry_date_as_mmyy()?;\n\n            Ok((\n                Some(WorldpayvantivCardData {\n                    card_type,\n                    number: card.card_number.clone(),\n                    exp_date,\n                    card_validation_num: Some(card.card_cvc.clone()),\n                }),\n                None,\n            ))\n        }\n        PaymentMethodData::CardDetailsForNetworkTransactionId(card_data) => {\n            let card_type = match card_data.card_network.clone() {\n                Some(card_type) => WorldpayvativCardType::try_from(card_type)?,\n                None => WorldpayvativCardType::try_from(&card_data.get_card_issuer()?)?,\n            };\n\n            let exp_date = card_data.get_expiry_date_as_mmyy()?;\n\n            Ok((\n                Some(WorldpayvantivCardData {\n                    card_type,\n                    number: card_data.card_number.clone(),\n                    exp_date,\n                    card_validation_num: None,\n                }),\n                None,\n            ))\n        }\n        PaymentMethodData::MandatePayment => Ok((None, None)),\n        PaymentMethodData::Wallet(wallet_data) => match wallet_data {\n            hyperswitch_domain_models::payment_method_data::WalletData::ApplePay(\n                apple_pay_data,\n            ) => match payment_method_token.clone() {\n                Some(\n                    hyperswitch_domain_models::router_data::PaymentMethodToken::ApplePayDecrypt(\n                        apple_pay_decrypted_data,\n                    ),\n                ) => {\n                    let number = apple_pay_decrypted_data\n                        .application_primary_account_number\n                        .clone();\n                    let exp_date = apple_pay_decrypted_data\n                        .get_expiry_date_as_mmyy()\n                        .change_context(errors::ConnectorError::InvalidDataFormat {\n                            field_name: \"payment_method_data.card.card_exp_month\",\n                        })?;\n\n                    let cardholder_authentication = CardholderAuthentication {\n                        authentication_value: apple_pay_decrypted_data\n                            .payment_data\n                            .online_payment_cryptogram\n                            .clone(),\n                    };\n\n                    let apple_pay_network = apple_pay_data\n    .payment_method\n    .network\n    .parse::<WorldPayVativApplePayNetwork>()\n    .map_err(|_| {\n        error_stack::Report::new(errors::ConnectorError::NotSupported {\n            message: format!(\n                \"Invalid Apple Pay network '{}'. Supported networks: Visa,MasterCard,AmEx,Discover,DinersClub,JCB,UnionPay\",\n                apple_pay_data.payment_method.network\n            ),\n            connector: \"worldpay_vativ\"\n        })\n    })?;\n\n                    Ok((\n                        (Some(WorldpayvantivCardData {\n                            card_type: apple_pay_network.into(),\n                            number,\n                            exp_date,\n                            card_validation_num: None,\n                        })),\n                        Some(cardholder_authentication),\n                    ))\n                }\n                _ => Err(\n                    errors::ConnectorError::NotImplemented(\"Payment method type\".to_string())\n                        .into(),\n                ),\n            },\n            hyperswitch_domain_models::payment_method_data::WalletData::GooglePay(\n                google_pay_data,\n            ) => match payment_method_token.clone() {\n                Some(\n                    hyperswitch_domain_models::router_data::PaymentMethodToken::GooglePayDecrypt(\n                        google_pay_decrypted_data,\n                    ),\n                ) => {\n                    let number = google_pay_decrypted_data\n                        .application_primary_account_number\n                        .clone();\n                    let exp_date = google_pay_decrypted_data\n                        .get_expiry_date_as_mmyy()\n                        .change_context(errors::ConnectorError::InvalidDataFormat {\n                            field_name: \"payment_method_data.card.card_exp_month\",\n                        })?;\n\n                    let cardholder_authentication = CardholderAuthentication {\n                        authentication_value: google_pay_decrypted_data\n                            .cryptogram\n                            .clone()\n                            .ok_or_else(|| errors::ConnectorError::MissingRequiredField {\n                                field_name: \"cryptogram\",\n                            })?,\n                    };\n                    let google_pay_network = google_pay_data\n    .info\n    .card_network\n    .parse::<WorldPayVativGooglePayNetwork>()\n    .map_err(|_| {\n        error_stack::Report::new(errors::ConnectorError::NotSupported {\n            message: format!(\n                \"Invalid Google Pay card network '{}'. Supported networks: VISA, MASTERCARD, AMEX, DISCOVER, JCB, UNIONPAY\",\n                google_pay_data.info.card_network\n            ),\n            connector: \"worldpay_vativ\"\n        })\n    })?;\n\n                    Ok((\n                        (Some(WorldpayvantivCardData {\n                            card_type: google_pay_network.into(),\n                            number,\n                            exp_date,\n                            card_validation_num: None,\n                        })),\n                        Some(cardholder_authentication),\n                    ))\n                }\n                _ => {\n                    Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into())\n                }\n            },\n            _ => Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into()),\n        },\n        _ => Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into()),\n    }\n}",
+      "after_code": "fn get_vantiv_card_data(\n    payment_method_data: &PaymentMethodData,\n    payment_method_token: Option<hyperswitch_domain_models::router_data::PaymentMethodToken>,\n) -> Result<\n    (\n        Option<WorldpayvantivCardData>,\n        Option<CardholderAuthentication>,\n    ),\n    error_stack::Report<errors::ConnectorError>,\n> {\n    match payment_method_data {\n        PaymentMethodData::Card(card) => {\n            let card_type = match card.card_network.clone() {\n                Some(card_type) => WorldpayvativCardType::try_from(card_type)?,\n                None => WorldpayvativCardType::try_from(&card.get_card_issuer()?)?,\n            };\n\n            let exp_date = card.get_expiry_date_as_mmyy()?;\n\n            Ok((\n                Some(WorldpayvantivCardData {\n                    card_type,\n                    number: card.card_number.clone(),\n                    exp_date,\n                    card_validation_num: Some(card.card_cvc.clone()),\n                }),\n                None,\n            ))\n        }\n        PaymentMethodData::CardDetailsForNetworkTransactionId(card_data) => {\n            let card_type = match card_data.card_network.clone() {\n                Some(card_type) => WorldpayvativCardType::try_from(card_type)?,\n                None => WorldpayvativCardType::try_from(&card_data.get_card_issuer()?)?,\n            };\n\n            let exp_date = card_data.get_expiry_date_as_mmyy()?;\n\n            Ok((\n                Some(WorldpayvantivCardData {\n                    card_type,\n                    number: card_data.card_number.clone(),\n                    exp_date,\n                    card_validation_num: None,\n                }),\n                None,\n            ))\n        }\n        PaymentMethodData::MandatePayment => Ok((None, None)),\n        PaymentMethodData::Wallet(wallet_data) => match wallet_data {\n            hyperswitch_domain_models::payment_method_data::WalletData::ApplePay(\n                apple_pay_data,\n            ) => match payment_method_token.clone() {\n                Some(\n                    hyperswitch_domain_models::router_data::PaymentMethodToken::ApplePayDecrypt(\n                        apple_pay_decrypted_data,\n                    ),\n                ) => {\n                    let number = apple_pay_decrypted_data\n                        .application_primary_account_number\n                        .clone();\n                    let exp_date = apple_pay_decrypted_data\n                        .get_expiry_date_as_mmyy()\n                        .change_context(errors::ConnectorError::InvalidDataFormat {\n                            field_name: \"payment_method_data.card.card_exp_month\",\n                        })?;\n\n                    let cardholder_authentication = CardholderAuthentication {\n                        authentication_value: apple_pay_decrypted_data\n                            .payment_data\n                            .online_payment_cryptogram\n                            .clone(),\n                    };\n\n                    let apple_pay_network = apple_pay_data\n                    .payment_method\n                    .network\n                    .parse::<WorldPayVativApplePayNetwork>()\n                    .map_err(|_| {\n                        error_stack::Report::new(errors::ConnectorError::NotSupported {\n                            message: format!(\n                                \"Invalid Apple Pay network '{}'. Supported networks: Visa,MasterCard,AmEx,Discover,DinersClub,JCB,UnionPay\",\n                                apple_pay_data.payment_method.network\n                            ),\n                            connector: \"worldpay_vativ\"\n                        })\n                    })?;\n\n                    Ok((\n                        (Some(WorldpayvantivCardData {\n                            card_type: apple_pay_network.into(),\n                            number,\n                            exp_date,\n                            card_validation_num: None,\n                        })),\n                        Some(cardholder_authentication),\n                    ))\n                }\n                _ => Err(\n                    errors::ConnectorError::NotImplemented(\"Payment method type\".to_string())\n                        .into(),\n                ),\n            },\n            hyperswitch_domain_models::payment_method_data::WalletData::GooglePay(\n                google_pay_data,\n            ) => match payment_method_token.clone() {\n                Some(\n                    hyperswitch_domain_models::router_data::PaymentMethodToken::GooglePayDecrypt(\n                        google_pay_decrypted_data,\n                    ),\n                ) => {\n                    let number = google_pay_decrypted_data\n                        .application_primary_account_number\n                        .clone();\n                    let exp_date = google_pay_decrypted_data\n                        .get_expiry_date_as_mmyy()\n                        .change_context(errors::ConnectorError::InvalidDataFormat {\n                            field_name: \"payment_method_data.card.card_exp_month\",\n                        })?;\n\n                    let cardholder_authentication = CardholderAuthentication {\n                        authentication_value: google_pay_decrypted_data\n                            .cryptogram\n                            .clone()\n                            .ok_or_else(|| errors::ConnectorError::MissingRequiredField {\n                                field_name: \"cryptogram\",\n                            })?,\n                    };\n                    let google_pay_network = google_pay_data\n                        .info\n                        .card_network\n                        .parse::<WorldPayVativGooglePayNetwork>()\n                        .map_err(|_| {\n                            error_stack::Report::new(errors::ConnectorError::NotSupported {\n                                message: format!(\n                                    \"Invalid Google Pay card network '{}'. Supported networks: VISA, MASTERCARD, AMEX, DISCOVER, JCB, UNIONPAY\",\n                                    google_pay_data.info.card_network\n                                ),\n                                connector: \"worldpay_vativ\"\n                            })\n                        })?;\n\n                    Ok((\n                        (Some(WorldpayvantivCardData {\n                            card_type: google_pay_network.into(),\n                            number,\n                            exp_date,\n                            card_validation_num: None,\n                        })),\n                        Some(cardholder_authentication),\n                    ))\n                }\n                _ => {\n                    Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into())\n                }\n            },\n            _ => Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into()),\n        },\n        _ => Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into()),\n    }\n}",
+      "diff_span": {
+        "before": "\n                    let apple_pay_network = apple_pay_data\n    .payment_method\n    .network\n    .parse::<WorldPayVativApplePayNetwork>()\n    .map_err(|_| {\n        error_stack::Report::new(errors::ConnectorError::NotSupported {\n            message: format!(\n                \"Invalid Apple Pay network '{}'. Supported networks: Visa,MasterCard,AmEx,Discover,DinersClub,JCB,UnionPay\",\n                apple_pay_data.payment_method.network\n            ),\n            connector: \"worldpay_vativ\"\n        })\n    })?;\n\n                    Ok((\n                        (Some(WorldpayvantivCardData {\n                            card_type: apple_pay_network.into(),\n                            number,\n                            exp_date,\n                            card_validation_num: None,\n                        })),\n                        Some(cardholder_authentication),\n                    ))\n                }\n                _ => Err(\n                    errors::ConnectorError::NotImplemented(\"Payment method type\".to_string())\n                        .into(),\n                ),\n            },\n            hyperswitch_domain_models::payment_method_data::WalletData::GooglePay(\n                google_pay_data,\n            ) => match payment_method_token.clone() {\n                Some(\n                    hyperswitch_domain_models::router_data::PaymentMethodToken::GooglePayDecrypt(\n                        google_pay_decrypted_data,\n                    ),\n                ) => {\n                    let number = google_pay_decrypted_data\n                        .application_primary_account_number\n                        .clone();\n                    let exp_date = google_pay_decrypted_data\n                        .get_expiry_date_as_mmyy()\n                        .change_context(errors::ConnectorError::InvalidDataFormat {\n                            field_name: \"payment_method_data.card.card_exp_month\",\n                        })?;\n\n                    let cardholder_authentication = CardholderAuthentication {\n                        authentication_value: google_pay_decrypted_data\n                            .cryptogram\n                            .clone()\n                            .ok_or_else(|| errors::ConnectorError::MissingRequiredField {\n                                field_name: \"cryptogram\",\n                            })?,\n                    };\n                    let google_pay_network = google_pay_data\n    .info\n    .card_network\n    .parse::<WorldPayVativGooglePayNetwork>()\n    .map_err(|_| {\n        error_stack::Report::new(errors::ConnectorError::NotSupported {\n            message: format!(\n                \"Invalid Google Pay card network '{}'. Supported networks: VISA, MASTERCARD, AMEX, DISCOVER, JCB, UNIONPAY\",\n                google_pay_data.info.card_network\n            ),\n            connector: \"worldpay_vativ\"\n        })\n    })?;\n\n                    Ok((",
+        "after": "\n                    let apple_pay_network = apple_pay_data\n                    .payment_method\n                    .network\n                    .parse::<WorldPayVativApplePayNetwork>()\n                    .map_err(|_| {\n                        error_stack::Report::new(errors::ConnectorError::NotSupported {\n                            message: format!(\n                                \"Invalid Apple Pay network '{}'. Supported networks: Visa,MasterCard,AmEx,Discover,DinersClub,JCB,UnionPay\",\n                                apple_pay_data.payment_method.network\n                            ),\n                            connector: \"worldpay_vativ\"\n                        })\n                    })?;\n\n                    Ok((\n                        (Some(WorldpayvantivCardData {\n                            card_type: apple_pay_network.into(),\n                            number,\n                            exp_date,\n                            card_validation_num: None,\n                        })),\n                        Some(cardholder_authentication),\n                    ))\n                }\n                _ => Err(\n                    errors::ConnectorError::NotImplemented(\"Payment method type\".to_string())\n                        .into(),\n                ),\n            },\n            hyperswitch_domain_models::payment_method_data::WalletData::GooglePay(\n                google_pay_data,\n            ) => match payment_method_token.clone() {\n                Some(\n                    hyperswitch_domain_models::router_data::PaymentMethodToken::GooglePayDecrypt(\n                        google_pay_decrypted_data,\n                    ),\n                ) => {\n                    let number = google_pay_decrypted_data\n                        .application_primary_account_number\n                        .clone();\n                    let exp_date = google_pay_decrypted_data\n                        .get_expiry_date_as_mmyy()\n                        .change_context(errors::ConnectorError::InvalidDataFormat {\n                            field_name: \"payment_method_data.card.card_exp_month\",\n                        })?;\n\n                    let cardholder_authentication = CardholderAuthentication {\n                        authentication_value: google_pay_decrypted_data\n                            .cryptogram\n                            .clone()\n                            .ok_or_else(|| errors::ConnectorError::MissingRequiredField {\n                                field_name: \"cryptogram\",\n                            })?,\n                    };\n                    let google_pay_network = google_pay_data\n                        .info\n                        .card_network\n                        .parse::<WorldPayVativGooglePayNetwork>()\n                        .map_err(|_| {\n                            error_stack::Report::new(errors::ConnectorError::NotSupported {\n                                message: format!(\n                                    \"Invalid Google Pay card network '{}'. Supported networks: VISA, MASTERCARD, AMEX, DISCOVER, JCB, UNIONPAY\",\n                                    google_pay_data.info.card_network\n                                ),\n                                connector: \"worldpay_vativ\"\n                            })\n                        })?;\n\n                    Ok(("
+      },
+      "commit_sha": "2fe4bcc0af2e8220eaf06a49c511cd94f78f8887"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::struct::ExtendedCardResponse",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct ExtendedCardResponse {\n    pub message: Option<String>,\n    pub code: Option<String>,\n}",
+      "diff_span": null,
+      "commit_sha": "2fe4bcc0af2e8220eaf06a49c511cd94f78f8887"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::struct::AccountUpdater",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct AccountUpdater {\n    pub original_card_token_info : Option<CardTokenInfo>,\n    pub new_card_token_info: Option<CardTokenInfo>,\n    pub extended_card_response: ExtendedCardResponse,\n}",
+      "diff_span": null,
+      "commit_sha": "2fe4bcc0af2e8220eaf06a49c511cd94f78f8887"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::struct::CardTokenInfo",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct CardTokenInfo {\n    pub cnp_token: Secret<String>,\n    pub exp_date: Option<String>,\n    pub type_field: Option<String>,\n    pub bin: Option<String>,\n}",
+      "diff_span": null,
+      "commit_sha": "2fe4bcc0af2e8220eaf06a49c511cd94f78f8887"
+    }
+  ]
+}

diffs/pr_10112/3328feb/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "3328feb87270e1adccba7cb5f7692f08049d3b68",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::impl::RouterData<F, SetupMandateRequestData, PaymentsResponseData>",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F>\n    TryFrom<\n        ResponseRouterData<\n            F,\n            TesouroSetupMandateResponse,\n            SetupMandateRequestData,\n            PaymentsResponseData,\n        >,\n    > for RouterData<F, SetupMandateRequestData, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: ResponseRouterData<\n            F,\n            TesouroSetupMandateResponse,\n            SetupMandateRequestData,\n            PaymentsResponseData,\n        >,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(account_setup_response) =\n                    response.data.verify_account.verify_account_response\n                {\n                    let connector_metadata = serde_json::json!(TesouroTransactionMetadata {\n                        payment_id: account_setup_response.payment_id.clone()\n                    });\n                    Ok(Self {\n                        status: enums::AttemptStatus::Charged,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(\n                                account_setup_response.transaction_id.clone(),\n                            ),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(get_mandate_reference(\n                                Some(account_setup_response.token_details),\n                                Some(account_setup_response.payment_id),\n                                Some(account_setup_response.activity_date),\n                            )?),\n                            connector_metadata: Some(connector_metadata),\n                            network_txn_id: None,\n                            connector_response_reference_id: None,\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        ..item.data\n                    })\n                } else if let Some(errors) = response.data.verify_account.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n                    let connector_transaction_id = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.transaction_id.clone());\n\n                    Ok(Self {\n                        status: enums::AttemptStatus::Failure,\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or account verify response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(tesouro_api_error_response) => {\n                let message = tesouro_api_error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    status: enums::AttemptStatus::Failure,\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "after_code": "impl<F>\n    TryFrom<\n        ResponseRouterData<\n            F,\n            TesouroSetupMandateResponse,\n            SetupMandateRequestData,\n            PaymentsResponseData,\n        >,\n    > for RouterData<F, SetupMandateRequestData, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: ResponseRouterData<\n            F,\n            TesouroSetupMandateResponse,\n            SetupMandateRequestData,\n            PaymentsResponseData,\n        >,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(account_setup_response) =\n                    response.data.verify_account.verify_account_response\n                {\n                    let connector_metadata = serde_json::json!(TesouroTransactionMetadata {\n                        payment_id: account_setup_response.payment_id.clone()\n                    });\n                    Ok(Self {\n                        status: enums::AttemptStatus::Charged,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(\n                                account_setup_response.transaction_id.clone(),\n                            ),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(get_mandate_reference(\n                                Some(account_setup_response.token_details),\n                                Some(account_setup_response.payment_id),\n                                Some(account_setup_response.activity_date),\n                            )?),\n                            connector_metadata: Some(connector_metadata),\n                            network_txn_id: None,\n                            connector_response_reference_id: None,\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        ..item.data\n                    })\n                } else if let Some(errors) = response.data.verify_account.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n                    let connector_transaction_id = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.transaction_id.clone());\n\n                    Ok(Self {\n                        status: enums::AttemptStatus::Failure,\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or account verify response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(tesouro_api_error_response) => {\n                let message = tesouro_api_error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    status: enums::AttemptStatus::Failure,\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or account verify response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(tesouro_api_error_response) => {\n                let message = tesouro_api_error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    status: enums::AttemptStatus::Failure,\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "3328feb87270e1adccba7cb5f7692f08049d3b68"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::RouterData<F, SetupMandateRequestData, PaymentsResponseData>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: ResponseRouterData<\n            F,\n            TesouroSetupMandateResponse,\n            SetupMandateRequestData,\n            PaymentsResponseData,\n        >,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(account_setup_response) =\n                    response.data.verify_account.verify_account_response\n                {\n                    let connector_metadata = serde_json::json!(TesouroTransactionMetadata {\n                        payment_id: account_setup_response.payment_id.clone()\n                    });\n                    Ok(Self {\n                        status: enums::AttemptStatus::Charged,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(\n                                account_setup_response.transaction_id.clone(),\n                            ),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(get_mandate_reference(\n                                Some(account_setup_response.token_details),\n                                Some(account_setup_response.payment_id),\n                                Some(account_setup_response.activity_date),\n                            )?),\n                            connector_metadata: Some(connector_metadata),\n                            network_txn_id: None,\n                            connector_response_reference_id: None,\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        ..item.data\n                    })\n                } else if let Some(errors) = response.data.verify_account.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n                    let connector_transaction_id = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.transaction_id.clone());\n\n                    Ok(Self {\n                        status: enums::AttemptStatus::Failure,\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or account verify response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(tesouro_api_error_response) => {\n                let message = tesouro_api_error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    status: enums::AttemptStatus::Failure,\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "after_code": "fn try_from(\n        item: ResponseRouterData<\n            F,\n            TesouroSetupMandateResponse,\n            SetupMandateRequestData,\n            PaymentsResponseData,\n        >,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(account_setup_response) =\n                    response.data.verify_account.verify_account_response\n                {\n                    let connector_metadata = serde_json::json!(TesouroTransactionMetadata {\n                        payment_id: account_setup_response.payment_id.clone()\n                    });\n                    Ok(Self {\n                        status: enums::AttemptStatus::Charged,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(\n                                account_setup_response.transaction_id.clone(),\n                            ),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(get_mandate_reference(\n                                Some(account_setup_response.token_details),\n                                Some(account_setup_response.payment_id),\n                                Some(account_setup_response.activity_date),\n                            )?),\n                            connector_metadata: Some(connector_metadata),\n                            network_txn_id: None,\n                            connector_response_reference_id: None,\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        ..item.data\n                    })\n                } else if let Some(errors) = response.data.verify_account.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n                    let connector_transaction_id = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.transaction_id.clone());\n\n                    Ok(Self {\n                        status: enums::AttemptStatus::Failure,\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or account verify response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(tesouro_api_error_response) => {\n                let message = tesouro_api_error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    status: enums::AttemptStatus::Failure,\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or account verify response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(tesouro_api_error_response) => {\n                let message = tesouro_api_error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    status: enums::AttemptStatus::Failure,\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "3328feb87270e1adccba7cb5f7692f08049d3b68"
+    }
+  ]
+}

diffs/pr_10112/3b27318/diff.json

@@ -0,0 +1,40 @@
+{
+  "commit_sha": "3b273184cc7b0e213ef27a1ebe52c332b85842a0",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/router/src/core/webhooks/recovery_incoming.rs",
+    "crates/router/src/types/storage/revenue_recovery_redis_operation.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/webhooks/recovery_incoming.rs::RevenueRecoveryAttempt::function::store_payment_processor_tokens_in_redis",
+      "file": "crates/router/src/core/webhooks/recovery_incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn store_payment_processor_tokens_in_redis(\n        &self,\n        state: &SessionState,\n        recovery_attempt: &revenue_recovery::RecoveryPaymentAttempt,\n        payment_connector_name: Option<common_enums::connector_enums::Connector>,\n    ) -> CustomResult<(), errors::RevenueRecoveryError> {\n        let revenue_recovery_attempt_data = &self.0;\n        let error_code = recovery_attempt.error_code.clone();\n        let error_message = revenue_recovery_attempt_data.error_message.clone();\n        let connector_name = payment_connector_name\n            .ok_or(errors::RevenueRecoveryError::TransactionWebhookProcessingFailed)\n            .attach_printable(\"unable to derive payment connector\")?\n            .to_string();\n\n        let gsm_record = helpers::get_gsm_record(\n            state,\n            error_code.clone(),\n            error_message,\n            connector_name,\n            REVENUE_RECOVERY.to_string(),\n        )\n        .await;\n\n        let is_hard_decline = gsm_record\n            .and_then(|record| record.error_category)\n            .map(|category| category == common_enums::ErrorCategory::HardDecline)\n            .unwrap_or(false);\n\n        // Extract required fields from the revenue recovery attempt data\n        let connector_customer_id = revenue_recovery_attempt_data.connector_customer_id.clone();\n\n        let attempt_id = recovery_attempt.attempt_id.clone();\n        let token_unit = PaymentProcessorTokenStatus {\n            error_code,\n            inserted_by_attempt_id: attempt_id.clone(),\n            daily_retry_history: HashMap::from([(recovery_attempt.created_at.date(), 1)]),\n            scheduled_at: None,\n            is_hard_decline: Some(is_hard_decline),\n            modified_at: Some(recovery_attempt.created_at),\n            payment_processor_token_details: PaymentProcessorTokenDetails {\n                payment_processor_token: revenue_recovery_attempt_data\n                    .processor_payment_method_token\n                    .clone(),\n                expiry_month: revenue_recovery_attempt_data\n                    .card_info\n                    .card_exp_month\n                    .clone(),\n                expiry_year: revenue_recovery_attempt_data\n                    .card_info\n                    .card_exp_year\n                    .clone(),\n                card_issuer: revenue_recovery_attempt_data.card_info.card_issuer.clone(),\n                last_four_digits: revenue_recovery_attempt_data.card_info.last4.clone(),\n                card_network: revenue_recovery_attempt_data.card_info.card_network.clone(),\n                card_type: revenue_recovery_attempt_data.card_info.card_type.clone(),\n            },\n        };\n\n        // Make the Redis call to store tokens\n        RedisTokenManager::upsert_payment_processor_token(\n            state,\n            &connector_customer_id,\n            token_unit,\n        )\n        .await\n        .change_context(errors::RevenueRecoveryError::RevenueRecoveryRedisInsertFailed)\n        .attach_printable(\"Failed to store payment processor tokens in Redis\")?;\n\n        Ok(())\n    }",
+      "after_code": "async fn store_payment_processor_tokens_in_redis(\n        &self,\n        state: &SessionState,\n        recovery_attempt: &revenue_recovery::RecoveryPaymentAttempt,\n        payment_connector_name: Option<common_enums::connector_enums::Connector>,\n    ) -> CustomResult<(), errors::RevenueRecoveryError> {\n        let revenue_recovery_attempt_data = &self.0;\n        let error_code = recovery_attempt.error_code.clone();\n        let error_message = revenue_recovery_attempt_data.error_message.clone();\n        let connector_name = payment_connector_name\n            .ok_or(errors::RevenueRecoveryError::TransactionWebhookProcessingFailed)\n            .attach_printable(\"unable to derive payment connector\")?\n            .to_string();\n\n        let gsm_record = helpers::get_gsm_record(\n            state,\n            error_code.clone(),\n            error_message,\n            connector_name,\n            REVENUE_RECOVERY.to_string(),\n        )\n        .await;\n\n        let is_hard_decline = gsm_record\n            .and_then(|record| record.error_category)\n            .map(|category| category == common_enums::ErrorCategory::HardDecline)\n            .unwrap_or(false);\n\n        // Extract required fields from the revenue recovery attempt data\n        let connector_customer_id = revenue_recovery_attempt_data.connector_customer_id.clone();\n\n        let attempt_id = recovery_attempt.attempt_id.clone();\n        let token_unit = PaymentProcessorTokenStatus {\n            error_code,\n            inserted_by_attempt_id: attempt_id.clone(),\n            daily_retry_history: HashMap::from([(recovery_attempt.created_at.date(), 1)]),\n            scheduled_at: None,\n            is_hard_decline: Some(is_hard_decline),\n            modified_at: Some(recovery_attempt.created_at),\n            payment_processor_token_details: PaymentProcessorTokenDetails {\n                payment_processor_token: revenue_recovery_attempt_data\n                    .processor_payment_method_token\n                    .clone(),\n                expiry_month: revenue_recovery_attempt_data\n                    .card_info\n                    .card_exp_month\n                    .clone(),\n                expiry_year: revenue_recovery_attempt_data\n                    .card_info\n                    .card_exp_year\n                    .clone(),\n                card_issuer: revenue_recovery_attempt_data.card_info.card_issuer.clone(),\n                last_four_digits: revenue_recovery_attempt_data.card_info.last4.clone(),\n                card_network: revenue_recovery_attempt_data.card_info.card_network.clone(),\n                card_type: revenue_recovery_attempt_data.card_info.card_type.clone(),\n            },\n            is_active: Some(true),\n            account_update_history: None\n        };\n\n        // Make the Redis call to store tokens\n        RedisTokenManager::upsert_payment_processor_token(\n            state,\n            &connector_customer_id,\n            token_unit,\n        )\n        .await\n        .change_context(errors::RevenueRecoveryError::RevenueRecoveryRedisInsertFailed)\n        .attach_printable(\"Failed to store payment processor tokens in Redis\")?;\n\n        Ok(())\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "                card_type: revenue_recovery_attempt_data.card_info.card_type.clone(),\n            },\n            is_active: Some(true),\n            account_update_history: None\n        };\n"
+      },
+      "commit_sha": "3b273184cc7b0e213ef27a1ebe52c332b85842a0"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/recovery_incoming.rs::impl::RevenueRecoveryAttempt",
+      "file": "crates/router/src/core/webhooks/recovery_incoming.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl RevenueRecoveryAttempt {\n    pub async fn load_recovery_attempt_from_api(\n        data: api_models::payments::RecoveryPaymentsCreate,\n        state: &SessionState,\n        req_state: &ReqState,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        payment_intent: revenue_recovery::RecoveryPaymentIntent,\n        payment_merchant_connector_account: domain::MerchantConnectorAccount,\n    ) -> CustomResult<\n        (\n            revenue_recovery::RecoveryPaymentAttempt,\n            revenue_recovery::RecoveryPaymentIntent,\n        ),\n        errors::RevenueRecoveryError,\n    > {\n        let recovery_attempt = Self(revenue_recovery::RevenueRecoveryAttemptData::foreign_from(\n            &data,\n        ));\n        recovery_attempt\n            .get_payment_attempt(state, req_state, merchant_context, profile, &payment_intent)\n            .await\n            .transpose()\n            .async_unwrap_or_else(|| async {\n                recovery_attempt\n                    .record_payment_attempt(\n                        state,\n                        req_state,\n                        merchant_context,\n                        profile,\n                        &payment_intent,\n                        &data.billing_merchant_connector_id,\n                        Some(payment_merchant_connector_account),\n                    )\n                    .await\n            })\n            .await\n    }\n\n    fn get_recovery_invoice_transaction_details(\n        connector_enum: &connector_integration_interface::ConnectorEnum,\n        request_details: &hyperswitch_interfaces::webhooks::IncomingWebhookRequestDetails<'_>,\n        billing_connector_payment_details: Option<\n            &revenue_recovery_response::BillingConnectorPaymentsSyncResponse,\n        >,\n        billing_connector_invoice_details: &revenue_recovery::RevenueRecoveryInvoiceData,\n    ) -> CustomResult<Self, errors::RevenueRecoveryError> {\n        billing_connector_payment_details.map_or_else(\n            || {\n                interface_webhooks::IncomingWebhook::get_revenue_recovery_attempt_details(\n                    connector_enum,\n                    request_details,\n                )\n                .change_context(errors::RevenueRecoveryError::TransactionWebhookProcessingFailed)\n                .attach_printable(\n                    \"Failed to get recovery attempt details from the billing connector\",\n                )\n                .map(RevenueRecoveryAttempt)\n            },\n            |data| {\n                Ok(Self(revenue_recovery::RevenueRecoveryAttemptData::from((\n                    data,\n                    billing_connector_invoice_details,\n                ))))\n            },\n        )\n    }\n    pub fn get_revenue_recovery_attempt(\n        payment_intent: &domain_payments::PaymentIntent,\n        revenue_recovery_metadata: &api_payments::PaymentRevenueRecoveryMetadata,\n        billing_connector_account: &domain::MerchantConnectorAccount,\n        card_info: api_payments::AdditionalCardInfo,\n        payment_processor_token: &str,\n    ) -> CustomResult<Self, errors::RevenueRecoveryError> {\n        let revenue_recovery_data = payment_intent\n            .create_revenue_recovery_attempt_data(\n                revenue_recovery_metadata.clone(),\n                billing_connector_account,\n                card_info,\n                payment_processor_token,\n            )\n            .change_context(errors::RevenueRecoveryError::RevenueRecoveryAttemptDataCreateFailed)\n            .attach_printable(\"Failed to build recovery attempt data\")?;\n        Ok(Self(revenue_recovery_data))\n    }\n    async fn get_payment_attempt(\n        &self,\n        state: &SessionState,\n        req_state: &ReqState,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        payment_intent: &revenue_recovery::RecoveryPaymentIntent,\n    ) -> CustomResult<\n        Option<(\n            revenue_recovery::RecoveryPaymentAttempt,\n            revenue_recovery::RecoveryPaymentIntent,\n        )>,\n        errors::RevenueRecoveryError,\n    > {\n        let attempt_response =\n            Box::pin(payments::payments_list_attempts_using_payment_intent_id::<\n                payments::operations::PaymentGetListAttempts,\n                api_payments::PaymentAttemptListResponse,\n                _,\n                payments::operations::payment_attempt_list::PaymentGetListAttempts,\n                hyperswitch_domain_models::payments::PaymentAttemptListData<\n                    payments::operations::PaymentGetListAttempts,\n                >,\n            >(\n                state.clone(),\n                req_state.clone(),\n                merchant_context.clone(),\n                profile.clone(),\n                payments::operations::PaymentGetListAttempts,\n                api_payments::PaymentAttemptListRequest {\n                    payment_intent_id: payment_intent.payment_id.clone(),\n                },\n                payment_intent.payment_id.clone(),\n                hyperswitch_domain_models::payments::HeaderPayload::default(),\n            ))\n            .await;\n        let response = match attempt_response {\n            Ok(services::ApplicationResponse::JsonWithHeaders((payments_response, _))) => {\n                let final_attempt = self\n                    .0\n                    .charge_id\n                    .as_ref()\n                    .map(|charge_id| {\n                        payments_response\n                            .find_attempt_in_attempts_list_using_charge_id(charge_id.clone())\n                    })\n                    .unwrap_or_else(|| {\n                        self.0\n                            .connector_transaction_id\n                            .as_ref()\n                            .and_then(|transaction_id| {\n                                payments_response\n                                    .find_attempt_in_attempts_list_using_connector_transaction_id(\n                                        transaction_id,\n                                    )\n                            })\n                    });\n                let payment_attempt =\n                    final_attempt.map(|res| revenue_recovery::RecoveryPaymentAttempt {\n                        attempt_id: res.id.to_owned(),\n                        attempt_status: res.status.to_owned(),\n                        feature_metadata: res.feature_metadata.to_owned(),\n                        amount: res.amount.net_amount,\n                        network_advice_code: res.error.clone().and_then(|e| e.network_advice_code), // Placeholder, to be populated if available\n                        network_decline_code: res\n                            .error\n                            .clone()\n                            .and_then(|e| e.network_decline_code), // Placeholder, to be populated if available\n                        error_code: res.error.clone().map(|error| error.code),\n                        created_at: res.created_at,\n                    });\n                // If we have an attempt, combine it with payment_intent in a tuple.\n                let res_with_payment_intent_and_attempt =\n                    payment_attempt.map(|attempt| (attempt, (*payment_intent).clone()));\n                Ok(res_with_payment_intent_and_attempt)\n            }\n            Ok(_) => Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)\n                .attach_printable(\"Unexpected response from payment intent core\"),\n            error @ Err(_) => {\n                logger::error!(?error);\n                Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)\n                    .attach_printable(\"failed to fetch payment attempt in recovery webhook flow\")\n            }\n        }?;\n        Ok(response)\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn record_payment_attempt(\n        &self,\n        state: &SessionState,\n        req_state: &ReqState,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        payment_intent: &revenue_recovery::RecoveryPaymentIntent,\n        billing_connector_account_id: &id_type::MerchantConnectorAccountId,\n        payment_connector_account: Option<domain::MerchantConnectorAccount>,\n    ) -> CustomResult<\n        (\n            revenue_recovery::RecoveryPaymentAttempt,\n            revenue_recovery::RecoveryPaymentIntent,\n        ),\n        errors::RevenueRecoveryError,\n    > {\n        let payment_connector_id =   payment_connector_account.as_ref().map(|account: &hyperswitch_domain_models::merchant_connector_account::MerchantConnectorAccount| account.id.clone());\n        let payment_connector_name = payment_connector_account\n            .as_ref()\n            .map(|account| account.connector_name);\n        let request_payload: api_payments::PaymentsAttemptRecordRequest = self\n            .create_payment_record_request(\n                state,\n                billing_connector_account_id,\n                payment_connector_id,\n                payment_connector_name,\n                common_enums::TriggeredBy::External,\n            )\n            .await?;\n        let attempt_response = Box::pin(payments::record_attempt_core(\n            state.clone(),\n            req_state.clone(),\n            merchant_context.clone(),\n            profile.clone(),\n            request_payload,\n            payment_intent.payment_id.clone(),\n            hyperswitch_domain_models::payments::HeaderPayload::default(),\n        ))\n        .await;\n\n        let (recovery_attempt, updated_recovery_intent) = match attempt_response {\n            Ok(services::ApplicationResponse::JsonWithHeaders((attempt_response, _))) => {\n                Ok((\n                    revenue_recovery::RecoveryPaymentAttempt {\n                        attempt_id: attempt_response.id.clone(),\n                        attempt_status: attempt_response.status,\n                        feature_metadata: attempt_response.payment_attempt_feature_metadata,\n                        amount: attempt_response.amount,\n                        network_advice_code: attempt_response\n                            .error_details\n                            .clone()\n                            .and_then(|error| error.network_decline_code), // Placeholder, to be populated if available\n                        network_decline_code: attempt_response\n                            .error_details\n                            .clone()\n                            .and_then(|error| error.network_decline_code), // Placeholder, to be populated if available\n                        error_code: attempt_response\n                            .error_details\n                            .clone()\n                            .map(|error| error.code),\n                        created_at: attempt_response.created_at,\n                    },\n                    revenue_recovery::RecoveryPaymentIntent {\n                        payment_id: payment_intent.payment_id.clone(),\n                        status: attempt_response.status.into(), // Using status from attempt_response\n                        feature_metadata: attempt_response.payment_intent_feature_metadata, // Using feature_metadata from attempt_response\n                        merchant_id: payment_intent.merchant_id.clone(),\n                        merchant_reference_id: payment_intent.merchant_reference_id.clone(),\n                        invoice_amount: payment_intent.invoice_amount,\n                        invoice_currency: payment_intent.invoice_currency,\n                        created_at: payment_intent.created_at,\n                        billing_address: payment_intent.billing_address.clone(),\n                    },\n                ))\n            }\n            Ok(_) => Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)\n                .attach_printable(\"Unexpected response from record attempt core\"),\n            error @ Err(_) => {\n                logger::error!(?error);\n                Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)\n                    .attach_printable(\"failed to record attempt in recovery webhook flow\")\n            }\n        }?;\n\n        let response = (recovery_attempt, updated_recovery_intent);\n\n        self.store_payment_processor_tokens_in_redis(state, &response.0, payment_connector_name)\n            .await\n            .map_err(|e| {\n                router_env::logger::error!(\n                    \"Failed to store payment processor tokens in Redis: {:?}\",\n                    e\n                );\n                errors::RevenueRecoveryError::RevenueRecoveryRedisInsertFailed\n            })?;\n\n        Ok(response)\n    }\n\n    pub async fn create_payment_record_request(\n        &self,\n        state: &SessionState,\n        billing_merchant_connector_account_id: &id_type::MerchantConnectorAccountId,\n        payment_merchant_connector_account_id: Option<id_type::MerchantConnectorAccountId>,\n        payment_connector: Option<common_enums::connector_enums::Connector>,\n        triggered_by: common_enums::TriggeredBy,\n    ) -> CustomResult<api_payments::PaymentsAttemptRecordRequest, errors::RevenueRecoveryError>\n    {\n        let revenue_recovery_attempt_data = &self.0;\n        let amount_details =\n            api_payments::PaymentAttemptAmountDetails::from(revenue_recovery_attempt_data);\n        let feature_metadata = api_payments::PaymentAttemptFeatureMetadata {\n            revenue_recovery: Some(api_payments::PaymentAttemptRevenueRecoveryData {\n                // Since we are recording the external paymenmt attempt, this is hardcoded to External\n                attempt_triggered_by: triggered_by,\n                charge_id: self.0.charge_id.clone(),\n            }),\n        };\n\n        let card_info = revenue_recovery_attempt_data\n            .card_info\n            .card_isin\n            .clone()\n            .async_and_then(|isin| async move {\n                let issuer_identifier_number = isin.clone();\n                state\n                    .store\n                    .get_card_info(issuer_identifier_number.as_str())\n                    .await\n                    .map_err(|error| services::logger::warn!(card_info_error=?error))\n                    .ok()\n            })\n            .await\n            .flatten();\n        let payment_method_data = api_models::payments::RecordAttemptPaymentMethodDataRequest {\n            payment_method_data: api_models::payments::AdditionalPaymentData::Card(Box::new(\n                revenue_recovery_attempt_data.card_info.clone(),\n            )),\n            billing: None,\n        };\n\n        let card_issuer = revenue_recovery_attempt_data.card_info.card_issuer.clone();\n\n        let error =\n            Option::<api_payments::RecordAttemptErrorDetails>::from(revenue_recovery_attempt_data);\n        Ok(api_payments::PaymentsAttemptRecordRequest {\n            amount_details,\n            status: revenue_recovery_attempt_data.status,\n            billing: None,\n            shipping: None,\n            connector: payment_connector,\n            payment_merchant_connector_id: payment_merchant_connector_account_id,\n            error,\n            description: None,\n            connector_transaction_id: revenue_recovery_attempt_data\n                .connector_transaction_id\n                .clone(),\n            payment_method_type: revenue_recovery_attempt_data.payment_method_type,\n            billing_connector_id: billing_merchant_connector_account_id.clone(),\n            payment_method_subtype: revenue_recovery_attempt_data.payment_method_sub_type,\n            payment_method_data: Some(payment_method_data),\n            metadata: None,\n            feature_metadata: Some(feature_metadata),\n            transaction_created_at: revenue_recovery_attempt_data.transaction_created_at,\n            processor_payment_method_token: revenue_recovery_attempt_data\n                .processor_payment_method_token\n                .clone(),\n            connector_customer_id: revenue_recovery_attempt_data.connector_customer_id.clone(),\n            retry_count: revenue_recovery_attempt_data.retry_count,\n            invoice_next_billing_time: revenue_recovery_attempt_data.invoice_next_billing_time,\n            invoice_billing_started_at_time: revenue_recovery_attempt_data\n                .invoice_billing_started_at_time,\n            triggered_by,\n            card_network: revenue_recovery_attempt_data.card_info.card_network.clone(),\n            card_issuer,\n        })\n    }\n\n    pub async fn find_payment_merchant_connector_account(\n        &self,\n        state: &SessionState,\n        key_store: &domain::MerchantKeyStore,\n        billing_connector_account: &domain::MerchantConnectorAccount,\n    ) -> CustomResult<Option<domain::MerchantConnectorAccount>, errors::RevenueRecoveryError> {\n        let payment_merchant_connector_account_id = billing_connector_account\n            .get_payment_merchant_connector_account_id_using_account_reference_id(\n                self.0.connector_account_reference_id.clone(),\n            );\n        let db = &*state.store;\n        let key_manager_state = &(state).into();\n        let payment_merchant_connector_account = payment_merchant_connector_account_id\n            .as_ref()\n            .async_map(|mca_id| async move {\n                db.find_merchant_connector_account_by_id(key_manager_state, mca_id, key_store)\n                    .await\n            })\n            .await\n            .transpose()\n            .change_context(errors::RevenueRecoveryError::PaymentMerchantConnectorAccountNotFound)\n            .attach_printable(\n                \"failed to fetch payment merchant connector id using account reference id\",\n            )?;\n        Ok(payment_merchant_connector_account)\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn get_recovery_payment_attempt(\n        is_recovery_transaction_event: bool,\n        billing_connector_account: &domain::MerchantConnectorAccount,\n        state: &SessionState,\n        connector_enum: &connector_integration_interface::ConnectorEnum,\n        req_state: &ReqState,\n        billing_connector_payment_details: Option<\n            &revenue_recovery_response::BillingConnectorPaymentsSyncResponse,\n        >,\n        request_details: &hyperswitch_interfaces::webhooks::IncomingWebhookRequestDetails<'_>,\n        merchant_context: &domain::MerchantContext,\n        business_profile: &domain::Profile,\n        payment_intent: &revenue_recovery::RecoveryPaymentIntent,\n        invoice_details: &revenue_recovery::RevenueRecoveryInvoiceData,\n    ) -> CustomResult<\n        (\n            Option<revenue_recovery::RecoveryPaymentAttempt>,\n            revenue_recovery::RecoveryPaymentIntent,\n        ),\n        errors::RevenueRecoveryError,\n    > {\n        let payment_attempt_with_recovery_intent = match is_recovery_transaction_event {\n            true => {\n                let invoice_transaction_details = Self::get_recovery_invoice_transaction_details(\n                    connector_enum,\n                    request_details,\n                    billing_connector_payment_details,\n                    invoice_details,\n                )?;\n\n                // Find the payment merchant connector ID at the top level to avoid multiple DB calls.\n                let payment_merchant_connector_account = invoice_transaction_details\n                    .find_payment_merchant_connector_account(\n                        state,\n                        merchant_context.get_merchant_key_store(),\n                        billing_connector_account,\n                    )\n                    .await?;\n\n                let (payment_attempt, updated_payment_intent) = invoice_transaction_details\n                    .get_payment_attempt(\n                        state,\n                        req_state,\n                        merchant_context,\n                        business_profile,\n                        payment_intent,\n                    )\n                    .await\n                    .transpose()\n                    .async_unwrap_or_else(|| async {\n                        invoice_transaction_details\n                            .record_payment_attempt(\n                                state,\n                                req_state,\n                                merchant_context,\n                                business_profile,\n                                payment_intent,\n                                &billing_connector_account.get_id(),\n                                payment_merchant_connector_account,\n                            )\n                            .await\n                    })\n                    .await?;\n                (Some(payment_attempt), updated_payment_intent)\n            }\n\n            false => (None, payment_intent.clone()),\n        };\n\n        Ok(payment_attempt_with_recovery_intent)\n    }\n\n    /// Store payment processor tokens in Redis for retry management\n    async fn store_payment_processor_tokens_in_redis(\n        &self,\n        state: &SessionState,\n        recovery_attempt: &revenue_recovery::RecoveryPaymentAttempt,\n        payment_connector_name: Option<common_enums::connector_enums::Connector>,\n    ) -> CustomResult<(), errors::RevenueRecoveryError> {\n        let revenue_recovery_attempt_data = &self.0;\n        let error_code = recovery_attempt.error_code.clone();\n        let error_message = revenue_recovery_attempt_data.error_message.clone();\n        let connector_name = payment_connector_name\n            .ok_or(errors::RevenueRecoveryError::TransactionWebhookProcessingFailed)\n            .attach_printable(\"unable to derive payment connector\")?\n            .to_string();\n\n        let gsm_record = helpers::get_gsm_record(\n            state,\n            error_code.clone(),\n            error_message,\n            connector_name,\n            REVENUE_RECOVERY.to_string(),\n        )\n        .await;\n\n        let is_hard_decline = gsm_record\n            .and_then(|record| record.error_category)\n            .map(|category| category == common_enums::ErrorCategory::HardDecline)\n            .unwrap_or(false);\n\n        // Extract required fields from the revenue recovery attempt data\n        let connector_customer_id = revenue_recovery_attempt_data.connector_customer_id.clone();\n\n        let attempt_id = recovery_attempt.attempt_id.clone();\n        let token_unit = PaymentProcessorTokenStatus {\n            error_code,\n            inserted_by_attempt_id: attempt_id.clone(),\n            daily_retry_history: HashMap::from([(recovery_attempt.created_at.date(), 1)]),\n            scheduled_at: None,\n            is_hard_decline: Some(is_hard_decline),\n            modified_at: Some(recovery_attempt.created_at),\n            payment_processor_token_details: PaymentProcessorTokenDetails {\n                payment_processor_token: revenue_recovery_attempt_data\n                    .processor_payment_method_token\n                    .clone(),\n                expiry_month: revenue_recovery_attempt_data\n                    .card_info\n                    .card_exp_month\n                    .clone(),\n                expiry_year: revenue_recovery_attempt_data\n                    .card_info\n                    .card_exp_year\n                    .clone(),\n                card_issuer: revenue_recovery_attempt_data.card_info.card_issuer.clone(),\n                last_four_digits: revenue_recovery_attempt_data.card_info.last4.clone(),\n                card_network: revenue_recovery_attempt_data.card_info.card_network.clone(),\n                card_type: revenue_recovery_attempt_data.card_info.card_type.clone(),\n            },\n        };\n\n        // Make the Redis call to store tokens\n        RedisTokenManager::upsert_payment_processor_token(\n            state,\n            &connector_customer_id,\n            token_unit,\n        )\n        .await\n        .change_context(errors::RevenueRecoveryError::RevenueRecoveryRedisInsertFailed)\n        .attach_printable(\"Failed to store payment processor tokens in Redis\")?;\n\n        Ok(())\n    }\n}",
+      "after_code": "impl RevenueRecoveryAttempt {\n    pub async fn load_recovery_attempt_from_api(\n        data: api_models::payments::RecoveryPaymentsCreate,\n        state: &SessionState,\n        req_state: &ReqState,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        payment_intent: revenue_recovery::RecoveryPaymentIntent,\n        payment_merchant_connector_account: domain::MerchantConnectorAccount,\n    ) -> CustomResult<\n        (\n            revenue_recovery::RecoveryPaymentAttempt,\n            revenue_recovery::RecoveryPaymentIntent,\n        ),\n        errors::RevenueRecoveryError,\n    > {\n        let recovery_attempt = Self(revenue_recovery::RevenueRecoveryAttemptData::foreign_from(\n            &data,\n        ));\n        recovery_attempt\n            .get_payment_attempt(state, req_state, merchant_context, profile, &payment_intent)\n            .await\n            .transpose()\n            .async_unwrap_or_else(|| async {\n                recovery_attempt\n                    .record_payment_attempt(\n                        state,\n                        req_state,\n                        merchant_context,\n                        profile,\n                        &payment_intent,\n                        &data.billing_merchant_connector_id,\n                        Some(payment_merchant_connector_account),\n                    )\n                    .await\n            })\n            .await\n    }\n\n    fn get_recovery_invoice_transaction_details(\n        connector_enum: &connector_integration_interface::ConnectorEnum,\n        request_details: &hyperswitch_interfaces::webhooks::IncomingWebhookRequestDetails<'_>,\n        billing_connector_payment_details: Option<\n            &revenue_recovery_response::BillingConnectorPaymentsSyncResponse,\n        >,\n        billing_connector_invoice_details: &revenue_recovery::RevenueRecoveryInvoiceData,\n    ) -> CustomResult<Self, errors::RevenueRecoveryError> {\n        billing_connector_payment_details.map_or_else(\n            || {\n                interface_webhooks::IncomingWebhook::get_revenue_recovery_attempt_details(\n                    connector_enum,\n                    request_details,\n                )\n                .change_context(errors::RevenueRecoveryError::TransactionWebhookProcessingFailed)\n                .attach_printable(\n                    \"Failed to get recovery attempt details from the billing connector\",\n                )\n                .map(RevenueRecoveryAttempt)\n            },\n            |data| {\n                Ok(Self(revenue_recovery::RevenueRecoveryAttemptData::from((\n                    data,\n                    billing_connector_invoice_details,\n                ))))\n            },\n        )\n    }\n    pub fn get_revenue_recovery_attempt(\n        payment_intent: &domain_payments::PaymentIntent,\n        revenue_recovery_metadata: &api_payments::PaymentRevenueRecoveryMetadata,\n        billing_connector_account: &domain::MerchantConnectorAccount,\n        card_info: api_payments::AdditionalCardInfo,\n        payment_processor_token: &str,\n    ) -> CustomResult<Self, errors::RevenueRecoveryError> {\n        let revenue_recovery_data = payment_intent\n            .create_revenue_recovery_attempt_data(\n                revenue_recovery_metadata.clone(),\n                billing_connector_account,\n                card_info,\n                payment_processor_token,\n            )\n            .change_context(errors::RevenueRecoveryError::RevenueRecoveryAttemptDataCreateFailed)\n            .attach_printable(\"Failed to build recovery attempt data\")?;\n        Ok(Self(revenue_recovery_data))\n    }\n    async fn get_payment_attempt(\n        &self,\n        state: &SessionState,\n        req_state: &ReqState,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        payment_intent: &revenue_recovery::RecoveryPaymentIntent,\n    ) -> CustomResult<\n        Option<(\n            revenue_recovery::RecoveryPaymentAttempt,\n            revenue_recovery::RecoveryPaymentIntent,\n        )>,\n        errors::RevenueRecoveryError,\n    > {\n        let attempt_response =\n            Box::pin(payments::payments_list_attempts_using_payment_intent_id::<\n                payments::operations::PaymentGetListAttempts,\n                api_payments::PaymentAttemptListResponse,\n                _,\n                payments::operations::payment_attempt_list::PaymentGetListAttempts,\n                hyperswitch_domain_models::payments::PaymentAttemptListData<\n                    payments::operations::PaymentGetListAttempts,\n                >,\n            >(\n                state.clone(),\n                req_state.clone(),\n                merchant_context.clone(),\n                profile.clone(),\n                payments::operations::PaymentGetListAttempts,\n                api_payments::PaymentAttemptListRequest {\n                    payment_intent_id: payment_intent.payment_id.clone(),\n                },\n                payment_intent.payment_id.clone(),\n                hyperswitch_domain_models::payments::HeaderPayload::default(),\n            ))\n            .await;\n        let response = match attempt_response {\n            Ok(services::ApplicationResponse::JsonWithHeaders((payments_response, _))) => {\n                let final_attempt = self\n                    .0\n                    .charge_id\n                    .as_ref()\n                    .map(|charge_id| {\n                        payments_response\n                            .find_attempt_in_attempts_list_using_charge_id(charge_id.clone())\n                    })\n                    .unwrap_or_else(|| {\n                        self.0\n                            .connector_transaction_id\n                            .as_ref()\n                            .and_then(|transaction_id| {\n                                payments_response\n                                    .find_attempt_in_attempts_list_using_connector_transaction_id(\n                                        transaction_id,\n                                    )\n                            })\n                    });\n                let payment_attempt =\n                    final_attempt.map(|res| revenue_recovery::RecoveryPaymentAttempt {\n                        attempt_id: res.id.to_owned(),\n                        attempt_status: res.status.to_owned(),\n                        feature_metadata: res.feature_metadata.to_owned(),\n                        amount: res.amount.net_amount,\n                        network_advice_code: res.error.clone().and_then(|e| e.network_advice_code), // Placeholder, to be populated if available\n                        network_decline_code: res\n                            .error\n                            .clone()\n                            .and_then(|e| e.network_decline_code), // Placeholder, to be populated if available\n                        error_code: res.error.clone().map(|error| error.code),\n                        created_at: res.created_at,\n                    });\n                // If we have an attempt, combine it with payment_intent in a tuple.\n                let res_with_payment_intent_and_attempt =\n                    payment_attempt.map(|attempt| (attempt, (*payment_intent).clone()));\n                Ok(res_with_payment_intent_and_attempt)\n            }\n            Ok(_) => Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)\n                .attach_printable(\"Unexpected response from payment intent core\"),\n            error @ Err(_) => {\n                logger::error!(?error);\n                Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)\n                    .attach_printable(\"failed to fetch payment attempt in recovery webhook flow\")\n            }\n        }?;\n        Ok(response)\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn record_payment_attempt(\n        &self,\n        state: &SessionState,\n        req_state: &ReqState,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        payment_intent: &revenue_recovery::RecoveryPaymentIntent,\n        billing_connector_account_id: &id_type::MerchantConnectorAccountId,\n        payment_connector_account: Option<domain::MerchantConnectorAccount>,\n    ) -> CustomResult<\n        (\n            revenue_recovery::RecoveryPaymentAttempt,\n            revenue_recovery::RecoveryPaymentIntent,\n        ),\n        errors::RevenueRecoveryError,\n    > {\n        let payment_connector_id =   payment_connector_account.as_ref().map(|account: &hyperswitch_domain_models::merchant_connector_account::MerchantConnectorAccount| account.id.clone());\n        let payment_connector_name = payment_connector_account\n            .as_ref()\n            .map(|account| account.connector_name);\n        let request_payload: api_payments::PaymentsAttemptRecordRequest = self\n            .create_payment_record_request(\n                state,\n                billing_connector_account_id,\n                payment_connector_id,\n                payment_connector_name,\n                common_enums::TriggeredBy::External,\n            )\n            .await?;\n        let attempt_response = Box::pin(payments::record_attempt_core(\n            state.clone(),\n            req_state.clone(),\n            merchant_context.clone(),\n            profile.clone(),\n            request_payload,\n            payment_intent.payment_id.clone(),\n            hyperswitch_domain_models::payments::HeaderPayload::default(),\n        ))\n        .await;\n\n        let (recovery_attempt, updated_recovery_intent) = match attempt_response {\n            Ok(services::ApplicationResponse::JsonWithHeaders((attempt_response, _))) => {\n                Ok((\n                    revenue_recovery::RecoveryPaymentAttempt {\n                        attempt_id: attempt_response.id.clone(),\n                        attempt_status: attempt_response.status,\n                        feature_metadata: attempt_response.payment_attempt_feature_metadata,\n                        amount: attempt_response.amount,\n                        network_advice_code: attempt_response\n                            .error_details\n                            .clone()\n                            .and_then(|error| error.network_decline_code), // Placeholder, to be populated if available\n                        network_decline_code: attempt_response\n                            .error_details\n                            .clone()\n                            .and_then(|error| error.network_decline_code), // Placeholder, to be populated if available\n                        error_code: attempt_response\n                            .error_details\n                            .clone()\n                            .map(|error| error.code),\n                        created_at: attempt_response.created_at,\n                    },\n                    revenue_recovery::RecoveryPaymentIntent {\n                        payment_id: payment_intent.payment_id.clone(),\n                        status: attempt_response.status.into(), // Using status from attempt_response\n                        feature_metadata: attempt_response.payment_intent_feature_metadata, // Using feature_metadata from attempt_response\n                        merchant_id: payment_intent.merchant_id.clone(),\n                        merchant_reference_id: payment_intent.merchant_reference_id.clone(),\n                        invoice_amount: payment_intent.invoice_amount,\n                        invoice_currency: payment_intent.invoice_currency,\n                        created_at: payment_intent.created_at,\n                        billing_address: payment_intent.billing_address.clone(),\n                    },\n                ))\n            }\n            Ok(_) => Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)\n                .attach_printable(\"Unexpected response from record attempt core\"),\n            error @ Err(_) => {\n                logger::error!(?error);\n                Err(errors::RevenueRecoveryError::PaymentAttemptFetchFailed)\n                    .attach_printable(\"failed to record attempt in recovery webhook flow\")\n            }\n        }?;\n\n        let response = (recovery_attempt, updated_recovery_intent);\n\n        self.store_payment_processor_tokens_in_redis(state, &response.0, payment_connector_name)\n            .await\n            .map_err(|e| {\n                router_env::logger::error!(\n                    \"Failed to store payment processor tokens in Redis: {:?}\",\n                    e\n                );\n                errors::RevenueRecoveryError::RevenueRecoveryRedisInsertFailed\n            })?;\n\n        Ok(response)\n    }\n\n    pub async fn create_payment_record_request(\n        &self,\n        state: &SessionState,\n        billing_merchant_connector_account_id: &id_type::MerchantConnectorAccountId,\n        payment_merchant_connector_account_id: Option<id_type::MerchantConnectorAccountId>,\n        payment_connector: Option<common_enums::connector_enums::Connector>,\n        triggered_by: common_enums::TriggeredBy,\n    ) -> CustomResult<api_payments::PaymentsAttemptRecordRequest, errors::RevenueRecoveryError>\n    {\n        let revenue_recovery_attempt_data = &self.0;\n        let amount_details =\n            api_payments::PaymentAttemptAmountDetails::from(revenue_recovery_attempt_data);\n        let feature_metadata = api_payments::PaymentAttemptFeatureMetadata {\n            revenue_recovery: Some(api_payments::PaymentAttemptRevenueRecoveryData {\n                // Since we are recording the external paymenmt attempt, this is hardcoded to External\n                attempt_triggered_by: triggered_by,\n                charge_id: self.0.charge_id.clone(),\n            }),\n        };\n\n        let card_info = revenue_recovery_attempt_data\n            .card_info\n            .card_isin\n            .clone()\n            .async_and_then(|isin| async move {\n                let issuer_identifier_number = isin.clone();\n                state\n                    .store\n                    .get_card_info(issuer_identifier_number.as_str())\n                    .await\n                    .map_err(|error| services::logger::warn!(card_info_error=?error))\n                    .ok()\n            })\n            .await\n            .flatten();\n        let payment_method_data = api_models::payments::RecordAttemptPaymentMethodDataRequest {\n            payment_method_data: api_models::payments::AdditionalPaymentData::Card(Box::new(\n                revenue_recovery_attempt_data.card_info.clone(),\n            )),\n            billing: None,\n        };\n\n        let card_issuer = revenue_recovery_attempt_data.card_info.card_issuer.clone();\n\n        let error =\n            Option::<api_payments::RecordAttemptErrorDetails>::from(revenue_recovery_attempt_data);\n        Ok(api_payments::PaymentsAttemptRecordRequest {\n            amount_details,\n            status: revenue_recovery_attempt_data.status,\n            billing: None,\n            shipping: None,\n            connector: payment_connector,\n            payment_merchant_connector_id: payment_merchant_connector_account_id,\n            error,\n            description: None,\n            connector_transaction_id: revenue_recovery_attempt_data\n                .connector_transaction_id\n                .clone(),\n            payment_method_type: revenue_recovery_attempt_data.payment_method_type,\n            billing_connector_id: billing_merchant_connector_account_id.clone(),\n            payment_method_subtype: revenue_recovery_attempt_data.payment_method_sub_type,\n            payment_method_data: Some(payment_method_data),\n            metadata: None,\n            feature_metadata: Some(feature_metadata),\n            transaction_created_at: revenue_recovery_attempt_data.transaction_created_at,\n            processor_payment_method_token: revenue_recovery_attempt_data\n                .processor_payment_method_token\n                .clone(),\n            connector_customer_id: revenue_recovery_attempt_data.connector_customer_id.clone(),\n            retry_count: revenue_recovery_attempt_data.retry_count,\n            invoice_next_billing_time: revenue_recovery_attempt_data.invoice_next_billing_time,\n            invoice_billing_started_at_time: revenue_recovery_attempt_data\n                .invoice_billing_started_at_time,\n            triggered_by,\n            card_network: revenue_recovery_attempt_data.card_info.card_network.clone(),\n            card_issuer,\n        })\n    }\n\n    pub async fn find_payment_merchant_connector_account(\n        &self,\n        state: &SessionState,\n        key_store: &domain::MerchantKeyStore,\n        billing_connector_account: &domain::MerchantConnectorAccount,\n    ) -> CustomResult<Option<domain::MerchantConnectorAccount>, errors::RevenueRecoveryError> {\n        let payment_merchant_connector_account_id = billing_connector_account\n            .get_payment_merchant_connector_account_id_using_account_reference_id(\n                self.0.connector_account_reference_id.clone(),\n            );\n        let db = &*state.store;\n        let key_manager_state = &(state).into();\n        let payment_merchant_connector_account = payment_merchant_connector_account_id\n            .as_ref()\n            .async_map(|mca_id| async move {\n                db.find_merchant_connector_account_by_id(key_manager_state, mca_id, key_store)\n                    .await\n            })\n            .await\n            .transpose()\n            .change_context(errors::RevenueRecoveryError::PaymentMerchantConnectorAccountNotFound)\n            .attach_printable(\n                \"failed to fetch payment merchant connector id using account reference id\",\n            )?;\n        Ok(payment_merchant_connector_account)\n    }\n\n    #[allow(clippy::too_many_arguments)]\n    async fn get_recovery_payment_attempt(\n        is_recovery_transaction_event: bool,\n        billing_connector_account: &domain::MerchantConnectorAccount,\n        state: &SessionState,\n        connector_enum: &connector_integration_interface::ConnectorEnum,\n        req_state: &ReqState,\n        billing_connector_payment_details: Option<\n            &revenue_recovery_response::BillingConnectorPaymentsSyncResponse,\n        >,\n        request_details: &hyperswitch_interfaces::webhooks::IncomingWebhookRequestDetails<'_>,\n        merchant_context: &domain::MerchantContext,\n        business_profile: &domain::Profile,\n        payment_intent: &revenue_recovery::RecoveryPaymentIntent,\n        invoice_details: &revenue_recovery::RevenueRecoveryInvoiceData,\n    ) -> CustomResult<\n        (\n            Option<revenue_recovery::RecoveryPaymentAttempt>,\n            revenue_recovery::RecoveryPaymentIntent,\n        ),\n        errors::RevenueRecoveryError,\n    > {\n        let payment_attempt_with_recovery_intent = match is_recovery_transaction_event {\n            true => {\n                let invoice_transaction_details = Self::get_recovery_invoice_transaction_details(\n                    connector_enum,\n                    request_details,\n                    billing_connector_payment_details,\n                    invoice_details,\n                )?;\n\n                // Find the payment merchant connector ID at the top level to avoid multiple DB calls.\n                let payment_merchant_connector_account = invoice_transaction_details\n                    .find_payment_merchant_connector_account(\n                        state,\n                        merchant_context.get_merchant_key_store(),\n                        billing_connector_account,\n                    )\n                    .await?;\n\n                let (payment_attempt, updated_payment_intent) = invoice_transaction_details\n                    .get_payment_attempt(\n                        state,\n                        req_state,\n                        merchant_context,\n                        business_profile,\n                        payment_intent,\n                    )\n                    .await\n                    .transpose()\n                    .async_unwrap_or_else(|| async {\n                        invoice_transaction_details\n                            .record_payment_attempt(\n                                state,\n                                req_state,\n                                merchant_context,\n                                business_profile,\n                                payment_intent,\n                                &billing_connector_account.get_id(),\n                                payment_merchant_connector_account,\n                            )\n                            .await\n                    })\n                    .await?;\n                (Some(payment_attempt), updated_payment_intent)\n            }\n\n            false => (None, payment_intent.clone()),\n        };\n\n        Ok(payment_attempt_with_recovery_intent)\n    }\n\n    /// Store payment processor tokens in Redis for retry management\n    async fn store_payment_processor_tokens_in_redis(\n        &self,\n        state: &SessionState,\n        recovery_attempt: &revenue_recovery::RecoveryPaymentAttempt,\n        payment_connector_name: Option<common_enums::connector_enums::Connector>,\n    ) -> CustomResult<(), errors::RevenueRecoveryError> {\n        let revenue_recovery_attempt_data = &self.0;\n        let error_code = recovery_attempt.error_code.clone();\n        let error_message = revenue_recovery_attempt_data.error_message.clone();\n        let connector_name = payment_connector_name\n            .ok_or(errors::RevenueRecoveryError::TransactionWebhookProcessingFailed)\n            .attach_printable(\"unable to derive payment connector\")?\n            .to_string();\n\n        let gsm_record = helpers::get_gsm_record(\n            state,\n            error_code.clone(),\n            error_message,\n            connector_name,\n            REVENUE_RECOVERY.to_string(),\n        )\n        .await;\n\n        let is_hard_decline = gsm_record\n            .and_then(|record| record.error_category)\n            .map(|category| category == common_enums::ErrorCategory::HardDecline)\n            .unwrap_or(false);\n\n        // Extract required fields from the revenue recovery attempt data\n        let connector_customer_id = revenue_recovery_attempt_data.connector_customer_id.clone();\n\n        let attempt_id = recovery_attempt.attempt_id.clone();\n        let token_unit = PaymentProcessorTokenStatus {\n            error_code,\n            inserted_by_attempt_id: attempt_id.clone(),\n            daily_retry_history: HashMap::from([(recovery_attempt.created_at.date(), 1)]),\n            scheduled_at: None,\n            is_hard_decline: Some(is_hard_decline),\n            modified_at: Some(recovery_attempt.created_at),\n            payment_processor_token_details: PaymentProcessorTokenDetails {\n                payment_processor_token: revenue_recovery_attempt_data\n                    .processor_payment_method_token\n                    .clone(),\n                expiry_month: revenue_recovery_attempt_data\n                    .card_info\n                    .card_exp_month\n                    .clone(),\n                expiry_year: revenue_recovery_attempt_data\n                    .card_info\n                    .card_exp_year\n                    .clone(),\n                card_issuer: revenue_recovery_attempt_data.card_info.card_issuer.clone(),\n                last_four_digits: revenue_recovery_attempt_data.card_info.last4.clone(),\n                card_network: revenue_recovery_attempt_data.card_info.card_network.clone(),\n                card_type: revenue_recovery_attempt_data.card_info.card_type.clone(),\n            },\n            is_active: Some(true),\n            account_update_history: None\n        };\n\n        // Make the Redis call to store tokens\n        RedisTokenManager::upsert_payment_processor_token(\n            state,\n            &connector_customer_id,\n            token_unit,\n        )\n        .await\n        .change_context(errors::RevenueRecoveryError::RevenueRecoveryRedisInsertFailed)\n        .attach_printable(\"Failed to store payment processor tokens in Redis\")?;\n\n        Ok(())\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "                card_type: revenue_recovery_attempt_data.card_info.card_type.clone(),\n            },\n            is_active: Some(true),\n            account_update_history: None\n        };\n"
+      },
+      "commit_sha": "3b273184cc7b0e213ef27a1ebe52c332b85842a0"
+    }
+  ]
+}

diffs/pr_10112/51b1dd1/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "51b1dd142a8e78fa60added4e7fe0bada4d88378",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/router/src/core/revenue_recovery/types.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/revenue_recovery/types.rs::impl::Action",
+      "file": "crates/router/src/core/revenue_recovery/types.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl Action {\n    #[allow(clippy::too_many_arguments)]\n    pub async fn execute_payment(\n        state: &SessionState,\n        _merchant_id: &id_type::MerchantId,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,\n        latest_attempt_id: &id_type::GlobalAttemptId,\n        scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,\n    ) -> RecoveryResult<Self> {\n        let connector_customer_id = payment_intent\n            .extract_connector_customer_id_from_payment_intent()\n            .change_context(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n        let response = revenue_recovery_core::api::call_proxy_api(\n            state,\n            payment_intent,\n            revenue_recovery_payment_data,\n            revenue_recovery_metadata,\n            &scheduled_token\n                .payment_processor_token_details\n                .payment_processor_token,\n        )\n        .await;\n\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(\n                payment_intent,\n            );\n        // handle proxy api's response\n        match response {\n            Ok(payment_data) => {\n                let account_updater_action = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(\n                    state,\n                    &connector_customer_id,\n                    scheduled_token,\n                    payment_data.mandate_data.clone(),\n                    &payment_data.payment_attempt.id\n                ).await\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle get valid action: {:?}\",\n                        e\n                    );\n                })\n                .ok();\n\n                let _account_updater_result  = account_updater_action.async_map(|action| {\n                let customer_id  =  connector_customer_id.clone();\n                let payment_attempt_id = payment_data.payment_attempt.id.clone();\n                async move {\n                    action.handle_account_updater_action(\n                        state,\n                        customer_id.as_str(),\n                        scheduled_token,\n                        &payment_attempt_id\n                    ).await\n                }\n                })\n                .await\n                .transpose()\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle account updater action: {:?}\",\n                        e\n                    );\n                })\n                .ok();\n\n                match payment_data.payment_attempt.status.foreign_into() {\n                    RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                        let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                        let recovery_payment_tuple =\n                            recovery_incoming_flow::RecoveryPaymentTuple::new(\n                                &recovery_payment_intent,\n                                &recovery_payment_attempt,\n                            );\n\n                        // publish events to kafka\n                        if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                        // update the status of token in redis\n                        let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &None,\n                        &None,\n                        Some(&scheduled_token.payment_processor_token_details.payment_processor_token),\n                    )\n                    .await;\n\n                        // unlocking the token\n                        let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                        let event_status = common_enums::EventType::PaymentSucceeded;\n\n                        let payments_response = payment_data\n                            .clone()\n                            .generate_response(\n                                state,\n                                None,\n                                None,\n                                None,\n                                &merchant_context,\n                                profile,\n                                None,\n                            )\n                            .change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)\n                            .attach_printable(\"Failed while generating response for payment\")?;\n\n                        RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(\n                        state,\n                        common_enums::EventClass::Payments,\n                        event_status,\n                        payment_intent,\n                        &merchant_context,\n                        profile,\n                        payment_data.payment_attempt.id.get_string_repr().to_string(),\n                        payments_response\n                    )\n                    .await?;\n\n                        Ok(Self::SuccessfulPayment(\n                            payment_data.payment_attempt.clone(),\n                        ))\n                    }\n                    RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                        let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                        let recovery_payment_tuple =\n                            recovery_incoming_flow::RecoveryPaymentTuple::new(\n                                &recovery_payment_intent,\n                                &recovery_payment_attempt,\n                            );\n\n                        // publish events to kafka\n                        if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                        let error_code = payment_data\n                            .payment_attempt\n                            .clone()\n                            .error\n                            .map(|error| error.code);\n\n                        let is_hard_decline = revenue_recovery::check_hard_decline(\n                            state,\n                            &payment_data.payment_attempt,\n                        )\n                        .await\n                        .ok();\n\n                        let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &error_code,\n                        &is_hard_decline,\n                        Some(&scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token)\n                            ,\n                    )\n                    .await;\n\n                        // unlocking the token\n                        let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                        // Reopen calculate workflow on payment failure\n                        Box::pin(reopen_calculate_workflow_on_payment_failure(\n                            state,\n                            process,\n                            profile,\n                            merchant_context,\n                            payment_intent,\n                            revenue_recovery_payment_data,\n                            latest_attempt_id,\n                        ))\n                        .await?;\n\n                        // Return terminal failure to finish the current execute workflow\n                        Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))\n                    }\n\n                    RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                        Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))\n                    }\n                    RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                        logger::info!(?action, \"Invalid Payment Status For PCR Payment\");\n                        Ok(Self::ManualReviewAction)\n                    }\n                }\n            }\n            Err(err) =>\n            // check for an active attempt being constructed or not\n            {\n                logger::error!(execute_payment_res=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }\n\n    pub async fn execute_payment_task_response_handler(\n        &self,\n        state: &SessionState,\n        payment_intent: &PaymentIntent,\n        execute_task_process: &storage::ProcessTracker,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,\n    ) -> Result<(), errors::ProcessTrackerError> {\n        logger::info!(\"Entering execute_payment_task_response_handler\");\n\n        let db = &*state.store;\n        match self {\n            Self::SyncPayment(payment_attempt) => {\n                revenue_recovery_core::insert_psync_pcr_task_to_pt(\n                    revenue_recovery_payment_data.billing_mca.get_id().clone(),\n                    db,\n                    revenue_recovery_payment_data\n                        .merchant_account\n                        .get_id()\n                        .to_owned(),\n                    payment_intent.id.clone(),\n                    revenue_recovery_payment_data.profile.get_id().to_owned(),\n                    payment_attempt.id.clone(),\n                    storage::ProcessTrackerRunner::PassiveRecoveryWorkflow,\n                    revenue_recovery_payment_data.retry_algorithm,\n                )\n                .await\n                .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                .attach_printable(\"Failed to create a psync workflow in the process tracker\")?;\n\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_COMPLETE_FOR_PSYNC,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n\n            Self::RetryPayment(schedule_time) => {\n                db.as_scheduler()\n                    .retry_process(execute_task_process.clone(), *schedule_time)\n                    .await?;\n\n                // update the connector payment transmission field to Unsuccessful and unset active attempt id\n                revenue_recovery_metadata.set_payment_transmission_field_for_api_request(\n                    enums::PaymentConnectorTransmission::ConnectorCallUnsuccessful,\n                );\n\n                let payment_update_req =\n                PaymentsUpdateIntentRequest::update_feature_metadata_and_active_attempt_with_api(\n                    payment_intent\n                        .feature_metadata\n                        .clone()\n                        .unwrap_or_default()\n                        .convert_back()\n                        .set_payment_revenue_recovery_metadata_using_api(\n                            revenue_recovery_metadata.clone(),\n                        ),\n                    api_enums::UpdateActiveAttempt::Unset,\n                );\n                logger::info!(\n                    \"Call made to payments update intent api , with the request body {:?}\",\n                    payment_update_req\n                );\n                revenue_recovery_core::api::update_payment_intent_api(\n                    state,\n                    payment_intent.id.clone(),\n                    revenue_recovery_payment_data,\n                    payment_update_req,\n                )\n                .await\n                .change_context(errors::RecoveryError::PaymentCallFailed)?;\n                Ok(())\n            }\n            Self::TerminalFailure(payment_attempt) => {\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_FAILURE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                Ok(())\n            }\n            Self::SuccessfulPayment(payment_attempt) => {\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                // Record back to billing connector for terminal status\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                record_back_to_billing_connector(\n                    state,\n                    payment_attempt,\n                    payment_intent,\n                    &revenue_recovery_payment_data.billing_mca,\n                )\n                .await\n                .change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)\n                .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::ReviewPayment => {\n                // requeue the process tracker in case of error response\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Pending,\n                    business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_REQUEUE)),\n                };\n                db.as_scheduler()\n                    .update_process(execute_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n            Self::ManualReviewAction => {\n                logger::debug!(\"Invalid Payment Status For PCR Payment\");\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Review,\n                    business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_COMPLETE)),\n                };\n                // update the process tracker status as Review\n                db.as_scheduler()\n                    .update_process(execute_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n        }\n    }\n\n    pub async fn payment_sync_call(\n        state: &SessionState,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        payment_attempt: PaymentAttempt,\n    ) -> RecoveryResult<Self> {\n        logger::info!(\"Entering payment_sync_call\");\n\n        let response = revenue_recovery_core::api::call_psync_api(\n            state,\n            payment_intent.get_id(),\n            revenue_recovery_payment_data,\n            true,\n            true,\n        )\n        .await;\n        let used_token = get_payment_processor_token_id_from_payment_attempt(&payment_attempt);\n\n        match response {\n            Ok(_payment_data) => match payment_attempt.status.foreign_into() {\n                RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                    let connector_customer_id = payment_intent\n                        .extract_connector_customer_id_from_payment_intent()\n                        .change_context(errors::RecoveryError::ValueNotFound)\n                        .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n                    // update the status of token in redis\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                    state,\n                    &connector_customer_id,\n                    &None,\n                    &None,\n                    used_token.as_deref(),\n                )\n                .await;\n\n                    // unlocking the token\n                    let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                    state,\n                    &connector_customer_id,\n                )\n                .await;\n\n                    Ok(Self::SuccessfulPayment(payment_attempt))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                    let connector_customer_id = payment_intent\n                        .extract_connector_customer_id_from_payment_intent()\n                        .change_context(errors::RecoveryError::ValueNotFound)\n                        .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n                    let error_code = payment_attempt.clone().error.map(|error| error.code);\n\n                    let is_hard_decline =\n                        revenue_recovery::check_hard_decline(state, &payment_attempt)\n                            .await\n                            .ok();\n\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                            state,\n                            &connector_customer_id,\n                            &error_code,\n                            &is_hard_decline,\n                            used_token.as_deref(),\n                        )\n                        .await;\n\n                    // unlocking the token\n                    let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    // Reopen calculate workflow on payment failure\n                    Box::pin(reopen_calculate_workflow_on_payment_failure(\n                        state,\n                        process,\n                        profile,\n                        merchant_context,\n                        payment_intent,\n                        revenue_recovery_payment_data,\n                        payment_attempt.get_id(),\n                    ))\n                    .await?;\n\n                    Ok(Self::TerminalFailure(payment_attempt.clone()))\n                }\n\n                RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                    Ok(Self::SyncPayment(payment_attempt))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                    logger::info!(?action, \"Invalid Payment Status For PCR PSync Payment\");\n                    Ok(Self::ManualReviewAction)\n                }\n            },\n            Err(err) =>\n            // if there is an error while psync we create a new Review Task\n            {\n                logger::error!(sync_payment_response=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }\n    pub async fn psync_response_handler(\n        &self,\n        state: &SessionState,\n        payment_intent: &PaymentIntent,\n        psync_task_process: &storage::ProcessTracker,\n        revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n    ) -> Result<(), errors::ProcessTrackerError> {\n        logger::info!(\"Entering psync_response_handler\");\n\n        let db = &*state.store;\n\n        let connector_customer_id = payment_intent\n            .feature_metadata\n            .as_ref()\n            .and_then(|fm| fm.payment_revenue_recovery_metadata.as_ref())\n            .map(|rr| {\n                rr.billing_connector_payment_details\n                    .connector_customer_id\n                    .clone()\n            });\n\n        match self {\n            Self::SyncPayment(payment_attempt) => {\n                //  get a schedule time for psync\n                // and retry the process if there is a schedule time\n                // if None mark the pt status as Retries Exceeded and finish the task\n                payment_sync::recovery_retry_sync_task(\n                    state,\n                    connector_customer_id,\n                    revenue_recovery_metadata.connector.to_string(),\n                    revenue_recovery_payment_data\n                        .merchant_account\n                        .get_id()\n                        .clone(),\n                    psync_task_process.clone(),\n                )\n                .await?;\n                Ok(())\n            }\n\n            Self::RetryPayment(schedule_time) => {\n                // finish the psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                // fetch the execute task\n                let task = revenue_recovery_core::EXECUTE_WORKFLOW;\n                let runner = storage::ProcessTrackerRunner::PassiveRecoveryWorkflow;\n                let process_tracker_id = payment_intent\n                    .get_id()\n                    .get_execute_revenue_recovery_id(task, runner);\n                let execute_task_process = db\n                    .as_scheduler()\n                    .find_process_by_id(&process_tracker_id)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)?\n                    .get_required_value(\"Process Tracker\")?;\n                // retry the execute tasks\n                db.as_scheduler()\n                    .retry_process(execute_task_process, *schedule_time)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n\n            Self::TerminalFailure(payment_attempt) => {\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                // finish the current psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::SuccessfulPayment(payment_attempt) => {\n                // finish the current psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                // Record a successful transaction back to Billing Connector\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                record_back_to_billing_connector(\n                    state,\n                    payment_attempt,\n                    payment_intent,\n                    &revenue_recovery_payment_data.billing_mca,\n                )\n                .await\n                .change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)\n                .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::ReviewPayment => {\n                // requeue the process tracker task in case of psync api error\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Pending,\n                    business_status: Some(String::from(business_status::PSYNC_WORKFLOW_REQUEUE)),\n                };\n                db.as_scheduler()\n                    .update_process(psync_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n            Self::ManualReviewAction => {\n                logger::debug!(\"Invalid Payment Status For PCR Payment\");\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Review,\n                    business_status: Some(String::from(business_status::PSYNC_WORKFLOW_COMPLETE)),\n                };\n                // update the process tracker status as Review\n                db.as_scheduler()\n                    .update_process(psync_task_process.clone(), pt_update)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                Ok(())\n            }\n        }\n    }\n\n    pub(crate) async fn decide_retry_failure_action(\n        state: &SessionState,\n        merchant_id: &id_type::MerchantId,\n        pt: storage::ProcessTracker,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        payment_attempt: &PaymentAttempt,\n        payment_intent: &PaymentIntent,\n    ) -> RecoveryResult<Self> {\n        let db = &*state.store;\n        let next_retry_count = pt.retry_count + 1;\n        let error_message = payment_attempt\n            .error\n            .as_ref()\n            .map(|details| details.message.clone());\n        let error_code = payment_attempt\n            .error\n            .as_ref()\n            .map(|details| details.code.clone());\n        let connector_name = payment_attempt\n            .connector\n            .clone()\n            .ok_or(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"unable to derive payment connector from payment attempt\")?;\n        let gsm_record = helpers::get_gsm_record(\n            state,\n            error_code,\n            error_message,\n            connector_name,\n            REVENUE_RECOVERY.to_string(),\n        )\n        .await;\n        let is_hard_decline = gsm_record\n            .and_then(|gsm_record| gsm_record.error_category)\n            .map(|gsm_error_category| {\n                gsm_error_category == common_enums::ErrorCategory::HardDecline\n            })\n            .unwrap_or(false);\n        let schedule_time = revenue_recovery_payment_data\n            .get_schedule_time_based_on_retry_type(\n                state,\n                merchant_id,\n                next_retry_count,\n                payment_attempt,\n                payment_intent,\n                is_hard_decline,\n            )\n            .await;\n\n        match schedule_time {\n            Some(schedule_time) => Ok(Self::RetryPayment(schedule_time)),\n\n            None => Ok(Self::TerminalFailure(payment_attempt.clone())),\n        }\n    }\n}",
+      "after_code": "impl Action {\n    #[allow(clippy::too_many_arguments)]\n    pub async fn execute_payment(\n        state: &SessionState,\n        _merchant_id: &id_type::MerchantId,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,\n        latest_attempt_id: &id_type::GlobalAttemptId,\n        scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,\n    ) -> RecoveryResult<Self> {\n        let connector_customer_id = payment_intent\n            .extract_connector_customer_id_from_payment_intent()\n            .change_context(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n        let response = revenue_recovery_core::api::call_proxy_api(\n            state,\n            payment_intent,\n            revenue_recovery_payment_data,\n            revenue_recovery_metadata,\n            &scheduled_token\n                .payment_processor_token_details\n                .payment_processor_token,\n        )\n        .await;\n\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(\n                payment_intent,\n            );\n        // handle proxy api's response\n        match response {\n            Ok(payment_data) => {\n                let account_updater_action = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(\n                    state,\n                    &connector_customer_id,\n                    scheduled_token,\n                    payment_data.mandate_data.clone(),\n                    &payment_data.payment_attempt.id\n                ).await\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle get valid action: {:?}\",\n                        e\n                    );\n                })\n                .ok();\n\n                let _account_updater_result = account_updater_action\n                    .async_map(|action| {\n                        let customer_id = connector_customer_id.clone();\n                        let payment_attempt_id = payment_data.payment_attempt.id.clone();\n                        async move {\n                            action\n                                .handle_account_updater_action(\n                                    state,\n                                    customer_id.as_str(),\n                                    scheduled_token,\n                                    &payment_attempt_id,\n                                )\n                                .await\n                        }\n                    })\n                    .await\n                    .transpose()\n                    .inspect_err(|e| {\n                        logger::error!(\"Failed to handle account updater action: {:?}\", e);\n                    })\n                    .ok();\n\n                match payment_data.payment_attempt.status.foreign_into() {\n                    RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                        let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                        let recovery_payment_tuple =\n                            recovery_incoming_flow::RecoveryPaymentTuple::new(\n                                &recovery_payment_intent,\n                                &recovery_payment_attempt,\n                            );\n\n                        // publish events to kafka\n                        if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                        // update the status of token in redis\n                        let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &None,\n                        &None,\n                        Some(&scheduled_token.payment_processor_token_details.payment_processor_token),\n                    )\n                    .await;\n\n                        // unlocking the token\n                        let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                        let event_status = common_enums::EventType::PaymentSucceeded;\n\n                        let payments_response = payment_data\n                            .clone()\n                            .generate_response(\n                                state,\n                                None,\n                                None,\n                                None,\n                                &merchant_context,\n                                profile,\n                                None,\n                            )\n                            .change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)\n                            .attach_printable(\"Failed while generating response for payment\")?;\n\n                        RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(\n                        state,\n                        common_enums::EventClass::Payments,\n                        event_status,\n                        payment_intent,\n                        &merchant_context,\n                        profile,\n                        payment_data.payment_attempt.id.get_string_repr().to_string(),\n                        payments_response\n                    )\n                    .await?;\n\n                        Ok(Self::SuccessfulPayment(\n                            payment_data.payment_attempt.clone(),\n                        ))\n                    }\n                    RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                        let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                        let recovery_payment_tuple =\n                            recovery_incoming_flow::RecoveryPaymentTuple::new(\n                                &recovery_payment_intent,\n                                &recovery_payment_attempt,\n                            );\n\n                        // publish events to kafka\n                        if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                        let error_code = payment_data\n                            .payment_attempt\n                            .clone()\n                            .error\n                            .map(|error| error.code);\n\n                        let is_hard_decline = revenue_recovery::check_hard_decline(\n                            state,\n                            &payment_data.payment_attempt,\n                        )\n                        .await\n                        .ok();\n\n                        let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &error_code,\n                        &is_hard_decline,\n                        Some(&scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token)\n                            ,\n                    )\n                    .await;\n\n                        // unlocking the token\n                        let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                        // Reopen calculate workflow on payment failure\n                        Box::pin(reopen_calculate_workflow_on_payment_failure(\n                            state,\n                            process,\n                            profile,\n                            merchant_context,\n                            payment_intent,\n                            revenue_recovery_payment_data,\n                            latest_attempt_id,\n                        ))\n                        .await?;\n\n                        // Return terminal failure to finish the current execute workflow\n                        Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))\n                    }\n\n                    RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                        Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))\n                    }\n                    RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                        logger::info!(?action, \"Invalid Payment Status For PCR Payment\");\n                        Ok(Self::ManualReviewAction)\n                    }\n                }\n            }\n            Err(err) =>\n            // check for an active attempt being constructed or not\n            {\n                logger::error!(execute_payment_res=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }\n\n    pub async fn execute_payment_task_response_handler(\n        &self,\n        state: &SessionState,\n        payment_intent: &PaymentIntent,\n        execute_task_process: &storage::ProcessTracker,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,\n    ) -> Result<(), errors::ProcessTrackerError> {\n        logger::info!(\"Entering execute_payment_task_response_handler\");\n\n        let db = &*state.store;\n        match self {\n            Self::SyncPayment(payment_attempt) => {\n                revenue_recovery_core::insert_psync_pcr_task_to_pt(\n                    revenue_recovery_payment_data.billing_mca.get_id().clone(),\n                    db,\n                    revenue_recovery_payment_data\n                        .merchant_account\n                        .get_id()\n                        .to_owned(),\n                    payment_intent.id.clone(),\n                    revenue_recovery_payment_data.profile.get_id().to_owned(),\n                    payment_attempt.id.clone(),\n                    storage::ProcessTrackerRunner::PassiveRecoveryWorkflow,\n                    revenue_recovery_payment_data.retry_algorithm,\n                )\n                .await\n                .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                .attach_printable(\"Failed to create a psync workflow in the process tracker\")?;\n\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_COMPLETE_FOR_PSYNC,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n\n            Self::RetryPayment(schedule_time) => {\n                db.as_scheduler()\n                    .retry_process(execute_task_process.clone(), *schedule_time)\n                    .await?;\n\n                // update the connector payment transmission field to Unsuccessful and unset active attempt id\n                revenue_recovery_metadata.set_payment_transmission_field_for_api_request(\n                    enums::PaymentConnectorTransmission::ConnectorCallUnsuccessful,\n                );\n\n                let payment_update_req =\n                PaymentsUpdateIntentRequest::update_feature_metadata_and_active_attempt_with_api(\n                    payment_intent\n                        .feature_metadata\n                        .clone()\n                        .unwrap_or_default()\n                        .convert_back()\n                        .set_payment_revenue_recovery_metadata_using_api(\n                            revenue_recovery_metadata.clone(),\n                        ),\n                    api_enums::UpdateActiveAttempt::Unset,\n                );\n                logger::info!(\n                    \"Call made to payments update intent api , with the request body {:?}\",\n                    payment_update_req\n                );\n                revenue_recovery_core::api::update_payment_intent_api(\n                    state,\n                    payment_intent.id.clone(),\n                    revenue_recovery_payment_data,\n                    payment_update_req,\n                )\n                .await\n                .change_context(errors::RecoveryError::PaymentCallFailed)?;\n                Ok(())\n            }\n            Self::TerminalFailure(payment_attempt) => {\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_FAILURE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                Ok(())\n            }\n            Self::SuccessfulPayment(payment_attempt) => {\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                // Record back to billing connector for terminal status\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                record_back_to_billing_connector(\n                    state,\n                    payment_attempt,\n                    payment_intent,\n                    &revenue_recovery_payment_data.billing_mca,\n                )\n                .await\n                .change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)\n                .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::ReviewPayment => {\n                // requeue the process tracker in case of error response\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Pending,\n                    business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_REQUEUE)),\n                };\n                db.as_scheduler()\n                    .update_process(execute_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n            Self::ManualReviewAction => {\n                logger::debug!(\"Invalid Payment Status For PCR Payment\");\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Review,\n                    business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_COMPLETE)),\n                };\n                // update the process tracker status as Review\n                db.as_scheduler()\n                    .update_process(execute_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n        }\n    }\n\n    pub async fn payment_sync_call(\n        state: &SessionState,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        payment_attempt: PaymentAttempt,\n    ) -> RecoveryResult<Self> {\n        logger::info!(\"Entering payment_sync_call\");\n\n        let response = revenue_recovery_core::api::call_psync_api(\n            state,\n            payment_intent.get_id(),\n            revenue_recovery_payment_data,\n            true,\n            true,\n        )\n        .await;\n        let used_token = get_payment_processor_token_id_from_payment_attempt(&payment_attempt);\n\n        match response {\n            Ok(_payment_data) => match payment_attempt.status.foreign_into() {\n                RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                    let connector_customer_id = payment_intent\n                        .extract_connector_customer_id_from_payment_intent()\n                        .change_context(errors::RecoveryError::ValueNotFound)\n                        .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n                    // update the status of token in redis\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                    state,\n                    &connector_customer_id,\n                    &None,\n                    &None,\n                    used_token.as_deref(),\n                )\n                .await;\n\n                    // unlocking the token\n                    let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                    state,\n                    &connector_customer_id,\n                )\n                .await;\n\n                    Ok(Self::SuccessfulPayment(payment_attempt))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                    let connector_customer_id = payment_intent\n                        .extract_connector_customer_id_from_payment_intent()\n                        .change_context(errors::RecoveryError::ValueNotFound)\n                        .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n                    let error_code = payment_attempt.clone().error.map(|error| error.code);\n\n                    let is_hard_decline =\n                        revenue_recovery::check_hard_decline(state, &payment_attempt)\n                            .await\n                            .ok();\n\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                            state,\n                            &connector_customer_id,\n                            &error_code,\n                            &is_hard_decline,\n                            used_token.as_deref(),\n                        )\n                        .await;\n\n                    // unlocking the token\n                    let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    // Reopen calculate workflow on payment failure\n                    Box::pin(reopen_calculate_workflow_on_payment_failure(\n                        state,\n                        process,\n                        profile,\n                        merchant_context,\n                        payment_intent,\n                        revenue_recovery_payment_data,\n                        payment_attempt.get_id(),\n                    ))\n                    .await?;\n\n                    Ok(Self::TerminalFailure(payment_attempt.clone()))\n                }\n\n                RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                    Ok(Self::SyncPayment(payment_attempt))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                    logger::info!(?action, \"Invalid Payment Status For PCR PSync Payment\");\n                    Ok(Self::ManualReviewAction)\n                }\n            },\n            Err(err) =>\n            // if there is an error while psync we create a new Review Task\n            {\n                logger::error!(sync_payment_response=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }\n    pub async fn psync_response_handler(\n        &self,\n        state: &SessionState,\n        payment_intent: &PaymentIntent,\n        psync_task_process: &storage::ProcessTracker,\n        revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n    ) -> Result<(), errors::ProcessTrackerError> {\n        logger::info!(\"Entering psync_response_handler\");\n\n        let db = &*state.store;\n\n        let connector_customer_id = payment_intent\n            .feature_metadata\n            .as_ref()\n            .and_then(|fm| fm.payment_revenue_recovery_metadata.as_ref())\n            .map(|rr| {\n                rr.billing_connector_payment_details\n                    .connector_customer_id\n                    .clone()\n            });\n\n        match self {\n            Self::SyncPayment(payment_attempt) => {\n                //  get a schedule time for psync\n                // and retry the process if there is a schedule time\n                // if None mark the pt status as Retries Exceeded and finish the task\n                payment_sync::recovery_retry_sync_task(\n                    state,\n                    connector_customer_id,\n                    revenue_recovery_metadata.connector.to_string(),\n                    revenue_recovery_payment_data\n                        .merchant_account\n                        .get_id()\n                        .clone(),\n                    psync_task_process.clone(),\n                )\n                .await?;\n                Ok(())\n            }\n\n            Self::RetryPayment(schedule_time) => {\n                // finish the psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                // fetch the execute task\n                let task = revenue_recovery_core::EXECUTE_WORKFLOW;\n                let runner = storage::ProcessTrackerRunner::PassiveRecoveryWorkflow;\n                let process_tracker_id = payment_intent\n                    .get_id()\n                    .get_execute_revenue_recovery_id(task, runner);\n                let execute_task_process = db\n                    .as_scheduler()\n                    .find_process_by_id(&process_tracker_id)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)?\n                    .get_required_value(\"Process Tracker\")?;\n                // retry the execute tasks\n                db.as_scheduler()\n                    .retry_process(execute_task_process, *schedule_time)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n\n            Self::TerminalFailure(payment_attempt) => {\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                // finish the current psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::SuccessfulPayment(payment_attempt) => {\n                // finish the current psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                // Record a successful transaction back to Billing Connector\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                record_back_to_billing_connector(\n                    state,\n                    payment_attempt,\n                    payment_intent,\n                    &revenue_recovery_payment_data.billing_mca,\n                )\n                .await\n                .change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)\n                .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::ReviewPayment => {\n                // requeue the process tracker task in case of psync api error\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Pending,\n                    business_status: Some(String::from(business_status::PSYNC_WORKFLOW_REQUEUE)),\n                };\n                db.as_scheduler()\n                    .update_process(psync_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n            Self::ManualReviewAction => {\n                logger::debug!(\"Invalid Payment Status For PCR Payment\");\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Review,\n                    business_status: Some(String::from(business_status::PSYNC_WORKFLOW_COMPLETE)),\n                };\n                // update the process tracker status as Review\n                db.as_scheduler()\n                    .update_process(psync_task_process.clone(), pt_update)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                Ok(())\n            }\n        }\n    }\n\n    pub(crate) async fn decide_retry_failure_action(\n        state: &SessionState,\n        merchant_id: &id_type::MerchantId,\n        pt: storage::ProcessTracker,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        payment_attempt: &PaymentAttempt,\n        payment_intent: &PaymentIntent,\n    ) -> RecoveryResult<Self> {\n        let db = &*state.store;\n        let next_retry_count = pt.retry_count + 1;\n        let error_message = payment_attempt\n            .error\n            .as_ref()\n            .map(|details| details.message.clone());\n        let error_code = payment_attempt\n            .error\n            .as_ref()\n            .map(|details| details.code.clone());\n        let connector_name = payment_attempt\n            .connector\n            .clone()\n            .ok_or(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"unable to derive payment connector from payment attempt\")?;\n        let gsm_record = helpers::get_gsm_record(\n            state,\n            error_code,\n            error_message,\n            connector_name,\n            REVENUE_RECOVERY.to_string(),\n        )\n        .await;\n        let is_hard_decline = gsm_record\n            .and_then(|gsm_record| gsm_record.error_category)\n            .map(|gsm_error_category| {\n                gsm_error_category == common_enums::ErrorCategory::HardDecline\n            })\n            .unwrap_or(false);\n        let schedule_time = revenue_recovery_payment_data\n            .get_schedule_time_based_on_retry_type(\n                state,\n                merchant_id,\n                next_retry_count,\n                payment_attempt,\n                payment_intent,\n                is_hard_decline,\n            )\n            .await;\n\n        match schedule_time {\n            Some(schedule_time) => Ok(Self::RetryPayment(schedule_time)),\n\n            None => Ok(Self::TerminalFailure(payment_attempt.clone())),\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                .ok();\n\n                let _account_updater_result  = account_updater_action.async_map(|action| {\n                let customer_id  =  connector_customer_id.clone();\n                let payment_attempt_id = payment_data.payment_attempt.id.clone();\n                async move {\n                    action.handle_account_updater_action(\n                        state,\n                        customer_id.as_str(),\n                        scheduled_token,\n                        &payment_attempt_id\n                    ).await\n                }\n                })\n                .await\n                .transpose()\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle account updater action: {:?}\",\n                        e\n                    );\n                })\n                .ok();\n\n                match payment_data.payment_attempt.status.foreign_into() {",
+        "after": "                .ok();\n\n                let _account_updater_result = account_updater_action\n                    .async_map(|action| {\n                        let customer_id = connector_customer_id.clone();\n                        let payment_attempt_id = payment_data.payment_attempt.id.clone();\n                        async move {\n                            action\n                                .handle_account_updater_action(\n                                    state,\n                                    customer_id.as_str(),\n                                    scheduled_token,\n                                    &payment_attempt_id,\n                                )\n                                .await\n                        }\n                    })\n                    .await\n                    .transpose()\n                    .inspect_err(|e| {\n                        logger::error!(\"Failed to handle account updater action: {:?}\", e);\n                    })\n                    .ok();\n\n                match payment_data.payment_attempt.status.foreign_into() {"
+      },
+      "commit_sha": "51b1dd142a8e78fa60added4e7fe0bada4d88378"
+    },
+    {
+      "id": "crates/router/src/core/revenue_recovery/types.rs::Action::function::execute_payment",
+      "file": "crates/router/src/core/revenue_recovery/types.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn execute_payment(\n        state: &SessionState,\n        _merchant_id: &id_type::MerchantId,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,\n        latest_attempt_id: &id_type::GlobalAttemptId,\n        scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,\n    ) -> RecoveryResult<Self> {\n        let connector_customer_id = payment_intent\n            .extract_connector_customer_id_from_payment_intent()\n            .change_context(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n        let response = revenue_recovery_core::api::call_proxy_api(\n            state,\n            payment_intent,\n            revenue_recovery_payment_data,\n            revenue_recovery_metadata,\n            &scheduled_token\n                .payment_processor_token_details\n                .payment_processor_token,\n        )\n        .await;\n\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(\n                payment_intent,\n            );\n        // handle proxy api's response\n        match response {\n            Ok(payment_data) => {\n                let account_updater_action = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(\n                    state,\n                    &connector_customer_id,\n                    scheduled_token,\n                    payment_data.mandate_data.clone(),\n                    &payment_data.payment_attempt.id\n                ).await\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle get valid action: {:?}\",\n                        e\n                    );\n                })\n                .ok();\n\n                let _account_updater_result  = account_updater_action.async_map(|action| {\n                let customer_id  =  connector_customer_id.clone();\n                let payment_attempt_id = payment_data.payment_attempt.id.clone();\n                async move {\n                    action.handle_account_updater_action(\n                        state,\n                        customer_id.as_str(),\n                        scheduled_token,\n                        &payment_attempt_id\n                    ).await\n                }\n                })\n                .await\n                .transpose()\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle account updater action: {:?}\",\n                        e\n                    );\n                })\n                .ok();\n\n                match payment_data.payment_attempt.status.foreign_into() {\n                    RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                        let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                        let recovery_payment_tuple =\n                            recovery_incoming_flow::RecoveryPaymentTuple::new(\n                                &recovery_payment_intent,\n                                &recovery_payment_attempt,\n                            );\n\n                        // publish events to kafka\n                        if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                        // update the status of token in redis\n                        let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &None,\n                        &None,\n                        Some(&scheduled_token.payment_processor_token_details.payment_processor_token),\n                    )\n                    .await;\n\n                        // unlocking the token\n                        let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                        let event_status = common_enums::EventType::PaymentSucceeded;\n\n                        let payments_response = payment_data\n                            .clone()\n                            .generate_response(\n                                state,\n                                None,\n                                None,\n                                None,\n                                &merchant_context,\n                                profile,\n                                None,\n                            )\n                            .change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)\n                            .attach_printable(\"Failed while generating response for payment\")?;\n\n                        RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(\n                        state,\n                        common_enums::EventClass::Payments,\n                        event_status,\n                        payment_intent,\n                        &merchant_context,\n                        profile,\n                        payment_data.payment_attempt.id.get_string_repr().to_string(),\n                        payments_response\n                    )\n                    .await?;\n\n                        Ok(Self::SuccessfulPayment(\n                            payment_data.payment_attempt.clone(),\n                        ))\n                    }\n                    RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                        let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                        let recovery_payment_tuple =\n                            recovery_incoming_flow::RecoveryPaymentTuple::new(\n                                &recovery_payment_intent,\n                                &recovery_payment_attempt,\n                            );\n\n                        // publish events to kafka\n                        if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                        let error_code = payment_data\n                            .payment_attempt\n                            .clone()\n                            .error\n                            .map(|error| error.code);\n\n                        let is_hard_decline = revenue_recovery::check_hard_decline(\n                            state,\n                            &payment_data.payment_attempt,\n                        )\n                        .await\n                        .ok();\n\n                        let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &error_code,\n                        &is_hard_decline,\n                        Some(&scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token)\n                            ,\n                    )\n                    .await;\n\n                        // unlocking the token\n                        let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                        // Reopen calculate workflow on payment failure\n                        Box::pin(reopen_calculate_workflow_on_payment_failure(\n                            state,\n                            process,\n                            profile,\n                            merchant_context,\n                            payment_intent,\n                            revenue_recovery_payment_data,\n                            latest_attempt_id,\n                        ))\n                        .await?;\n\n                        // Return terminal failure to finish the current execute workflow\n                        Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))\n                    }\n\n                    RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                        Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))\n                    }\n                    RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                        logger::info!(?action, \"Invalid Payment Status For PCR Payment\");\n                        Ok(Self::ManualReviewAction)\n                    }\n                }\n            }\n            Err(err) =>\n            // check for an active attempt being constructed or not\n            {\n                logger::error!(execute_payment_res=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }",
+      "after_code": "pub async fn execute_payment(\n        state: &SessionState,\n        _merchant_id: &id_type::MerchantId,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,\n        latest_attempt_id: &id_type::GlobalAttemptId,\n        scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,\n    ) -> RecoveryResult<Self> {\n        let connector_customer_id = payment_intent\n            .extract_connector_customer_id_from_payment_intent()\n            .change_context(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n        let response = revenue_recovery_core::api::call_proxy_api(\n            state,\n            payment_intent,\n            revenue_recovery_payment_data,\n            revenue_recovery_metadata,\n            &scheduled_token\n                .payment_processor_token_details\n                .payment_processor_token,\n        )\n        .await;\n\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(\n                payment_intent,\n            );\n        // handle proxy api's response\n        match response {\n            Ok(payment_data) => {\n                let account_updater_action = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(\n                    state,\n                    &connector_customer_id,\n                    scheduled_token,\n                    payment_data.mandate_data.clone(),\n                    &payment_data.payment_attempt.id\n                ).await\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle get valid action: {:?}\",\n                        e\n                    );\n                })\n                .ok();\n\n                let _account_updater_result = account_updater_action\n                    .async_map(|action| {\n                        let customer_id = connector_customer_id.clone();\n                        let payment_attempt_id = payment_data.payment_attempt.id.clone();\n                        async move {\n                            action\n                                .handle_account_updater_action(\n                                    state,\n                                    customer_id.as_str(),\n                                    scheduled_token,\n                                    &payment_attempt_id,\n                                )\n                                .await\n                        }\n                    })\n                    .await\n                    .transpose()\n                    .inspect_err(|e| {\n                        logger::error!(\"Failed to handle account updater action: {:?}\", e);\n                    })\n                    .ok();\n\n                match payment_data.payment_attempt.status.foreign_into() {\n                    RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                        let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                        let recovery_payment_tuple =\n                            recovery_incoming_flow::RecoveryPaymentTuple::new(\n                                &recovery_payment_intent,\n                                &recovery_payment_attempt,\n                            );\n\n                        // publish events to kafka\n                        if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                        // update the status of token in redis\n                        let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &None,\n                        &None,\n                        Some(&scheduled_token.payment_processor_token_details.payment_processor_token),\n                    )\n                    .await;\n\n                        // unlocking the token\n                        let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                        let event_status = common_enums::EventType::PaymentSucceeded;\n\n                        let payments_response = payment_data\n                            .clone()\n                            .generate_response(\n                                state,\n                                None,\n                                None,\n                                None,\n                                &merchant_context,\n                                profile,\n                                None,\n                            )\n                            .change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)\n                            .attach_printable(\"Failed while generating response for payment\")?;\n\n                        RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(\n                        state,\n                        common_enums::EventClass::Payments,\n                        event_status,\n                        payment_intent,\n                        &merchant_context,\n                        profile,\n                        payment_data.payment_attempt.id.get_string_repr().to_string(),\n                        payments_response\n                    )\n                    .await?;\n\n                        Ok(Self::SuccessfulPayment(\n                            payment_data.payment_attempt.clone(),\n                        ))\n                    }\n                    RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                        let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                        let recovery_payment_tuple =\n                            recovery_incoming_flow::RecoveryPaymentTuple::new(\n                                &recovery_payment_intent,\n                                &recovery_payment_attempt,\n                            );\n\n                        // publish events to kafka\n                        if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                        let error_code = payment_data\n                            .payment_attempt\n                            .clone()\n                            .error\n                            .map(|error| error.code);\n\n                        let is_hard_decline = revenue_recovery::check_hard_decline(\n                            state,\n                            &payment_data.payment_attempt,\n                        )\n                        .await\n                        .ok();\n\n                        let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &error_code,\n                        &is_hard_decline,\n                        Some(&scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token)\n                            ,\n                    )\n                    .await;\n\n                        // unlocking the token\n                        let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                        // Reopen calculate workflow on payment failure\n                        Box::pin(reopen_calculate_workflow_on_payment_failure(\n                            state,\n                            process,\n                            profile,\n                            merchant_context,\n                            payment_intent,\n                            revenue_recovery_payment_data,\n                            latest_attempt_id,\n                        ))\n                        .await?;\n\n                        // Return terminal failure to finish the current execute workflow\n                        Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))\n                    }\n\n                    RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                        Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))\n                    }\n                    RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                        logger::info!(?action, \"Invalid Payment Status For PCR Payment\");\n                        Ok(Self::ManualReviewAction)\n                    }\n                }\n            }\n            Err(err) =>\n            // check for an active attempt being constructed or not\n            {\n                logger::error!(execute_payment_res=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "                .ok();\n\n                let _account_updater_result  = account_updater_action.async_map(|action| {\n                let customer_id  =  connector_customer_id.clone();\n                let payment_attempt_id = payment_data.payment_attempt.id.clone();\n                async move {\n                    action.handle_account_updater_action(\n                        state,\n                        customer_id.as_str(),\n                        scheduled_token,\n                        &payment_attempt_id\n                    ).await\n                }\n                })\n                .await\n                .transpose()\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle account updater action: {:?}\",\n                        e\n                    );\n                })\n                .ok();\n\n                match payment_data.payment_attempt.status.foreign_into() {",
+        "after": "                .ok();\n\n                let _account_updater_result = account_updater_action\n                    .async_map(|action| {\n                        let customer_id = connector_customer_id.clone();\n                        let payment_attempt_id = payment_data.payment_attempt.id.clone();\n                        async move {\n                            action\n                                .handle_account_updater_action(\n                                    state,\n                                    customer_id.as_str(),\n                                    scheduled_token,\n                                    &payment_attempt_id,\n                                )\n                                .await\n                        }\n                    })\n                    .await\n                    .transpose()\n                    .inspect_err(|e| {\n                        logger::error!(\"Failed to handle account updater action: {:?}\", e);\n                    })\n                    .ok();\n\n                match payment_data.payment_attempt.status.foreign_into() {"
+      },
+      "commit_sha": "51b1dd142a8e78fa60added4e7fe0bada4d88378"
+    }
+  ]
+}

diffs/pr_10112/8a44773/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "8a44773b9b157997bd0276962202fb4a23cc5261",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/router/src/types/storage/revenue_recovery_redis_operation.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs::AccountUpdaterAction::function::handle_account_updater_action",
+      "file": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn handle_account_updater_action(\n        &self,\n        state: &SessionState,\n        customer_id: &str,\n        account_updater_action: &Self,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        attempt_id: &id_type::GlobalAttemptId,\n    ) -> CustomResult<(), errors::StorageError> {\n        match account_updater_action {\n            Self::TokenUpdate(new_token, updated_mandate_details) => {\n                logger::info!(\"Handling TokenUpdate action with new token\");\n                // Implement token update logic here using additional_card_info if needed\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.is_active = Some(false);\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                )\n                .await?;\n\n                logger::info!(\"Successfully deactivated old token.\");\n\n                let new_token = PaymentProcessorTokenStatus {\n                    payment_processor_token_details: PaymentProcessorTokenDetails {\n                        payment_processor_token: new_token.to_owned(),\n                        expiry_month: updated_mandate_details.card_exp_month.clone(),\n                        expiry_year: updated_mandate_details.card_exp_year.clone(),\n                        card_issuer: None,\n                        last_four_digits: None,\n                        card_type: None,\n                        card_network: updated_mandate_details.card_network.clone(),\n                        card_isin: updated_mandate_details.card_isin.clone(),\n                    },\n                    inserted_by_attempt_id: attempt_id.to_owned(),\n                    error_code: None,\n                    daily_retry_history: HashMap::new(),\n                    scheduled_at: None,\n                    is_hard_decline: Some(false),\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: Some(true),\n                    account_update_history: Some(vec![AccountUpdateHistoryRecord {\n                        old_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        new_token: new_token.to_owned(),\n                        updated_at: PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        ),\n                        old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &scheduled_token.payment_processor_token_details,\n                        )),\n                        new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            updated_mandate_details,\n                        )),\n                    }]),\n                };\n\n                RedisTokenManager::upsert_payment_processor_token(state, customer_id, new_token)\n                    .await?;\n                logger::info!(\"Successfully updated token with new token information.\")\n            }\n            Self::ExpiryUpdate(updated_mandate_details) => {\n                logger::info!(\"Handling ExpiryUpdate action\");\n                // Implement expiry update logic here using additional_card_info\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.payment_processor_token_details.expiry_month =\n                    updated_mandate_details.card_exp_month.clone();\n                updated_token.payment_processor_token_details.expiry_year =\n                    updated_mandate_details.card_exp_year.clone();\n                updated_token.payment_processor_token_details.card_network =\n                    updated_mandate_details.card_network.clone();\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n                updated_token\n                    .account_update_history\n                    .get_or_insert(vec![])\n                    .push(AccountUpdateHistoryRecord {\n                        old_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        new_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        updated_at: PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        ),\n                        old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &scheduled_token.payment_processor_token_details,\n                        )),\n                        new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &updated_token.payment_processor_token_details,\n                        )),\n                    });\n\n                let _ = RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                )\n                .await?;\n\n                logger::info!(\"Successfully updated token expiry information.\")\n            }\n            Self::ExistingToken => {\n                logger::info!(\"Handling ExistingToken action - no changes needed\");\n                // No action needed for existing token\n            }\n            Self::NoAction => {\n                logger::info!(\"No action to be taken for NoAction case\");\n                // No action needed\n            }\n        };\n\n        Ok(())\n    }",
+      "after_code": "async fn handle_account_updater_action(\n        &self,\n        state: &SessionState,\n        customer_id: &str,\n        account_updater_action: &Self,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        attempt_id: &id_type::GlobalAttemptId,\n    ) -> CustomResult<(), errors::StorageError> {\n        match account_updater_action {\n            Self::TokenUpdate(new_token, updated_mandate_details) => {\n                logger::info!(\"Handling TokenUpdate action with new token\");\n                // Implement token update logic here using additional_card_info if needed\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.is_active = Some(false);\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                )\n                .await?;\n\n                logger::info!(\"Successfully deactivated old token.\");\n\n                let new_token = PaymentProcessorTokenStatus {\n                    payment_processor_token_details: PaymentProcessorTokenDetails {\n                        payment_processor_token: new_token.to_owned(),\n                        expiry_month: updated_mandate_details.card_exp_month.clone(),\n                        expiry_year: updated_mandate_details.card_exp_year.clone(),\n                        card_issuer: None,\n                        last_four_digits: None,\n                        card_type: None,\n                        card_network: updated_mandate_details.card_network.clone(),\n                        card_isin: updated_mandate_details.card_isin.clone(),\n                    },\n                    inserted_by_attempt_id: attempt_id.to_owned(),\n                    error_code: None,\n                    daily_retry_history: HashMap::new(),\n                    scheduled_at: None,\n                    is_hard_decline: Some(false),\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: Some(true),\n                    account_update_history: Some(vec![AccountUpdateHistoryRecord {\n                        old_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        new_token: new_token.to_owned(),\n                        updated_at: PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        ),\n                        old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &scheduled_token.payment_processor_token_details,\n                        )),\n                        new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            updated_mandate_details,\n                        )),\n                    }]),\n                };\n\n                RedisTokenManager::upsert_payment_processor_token(state, customer_id, new_token)\n                    .await?;\n                logger::info!(\"Successfully updated token with new token information.\")\n            }\n            Self::ExpiryUpdate(updated_mandate_details) => {\n                logger::info!(\"Handling ExpiryUpdate action\");\n                // Implement expiry update logic here using additional_card_info\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.payment_processor_token_details.expiry_month =\n                    updated_mandate_details.card_exp_month.clone();\n                updated_token.payment_processor_token_details.expiry_year =\n                    updated_mandate_details.card_exp_year.clone();\n                updated_token.payment_processor_token_details.card_network =\n                    updated_mandate_details.card_network.clone();\n                updated_token.payment_processor_token_details.card_isin =\n                    updated_mandate_details.card_isin.clone();\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n                updated_token\n                .account_update_history\n                .get_or_insert_with(Vec::new)\n                .push(AccountUpdateHistoryRecord {\n                    old_token: scheduled_token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    new_token: updated_token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    updated_at: PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    ),\n                    old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                        &scheduled_token.payment_processor_token_details,\n                    )),\n                    new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                        &updated_token.payment_processor_token_details,\n                    )),\n                });\n\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                )\n                .await?;\n\n                logger::info!(\"Successfully updated token expiry information.\")\n            }\n            Self::ExistingToken => {\n                logger::info!(\"Handling ExistingToken action - no changes needed\");\n                // No action needed for existing token\n            }\n            Self::NoAction => {\n                logger::info!(\"No action to be taken for NoAction case\");\n                // No action needed\n            }\n        };\n\n        Ok(())\n    }",
+      "diff_span": {
+        "before": "                ));\n                updated_token\n                    .account_update_history\n                    .get_or_insert(vec![])\n                    .push(AccountUpdateHistoryRecord {\n                        old_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        new_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        updated_at: PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        ),\n                        old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &scheduled_token.payment_processor_token_details,\n                        )),\n                        new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &updated_token.payment_processor_token_details,\n                        )),\n                    });\n\n                let _ = RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,",
+        "after": "                updated_token.payment_processor_token_details.card_network =\n                    updated_mandate_details.card_network.clone();\n                updated_token.payment_processor_token_details.card_isin =\n                    updated_mandate_details.card_isin.clone();\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n                updated_token\n                .account_update_history\n                .get_or_insert_with(Vec::new)\n                .push(AccountUpdateHistoryRecord {\n                    old_token: scheduled_token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    new_token: updated_token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    updated_at: PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    ),\n                    old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                        &scheduled_token.payment_processor_token_details,\n                    )),\n                    new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                        &updated_token.payment_processor_token_details,\n                    )),\n                });\n\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,"
+      },
+      "commit_sha": "8a44773b9b157997bd0276962202fb4a23cc5261"
+    },
+    {
+      "id": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs::impl::AccountUpdaterAction",
+      "file": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl AccountUpdaterAction {\n    async fn handle_account_updater_action(\n        &self,\n        state: &SessionState,\n        customer_id: &str,\n        account_updater_action: &Self,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        attempt_id: &id_type::GlobalAttemptId,\n    ) -> CustomResult<(), errors::StorageError> {\n        match account_updater_action {\n            Self::TokenUpdate(new_token, updated_mandate_details) => {\n                logger::info!(\"Handling TokenUpdate action with new token\");\n                // Implement token update logic here using additional_card_info if needed\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.is_active = Some(false);\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                )\n                .await?;\n\n                logger::info!(\"Successfully deactivated old token.\");\n\n                let new_token = PaymentProcessorTokenStatus {\n                    payment_processor_token_details: PaymentProcessorTokenDetails {\n                        payment_processor_token: new_token.to_owned(),\n                        expiry_month: updated_mandate_details.card_exp_month.clone(),\n                        expiry_year: updated_mandate_details.card_exp_year.clone(),\n                        card_issuer: None,\n                        last_four_digits: None,\n                        card_type: None,\n                        card_network: updated_mandate_details.card_network.clone(),\n                        card_isin: updated_mandate_details.card_isin.clone(),\n                    },\n                    inserted_by_attempt_id: attempt_id.to_owned(),\n                    error_code: None,\n                    daily_retry_history: HashMap::new(),\n                    scheduled_at: None,\n                    is_hard_decline: Some(false),\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: Some(true),\n                    account_update_history: Some(vec![AccountUpdateHistoryRecord {\n                        old_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        new_token: new_token.to_owned(),\n                        updated_at: PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        ),\n                        old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &scheduled_token.payment_processor_token_details,\n                        )),\n                        new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            updated_mandate_details,\n                        )),\n                    }]),\n                };\n\n                RedisTokenManager::upsert_payment_processor_token(state, customer_id, new_token)\n                    .await?;\n                logger::info!(\"Successfully updated token with new token information.\")\n            }\n            Self::ExpiryUpdate(updated_mandate_details) => {\n                logger::info!(\"Handling ExpiryUpdate action\");\n                // Implement expiry update logic here using additional_card_info\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.payment_processor_token_details.expiry_month =\n                    updated_mandate_details.card_exp_month.clone();\n                updated_token.payment_processor_token_details.expiry_year =\n                    updated_mandate_details.card_exp_year.clone();\n                updated_token.payment_processor_token_details.card_network =\n                    updated_mandate_details.card_network.clone();\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n                updated_token\n                    .account_update_history\n                    .get_or_insert(vec![])\n                    .push(AccountUpdateHistoryRecord {\n                        old_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        new_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        updated_at: PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        ),\n                        old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &scheduled_token.payment_processor_token_details,\n                        )),\n                        new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &updated_token.payment_processor_token_details,\n                        )),\n                    });\n\n                let _ = RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                )\n                .await?;\n\n                logger::info!(\"Successfully updated token expiry information.\")\n            }\n            Self::ExistingToken => {\n                logger::info!(\"Handling ExistingToken action - no changes needed\");\n                // No action needed for existing token\n            }\n            Self::NoAction => {\n                logger::info!(\"No action to be taken for NoAction case\");\n                // No action needed\n            }\n        };\n\n        Ok(())\n    }\n}",
+      "after_code": "impl AccountUpdaterAction {\n    async fn handle_account_updater_action(\n        &self,\n        state: &SessionState,\n        customer_id: &str,\n        account_updater_action: &Self,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        attempt_id: &id_type::GlobalAttemptId,\n    ) -> CustomResult<(), errors::StorageError> {\n        match account_updater_action {\n            Self::TokenUpdate(new_token, updated_mandate_details) => {\n                logger::info!(\"Handling TokenUpdate action with new token\");\n                // Implement token update logic here using additional_card_info if needed\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.is_active = Some(false);\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                )\n                .await?;\n\n                logger::info!(\"Successfully deactivated old token.\");\n\n                let new_token = PaymentProcessorTokenStatus {\n                    payment_processor_token_details: PaymentProcessorTokenDetails {\n                        payment_processor_token: new_token.to_owned(),\n                        expiry_month: updated_mandate_details.card_exp_month.clone(),\n                        expiry_year: updated_mandate_details.card_exp_year.clone(),\n                        card_issuer: None,\n                        last_four_digits: None,\n                        card_type: None,\n                        card_network: updated_mandate_details.card_network.clone(),\n                        card_isin: updated_mandate_details.card_isin.clone(),\n                    },\n                    inserted_by_attempt_id: attempt_id.to_owned(),\n                    error_code: None,\n                    daily_retry_history: HashMap::new(),\n                    scheduled_at: None,\n                    is_hard_decline: Some(false),\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: Some(true),\n                    account_update_history: Some(vec![AccountUpdateHistoryRecord {\n                        old_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        new_token: new_token.to_owned(),\n                        updated_at: PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        ),\n                        old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &scheduled_token.payment_processor_token_details,\n                        )),\n                        new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            updated_mandate_details,\n                        )),\n                    }]),\n                };\n\n                RedisTokenManager::upsert_payment_processor_token(state, customer_id, new_token)\n                    .await?;\n                logger::info!(\"Successfully updated token with new token information.\")\n            }\n            Self::ExpiryUpdate(updated_mandate_details) => {\n                logger::info!(\"Handling ExpiryUpdate action\");\n                // Implement expiry update logic here using additional_card_info\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.payment_processor_token_details.expiry_month =\n                    updated_mandate_details.card_exp_month.clone();\n                updated_token.payment_processor_token_details.expiry_year =\n                    updated_mandate_details.card_exp_year.clone();\n                updated_token.payment_processor_token_details.card_network =\n                    updated_mandate_details.card_network.clone();\n                updated_token.payment_processor_token_details.card_isin =\n                    updated_mandate_details.card_isin.clone();\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n                updated_token\n                .account_update_history\n                .get_or_insert_with(Vec::new)\n                .push(AccountUpdateHistoryRecord {\n                    old_token: scheduled_token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    new_token: updated_token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    updated_at: PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    ),\n                    old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                        &scheduled_token.payment_processor_token_details,\n                    )),\n                    new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                        &updated_token.payment_processor_token_details,\n                    )),\n                });\n\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                )\n                .await?;\n\n                logger::info!(\"Successfully updated token expiry information.\")\n            }\n            Self::ExistingToken => {\n                logger::info!(\"Handling ExistingToken action - no changes needed\");\n                // No action needed for existing token\n            }\n            Self::NoAction => {\n                logger::info!(\"No action to be taken for NoAction case\");\n                // No action needed\n            }\n        };\n\n        Ok(())\n    }\n}",
+      "diff_span": {
+        "before": "                ));\n                updated_token\n                    .account_update_history\n                    .get_or_insert(vec![])\n                    .push(AccountUpdateHistoryRecord {\n                        old_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        new_token: scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            .clone(),\n                        updated_at: PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        ),\n                        old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &scheduled_token.payment_processor_token_details,\n                        )),\n                        new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                            &updated_token.payment_processor_token_details,\n                        )),\n                    });\n\n                let _ = RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,",
+        "after": "                updated_token.payment_processor_token_details.card_network =\n                    updated_mandate_details.card_network.clone();\n                updated_token.payment_processor_token_details.card_isin =\n                    updated_mandate_details.card_isin.clone();\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n                updated_token\n                .account_update_history\n                .get_or_insert_with(Vec::new)\n                .push(AccountUpdateHistoryRecord {\n                    old_token: scheduled_token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    new_token: updated_token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    updated_at: PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    ),\n                    old_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                        &scheduled_token.payment_processor_token_details,\n                    )),\n                    new_token_info: Some(api_models::payments::AdditionalCardInfo::from(\n                        &updated_token.payment_processor_token_details,\n                    )),\n                });\n\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,"
+      },
+      "commit_sha": "8a44773b9b157997bd0276962202fb4a23cc5261"
+    }
+  ]
+}

diffs/pr_10112/8b31ab3/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "8b31ab36bb07198bf811f618012e7a4b79a8cc16",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::RefundsRouterData<RSync>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                let status = match response.data.payment_transaction.typename {\n                    TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,\n                    TesouroSyncStatus::DeclinedRefund\n                    | TesouroSyncStatus::DeclinedRefundAuthorization => {\n                        enums::RefundStatus::Failure\n                    }\n                    TesouroSyncStatus::GenericPaymentTransaction\n                    | TesouroSyncStatus::Refund\n                    | TesouroSyncStatus::RefundAuthorization\n                    | TesouroSyncStatus::ApprovedRefundAuthorization => {\n                        enums::RefundStatus::Pending\n                    }\n                    _ => {\n                        return Err(errors::ConnectorError::UnexpectedResponseError(\n                            bytes::Bytes::from(\"Invalid Status Received\".to_string()),\n                        )\n                        .into())\n                    }\n                };\n\n                if connector_utils::is_refund_failure(status) {\n                    let error_code = response\n                        .data\n                        .payment_transaction\n                        .processor_response_code\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    let error_message = response\n                        .data\n                        .payment_transaction\n                        .processor_response_message\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message.clone(),\n                            reason: Some(error_message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        response: Ok(RefundsResponseData {\n                            connector_refund_id: response.data.payment_transaction.id,\n                            refund_status: enums::RefundStatus::Success,\n                        }),\n                        ..item.data\n                    })\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "after_code": "fn try_from(\n        item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                let status = match response.data.payment_transaction.typename {\n                    TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,\n                    TesouroSyncStatus::DeclinedRefund\n                    | TesouroSyncStatus::DeclinedRefundAuthorization => {\n                        enums::RefundStatus::Failure\n                    }\n                    TesouroSyncStatus::GenericPaymentTransaction\n                    | TesouroSyncStatus::Refund\n                    | TesouroSyncStatus::RefundAuthorization\n                    | TesouroSyncStatus::ApprovedRefundAuthorization => {\n                        enums::RefundStatus::Pending\n                    }\n                    _ => {\n                        return Err(errors::ConnectorError::UnexpectedResponseError(\n                            bytes::Bytes::from(\"Invalid Status Received\".to_string()),\n                        )\n                        .into())\n                    }\n                };\n\n                if connector_utils::is_refund_failure(status) {\n                    let error_code = response\n                        .data\n                        .payment_transaction\n                        .processor_response_code\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    let error_message = response\n                        .data\n                        .payment_transaction\n                        .processor_response_message\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message.clone(),\n                            reason: Some(error_message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        response: Ok(RefundsResponseData {\n                            connector_refund_id: response.data.payment_transaction.id,\n                            refund_status: enums::RefundStatus::Success,\n                        }),\n                        ..item.data\n                    })\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data",
+        "after": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "8b31ab36bb07198bf811f618012e7a4b79a8cc16"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::impl::RefundsRouterData<RSync>",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<RefundsResponseRouterData<RSync, TesouroSyncResponse>> for RefundsRouterData<RSync> {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                let status = match response.data.payment_transaction.typename {\n                    TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,\n                    TesouroSyncStatus::DeclinedRefund\n                    | TesouroSyncStatus::DeclinedRefundAuthorization => {\n                        enums::RefundStatus::Failure\n                    }\n                    TesouroSyncStatus::GenericPaymentTransaction\n                    | TesouroSyncStatus::Refund\n                    | TesouroSyncStatus::RefundAuthorization\n                    | TesouroSyncStatus::ApprovedRefundAuthorization => {\n                        enums::RefundStatus::Pending\n                    }\n                    _ => {\n                        return Err(errors::ConnectorError::UnexpectedResponseError(\n                            bytes::Bytes::from(\"Invalid Status Received\".to_string()),\n                        )\n                        .into())\n                    }\n                };\n\n                if connector_utils::is_refund_failure(status) {\n                    let error_code = response\n                        .data\n                        .payment_transaction\n                        .processor_response_code\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    let error_message = response\n                        .data\n                        .payment_transaction\n                        .processor_response_message\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message.clone(),\n                            reason: Some(error_message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        response: Ok(RefundsResponseData {\n                            connector_refund_id: response.data.payment_transaction.id,\n                            refund_status: enums::RefundStatus::Success,\n                        }),\n                        ..item.data\n                    })\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "after_code": "impl TryFrom<RefundsResponseRouterData<RSync, TesouroSyncResponse>> for RefundsRouterData<RSync> {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                let status = match response.data.payment_transaction.typename {\n                    TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,\n                    TesouroSyncStatus::DeclinedRefund\n                    | TesouroSyncStatus::DeclinedRefundAuthorization => {\n                        enums::RefundStatus::Failure\n                    }\n                    TesouroSyncStatus::GenericPaymentTransaction\n                    | TesouroSyncStatus::Refund\n                    | TesouroSyncStatus::RefundAuthorization\n                    | TesouroSyncStatus::ApprovedRefundAuthorization => {\n                        enums::RefundStatus::Pending\n                    }\n                    _ => {\n                        return Err(errors::ConnectorError::UnexpectedResponseError(\n                            bytes::Bytes::from(\"Invalid Status Received\".to_string()),\n                        )\n                        .into())\n                    }\n                };\n\n                if connector_utils::is_refund_failure(status) {\n                    let error_code = response\n                        .data\n                        .payment_transaction\n                        .processor_response_code\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    let error_message = response\n                        .data\n                        .payment_transaction\n                        .processor_response_message\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message.clone(),\n                            reason: Some(error_message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        response: Ok(RefundsResponseData {\n                            connector_refund_id: response.data.payment_transaction.id,\n                            refund_status: enums::RefundStatus::Success,\n                        }),\n                        ..item.data\n                    })\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data",
+        "after": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "8b31ab36bb07198bf811f618012e7a4b79a8cc16"
+    }
+  ]
+}

diffs/pr_10112/9f9d6ff/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "9f9d6ff94f799ef0c0be1fc3463e8653aca1baeb",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/router/src/core/revenue_recovery/types.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/revenue_recovery/types.rs::impl::Action",
+      "file": "crates/router/src/core/revenue_recovery/types.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl Action {\n    #[allow(clippy::too_many_arguments)]\n    pub async fn execute_payment(\n        state: &SessionState,\n        _merchant_id: &id_type::MerchantId,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,\n        latest_attempt_id: &id_type::GlobalAttemptId,\n        scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,\n    ) -> RecoveryResult<Self> {\n        let connector_customer_id = payment_intent\n            .extract_connector_customer_id_from_payment_intent()\n            .change_context(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n        let response = revenue_recovery_core::api::call_proxy_api(\n            state,\n            payment_intent,\n            revenue_recovery_payment_data,\n            revenue_recovery_metadata,\n            &scheduled_token\n                .payment_processor_token_details\n                .payment_processor_token,\n        )\n        .await;\n\n        println!(\"response: {:?}\", response);\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(\n                payment_intent,\n            );\n        // handle proxy api's response\n        match response {\n            Ok(payment_data) => {\n                \n                let _account_updater_result = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(\n                    state,\n                    &connector_customer_id,\n                    scheduled_token,\n                    payment_data.mandate_data.clone(),\n                    &payment_data.payment_attempt.id\n                ).await\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle account updater token update: {:?}\",\n                        e\n                    );\n                });\n\n                match payment_data.payment_attempt.status.foreign_into() {\n                RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                    let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                    let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(\n                        &recovery_payment_intent,\n                        &recovery_payment_attempt,\n                    );\n\n                    // publish events to kafka\n                    if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                    // update the status of token in redis\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &None,\n                        &None,\n                        Some(&scheduled_token.payment_processor_token_details.payment_processor_token),\n                    )\n                    .await;\n\n                    // unlocking the token\n                    let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    let event_status = common_enums::EventType::PaymentSucceeded;\n\n                    let payments_response = payment_data\n                        .clone()\n                        .generate_response(\n                            state,\n                            None,\n                            None,\n                            None,\n                            &merchant_context,\n                            profile,\n                            None,\n                        )\n                        .change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)\n                        .attach_printable(\"Failed while generating response for payment\")?;\n\n                    RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(\n                        state,\n                        common_enums::EventClass::Payments,\n                        event_status,\n                        payment_intent,\n                        &merchant_context,\n                        profile,\n                        payment_data.payment_attempt.id.get_string_repr().to_string(),\n                        payments_response\n                    )\n                    .await?;\n\n                    Ok(Self::SuccessfulPayment(\n                        payment_data.payment_attempt.clone(),\n                    ))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                    let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                    let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(\n                        &recovery_payment_intent,\n                        &recovery_payment_attempt,\n                    );\n\n                    // publish events to kafka\n                    if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                    let error_code = payment_data\n                        .payment_attempt\n                        .clone()\n                        .error\n                        .map(|error| error.code);\n\n                    let is_hard_decline =\n                        revenue_recovery::check_hard_decline(state, &payment_data.payment_attempt)\n                            .await\n                            .ok();\n\n                    let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &error_code,\n                        &is_hard_decline,\n                        Some(&scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token)\n                            ,\n                    )\n                    .await;\n\n                    // unlocking the token\n                    let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    // Reopen calculate workflow on payment failure\n                    Box::pin(reopen_calculate_workflow_on_payment_failure(\n                        state,\n                        process,\n                        profile,\n                        merchant_context,\n                        payment_intent,\n                        revenue_recovery_payment_data,\n                        latest_attempt_id,\n                    ))\n                    .await?;\n\n                    // Return terminal failure to finish the current execute workflow\n                    Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))\n                }\n\n                RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                    Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                    logger::info!(?action, \"Invalid Payment Status For PCR Payment\");\n                    Ok(Self::ManualReviewAction)\n                }\n                }\n            },\n            Err(err) =>\n            // check for an active attempt being constructed or not\n            {\n                logger::error!(execute_payment_res=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }\n\n    pub async fn execute_payment_task_response_handler(\n        &self,\n        state: &SessionState,\n        payment_intent: &PaymentIntent,\n        execute_task_process: &storage::ProcessTracker,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,\n    ) -> Result<(), errors::ProcessTrackerError> {\n        logger::info!(\"Entering execute_payment_task_response_handler\");\n\n        let db = &*state.store;\n        match self {\n            Self::SyncPayment(payment_attempt) => {\n                revenue_recovery_core::insert_psync_pcr_task_to_pt(\n                    revenue_recovery_payment_data.billing_mca.get_id().clone(),\n                    db,\n                    revenue_recovery_payment_data\n                        .merchant_account\n                        .get_id()\n                        .to_owned(),\n                    payment_intent.id.clone(),\n                    revenue_recovery_payment_data.profile.get_id().to_owned(),\n                    payment_attempt.id.clone(),\n                    storage::ProcessTrackerRunner::PassiveRecoveryWorkflow,\n                    revenue_recovery_payment_data.retry_algorithm,\n                )\n                .await\n                .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                .attach_printable(\"Failed to create a psync workflow in the process tracker\")?;\n\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_COMPLETE_FOR_PSYNC,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n\n            Self::RetryPayment(schedule_time) => {\n                db.as_scheduler()\n                    .retry_process(execute_task_process.clone(), *schedule_time)\n                    .await?;\n\n                // update the connector payment transmission field to Unsuccessful and unset active attempt id\n                revenue_recovery_metadata.set_payment_transmission_field_for_api_request(\n                    enums::PaymentConnectorTransmission::ConnectorCallUnsuccessful,\n                );\n\n                let payment_update_req =\n                PaymentsUpdateIntentRequest::update_feature_metadata_and_active_attempt_with_api(\n                    payment_intent\n                        .feature_metadata\n                        .clone()\n                        .unwrap_or_default()\n                        .convert_back()\n                        .set_payment_revenue_recovery_metadata_using_api(\n                            revenue_recovery_metadata.clone(),\n                        ),\n                    api_enums::UpdateActiveAttempt::Unset,\n                );\n                logger::info!(\n                    \"Call made to payments update intent api , with the request body {:?}\",\n                    payment_update_req\n                );\n                revenue_recovery_core::api::update_payment_intent_api(\n                    state,\n                    payment_intent.id.clone(),\n                    revenue_recovery_payment_data,\n                    payment_update_req,\n                )\n                .await\n                .change_context(errors::RecoveryError::PaymentCallFailed)?;\n                Ok(())\n            }\n            Self::TerminalFailure(payment_attempt) => {\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_FAILURE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                Ok(())\n            }\n            Self::SuccessfulPayment(payment_attempt) => {\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                // Record back to billing connector for terminal status\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                record_back_to_billing_connector(\n                    state,\n                    payment_attempt,\n                    payment_intent,\n                    &revenue_recovery_payment_data.billing_mca,\n                )\n                .await\n                .change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)\n                .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::ReviewPayment => {\n                // requeue the process tracker in case of error response\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Pending,\n                    business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_REQUEUE)),\n                };\n                db.as_scheduler()\n                    .update_process(execute_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n            Self::ManualReviewAction => {\n                logger::debug!(\"Invalid Payment Status For PCR Payment\");\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Review,\n                    business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_COMPLETE)),\n                };\n                // update the process tracker status as Review\n                db.as_scheduler()\n                    .update_process(execute_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n        }\n    }\n\n    pub async fn payment_sync_call(\n        state: &SessionState,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        payment_attempt: PaymentAttempt,\n    ) -> RecoveryResult<Self> {\n        logger::info!(\"Entering payment_sync_call\");\n\n        let response = revenue_recovery_core::api::call_psync_api(\n            state,\n            payment_intent.get_id(),\n            revenue_recovery_payment_data,\n            true,\n            true,\n        )\n        .await;\n        let used_token = get_payment_processor_token_id_from_payment_attempt(&payment_attempt);\n\n        match response {\n            Ok(_payment_data) => match payment_attempt.status.foreign_into() {\n                RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                    let connector_customer_id = payment_intent\n                        .extract_connector_customer_id_from_payment_intent()\n                        .change_context(errors::RecoveryError::ValueNotFound)\n                        .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n                    // update the status of token in redis\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                    state,\n                    &connector_customer_id,\n                    &None,\n                    &None,\n                    used_token.as_deref(),\n                )\n                .await;\n\n                    // unlocking the token\n                    let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                    state,\n                    &connector_customer_id,\n                )\n                .await;\n\n                    Ok(Self::SuccessfulPayment(payment_attempt))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                    let connector_customer_id = payment_intent\n                        .extract_connector_customer_id_from_payment_intent()\n                        .change_context(errors::RecoveryError::ValueNotFound)\n                        .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n                    let error_code = payment_attempt.clone().error.map(|error| error.code);\n\n                    let is_hard_decline =\n                        revenue_recovery::check_hard_decline(state, &payment_attempt)\n                            .await\n                            .ok();\n\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                            state,\n                            &connector_customer_id,\n                            &error_code,\n                            &is_hard_decline,\n                            used_token.as_deref(),\n                        )\n                        .await;\n\n                    // unlocking the token\n                    let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    // Reopen calculate workflow on payment failure\n                    Box::pin(reopen_calculate_workflow_on_payment_failure(\n                        state,\n                        process,\n                        profile,\n                        merchant_context,\n                        payment_intent,\n                        revenue_recovery_payment_data,\n                        payment_attempt.get_id(),\n                    ))\n                    .await?;\n\n                    Ok(Self::TerminalFailure(payment_attempt.clone()))\n                }\n\n                RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                    Ok(Self::SyncPayment(payment_attempt))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                    logger::info!(?action, \"Invalid Payment Status For PCR PSync Payment\");\n                    Ok(Self::ManualReviewAction)\n                }\n            },\n            Err(err) =>\n            // if there is an error while psync we create a new Review Task\n            {\n                logger::error!(sync_payment_response=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }\n    pub async fn psync_response_handler(\n        &self,\n        state: &SessionState,\n        payment_intent: &PaymentIntent,\n        psync_task_process: &storage::ProcessTracker,\n        revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n    ) -> Result<(), errors::ProcessTrackerError> {\n        logger::info!(\"Entering psync_response_handler\");\n\n        let db = &*state.store;\n\n        let connector_customer_id = payment_intent\n            .feature_metadata\n            .as_ref()\n            .and_then(|fm| fm.payment_revenue_recovery_metadata.as_ref())\n            .map(|rr| {\n                rr.billing_connector_payment_details\n                    .connector_customer_id\n                    .clone()\n            });\n\n        match self {\n            Self::SyncPayment(payment_attempt) => {\n                //  get a schedule time for psync\n                // and retry the process if there is a schedule time\n                // if None mark the pt status as Retries Exceeded and finish the task\n                payment_sync::recovery_retry_sync_task(\n                    state,\n                    connector_customer_id,\n                    revenue_recovery_metadata.connector.to_string(),\n                    revenue_recovery_payment_data\n                        .merchant_account\n                        .get_id()\n                        .clone(),\n                    psync_task_process.clone(),\n                )\n                .await?;\n                Ok(())\n            }\n\n            Self::RetryPayment(schedule_time) => {\n                // finish the psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                // fetch the execute task\n                let task = revenue_recovery_core::EXECUTE_WORKFLOW;\n                let runner = storage::ProcessTrackerRunner::PassiveRecoveryWorkflow;\n                let process_tracker_id = payment_intent\n                    .get_id()\n                    .get_execute_revenue_recovery_id(task, runner);\n                let execute_task_process = db\n                    .as_scheduler()\n                    .find_process_by_id(&process_tracker_id)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)?\n                    .get_required_value(\"Process Tracker\")?;\n                // retry the execute tasks\n                db.as_scheduler()\n                    .retry_process(execute_task_process, *schedule_time)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n\n            Self::TerminalFailure(payment_attempt) => {\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                // finish the current psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::SuccessfulPayment(payment_attempt) => {\n                // finish the current psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                // Record a successful transaction back to Billing Connector\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                record_back_to_billing_connector(\n                    state,\n                    payment_attempt,\n                    payment_intent,\n                    &revenue_recovery_payment_data.billing_mca,\n                )\n                .await\n                .change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)\n                .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::ReviewPayment => {\n                // requeue the process tracker task in case of psync api error\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Pending,\n                    business_status: Some(String::from(business_status::PSYNC_WORKFLOW_REQUEUE)),\n                };\n                db.as_scheduler()\n                    .update_process(psync_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n            Self::ManualReviewAction => {\n                logger::debug!(\"Invalid Payment Status For PCR Payment\");\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Review,\n                    business_status: Some(String::from(business_status::PSYNC_WORKFLOW_COMPLETE)),\n                };\n                // update the process tracker status as Review\n                db.as_scheduler()\n                    .update_process(psync_task_process.clone(), pt_update)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                Ok(())\n            }\n        }\n    }\n\n    pub(crate) async fn decide_retry_failure_action(\n        state: &SessionState,\n        merchant_id: &id_type::MerchantId,\n        pt: storage::ProcessTracker,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        payment_attempt: &PaymentAttempt,\n        payment_intent: &PaymentIntent,\n    ) -> RecoveryResult<Self> {\n        let db = &*state.store;\n        let next_retry_count = pt.retry_count + 1;\n        let error_message = payment_attempt\n            .error\n            .as_ref()\n            .map(|details| details.message.clone());\n        let error_code = payment_attempt\n            .error\n            .as_ref()\n            .map(|details| details.code.clone());\n        let connector_name = payment_attempt\n            .connector\n            .clone()\n            .ok_or(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"unable to derive payment connector from payment attempt\")?;\n        let gsm_record = helpers::get_gsm_record(\n            state,\n            error_code,\n            error_message,\n            connector_name,\n            REVENUE_RECOVERY.to_string(),\n        )\n        .await;\n        let is_hard_decline = gsm_record\n            .and_then(|gsm_record| gsm_record.error_category)\n            .map(|gsm_error_category| {\n                gsm_error_category == common_enums::ErrorCategory::HardDecline\n            })\n            .unwrap_or(false);\n        let schedule_time = revenue_recovery_payment_data\n            .get_schedule_time_based_on_retry_type(\n                state,\n                merchant_id,\n                next_retry_count,\n                payment_attempt,\n                payment_intent,\n                is_hard_decline,\n            )\n            .await;\n\n        match schedule_time {\n            Some(schedule_time) => Ok(Self::RetryPayment(schedule_time)),\n\n            None => Ok(Self::TerminalFailure(payment_attempt.clone())),\n        }\n    }\n}",
+      "after_code": "impl Action {\n    #[allow(clippy::too_many_arguments)]\n    pub async fn execute_payment(\n        state: &SessionState,\n        _merchant_id: &id_type::MerchantId,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,\n        latest_attempt_id: &id_type::GlobalAttemptId,\n        scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,\n    ) -> RecoveryResult<Self> {\n        let connector_customer_id = payment_intent\n            .extract_connector_customer_id_from_payment_intent()\n            .change_context(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n        let response = revenue_recovery_core::api::call_proxy_api(\n            state,\n            payment_intent,\n            revenue_recovery_payment_data,\n            revenue_recovery_metadata,\n            &scheduled_token\n                .payment_processor_token_details\n                .payment_processor_token,\n        )\n        .await;\n\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(\n                payment_intent,\n            );\n        // handle proxy api's response\n        match response {\n            Ok(payment_data) => {\n                \n                let _account_updater_result = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(\n                    state,\n                    &connector_customer_id,\n                    scheduled_token,\n                    payment_data.mandate_data.clone(),\n                    &payment_data.payment_attempt.id\n                ).await\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle account updater token update: {:?}\",\n                        e\n                    );\n                });\n\n                match payment_data.payment_attempt.status.foreign_into() {\n                RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                    let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                    let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(\n                        &recovery_payment_intent,\n                        &recovery_payment_attempt,\n                    );\n\n                    // publish events to kafka\n                    if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                    // update the status of token in redis\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &None,\n                        &None,\n                        Some(&scheduled_token.payment_processor_token_details.payment_processor_token),\n                    )\n                    .await;\n\n                    // unlocking the token\n                    let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    let event_status = common_enums::EventType::PaymentSucceeded;\n\n                    let payments_response = payment_data\n                        .clone()\n                        .generate_response(\n                            state,\n                            None,\n                            None,\n                            None,\n                            &merchant_context,\n                            profile,\n                            None,\n                        )\n                        .change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)\n                        .attach_printable(\"Failed while generating response for payment\")?;\n\n                    RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(\n                        state,\n                        common_enums::EventClass::Payments,\n                        event_status,\n                        payment_intent,\n                        &merchant_context,\n                        profile,\n                        payment_data.payment_attempt.id.get_string_repr().to_string(),\n                        payments_response\n                    )\n                    .await?;\n\n                    Ok(Self::SuccessfulPayment(\n                        payment_data.payment_attempt.clone(),\n                    ))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                    let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                    let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(\n                        &recovery_payment_intent,\n                        &recovery_payment_attempt,\n                    );\n\n                    // publish events to kafka\n                    if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                    let error_code = payment_data\n                        .payment_attempt\n                        .clone()\n                        .error\n                        .map(|error| error.code);\n\n                    let is_hard_decline =\n                        revenue_recovery::check_hard_decline(state, &payment_data.payment_attempt)\n                            .await\n                            .ok();\n\n                    let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &error_code,\n                        &is_hard_decline,\n                        Some(&scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token)\n                            ,\n                    )\n                    .await;\n\n                    // unlocking the token\n                    let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    // Reopen calculate workflow on payment failure\n                    Box::pin(reopen_calculate_workflow_on_payment_failure(\n                        state,\n                        process,\n                        profile,\n                        merchant_context,\n                        payment_intent,\n                        revenue_recovery_payment_data,\n                        latest_attempt_id,\n                    ))\n                    .await?;\n\n                    // Return terminal failure to finish the current execute workflow\n                    Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))\n                }\n\n                RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                    Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                    logger::info!(?action, \"Invalid Payment Status For PCR Payment\");\n                    Ok(Self::ManualReviewAction)\n                }\n                }\n            },\n            Err(err) =>\n            // check for an active attempt being constructed or not\n            {\n                logger::error!(execute_payment_res=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }\n\n    pub async fn execute_payment_task_response_handler(\n        &self,\n        state: &SessionState,\n        payment_intent: &PaymentIntent,\n        execute_task_process: &storage::ProcessTracker,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,\n    ) -> Result<(), errors::ProcessTrackerError> {\n        logger::info!(\"Entering execute_payment_task_response_handler\");\n\n        let db = &*state.store;\n        match self {\n            Self::SyncPayment(payment_attempt) => {\n                revenue_recovery_core::insert_psync_pcr_task_to_pt(\n                    revenue_recovery_payment_data.billing_mca.get_id().clone(),\n                    db,\n                    revenue_recovery_payment_data\n                        .merchant_account\n                        .get_id()\n                        .to_owned(),\n                    payment_intent.id.clone(),\n                    revenue_recovery_payment_data.profile.get_id().to_owned(),\n                    payment_attempt.id.clone(),\n                    storage::ProcessTrackerRunner::PassiveRecoveryWorkflow,\n                    revenue_recovery_payment_data.retry_algorithm,\n                )\n                .await\n                .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                .attach_printable(\"Failed to create a psync workflow in the process tracker\")?;\n\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_COMPLETE_FOR_PSYNC,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n\n            Self::RetryPayment(schedule_time) => {\n                db.as_scheduler()\n                    .retry_process(execute_task_process.clone(), *schedule_time)\n                    .await?;\n\n                // update the connector payment transmission field to Unsuccessful and unset active attempt id\n                revenue_recovery_metadata.set_payment_transmission_field_for_api_request(\n                    enums::PaymentConnectorTransmission::ConnectorCallUnsuccessful,\n                );\n\n                let payment_update_req =\n                PaymentsUpdateIntentRequest::update_feature_metadata_and_active_attempt_with_api(\n                    payment_intent\n                        .feature_metadata\n                        .clone()\n                        .unwrap_or_default()\n                        .convert_back()\n                        .set_payment_revenue_recovery_metadata_using_api(\n                            revenue_recovery_metadata.clone(),\n                        ),\n                    api_enums::UpdateActiveAttempt::Unset,\n                );\n                logger::info!(\n                    \"Call made to payments update intent api , with the request body {:?}\",\n                    payment_update_req\n                );\n                revenue_recovery_core::api::update_payment_intent_api(\n                    state,\n                    payment_intent.id.clone(),\n                    revenue_recovery_payment_data,\n                    payment_update_req,\n                )\n                .await\n                .change_context(errors::RecoveryError::PaymentCallFailed)?;\n                Ok(())\n            }\n            Self::TerminalFailure(payment_attempt) => {\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_FAILURE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                Ok(())\n            }\n            Self::SuccessfulPayment(payment_attempt) => {\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        execute_task_process.clone(),\n                        business_status::EXECUTE_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                // Record back to billing connector for terminal status\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                record_back_to_billing_connector(\n                    state,\n                    payment_attempt,\n                    payment_intent,\n                    &revenue_recovery_payment_data.billing_mca,\n                )\n                .await\n                .change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)\n                .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::ReviewPayment => {\n                // requeue the process tracker in case of error response\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Pending,\n                    business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_REQUEUE)),\n                };\n                db.as_scheduler()\n                    .update_process(execute_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n            Self::ManualReviewAction => {\n                logger::debug!(\"Invalid Payment Status For PCR Payment\");\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Review,\n                    business_status: Some(String::from(business_status::EXECUTE_WORKFLOW_COMPLETE)),\n                };\n                // update the process tracker status as Review\n                db.as_scheduler()\n                    .update_process(execute_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n        }\n    }\n\n    pub async fn payment_sync_call(\n        state: &SessionState,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        payment_attempt: PaymentAttempt,\n    ) -> RecoveryResult<Self> {\n        logger::info!(\"Entering payment_sync_call\");\n\n        let response = revenue_recovery_core::api::call_psync_api(\n            state,\n            payment_intent.get_id(),\n            revenue_recovery_payment_data,\n            true,\n            true,\n        )\n        .await;\n        let used_token = get_payment_processor_token_id_from_payment_attempt(&payment_attempt);\n\n        match response {\n            Ok(_payment_data) => match payment_attempt.status.foreign_into() {\n                RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                    let connector_customer_id = payment_intent\n                        .extract_connector_customer_id_from_payment_intent()\n                        .change_context(errors::RecoveryError::ValueNotFound)\n                        .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n                    // update the status of token in redis\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                    state,\n                    &connector_customer_id,\n                    &None,\n                    &None,\n                    used_token.as_deref(),\n                )\n                .await;\n\n                    // unlocking the token\n                    let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                    state,\n                    &connector_customer_id,\n                )\n                .await;\n\n                    Ok(Self::SuccessfulPayment(payment_attempt))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                    let connector_customer_id = payment_intent\n                        .extract_connector_customer_id_from_payment_intent()\n                        .change_context(errors::RecoveryError::ValueNotFound)\n                        .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n                    let error_code = payment_attempt.clone().error.map(|error| error.code);\n\n                    let is_hard_decline =\n                        revenue_recovery::check_hard_decline(state, &payment_attempt)\n                            .await\n                            .ok();\n\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                            state,\n                            &connector_customer_id,\n                            &error_code,\n                            &is_hard_decline,\n                            used_token.as_deref(),\n                        )\n                        .await;\n\n                    // unlocking the token\n                    let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    // Reopen calculate workflow on payment failure\n                    Box::pin(reopen_calculate_workflow_on_payment_failure(\n                        state,\n                        process,\n                        profile,\n                        merchant_context,\n                        payment_intent,\n                        revenue_recovery_payment_data,\n                        payment_attempt.get_id(),\n                    ))\n                    .await?;\n\n                    Ok(Self::TerminalFailure(payment_attempt.clone()))\n                }\n\n                RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                    Ok(Self::SyncPayment(payment_attempt))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                    logger::info!(?action, \"Invalid Payment Status For PCR PSync Payment\");\n                    Ok(Self::ManualReviewAction)\n                }\n            },\n            Err(err) =>\n            // if there is an error while psync we create a new Review Task\n            {\n                logger::error!(sync_payment_response=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }\n    pub async fn psync_response_handler(\n        &self,\n        state: &SessionState,\n        payment_intent: &PaymentIntent,\n        psync_task_process: &storage::ProcessTracker,\n        revenue_recovery_metadata: &mut PaymentRevenueRecoveryMetadata,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n    ) -> Result<(), errors::ProcessTrackerError> {\n        logger::info!(\"Entering psync_response_handler\");\n\n        let db = &*state.store;\n\n        let connector_customer_id = payment_intent\n            .feature_metadata\n            .as_ref()\n            .and_then(|fm| fm.payment_revenue_recovery_metadata.as_ref())\n            .map(|rr| {\n                rr.billing_connector_payment_details\n                    .connector_customer_id\n                    .clone()\n            });\n\n        match self {\n            Self::SyncPayment(payment_attempt) => {\n                //  get a schedule time for psync\n                // and retry the process if there is a schedule time\n                // if None mark the pt status as Retries Exceeded and finish the task\n                payment_sync::recovery_retry_sync_task(\n                    state,\n                    connector_customer_id,\n                    revenue_recovery_metadata.connector.to_string(),\n                    revenue_recovery_payment_data\n                        .merchant_account\n                        .get_id()\n                        .clone(),\n                    psync_task_process.clone(),\n                )\n                .await?;\n                Ok(())\n            }\n\n            Self::RetryPayment(schedule_time) => {\n                // finish the psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                // fetch the execute task\n                let task = revenue_recovery_core::EXECUTE_WORKFLOW;\n                let runner = storage::ProcessTrackerRunner::PassiveRecoveryWorkflow;\n                let process_tracker_id = payment_intent\n                    .get_id()\n                    .get_execute_revenue_recovery_id(task, runner);\n                let execute_task_process = db\n                    .as_scheduler()\n                    .find_process_by_id(&process_tracker_id)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)?\n                    .get_required_value(\"Process Tracker\")?;\n                // retry the execute tasks\n                db.as_scheduler()\n                    .retry_process(execute_task_process, *schedule_time)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n\n            Self::TerminalFailure(payment_attempt) => {\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                // finish the current psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::SuccessfulPayment(payment_attempt) => {\n                // finish the current psync task\n                db.as_scheduler()\n                    .finish_process_with_business_status(\n                        psync_task_process.clone(),\n                        business_status::PSYNC_WORKFLOW_COMPLETE,\n                    )\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                // Record a successful transaction back to Billing Connector\n                // TODO: Add support for retrying failed outgoing recordback webhooks\n                record_back_to_billing_connector(\n                    state,\n                    payment_attempt,\n                    payment_intent,\n                    &revenue_recovery_payment_data.billing_mca,\n                )\n                .await\n                .change_context(errors::RecoveryError::RecordBackToBillingConnectorFailed)\n                .attach_printable(\"Failed to update the process tracker\")?;\n                Ok(())\n            }\n            Self::ReviewPayment => {\n                // requeue the process tracker task in case of psync api error\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Pending,\n                    business_status: Some(String::from(business_status::PSYNC_WORKFLOW_REQUEUE)),\n                };\n                db.as_scheduler()\n                    .update_process(psync_task_process.clone(), pt_update)\n                    .await?;\n                Ok(())\n            }\n            Self::ManualReviewAction => {\n                logger::debug!(\"Invalid Payment Status For PCR Payment\");\n                let pt_update = storage::ProcessTrackerUpdate::StatusUpdate {\n                    status: enums::ProcessTrackerStatus::Review,\n                    business_status: Some(String::from(business_status::PSYNC_WORKFLOW_COMPLETE)),\n                };\n                // update the process tracker status as Review\n                db.as_scheduler()\n                    .update_process(psync_task_process.clone(), pt_update)\n                    .await\n                    .change_context(errors::RecoveryError::ProcessTrackerFailure)\n                    .attach_printable(\"Failed to update the process tracker\")?;\n\n                Ok(())\n            }\n        }\n    }\n\n    pub(crate) async fn decide_retry_failure_action(\n        state: &SessionState,\n        merchant_id: &id_type::MerchantId,\n        pt: storage::ProcessTracker,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        payment_attempt: &PaymentAttempt,\n        payment_intent: &PaymentIntent,\n    ) -> RecoveryResult<Self> {\n        let db = &*state.store;\n        let next_retry_count = pt.retry_count + 1;\n        let error_message = payment_attempt\n            .error\n            .as_ref()\n            .map(|details| details.message.clone());\n        let error_code = payment_attempt\n            .error\n            .as_ref()\n            .map(|details| details.code.clone());\n        let connector_name = payment_attempt\n            .connector\n            .clone()\n            .ok_or(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"unable to derive payment connector from payment attempt\")?;\n        let gsm_record = helpers::get_gsm_record(\n            state,\n            error_code,\n            error_message,\n            connector_name,\n            REVENUE_RECOVERY.to_string(),\n        )\n        .await;\n        let is_hard_decline = gsm_record\n            .and_then(|gsm_record| gsm_record.error_category)\n            .map(|gsm_error_category| {\n                gsm_error_category == common_enums::ErrorCategory::HardDecline\n            })\n            .unwrap_or(false);\n        let schedule_time = revenue_recovery_payment_data\n            .get_schedule_time_based_on_retry_type(\n                state,\n                merchant_id,\n                next_retry_count,\n                payment_attempt,\n                payment_intent,\n                is_hard_decline,\n            )\n            .await;\n\n        match schedule_time {\n            Some(schedule_time) => Ok(Self::RetryPayment(schedule_time)),\n\n            None => Ok(Self::TerminalFailure(payment_attempt.clone())),\n        }\n    }\n}",
+      "diff_span": {
+        "before": "        .await;\n\n        println!(\"response: {:?}\", response);\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(",
+        "after": ""
+      },
+      "commit_sha": "9f9d6ff94f799ef0c0be1fc3463e8653aca1baeb"
+    },
+    {
+      "id": "crates/router/src/core/revenue_recovery/types.rs::Action::function::execute_payment",
+      "file": "crates/router/src/core/revenue_recovery/types.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn execute_payment(\n        state: &SessionState,\n        _merchant_id: &id_type::MerchantId,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,\n        latest_attempt_id: &id_type::GlobalAttemptId,\n        scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,\n    ) -> RecoveryResult<Self> {\n        let connector_customer_id = payment_intent\n            .extract_connector_customer_id_from_payment_intent()\n            .change_context(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n        let response = revenue_recovery_core::api::call_proxy_api(\n            state,\n            payment_intent,\n            revenue_recovery_payment_data,\n            revenue_recovery_metadata,\n            &scheduled_token\n                .payment_processor_token_details\n                .payment_processor_token,\n        )\n        .await;\n\n        println!(\"response: {:?}\", response);\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(\n                payment_intent,\n            );\n        // handle proxy api's response\n        match response {\n            Ok(payment_data) => {\n                \n                let _account_updater_result = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(\n                    state,\n                    &connector_customer_id,\n                    scheduled_token,\n                    payment_data.mandate_data.clone(),\n                    &payment_data.payment_attempt.id\n                ).await\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle account updater token update: {:?}\",\n                        e\n                    );\n                });\n\n                match payment_data.payment_attempt.status.foreign_into() {\n                RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                    let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                    let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(\n                        &recovery_payment_intent,\n                        &recovery_payment_attempt,\n                    );\n\n                    // publish events to kafka\n                    if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                    // update the status of token in redis\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &None,\n                        &None,\n                        Some(&scheduled_token.payment_processor_token_details.payment_processor_token),\n                    )\n                    .await;\n\n                    // unlocking the token\n                    let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    let event_status = common_enums::EventType::PaymentSucceeded;\n\n                    let payments_response = payment_data\n                        .clone()\n                        .generate_response(\n                            state,\n                            None,\n                            None,\n                            None,\n                            &merchant_context,\n                            profile,\n                            None,\n                        )\n                        .change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)\n                        .attach_printable(\"Failed while generating response for payment\")?;\n\n                    RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(\n                        state,\n                        common_enums::EventClass::Payments,\n                        event_status,\n                        payment_intent,\n                        &merchant_context,\n                        profile,\n                        payment_data.payment_attempt.id.get_string_repr().to_string(),\n                        payments_response\n                    )\n                    .await?;\n\n                    Ok(Self::SuccessfulPayment(\n                        payment_data.payment_attempt.clone(),\n                    ))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                    let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                    let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(\n                        &recovery_payment_intent,\n                        &recovery_payment_attempt,\n                    );\n\n                    // publish events to kafka\n                    if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                    let error_code = payment_data\n                        .payment_attempt\n                        .clone()\n                        .error\n                        .map(|error| error.code);\n\n                    let is_hard_decline =\n                        revenue_recovery::check_hard_decline(state, &payment_data.payment_attempt)\n                            .await\n                            .ok();\n\n                    let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &error_code,\n                        &is_hard_decline,\n                        Some(&scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token)\n                            ,\n                    )\n                    .await;\n\n                    // unlocking the token\n                    let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    // Reopen calculate workflow on payment failure\n                    Box::pin(reopen_calculate_workflow_on_payment_failure(\n                        state,\n                        process,\n                        profile,\n                        merchant_context,\n                        payment_intent,\n                        revenue_recovery_payment_data,\n                        latest_attempt_id,\n                    ))\n                    .await?;\n\n                    // Return terminal failure to finish the current execute workflow\n                    Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))\n                }\n\n                RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                    Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                    logger::info!(?action, \"Invalid Payment Status For PCR Payment\");\n                    Ok(Self::ManualReviewAction)\n                }\n                }\n            },\n            Err(err) =>\n            // check for an active attempt being constructed or not\n            {\n                logger::error!(execute_payment_res=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }",
+      "after_code": "pub async fn execute_payment(\n        state: &SessionState,\n        _merchant_id: &id_type::MerchantId,\n        payment_intent: &PaymentIntent,\n        process: &storage::ProcessTracker,\n        profile: &domain::Profile,\n        merchant_context: domain::MerchantContext,\n        revenue_recovery_payment_data: &storage::revenue_recovery::RevenueRecoveryPaymentData,\n        revenue_recovery_metadata: &PaymentRevenueRecoveryMetadata,\n        latest_attempt_id: &id_type::GlobalAttemptId,\n        scheduled_token: &storage::revenue_recovery_redis_operation::PaymentProcessorTokenStatus,\n    ) -> RecoveryResult<Self> {\n        let connector_customer_id = payment_intent\n            .extract_connector_customer_id_from_payment_intent()\n            .change_context(errors::RecoveryError::ValueNotFound)\n            .attach_printable(\"Failed to extract customer ID from payment intent\")?;\n\n        let response = revenue_recovery_core::api::call_proxy_api(\n            state,\n            payment_intent,\n            revenue_recovery_payment_data,\n            revenue_recovery_metadata,\n            &scheduled_token\n                .payment_processor_token_details\n                .payment_processor_token,\n        )\n        .await;\n\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(\n                payment_intent,\n            );\n        // handle proxy api's response\n        match response {\n            Ok(payment_data) => {\n                \n                let _account_updater_result = storage::revenue_recovery_redis_operation::RedisTokenManager::handle_account_updater_token_update(\n                    state,\n                    &connector_customer_id,\n                    scheduled_token,\n                    payment_data.mandate_data.clone(),\n                    &payment_data.payment_attempt.id\n                ).await\n                .inspect_err(|e| {\n                    logger::error!(\n                        \"Failed to handle account updater token update: {:?}\",\n                        e\n                    );\n                });\n\n                match payment_data.payment_attempt.status.foreign_into() {\n                RevenueRecoveryPaymentsAttemptStatus::Succeeded => {\n                    let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                    let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(\n                        &recovery_payment_intent,\n                        &recovery_payment_attempt,\n                    );\n\n                    // publish events to kafka\n                    if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                    // update the status of token in redis\n                    let _update_error_code = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &None,\n                        &None,\n                        Some(&scheduled_token.payment_processor_token_details.payment_processor_token),\n                    )\n                    .await;\n\n                    // unlocking the token\n                    let _unlock_the_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    let event_status = common_enums::EventType::PaymentSucceeded;\n\n                    let payments_response = payment_data\n                        .clone()\n                        .generate_response(\n                            state,\n                            None,\n                            None,\n                            None,\n                            &merchant_context,\n                            profile,\n                            None,\n                        )\n                        .change_context(errors::RecoveryError::PaymentsResponseGenerationFailed)\n                        .attach_printable(\"Failed while generating response for payment\")?;\n\n                    RevenueRecoveryOutgoingWebhook::send_outgoing_webhook_based_on_revenue_recovery_status(\n                        state,\n                        common_enums::EventClass::Payments,\n                        event_status,\n                        payment_intent,\n                        &merchant_context,\n                        profile,\n                        payment_data.payment_attempt.id.get_string_repr().to_string(),\n                        payments_response\n                    )\n                    .await?;\n\n                    Ok(Self::SuccessfulPayment(\n                        payment_data.payment_attempt.clone(),\n                    ))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::Failed => {\n                    let recovery_payment_attempt =\n                        hyperswitch_domain_models::revenue_recovery::RecoveryPaymentAttempt::from(\n                            &payment_data.payment_attempt,\n                        );\n\n                    let recovery_payment_tuple = recovery_incoming_flow::RecoveryPaymentTuple::new(\n                        &recovery_payment_intent,\n                        &recovery_payment_attempt,\n                    );\n\n                    // publish events to kafka\n                    if let Err(e) = recovery_incoming_flow::RecoveryPaymentTuple::publish_revenue_recovery_event_to_kafka(\n                        state,\n                        &recovery_payment_tuple,\n                        Some(process.retry_count+1)\n                    )\n                    .await{\n                        router_env::logger::error!(\n                            \"Failed to publish revenue recovery event to kafka: {:?}\",\n                            e\n                        );\n                    };\n\n                    let error_code = payment_data\n                        .payment_attempt\n                        .clone()\n                        .error\n                        .map(|error| error.code);\n\n                    let is_hard_decline =\n                        revenue_recovery::check_hard_decline(state, &payment_data.payment_attempt)\n                            .await\n                            .ok();\n\n                    let _update_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::update_payment_processor_token_error_code_from_process_tracker(\n                        state,\n                        &connector_customer_id,\n                        &error_code,\n                        &is_hard_decline,\n                        Some(&scheduled_token\n                            .payment_processor_token_details\n                            .payment_processor_token)\n                            ,\n                    )\n                    .await;\n\n                    // unlocking the token\n                    let _unlock_connector_customer_id = storage::revenue_recovery_redis_operation::RedisTokenManager::unlock_connector_customer_status(\n                        state,\n                        &connector_customer_id,\n                    )\n                    .await;\n\n                    // Reopen calculate workflow on payment failure\n                    Box::pin(reopen_calculate_workflow_on_payment_failure(\n                        state,\n                        process,\n                        profile,\n                        merchant_context,\n                        payment_intent,\n                        revenue_recovery_payment_data,\n                        latest_attempt_id,\n                    ))\n                    .await?;\n\n                    // Return terminal failure to finish the current execute workflow\n                    Ok(Self::TerminalFailure(payment_data.payment_attempt.clone()))\n                }\n\n                RevenueRecoveryPaymentsAttemptStatus::Processing => {\n                    Ok(Self::SyncPayment(payment_data.payment_attempt.clone()))\n                }\n                RevenueRecoveryPaymentsAttemptStatus::InvalidStatus(action) => {\n                    logger::info!(?action, \"Invalid Payment Status For PCR Payment\");\n                    Ok(Self::ManualReviewAction)\n                }\n                }\n            },\n            Err(err) =>\n            // check for an active attempt being constructed or not\n            {\n                logger::error!(execute_payment_res=?err);\n                Ok(Self::ReviewPayment)\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "        .await;\n\n        println!(\"response: {:?}\", response);\n        let recovery_payment_intent =\n            hyperswitch_domain_models::revenue_recovery::RecoveryPaymentIntent::from(",
+        "after": ""
+      },
+      "commit_sha": "9f9d6ff94f799ef0c0be1fc3463e8653aca1baeb"
+    }
+  ]
+}

diffs/pr_10112/a18902f/diff.json

@@ -0,0 +1,69 @@
+{
+  "commit_sha": "a18902f5fe9ef32589f905ad06113696aadf398b",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {\n            (Some(sale_response), None) => {\n                let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .sale_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| sale_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: sale_response.response.to_string(),\n                            message: sale_response.message.clone(),\n                            reason: Some(sale_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(sale_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);\n\n                    // While making an authorize flow call to WorldpayVantiv, if Account Updater is enabled then we well get new card token info in response.\n                    // We are extracting that new card token info here to be sent back in mandate_id in router_data.\n                    let mandate_reference_data = match item.data.request.payment_method_data {\n                        PaymentMethodData::MandatePayment => {\n                            if let Some(account_updater) = sale_response.account_updater.as_ref() {\n                                account_updater\n                                    .new_card_token_info\n                                    .clone()\n                                    .map(MandateReference::from)\n                            } else {\n                                sale_response\n                                    .token_response\n                                    .clone()\n                                    .map(MandateReference::from)\n                            }\n                        }\n                        _ => sale_response\n                            .token_response\n                            .clone()\n                            .map(MandateReference::from),\n                    };     \n\n                    println!(\"mandate_reference_data: {:?}\", mandate_reference_data);                                 \n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(sale_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),\n                        minor_amount_captured: sale_response.approved_amount,\n                        ..item.data\n                    })\n                }\n            },\n            (None, Some(auth_response)) => {\n                let payment_flow_type = if item.data.request.is_auto_capture()? {\n                    WorldpayvantivPaymentFlow::Sale\n                } else {\n                    WorldpayvantivPaymentFlow::Auth\n                };\n\n                let status = get_attempt_status(payment_flow_type, auth_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .authorization_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| auth_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: auth_response.response.to_string(),\n                            message: auth_response.message.clone(),\n                            reason: Some(auth_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(auth_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);\n                    let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(auth_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)\n                        } else {\n                            None\n                        },\n                        minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        ..item.data\n                    })\n                }\n            },\n            (None, None) => {\n                Ok(Self {\n                status: common_enums::AttemptStatus::Failure,\n                response: Err(ErrorResponse {\n                    code: item.response.response_code.clone(),\n                    message: item.response.message.clone(),\n                    reason: Some(item.response.message.clone()),\n                    status_code: item.http_code,\n                    attempt_status: None,\n                    connector_transaction_id: None, // Transaction id not created at connector\n                    network_advice_code: None,\n                    network_decline_code: None,\n                    network_error_message: None,\n                    connector_metadata: None,\n                }),\n                ..item.data\n            })},\n            (_, _) => {  Err(errors::ConnectorError::UnexpectedResponseError(\n                bytes::Bytes::from(\"Only one of 'sale_response' or 'authorisation_response' is expected, but both were received\".to_string()),           \n             ))?\n            },\n    }\n    }",
+      "after_code": "fn try_from(\n        item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {\n            (Some(sale_response), None) => {\n                let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .sale_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| sale_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: sale_response.response.to_string(),\n                            message: sale_response.message.clone(),\n                            reason: Some(sale_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(sale_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);\n\n                    // While making an authorize flow call to WorldpayVantiv, if Account Updater is enabled then we well get new card token info in response.\n                    // We are extracting that new card token info here to be sent back in mandate_id in router_data.\n                    let mandate_reference_data = match item.data.request.payment_method_data {\n                        PaymentMethodData::MandatePayment => {\n                            if let Some(account_updater) = sale_response.account_updater.as_ref() {\n                                account_updater\n                                    .new_card_token_info\n                                    .clone()\n                                    .map(MandateReference::from)\n                            } else {\n                                sale_response\n                                    .token_response\n                                    .clone()\n                                    .map(MandateReference::from)\n                            }\n                        }\n                        _ => sale_response\n                            .token_response\n                            .clone()\n                            .map(MandateReference::from),\n                    };                                     \n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(sale_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),\n                        minor_amount_captured: sale_response.approved_amount,\n                        ..item.data\n                    })\n                }\n            },\n            (None, Some(auth_response)) => {\n                let payment_flow_type = if item.data.request.is_auto_capture()? {\n                    WorldpayvantivPaymentFlow::Sale\n                } else {\n                    WorldpayvantivPaymentFlow::Auth\n                };\n\n                let status = get_attempt_status(payment_flow_type, auth_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .authorization_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| auth_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: auth_response.response.to_string(),\n                            message: auth_response.message.clone(),\n                            reason: Some(auth_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(auth_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);\n                    let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(auth_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)\n                        } else {\n                            None\n                        },\n                        minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        ..item.data\n                    })\n                }\n            },\n            (None, None) => {\n                Ok(Self {\n                status: common_enums::AttemptStatus::Failure,\n                response: Err(ErrorResponse {\n                    code: item.response.response_code.clone(),\n                    message: item.response.message.clone(),\n                    reason: Some(item.response.message.clone()),\n                    status_code: item.http_code,\n                    attempt_status: None,\n                    connector_transaction_id: None, // Transaction id not created at connector\n                    network_advice_code: None,\n                    network_decline_code: None,\n                    network_error_message: None,\n                    connector_metadata: None,\n                }),\n                ..item.data\n            })},\n            (_, _) => {  Err(errors::ConnectorError::UnexpectedResponseError(\n                bytes::Bytes::from(\"Only one of 'sale_response' or 'authorisation_response' is expected, but both were received\".to_string()),           \n             ))?\n            },\n    }\n    }",
+      "diff_span": {
+        "before": "                            .clone()\n                            .map(MandateReference::from),\n                    };     \n\n                    println!(\"mandate_reference_data: {:?}\", mandate_reference_data);                                 \n\n                    Ok(Self {",
+        "after": "                            .clone()\n                            .map(MandateReference::from),\n                    };                                     \n\n                    Ok(Self {"
+      },
+      "commit_sha": "a18902f5fe9ef32589f905ad06113696aadf398b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::MandateReference::function::from",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn from(token_data: AccountUpdaterCardTokenInfo) -> Self {\n         let mandate_metadata = api_models::payments::AdditionalCardInfo::from(&token_data);\n\n        let mandate_metadata_json =  serde_json::to_value(&mandate_metadata).inspect_err(|e| logger::error!(\"Failed to construct Mandate Reference from the AccoutnUpdaterCardTokenInfo\")).ok();\n\n        let mandate_metadata_secret_json = mandate_metadata_json.map(pii::SecretSerdeValue::new);\n\n        Self {\n            connector_mandate_id: Some(token_data.cnp_token.expose()),\n            payment_method_id: None,\n            mandate_metadata: mandate_metadata_secret_json,\n            connector_mandate_request_reference_id: None,\n        }\n    }",
+      "after_code": "fn from(token_data: AccountUpdaterCardTokenInfo) -> Self {\n         let mandate_metadata = api_models::payments::AdditionalCardInfo::from(&token_data);\n\n        let mandate_metadata_json =  serde_json::to_value(&mandate_metadata).inspect_err(|_| logger::error!(\"Failed to construct Mandate Reference from the AccoutnUpdaterCardTokenInfo\")).ok();\n\n        let mandate_metadata_secret_json = mandate_metadata_json.map(pii::SecretSerdeValue::new);\n\n        Self {\n            connector_mandate_id: Some(token_data.cnp_token.expose()),\n            payment_method_id: None,\n            mandate_metadata: mandate_metadata_secret_json,\n            connector_mandate_request_reference_id: None,\n        }\n    }",
+      "diff_span": {
+        "before": "         let mandate_metadata = api_models::payments::AdditionalCardInfo::from(&token_data);\n\n        let mandate_metadata_json =  serde_json::to_value(&mandate_metadata).inspect_err(|e| logger::error!(\"Failed to construct Mandate Reference from the AccoutnUpdaterCardTokenInfo\")).ok();\n\n        let mandate_metadata_secret_json = mandate_metadata_json.map(pii::SecretSerdeValue::new);",
+        "after": "         let mandate_metadata = api_models::payments::AdditionalCardInfo::from(&token_data);\n\n        let mandate_metadata_json =  serde_json::to_value(&mandate_metadata).inspect_err(|_| logger::error!(\"Failed to construct Mandate Reference from the AccoutnUpdaterCardTokenInfo\")).ok();\n\n        let mandate_metadata_secret_json = mandate_metadata_json.map(pii::SecretSerdeValue::new);"
+      },
+      "commit_sha": "a18902f5fe9ef32589f905ad06113696aadf398b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::impl::MandateReference",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl From<AccountUpdaterCardTokenInfo> for MandateReference {\n    fn from(token_data: AccountUpdaterCardTokenInfo) -> Self {\n         let mandate_metadata = api_models::payments::AdditionalCardInfo::from(&token_data);\n\n        let mandate_metadata_json =  serde_json::to_value(&mandate_metadata).inspect_err(|e| logger::error!(\"Failed to construct Mandate Reference from the AccoutnUpdaterCardTokenInfo\")).ok();\n\n        let mandate_metadata_secret_json = mandate_metadata_json.map(pii::SecretSerdeValue::new);\n\n        Self {\n            connector_mandate_id: Some(token_data.cnp_token.expose()),\n            payment_method_id: None,\n            mandate_metadata: mandate_metadata_secret_json,\n            connector_mandate_request_reference_id: None,\n        }\n    }\n}",
+      "after_code": "impl From<AccountUpdaterCardTokenInfo> for MandateReference {\n    fn from(token_data: AccountUpdaterCardTokenInfo) -> Self {\n         let mandate_metadata = api_models::payments::AdditionalCardInfo::from(&token_data);\n\n        let mandate_metadata_json =  serde_json::to_value(&mandate_metadata).inspect_err(|_| logger::error!(\"Failed to construct Mandate Reference from the AccoutnUpdaterCardTokenInfo\")).ok();\n\n        let mandate_metadata_secret_json = mandate_metadata_json.map(pii::SecretSerdeValue::new);\n\n        Self {\n            connector_mandate_id: Some(token_data.cnp_token.expose()),\n            payment_method_id: None,\n            mandate_metadata: mandate_metadata_secret_json,\n            connector_mandate_request_reference_id: None,\n        }\n    }\n}",
+      "diff_span": {
+        "before": "         let mandate_metadata = api_models::payments::AdditionalCardInfo::from(&token_data);\n\n        let mandate_metadata_json =  serde_json::to_value(&mandate_metadata).inspect_err(|e| logger::error!(\"Failed to construct Mandate Reference from the AccoutnUpdaterCardTokenInfo\")).ok();\n\n        let mandate_metadata_secret_json = mandate_metadata_json.map(pii::SecretSerdeValue::new);",
+        "after": "         let mandate_metadata = api_models::payments::AdditionalCardInfo::from(&token_data);\n\n        let mandate_metadata_json =  serde_json::to_value(&mandate_metadata).inspect_err(|_| logger::error!(\"Failed to construct Mandate Reference from the AccoutnUpdaterCardTokenInfo\")).ok();\n\n        let mandate_metadata_secret_json = mandate_metadata_json.map(pii::SecretSerdeValue::new);"
+      },
+      "commit_sha": "a18902f5fe9ef32589f905ad06113696aadf398b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::impl::RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F>\n    TryFrom<ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>>\n    for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {\n            (Some(sale_response), None) => {\n                let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .sale_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| sale_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: sale_response.response.to_string(),\n                            message: sale_response.message.clone(),\n                            reason: Some(sale_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(sale_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);\n\n                    // While making an authorize flow call to WorldpayVantiv, if Account Updater is enabled then we well get new card token info in response.\n                    // We are extracting that new card token info here to be sent back in mandate_id in router_data.\n                    let mandate_reference_data = match item.data.request.payment_method_data {\n                        PaymentMethodData::MandatePayment => {\n                            if let Some(account_updater) = sale_response.account_updater.as_ref() {\n                                account_updater\n                                    .new_card_token_info\n                                    .clone()\n                                    .map(MandateReference::from)\n                            } else {\n                                sale_response\n                                    .token_response\n                                    .clone()\n                                    .map(MandateReference::from)\n                            }\n                        }\n                        _ => sale_response\n                            .token_response\n                            .clone()\n                            .map(MandateReference::from),\n                    };     \n\n                    println!(\"mandate_reference_data: {:?}\", mandate_reference_data);                                 \n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(sale_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),\n                        minor_amount_captured: sale_response.approved_amount,\n                        ..item.data\n                    })\n                }\n            },\n            (None, Some(auth_response)) => {\n                let payment_flow_type = if item.data.request.is_auto_capture()? {\n                    WorldpayvantivPaymentFlow::Sale\n                } else {\n                    WorldpayvantivPaymentFlow::Auth\n                };\n\n                let status = get_attempt_status(payment_flow_type, auth_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .authorization_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| auth_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: auth_response.response.to_string(),\n                            message: auth_response.message.clone(),\n                            reason: Some(auth_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(auth_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);\n                    let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(auth_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)\n                        } else {\n                            None\n                        },\n                        minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        ..item.data\n                    })\n                }\n            },\n            (None, None) => {\n                Ok(Self {\n                status: common_enums::AttemptStatus::Failure,\n                response: Err(ErrorResponse {\n                    code: item.response.response_code.clone(),\n                    message: item.response.message.clone(),\n                    reason: Some(item.response.message.clone()),\n                    status_code: item.http_code,\n                    attempt_status: None,\n                    connector_transaction_id: None, // Transaction id not created at connector\n                    network_advice_code: None,\n                    network_decline_code: None,\n                    network_error_message: None,\n                    connector_metadata: None,\n                }),\n                ..item.data\n            })},\n            (_, _) => {  Err(errors::ConnectorError::UnexpectedResponseError(\n                bytes::Bytes::from(\"Only one of 'sale_response' or 'authorisation_response' is expected, but both were received\".to_string()),           \n             ))?\n            },\n    }\n    }\n}",
+      "after_code": "impl<F>\n    TryFrom<ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>>\n    for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {\n            (Some(sale_response), None) => {\n                let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .sale_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| sale_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: sale_response.response.to_string(),\n                            message: sale_response.message.clone(),\n                            reason: Some(sale_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(sale_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);\n\n                    // While making an authorize flow call to WorldpayVantiv, if Account Updater is enabled then we well get new card token info in response.\n                    // We are extracting that new card token info here to be sent back in mandate_id in router_data.\n                    let mandate_reference_data = match item.data.request.payment_method_data {\n                        PaymentMethodData::MandatePayment => {\n                            if let Some(account_updater) = sale_response.account_updater.as_ref() {\n                                account_updater\n                                    .new_card_token_info\n                                    .clone()\n                                    .map(MandateReference::from)\n                            } else {\n                                sale_response\n                                    .token_response\n                                    .clone()\n                                    .map(MandateReference::from)\n                            }\n                        }\n                        _ => sale_response\n                            .token_response\n                            .clone()\n                            .map(MandateReference::from),\n                    };                                     \n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(sale_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),\n                        minor_amount_captured: sale_response.approved_amount,\n                        ..item.data\n                    })\n                }\n            },\n            (None, Some(auth_response)) => {\n                let payment_flow_type = if item.data.request.is_auto_capture()? {\n                    WorldpayvantivPaymentFlow::Sale\n                } else {\n                    WorldpayvantivPaymentFlow::Auth\n                };\n\n                let status = get_attempt_status(payment_flow_type, auth_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .authorization_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| auth_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: auth_response.response.to_string(),\n                            message: auth_response.message.clone(),\n                            reason: Some(auth_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(auth_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);\n                    let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(auth_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)\n                        } else {\n                            None\n                        },\n                        minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        ..item.data\n                    })\n                }\n            },\n            (None, None) => {\n                Ok(Self {\n                status: common_enums::AttemptStatus::Failure,\n                response: Err(ErrorResponse {\n                    code: item.response.response_code.clone(),\n                    message: item.response.message.clone(),\n                    reason: Some(item.response.message.clone()),\n                    status_code: item.http_code,\n                    attempt_status: None,\n                    connector_transaction_id: None, // Transaction id not created at connector\n                    network_advice_code: None,\n                    network_decline_code: None,\n                    network_error_message: None,\n                    connector_metadata: None,\n                }),\n                ..item.data\n            })},\n            (_, _) => {  Err(errors::ConnectorError::UnexpectedResponseError(\n                bytes::Bytes::from(\"Only one of 'sale_response' or 'authorisation_response' is expected, but both were received\".to_string()),           \n             ))?\n            },\n    }\n    }\n}",
+      "diff_span": {
+        "before": "                            .clone()\n                            .map(MandateReference::from),\n                    };     \n\n                    println!(\"mandate_reference_data: {:?}\", mandate_reference_data);                                 \n\n                    Ok(Self {",
+        "after": "                            .clone()\n                            .map(MandateReference::from),\n                    };                                     \n\n                    Ok(Self {"
+      },
+      "commit_sha": "a18902f5fe9ef32589f905ad06113696aadf398b"
+    }
+  ]
+}

diffs/pr_10112/a3c3975/diff.json

@@ -0,0 +1,40 @@
+{
+  "commit_sha": "a3c3975922a5c7185f193f918c5257de70ded850",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/unified_connector_service/transformers.rs",
+    "crates/router/src/core/payments/operations/payment_response.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/unified_connector_service/transformers.rs::ConnectorResponseData::function::foreign_try_from",
+      "file": "crates/hyperswitch_interfaces/src/unified_connector_service/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn foreign_try_from(value: payments_grpc::ConnectorResponseData) -> Result<Self, Self::Error> {\n        // Extract additional_payment_method_data\n        let additional_payment_method_data = value\n            .additional_payment_method_data\n            .map(AdditionalPaymentMethodConnectorResponse::foreign_try_from)\n            .transpose()?;\n\n        let extended_authorization_response_data =\n            value.extended_authorization_response_data.map(|data| {\n                ExtendedAuthorizationResponseData {\n                    capture_before: data\n                        .capture_before\n                        .and_then(|ts| time::OffsetDateTime::from_unix_timestamp(ts).ok())\n                        .map(|offset_dt| {\n                            time::PrimitiveDateTime::new(offset_dt.date(), offset_dt.time())\n                        }),\n                    extended_authentication_applied: data\n                        .extended_authentication_applied\n                        .map(ExtendedAuthorizationAppliedBool::from),\n                    extended_authorization_last_applied_at: None, // This field has to be added to UCS\n                }\n            });\n\n        let is_overcapture_enabled = value\n            .is_overcapture_enabled\n            .map(OvercaptureEnabledBool::new);\n\n        Ok(Self::new(\n            additional_payment_method_data,\n            is_overcapture_enabled,\n            extended_authorization_response_data,\n            None\n        ))\n    }",
+      "after_code": "fn foreign_try_from(value: payments_grpc::ConnectorResponseData) -> Result<Self, Self::Error> {\n        // Extract additional_payment_method_data\n        let additional_payment_method_data = value\n            .additional_payment_method_data\n            .map(AdditionalPaymentMethodConnectorResponse::foreign_try_from)\n            .transpose()?;\n\n        let extended_authorization_response_data =\n            value.extended_authorization_response_data.map(|data| {\n                ExtendedAuthorizationResponseData {\n                    capture_before: data\n                        .capture_before\n                        .and_then(|ts| time::OffsetDateTime::from_unix_timestamp(ts).ok())\n                        .map(|offset_dt| {\n                            time::PrimitiveDateTime::new(offset_dt.date(), offset_dt.time())\n                        }),\n                    extended_authentication_applied: data\n                        .extended_authentication_applied\n                        .map(ExtendedAuthorizationAppliedBool::from),\n                    extended_authorization_last_applied_at: None, // This field has to be added to UCS\n                }\n            });\n\n        let is_overcapture_enabled = value\n            .is_overcapture_enabled\n            .map(OvercaptureEnabledBool::new);\n\n        Ok(Self::new(\n            additional_payment_method_data,\n            is_overcapture_enabled,\n            extended_authorization_response_data,\n            None,\n        ))\n    }",
+      "diff_span": {
+        "before": "            is_overcapture_enabled,\n            extended_authorization_response_data,\n            None\n        ))\n    }",
+        "after": "            is_overcapture_enabled,\n            extended_authorization_response_data,\n            None,\n        ))\n    }"
+      },
+      "commit_sha": "a3c3975922a5c7185f193f918c5257de70ded850"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/unified_connector_service/transformers.rs::impl::ConnectorResponseData",
+      "file": "crates/hyperswitch_interfaces/src/unified_connector_service/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl ForeignTryFrom<payments_grpc::ConnectorResponseData> for ConnectorResponseData {\n    type Error = error_stack::Report<UnifiedConnectorServiceError>;\n\n    fn foreign_try_from(value: payments_grpc::ConnectorResponseData) -> Result<Self, Self::Error> {\n        // Extract additional_payment_method_data\n        let additional_payment_method_data = value\n            .additional_payment_method_data\n            .map(AdditionalPaymentMethodConnectorResponse::foreign_try_from)\n            .transpose()?;\n\n        let extended_authorization_response_data =\n            value.extended_authorization_response_data.map(|data| {\n                ExtendedAuthorizationResponseData {\n                    capture_before: data\n                        .capture_before\n                        .and_then(|ts| time::OffsetDateTime::from_unix_timestamp(ts).ok())\n                        .map(|offset_dt| {\n                            time::PrimitiveDateTime::new(offset_dt.date(), offset_dt.time())\n                        }),\n                    extended_authentication_applied: data\n                        .extended_authentication_applied\n                        .map(ExtendedAuthorizationAppliedBool::from),\n                    extended_authorization_last_applied_at: None, // This field has to be added to UCS\n                }\n            });\n\n        let is_overcapture_enabled = value\n            .is_overcapture_enabled\n            .map(OvercaptureEnabledBool::new);\n\n        Ok(Self::new(\n            additional_payment_method_data,\n            is_overcapture_enabled,\n            extended_authorization_response_data,\n            None\n        ))\n    }\n}",
+      "after_code": "impl ForeignTryFrom<payments_grpc::ConnectorResponseData> for ConnectorResponseData {\n    type Error = error_stack::Report<UnifiedConnectorServiceError>;\n\n    fn foreign_try_from(value: payments_grpc::ConnectorResponseData) -> Result<Self, Self::Error> {\n        // Extract additional_payment_method_data\n        let additional_payment_method_data = value\n            .additional_payment_method_data\n            .map(AdditionalPaymentMethodConnectorResponse::foreign_try_from)\n            .transpose()?;\n\n        let extended_authorization_response_data =\n            value.extended_authorization_response_data.map(|data| {\n                ExtendedAuthorizationResponseData {\n                    capture_before: data\n                        .capture_before\n                        .and_then(|ts| time::OffsetDateTime::from_unix_timestamp(ts).ok())\n                        .map(|offset_dt| {\n                            time::PrimitiveDateTime::new(offset_dt.date(), offset_dt.time())\n                        }),\n                    extended_authentication_applied: data\n                        .extended_authentication_applied\n                        .map(ExtendedAuthorizationAppliedBool::from),\n                    extended_authorization_last_applied_at: None, // This field has to be added to UCS\n                }\n            });\n\n        let is_overcapture_enabled = value\n            .is_overcapture_enabled\n            .map(OvercaptureEnabledBool::new);\n\n        Ok(Self::new(\n            additional_payment_method_data,\n            is_overcapture_enabled,\n            extended_authorization_response_data,\n            None,\n        ))\n    }\n}",
+      "diff_span": {
+        "before": "            is_overcapture_enabled,\n            extended_authorization_response_data,\n            None\n        ))\n    }",
+        "after": "            is_overcapture_enabled,\n            extended_authorization_response_data,\n            None,\n        ))\n    }"
+      },
+      "commit_sha": "a3c3975922a5c7185f193f918c5257de70ded850"
+    }
+  ]
+}

diffs/pr_10112/a4dd18d/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "a4dd18df86508e2bf63630fcde9b0c77968da9bb",
+  "pr_number": 10112,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10112/b49fa6e/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "b49fa6e8e54cb8e39907cdc547a0542bedce7206",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::RefundsRouterData<RSync>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                let status = match response.data.payment_transaction.typename {\n                    TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,\n                    TesouroSyncStatus::DeclinedRefund\n                    | TesouroSyncStatus::DeclinedRefundAuthorization => {\n                        enums::RefundStatus::Failure\n                    }\n                    TesouroSyncStatus::GenericPaymentTransaction\n                    | TesouroSyncStatus::Refund\n                    | TesouroSyncStatus::RefundAuthorization\n                    | TesouroSyncStatus::ApprovedRefundAuthorization => {\n                        enums::RefundStatus::Pending\n                    }\n                    _ => {\n                        return Err(errors::ConnectorError::UnexpectedResponseError(\n                            bytes::Bytes::from(\"Invalid Status Received\".to_string()),\n                        )\n                        .into())\n                    }\n                };\n\n                if connector_utils::is_refund_failure(status) {\n                    let error_code = response\n                        .data\n                        .payment_transaction\n                        .processor_response_code\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    let error_message = response\n                        .data\n                        .payment_transaction\n                        .processor_response_message\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message.clone(),\n                            reason: Some(error_message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        response: Ok(RefundsResponseData {\n                            connector_refund_id: response.data.payment_transaction.id,\n                            refund_status: enums::RefundStatus::Success,\n                        }),\n                        ..item.data\n                    })\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "after_code": "fn try_from(\n        item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                let status = match response.data.payment_transaction.typename {\n                    TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,\n                    TesouroSyncStatus::DeclinedRefund\n                    | TesouroSyncStatus::DeclinedRefundAuthorization => {\n                        enums::RefundStatus::Failure\n                    }\n                    TesouroSyncStatus::GenericPaymentTransaction\n                    | TesouroSyncStatus::Refund\n                    | TesouroSyncStatus::RefundAuthorization\n                    | TesouroSyncStatus::ApprovedRefundAuthorization => {\n                        enums::RefundStatus::Pending\n                    }\n                    _ => {\n                        return Err(errors::ConnectorError::UnexpectedResponseError(\n                            bytes::Bytes::from(\"Invalid Status Received\".to_string()),\n                        )\n                        .into())\n                    }\n                };\n\n                if connector_utils::is_refund_failure(status) {\n                    let error_code = response\n                        .data\n                        .payment_transaction\n                        .processor_response_code\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    let error_message = response\n                        .data\n                        .payment_transaction\n                        .processor_response_message\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message.clone(),\n                            reason: Some(error_message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        response: Ok(RefundsResponseData {\n                            connector_refund_id: response.data.payment_transaction.id,\n                            refund_status: enums::RefundStatus::Success,\n                        }),\n                        ..item.data\n                    })\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data",
+        "after": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "b49fa6e8e54cb8e39907cdc547a0542bedce7206"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::impl::RefundsRouterData<RSync>",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<RefundsResponseRouterData<RSync, TesouroSyncResponse>> for RefundsRouterData<RSync> {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                let status = match response.data.payment_transaction.typename {\n                    TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,\n                    TesouroSyncStatus::DeclinedRefund\n                    | TesouroSyncStatus::DeclinedRefundAuthorization => {\n                        enums::RefundStatus::Failure\n                    }\n                    TesouroSyncStatus::GenericPaymentTransaction\n                    | TesouroSyncStatus::Refund\n                    | TesouroSyncStatus::RefundAuthorization\n                    | TesouroSyncStatus::ApprovedRefundAuthorization => {\n                        enums::RefundStatus::Pending\n                    }\n                    _ => {\n                        return Err(errors::ConnectorError::UnexpectedResponseError(\n                            bytes::Bytes::from(\"Invalid Status Received\".to_string()),\n                        )\n                        .into())\n                    }\n                };\n\n                if connector_utils::is_refund_failure(status) {\n                    let error_code = response\n                        .data\n                        .payment_transaction\n                        .processor_response_code\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    let error_message = response\n                        .data\n                        .payment_transaction\n                        .processor_response_message\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message.clone(),\n                            reason: Some(error_message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        response: Ok(RefundsResponseData {\n                            connector_refund_id: response.data.payment_transaction.id,\n                            refund_status: enums::RefundStatus::Success,\n                        }),\n                        ..item.data\n                    })\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "after_code": "impl TryFrom<RefundsResponseRouterData<RSync, TesouroSyncResponse>> for RefundsRouterData<RSync> {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: RefundsResponseRouterData<RSync, TesouroSyncResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                let status = match response.data.payment_transaction.typename {\n                    TesouroSyncStatus::ApprovedRefund => enums::RefundStatus::Success,\n                    TesouroSyncStatus::DeclinedRefund\n                    | TesouroSyncStatus::DeclinedRefundAuthorization => {\n                        enums::RefundStatus::Failure\n                    }\n                    TesouroSyncStatus::GenericPaymentTransaction\n                    | TesouroSyncStatus::Refund\n                    | TesouroSyncStatus::RefundAuthorization\n                    | TesouroSyncStatus::ApprovedRefundAuthorization => {\n                        enums::RefundStatus::Pending\n                    }\n                    _ => {\n                        return Err(errors::ConnectorError::UnexpectedResponseError(\n                            bytes::Bytes::from(\"Invalid Status Received\".to_string()),\n                        )\n                        .into())\n                    }\n                };\n\n                if connector_utils::is_refund_failure(status) {\n                    let error_code = response\n                        .data\n                        .payment_transaction\n                        .processor_response_code\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    let error_message = response\n                        .data\n                        .payment_transaction\n                        .processor_response_message\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message.clone(),\n                            reason: Some(error_message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        response: Ok(RefundsResponseData {\n                            connector_refund_id: response.data.payment_transaction.id,\n                            refund_status: enums::RefundStatus::Success,\n                        }),\n                        ..item.data\n                    })\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data",
+        "after": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "b49fa6e8e54cb8e39907cdc547a0542bedce7206"
+    }
+  ]
+}

diffs/pr_10112/c87e08a/diff.json

@@ -0,0 +1,81 @@
+{
+  "commit_sha": "c87e08a37f33bfd3ad32f63d972686a7e3c4a029",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+    "crates/router/src/core/payments/operations/payment_response.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::api_models::payments::AdditionalCardInfo::function::from",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn from(token_data: &AccountUpdaterCardTokenInfo) -> Self {\n        let card_exp_month = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.as_str().get(0..2).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        let card_exp_year = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.as_str().get(2..4).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        Self {\n            card_issuer: None,\n            card_network: token_data\n                .card_type\n                .clone()\n                .map(common_enums::CardNetwork::from),\n            card_type: None,\n            card_issuing_country: None,\n            bank_code: None,\n            last4: None,\n            card_isin: token_data.bin.clone(),\n            card_extended_bin: None,\n            card_exp_month,\n            card_exp_year,\n            card_holder_name: None,\n            payment_checks: None,\n            authentication_data: None,\n            is_regulated: None,\n            signature_network: None,\n        }\n    }",
+      "after_code": "fn from(token_data: &AccountUpdaterCardTokenInfo) -> Self {\n        let card_exp_month = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.peek().as_str().get(0..2).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        let card_exp_year = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.peek().as_str().get(2..4).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        Self {\n            card_issuer: None,\n            card_network: token_data\n                .card_type\n                .clone()\n                .map(common_enums::CardNetwork::from),\n            card_type: None,\n            card_issuing_country: None,\n            bank_code: None,\n            last4: None,\n            card_isin: token_data.bin.clone(),\n            card_extended_bin: None,\n            card_exp_month,\n            card_exp_year,\n            card_holder_name: None,\n            payment_checks: None,\n            authentication_data: None,\n            is_regulated: None,\n            signature_network: None,\n        }\n    }",
+      "diff_span": {
+        "before": "            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.as_str().get(0..2).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        let card_exp_year = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.as_str().get(2..4).map(|s| s.to_string()))\n            .map(Secret::new);\n",
+        "after": "            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.peek().as_str().get(0..2).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        let card_exp_year = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.peek().as_str().get(2..4).map(|s| s.to_string()))\n            .map(Secret::new);\n"
+      },
+      "commit_sha": "c87e08a37f33bfd3ad32f63d972686a7e3c4a029"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::impl::api_models::payments::AdditionalCardInfo",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl From<&AccountUpdaterCardTokenInfo> for api_models::payments::AdditionalCardInfo {\n    fn from(token_data: &AccountUpdaterCardTokenInfo) -> Self {\n        let card_exp_month = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.as_str().get(0..2).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        let card_exp_year = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.as_str().get(2..4).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        Self {\n            card_issuer: None,\n            card_network: token_data\n                .card_type\n                .clone()\n                .map(common_enums::CardNetwork::from),\n            card_type: None,\n            card_issuing_country: None,\n            bank_code: None,\n            last4: None,\n            card_isin: token_data.bin.clone(),\n            card_extended_bin: None,\n            card_exp_month,\n            card_exp_year,\n            card_holder_name: None,\n            payment_checks: None,\n            authentication_data: None,\n            is_regulated: None,\n            signature_network: None,\n        }\n    }\n}",
+      "after_code": "impl From<&AccountUpdaterCardTokenInfo> for api_models::payments::AdditionalCardInfo {\n    fn from(token_data: &AccountUpdaterCardTokenInfo) -> Self {\n        let card_exp_month = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.peek().as_str().get(0..2).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        let card_exp_year = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.peek().as_str().get(2..4).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        Self {\n            card_issuer: None,\n            card_network: token_data\n                .card_type\n                .clone()\n                .map(common_enums::CardNetwork::from),\n            card_type: None,\n            card_issuing_country: None,\n            bank_code: None,\n            last4: None,\n            card_isin: token_data.bin.clone(),\n            card_extended_bin: None,\n            card_exp_month,\n            card_exp_year,\n            card_holder_name: None,\n            payment_checks: None,\n            authentication_data: None,\n            is_regulated: None,\n            signature_network: None,\n        }\n    }\n}",
+      "diff_span": {
+        "before": "            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.as_str().get(0..2).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        let card_exp_year = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.as_str().get(2..4).map(|s| s.to_string()))\n            .map(Secret::new);\n",
+        "after": "            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.peek().as_str().get(0..2).map(|s| s.to_string()))\n            .map(Secret::new);\n\n        let card_exp_year = token_data\n            .exp_date\n            .as_ref()\n            .and_then(|exp_date| exp_date.peek().as_str().get(2..4).map(|s| s.to_string()))\n            .map(Secret::new);\n"
+      },
+      "commit_sha": "c87e08a37f33bfd3ad32f63d972686a7e3c4a029"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::struct::AccountUpdaterCardTokenInfoMetadata",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub struct AccountUpdaterCardTokenInfoMetadata {\n    pub exp_date: Option<String>,\n    #[serde(rename = \"type\")]\n    pub card_type: Option<String>,\n    pub bin: Option<String>,\n}",
+      "after_code": "pub struct AccountUpdaterCardTokenInfoMetadata {\n    pub exp_date: Option<Secret<String>>,\n    #[serde(rename = \"type\")]\n    pub card_type: Option<String>,\n    pub bin: Option<String>,\n}",
+      "diff_span": {
+        "before": "pub struct AccountUpdaterCardTokenInfoMetadata {\n    pub exp_date: Option<String>,\n    #[serde(rename = \"type\")]\n    pub card_type: Option<String>,",
+        "after": "pub struct AccountUpdaterCardTokenInfoMetadata {\n    pub exp_date: Option<Secret<String>>,\n    #[serde(rename = \"type\")]\n    pub card_type: Option<String>,"
+      },
+      "commit_sha": "c87e08a37f33bfd3ad32f63d972686a7e3c4a029",
+      "before_imports": [
+        "use common_utils::{\n    ext_traits::Encode,\n    pii,\n    types::{MinorUnit, StringMajorUnit, StringMinorUnitForConnector},\n};",
+        "use hyperswitch_domain_models::{\n    payment_method_data::PaymentMethodData,\n    router_data::{\n        AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,\n        ErrorResponse, RouterData,\n    },\n    router_flow_types::{\n        refunds::{Execute, RSync},\n        Dsync, Fetch, Retrieve, Upload,\n    },\n    router_request_types::{\n        DisputeSyncData, FetchDisputesRequestData, PaymentsAuthorizeData,\n        PaymentsCancelPostCaptureData, PaymentsSyncData, ResponseId, RetrieveFileRequestData,\n        SetupMandateRequestData, UploadFileRequestData,\n    },\n    router_response_types::{\n        DisputeSyncResponse, FetchDisputesResponse, MandateReference, PaymentsResponseData,\n        RefundsResponseData, RetrieveFileResponse, UploadFileResponse,\n    },\n    types::{\n        PaymentsAuthorizeRouterData, PaymentsCancelPostCaptureRouterData, PaymentsCancelRouterData,\n        PaymentsCaptureRouterData, RefundsRouterData, SetupMandateRouterData,\n    },\n};",
+        "use crate::{\n    types::{\n        AcceptDisputeRouterData, DisputeSyncRouterData, FetchDisputeRouterData,\n        PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,\n        RefundsResponseRouterData, ResponseRouterData, RetrieveFileRouterData,\n        SubmitEvidenceRouterData,\n    },\n    utils::{\n        self as connector_utils, CardData, PaymentsAuthorizeRequestData,\n        PaymentsSetupMandateRequestData, RouterData as UtilsRouterData,\n    },\n};"
+      ],
+      "after_imports": [
+        "use masking::{ExposeInterface, PeekInterface, Secret};",
+        "use common_utils::{\n    ext_traits::Encode,\n    pii,\n    types::{MinorUnit, StringMajorUnit, StringMinorUnitForConnector},\n};",
+        "use hyperswitch_domain_models::{\n    payment_method_data::PaymentMethodData,\n    router_data::{\n        AdditionalPaymentMethodConnectorResponse, ConnectorAuthType, ConnectorResponseData,\n        ErrorResponse, RouterData,\n    },\n    router_flow_types::{\n        refunds::{Execute, RSync},\n        Dsync, Fetch, Retrieve, Upload,\n    },\n    router_request_types::{\n        DisputeSyncData, FetchDisputesRequestData, PaymentsAuthorizeData,\n        PaymentsCancelPostCaptureData, PaymentsSyncData, ResponseId, RetrieveFileRequestData,\n        SetupMandateRequestData, UploadFileRequestData,\n    },\n    router_response_types::{\n        DisputeSyncResponse, FetchDisputesResponse, MandateReference, PaymentsResponseData,\n        RefundsResponseData, RetrieveFileResponse, UploadFileResponse,\n    },\n    types::{\n        PaymentsAuthorizeRouterData, PaymentsCancelPostCaptureRouterData, PaymentsCancelRouterData,\n        PaymentsCaptureRouterData, RefundsRouterData, SetupMandateRouterData,\n    },\n};",
+        "use crate::{\n    types::{\n        AcceptDisputeRouterData, DisputeSyncRouterData, FetchDisputeRouterData,\n        PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,\n        RefundsResponseRouterData, ResponseRouterData, RetrieveFileRouterData,\n        SubmitEvidenceRouterData,\n    },\n    utils::{\n        self as connector_utils, CardData, PaymentsAuthorizeRequestData,\n        PaymentsSetupMandateRequestData, RouterData as UtilsRouterData,\n    },\n};"
+      ]
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::struct::AccountUpdaterCardTokenInfo",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct AccountUpdaterCardTokenInfo {\n    pub cnp_token: Secret<String>,\n    pub exp_date: Option<String>,\n    #[serde(rename = \"type\")]\n    pub card_type: Option<WorldpayvativCardType>,\n    pub bin: Option<String>,\n}",
+      "after_code": "pub struct AccountUpdaterCardTokenInfo {\n    pub cnp_token: Secret<String>,\n    pub exp_date: Option<Secret<String>>,\n    #[serde(rename = \"type\")]\n    pub card_type: Option<WorldpayvativCardType>,\n    pub bin: Option<String>,\n}",
+      "diff_span": {
+        "before": "pub struct AccountUpdaterCardTokenInfo {\n    pub cnp_token: Secret<String>,\n    pub exp_date: Option<String>,\n    #[serde(rename = \"type\")]\n    pub card_type: Option<WorldpayvativCardType>,",
+        "after": "pub struct AccountUpdaterCardTokenInfo {\n    pub cnp_token: Secret<String>,\n    pub exp_date: Option<Secret<String>>,\n    #[serde(rename = \"type\")]\n    pub card_type: Option<WorldpayvativCardType>,"
+      },
+      "commit_sha": "c87e08a37f33bfd3ad32f63d972686a7e3c4a029"
+    }
+  ]
+}

diffs/pr_10112/cca4ee4/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "cca4ee455f5ffa7f1a165a123bc25c57242122a5",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::impl::RefundsRouterData<Execute>",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<RefundsResponseRouterData<Execute, TesouroRefundResponse>>\n    for RefundsRouterData<Execute>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(refund_previous_payment_response) = response\n                    .data\n                    .refund_previous_payment\n                    .refund_previous_payment_response\n                {\n                    let transaction_id = refund_previous_payment_response.transaction_id;\n                    match refund_previous_payment_response.type_name {\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {\n                            Ok(Self {\n                                response: Ok(RefundsResponseData {\n                                    connector_refund_id: transaction_id,\n                                    refund_status: enums::RefundStatus::Success,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {\n                            Ok(Self {\n                                response: Err(ErrorResponse {\n                                    code: refund_previous_payment_response\n                                        .decline_type\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_CODE.to_string()),\n                                    message: refund_previous_payment_response\n                                        .message\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                                    reason: refund_previous_payment_response.message.clone(),\n                                    status_code: item.http_code,\n                                    attempt_status: None,\n                                    connector_transaction_id: None,\n                                    network_advice_code: None,\n                                    network_decline_code: None,\n                                    network_error_message: None,\n                                    connector_metadata: None,\n                                    mandate_reference: None,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        None => Ok(Self {\n                            response: Ok(RefundsResponseData {\n                                connector_refund_id: transaction_id,\n                                refund_status: enums::RefundStatus::Pending,\n                            }),\n                            ..item.data\n                        }),\n                    }\n                } else if let Some(errors) = response.data.refund_previous_payment.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or refund_previous_payment_response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "after_code": "impl TryFrom<RefundsResponseRouterData<Execute, TesouroRefundResponse>>\n    for RefundsRouterData<Execute>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(refund_previous_payment_response) = response\n                    .data\n                    .refund_previous_payment\n                    .refund_previous_payment_response\n                {\n                    let transaction_id = refund_previous_payment_response.transaction_id;\n                    match refund_previous_payment_response.type_name {\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {\n                            Ok(Self {\n                                response: Ok(RefundsResponseData {\n                                    connector_refund_id: transaction_id,\n                                    refund_status: enums::RefundStatus::Success,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {\n                            Ok(Self {\n                                response: Err(ErrorResponse {\n                                    code: refund_previous_payment_response\n                                        .decline_type\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_CODE.to_string()),\n                                    message: refund_previous_payment_response\n                                        .message\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                                    reason: refund_previous_payment_response.message.clone(),\n                                    status_code: item.http_code,\n                                    attempt_status: None,\n                                    connector_transaction_id: None,\n                                    network_advice_code: None,\n                                    network_decline_code: None,\n                                    network_error_message: None,\n                                    connector_metadata: None,\n                                    mandate_reference: None,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        None => Ok(Self {\n                            response: Ok(RefundsResponseData {\n                                connector_refund_id: transaction_id,\n                                refund_status: enums::RefundStatus::Pending,\n                            }),\n                            ..item.data\n                        }),\n                    }\n                } else if let Some(errors) = response.data.refund_previous_payment.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or refund_previous_payment_response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data",
+        "after": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "cca4ee455f5ffa7f1a165a123bc25c57242122a5"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs::RefundsRouterData<Execute>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/tesouro/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(refund_previous_payment_response) = response\n                    .data\n                    .refund_previous_payment\n                    .refund_previous_payment_response\n                {\n                    let transaction_id = refund_previous_payment_response.transaction_id;\n                    match refund_previous_payment_response.type_name {\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {\n                            Ok(Self {\n                                response: Ok(RefundsResponseData {\n                                    connector_refund_id: transaction_id,\n                                    refund_status: enums::RefundStatus::Success,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {\n                            Ok(Self {\n                                response: Err(ErrorResponse {\n                                    code: refund_previous_payment_response\n                                        .decline_type\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_CODE.to_string()),\n                                    message: refund_previous_payment_response\n                                        .message\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                                    reason: refund_previous_payment_response.message.clone(),\n                                    status_code: item.http_code,\n                                    attempt_status: None,\n                                    connector_transaction_id: None,\n                                    network_advice_code: None,\n                                    network_decline_code: None,\n                                    network_error_message: None,\n                                    connector_metadata: None,\n                                    mandate_reference: None,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        None => Ok(Self {\n                            response: Ok(RefundsResponseData {\n                                connector_refund_id: transaction_id,\n                                refund_status: enums::RefundStatus::Pending,\n                            }),\n                            ..item.data\n                        }),\n                    }\n                } else if let Some(errors) = response.data.refund_previous_payment.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or refund_previous_payment_response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "after_code": "fn try_from(\n        item: RefundsResponseRouterData<Execute, TesouroRefundResponse>,\n    ) -> Result<Self, Self::Error> {\n        match item.response {\n            TesouroApiResponse::TesouroApiSuccessResponse(response) => {\n                if let Some(refund_previous_payment_response) = response\n                    .data\n                    .refund_previous_payment\n                    .refund_previous_payment_response\n                {\n                    let transaction_id = refund_previous_payment_response.transaction_id;\n                    match refund_previous_payment_response.type_name {\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentApproval) => {\n                            Ok(Self {\n                                response: Ok(RefundsResponseData {\n                                    connector_refund_id: transaction_id,\n                                    refund_status: enums::RefundStatus::Success,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        Some(RefundTransactionResponseType::RefundPreviousPaymentDecline) => {\n                            Ok(Self {\n                                response: Err(ErrorResponse {\n                                    code: refund_previous_payment_response\n                                        .decline_type\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_CODE.to_string()),\n                                    message: refund_previous_payment_response\n                                        .message\n                                        .clone()\n                                        .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                                    reason: refund_previous_payment_response.message.clone(),\n                                    status_code: item.http_code,\n                                    attempt_status: None,\n                                    connector_transaction_id: None,\n                                    network_advice_code: None,\n                                    network_decline_code: None,\n                                    network_error_message: None,\n                                    connector_metadata: None,\n                                    mandate_reference: None,\n                                }),\n                                ..item.data\n                            })\n                        }\n                        None => Ok(Self {\n                            response: Ok(RefundsResponseData {\n                                connector_refund_id: transaction_id,\n                                refund_status: enums::RefundStatus::Pending,\n                            }),\n                            ..item.data\n                        }),\n                    }\n                } else if let Some(errors) = response.data.refund_previous_payment.errors {\n                    let error_response = errors.first();\n                    let error_code = error_response\n                        .as_ref()\n                        .and_then(|error_data| error_data.processor_response_code.clone())\n                        .unwrap_or(NO_ERROR_CODE.to_string());\n                    let error_message = error_response\n                        .as_ref()\n                        .map(|error_data| error_data.message.clone());\n\n                    Ok(Self {\n                        response: Err(ErrorResponse {\n                            code: error_code.clone(),\n                            message: error_message\n                                .clone()\n                                .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                            reason: error_message.clone(),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: None,\n                            network_advice_code: None,\n                            network_decline_code: None,\n                            network_error_message: None,\n                            connector_metadata: None,\n                            mandate_reference: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    Err(errors::ConnectorError::UnexpectedResponseError(\n                        bytes::Bytes::from(\n                            \"Expected either error or refund_previous_payment_response\".to_string(),\n                        ),\n                    ))?\n                }\n            }\n            TesouroApiResponse::TesouroErrorResponse(error_response) => {\n                let message = error_response\n                    .errors\n                    .iter()\n                    .map(|error| error.message.to_string())\n                    .collect::<Vec<String>>();\n\n                let error_message = match !message.is_empty() {\n                    true => Some(message.join(\" \")),\n                    false => None,\n                };\n                Ok(Self {\n                    response: Err(ErrorResponse {\n                        code: NO_ERROR_CODE.to_string(),\n                        message: error_message\n                            .clone()\n                            .unwrap_or(NO_ERROR_MESSAGE.to_string()),\n                        reason: error_message.clone(),\n                        status_code: item.http_code,\n                        attempt_status: None,\n                        connector_transaction_id: None,\n                        network_advice_code: None,\n                        network_decline_code: None,\n                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data\n                })\n            }\n        }\n    }",
+      "diff_span": {
+        "before": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None\n                    }),\n                    ..item.data",
+        "after": "                        network_error_message: None,\n                        connector_metadata: None,\n                        mandate_reference: None,\n                    }),\n                    ..item.data"
+      },
+      "commit_sha": "cca4ee455f5ffa7f1a165a123bc25c57242122a5"
+    }
+  ]
+}

diffs/pr_10112/dd02f99/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "dd02f99af531de5b4ce87e265efae7c50566a6ea",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/router/src/types/storage/revenue_recovery_redis_operation.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs::AccountUpdaterAction::function::handle_account_updater_action",
+      "file": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn handle_account_updater_action(\n        &self,\n        state: &SessionState,\n        customer_id: &str,\n        account_updater_action: &Self,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        attempt_id : &id_type::GlobalAttemptId,\n    ) -> CustomResult<(), errors::StorageError>\n    {\n        match account_updater_action {\n            Self::TokenUpdate(new_token, additional_card_info) => {\n                logger::info!(\n                    \"Handling TokenUpdate action with new token\"\n                );\n                // Implement token update logic here using additional_card_info if needed\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.is_active = Some(false);\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n\n                println!(\"updated_token: {:?}\", updated_token);\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                );\n\n                logger::info!(\"Successfully deactivated old token.\");\n\n                let new_token  =  PaymentProcessorTokenStatus {\n                    payment_processor_token_details: PaymentProcessorTokenDetails {\n                        payment_processor_token: new_token.to_owned(),\n                        expiry_month: additional_card_info.card_exp_month.clone(),\n                        expiry_year: additional_card_info.card_exp_year.clone(),\n                        card_issuer: additional_card_info.card_issuer.clone(),\n                        last_four_digits: additional_card_info.last4.clone(),\n                        card_type: additional_card_info.card_type.clone(),\n                        card_network: additional_card_info.card_network.clone(),\n                    },\n                    inserted_by_attempt_id: attempt_id.to_owned(),\n                    error_code: None,\n                    daily_retry_history: HashMap::new(),\n                    scheduled_at: None,\n                    is_hard_decline: Some(false),\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: Some(true),\n                    account_update_history: None,\n                };\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    new_token,\n                ).await?;\n                logger::info!(\"Successfully updated token with new token information.\")\n            }\n            Self::ExpiryUpdate(additional_card_info) => {\n                logger::info!(\"Handling ExpiryUpdate action\");\n                // Implement expiry update logic here using additional_card_info\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.payment_processor_token_details.expiry_month =\n                    additional_card_info.card_exp_month.clone();\n                updated_token.payment_processor_token_details.expiry_year =\n                    additional_card_info.card_exp_year.clone();\n\n                let _ = RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                ).await?;\n\n                logger::info!(\"Successfully updated token expiry information.\")\n            }\n            Self::ExistingToken => {\n                logger::info!(\"Handling ExistingToken action - no changes needed\");\n                // No action needed for existing token\n            }\n            Self::NoAction => {\n                logger::info!(\"No action to be taken for NoAction case\");\n                // No action needed\n            }\n        };\n\n        Ok(())\n    }",
+      "after_code": "async fn handle_account_updater_action(\n        &self,\n        state: &SessionState,\n        customer_id: &str,\n        account_updater_action: &Self,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        attempt_id : &id_type::GlobalAttemptId,\n    ) -> CustomResult<(), errors::StorageError>\n    {\n        match account_updater_action {\n            Self::TokenUpdate(new_token, additional_card_info) => {\n                logger::info!(\n                    \"Handling TokenUpdate action with new token\"\n                );\n                // Implement token update logic here using additional_card_info if needed\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.is_active = Some(false);\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                ).await?;\n\n                logger::info!(\"Successfully deactivated old token.\");\n\n                let new_token  =  PaymentProcessorTokenStatus {\n                    payment_processor_token_details: PaymentProcessorTokenDetails {\n                        payment_processor_token: new_token.to_owned(),\n                        expiry_month: additional_card_info.card_exp_month.clone(),\n                        expiry_year: additional_card_info.card_exp_year.clone(),\n                        card_issuer: additional_card_info.card_issuer.clone(),\n                        last_four_digits: additional_card_info.last4.clone(),\n                        card_type: additional_card_info.card_type.clone(),\n                        card_network: additional_card_info.card_network.clone(),\n                    },\n                    inserted_by_attempt_id: attempt_id.to_owned(),\n                    error_code: None,\n                    daily_retry_history: HashMap::new(),\n                    scheduled_at: None,\n                    is_hard_decline: Some(false),\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: Some(true),\n                    account_update_history: None,\n                };\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    new_token,\n                ).await?;\n                logger::info!(\"Successfully updated token with new token information.\")\n            }\n            Self::ExpiryUpdate(additional_card_info) => {\n                logger::info!(\"Handling ExpiryUpdate action\");\n                // Implement expiry update logic here using additional_card_info\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.payment_processor_token_details.expiry_month =\n                    additional_card_info.card_exp_month.clone();\n                updated_token.payment_processor_token_details.expiry_year =\n                    additional_card_info.card_exp_year.clone();\n\n                let _ = RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                ).await?;\n\n                logger::info!(\"Successfully updated token expiry information.\")\n            }\n            Self::ExistingToken => {\n                logger::info!(\"Handling ExistingToken action - no changes needed\");\n                // No action needed for existing token\n            }\n            Self::NoAction => {\n                logger::info!(\"No action to be taken for NoAction case\");\n                // No action needed\n            }\n        };\n\n        Ok(())\n    }",
+      "diff_span": {
+        "before": "                ));\n\n                println!(\"updated_token: {:?}\", updated_token);\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                );\n\n                logger::info!(\"Successfully deactivated old token.\");",
+        "after": "                    customer_id,\n                    updated_token,\n                ).await?;\n\n                logger::info!(\"Successfully deactivated old token.\");"
+      },
+      "commit_sha": "dd02f99af531de5b4ce87e265efae7c50566a6ea"
+    },
+    {
+      "id": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs::impl::AccountUpdaterAction",
+      "file": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl AccountUpdaterAction {\n    async fn handle_account_updater_action(\n        &self,\n        state: &SessionState,\n        customer_id: &str,\n        account_updater_action: &Self,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        attempt_id : &id_type::GlobalAttemptId,\n    ) -> CustomResult<(), errors::StorageError>\n    {\n        match account_updater_action {\n            Self::TokenUpdate(new_token, additional_card_info) => {\n                logger::info!(\n                    \"Handling TokenUpdate action with new token\"\n                );\n                // Implement token update logic here using additional_card_info if needed\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.is_active = Some(false);\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n\n                println!(\"updated_token: {:?}\", updated_token);\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                );\n\n                logger::info!(\"Successfully deactivated old token.\");\n\n                let new_token  =  PaymentProcessorTokenStatus {\n                    payment_processor_token_details: PaymentProcessorTokenDetails {\n                        payment_processor_token: new_token.to_owned(),\n                        expiry_month: additional_card_info.card_exp_month.clone(),\n                        expiry_year: additional_card_info.card_exp_year.clone(),\n                        card_issuer: additional_card_info.card_issuer.clone(),\n                        last_four_digits: additional_card_info.last4.clone(),\n                        card_type: additional_card_info.card_type.clone(),\n                        card_network: additional_card_info.card_network.clone(),\n                    },\n                    inserted_by_attempt_id: attempt_id.to_owned(),\n                    error_code: None,\n                    daily_retry_history: HashMap::new(),\n                    scheduled_at: None,\n                    is_hard_decline: Some(false),\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: Some(true),\n                    account_update_history: None,\n                };\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    new_token,\n                ).await?;\n                logger::info!(\"Successfully updated token with new token information.\")\n            }\n            Self::ExpiryUpdate(additional_card_info) => {\n                logger::info!(\"Handling ExpiryUpdate action\");\n                // Implement expiry update logic here using additional_card_info\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.payment_processor_token_details.expiry_month =\n                    additional_card_info.card_exp_month.clone();\n                updated_token.payment_processor_token_details.expiry_year =\n                    additional_card_info.card_exp_year.clone();\n\n                let _ = RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                ).await?;\n\n                logger::info!(\"Successfully updated token expiry information.\")\n            }\n            Self::ExistingToken => {\n                logger::info!(\"Handling ExistingToken action - no changes needed\");\n                // No action needed for existing token\n            }\n            Self::NoAction => {\n                logger::info!(\"No action to be taken for NoAction case\");\n                // No action needed\n            }\n        };\n\n        Ok(())\n    }\n}",
+      "after_code": "impl AccountUpdaterAction {\n    async fn handle_account_updater_action(\n        &self,\n        state: &SessionState,\n        customer_id: &str,\n        account_updater_action: &Self,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        attempt_id : &id_type::GlobalAttemptId,\n    ) -> CustomResult<(), errors::StorageError>\n    {\n        match account_updater_action {\n            Self::TokenUpdate(new_token, additional_card_info) => {\n                logger::info!(\n                    \"Handling TokenUpdate action with new token\"\n                );\n                // Implement token update logic here using additional_card_info if needed\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.is_active = Some(false);\n                updated_token.modified_at = Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                ));\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                ).await?;\n\n                logger::info!(\"Successfully deactivated old token.\");\n\n                let new_token  =  PaymentProcessorTokenStatus {\n                    payment_processor_token_details: PaymentProcessorTokenDetails {\n                        payment_processor_token: new_token.to_owned(),\n                        expiry_month: additional_card_info.card_exp_month.clone(),\n                        expiry_year: additional_card_info.card_exp_year.clone(),\n                        card_issuer: additional_card_info.card_issuer.clone(),\n                        last_four_digits: additional_card_info.last4.clone(),\n                        card_type: additional_card_info.card_type.clone(),\n                        card_network: additional_card_info.card_network.clone(),\n                    },\n                    inserted_by_attempt_id: attempt_id.to_owned(),\n                    error_code: None,\n                    daily_retry_history: HashMap::new(),\n                    scheduled_at: None,\n                    is_hard_decline: Some(false),\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: Some(true),\n                    account_update_history: None,\n                };\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    new_token,\n                ).await?;\n                logger::info!(\"Successfully updated token with new token information.\")\n            }\n            Self::ExpiryUpdate(additional_card_info) => {\n                logger::info!(\"Handling ExpiryUpdate action\");\n                // Implement expiry update logic here using additional_card_info\n\n                let mut updated_token = scheduled_token.clone();\n                updated_token.payment_processor_token_details.expiry_month =\n                    additional_card_info.card_exp_month.clone();\n                updated_token.payment_processor_token_details.expiry_year =\n                    additional_card_info.card_exp_year.clone();\n\n                let _ = RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                ).await?;\n\n                logger::info!(\"Successfully updated token expiry information.\")\n            }\n            Self::ExistingToken => {\n                logger::info!(\"Handling ExistingToken action - no changes needed\");\n                // No action needed for existing token\n            }\n            Self::NoAction => {\n                logger::info!(\"No action to be taken for NoAction case\");\n                // No action needed\n            }\n        };\n\n        Ok(())\n    }\n}",
+      "diff_span": {
+        "before": "                ));\n\n                println!(\"updated_token: {:?}\", updated_token);\n\n                RedisTokenManager::upsert_payment_processor_token(\n                    state,\n                    customer_id,\n                    updated_token,\n                );\n\n                logger::info!(\"Successfully deactivated old token.\");",
+        "after": "                    customer_id,\n                    updated_token,\n                ).await?;\n\n                logger::info!(\"Successfully deactivated old token.\");"
+      },
+      "commit_sha": "dd02f99af531de5b4ce87e265efae7c50566a6ea"
+    }
+  ]
+}

diffs/pr_10112/e2383f4/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "e2383f4ea26f5108df81d36c2d8d651d6b1cee34",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/router/src/types/storage/revenue_recovery_redis_operation.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs::impl::RedisTokenManager",
+      "file": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl RedisTokenManager {\n    fn get_connector_customer_lock_key(connector_customer_id: &str) -> String {\n        format!(\"customer:{connector_customer_id}:status\")\n    }\n\n    fn get_connector_customer_tokens_key(connector_customer_id: &str) -> String {\n        format!(\"customer:{connector_customer_id}:tokens\")\n    }\n\n    /// Lock connector customer\n    #[instrument(skip_all)]\n    pub async fn lock_connector_customer_status(\n        state: &SessionState,\n        connector_customer_id: &str,\n        payment_id: &id_type::GlobalPaymentId,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n\n        let lock_key = Self::get_connector_customer_lock_key(connector_customer_id);\n        let seconds = &state.conf.revenue_recovery.redis_ttl_in_seconds;\n\n        let result: bool = match redis_conn\n            .set_key_if_not_exists_with_expiry(\n                &lock_key.into(),\n                payment_id.get_string_repr(),\n                Some(*seconds),\n            )\n            .await\n        {\n            Ok(resp) => resp == SetnxReply::KeySet,\n            Err(error) => {\n                tracing::error!(operation = \"lock_stream\", err = ?error);\n                false\n            }\n        };\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            payment_id = payment_id.get_string_repr(),\n            lock_acquired = %result,\n            \"Connector customer lock attempt\"\n        );\n\n        Ok(result)\n    }\n    #[instrument(skip_all)]\n    pub async fn update_connector_customer_lock_ttl(\n        state: &SessionState,\n        connector_customer_id: &str,\n        exp_in_seconds: i64,\n    ) -> CustomResult<(), errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n\n        let lock_key = Self::get_connector_customer_lock_key(connector_customer_id);\n\n        let result: bool = redis_conn\n            .set_expiry(&lock_key.clone().into(), exp_in_seconds)\n            .await\n            .map_or_else(\n                |error| {\n                    tracing::error!(operation = \"update_lock_ttl\", err = ?error);\n                    false\n                },\n                |_| true,\n            );\n\n        if result {\n            tracing::debug!(\n                lock_key = %lock_key,\n                new_ttl_in_seconds = exp_in_seconds,\n                \"Redis key TTL updated successfully\"\n            );\n        } else {\n            tracing::error!(\n                lock_key = %lock_key,\n                \"Failed to update TTL: key not found or error occurred\"\n            );\n        }\n\n        Ok(())\n    }\n\n    /// Unlock connector customer status\n    #[instrument(skip_all)]\n    pub async fn unlock_connector_customer_status(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n\n        let lock_key = Self::get_connector_customer_lock_key(connector_customer_id);\n\n        match redis_conn.delete_key(&lock_key.into()).await {\n            Ok(DelReply::KeyDeleted) => {\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"Connector customer unlocked\"\n                );\n                Ok(true)\n            }\n            Ok(DelReply::KeyNotDeleted) => {\n                tracing::debug!(\"Tried to unlock a stream which is already unlocked\");\n                Ok(false)\n            }\n            Err(err) => {\n                tracing::error!(?err, \"Failed to delete lock key\");\n                Ok(false)\n            }\n        }\n    }\n\n    /// Get all payment processor tokens for a connector customer\n    #[instrument(skip_all)]\n    pub async fn get_connector_customer_payment_processor_tokens(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<HashMap<String, PaymentProcessorTokenStatus>, errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n        let tokens_key = Self::get_connector_customer_tokens_key(connector_customer_id);\n\n        let get_hash_err =\n            errors::StorageError::RedisError(errors::RedisError::GetHashFieldFailed.into());\n\n        let payment_processor_tokens: HashMap<String, String> = redis_conn\n            .get_hash_fields(&tokens_key.into())\n            .await\n            .change_context(get_hash_err)?;\n\n        let payment_processor_token_info_map: HashMap<String, PaymentProcessorTokenStatus> =\n            payment_processor_tokens\n                .into_iter()\n                .filter_map(|(token_id, token_data)| {\n                    match serde_json::from_str::<PaymentProcessorTokenStatus>(&token_data) {\n                        Ok(token_status) => Some((token_id, token_status)),\n                        Err(err) => {\n                            tracing::warn!(\n                                connector_customer_id = %connector_customer_id,\n                                token_id = %token_id,\n                                error = %err,\n                                \"Failed to deserialize token data, skipping\",\n                            );\n                            None\n                        }\n                    }\n                })\n                .collect();\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Fetched payment processor tokens\",\n        );\n\n        Ok(payment_processor_token_info_map)\n    }\n\n    /// Update connector customer payment processor tokens or add if doesn't exist\n    #[instrument(skip_all)]\n    pub async fn update_or_add_connector_customer_payment_processor_tokens(\n        state: &SessionState,\n        connector_customer_id: &str,\n        payment_processor_token_info_map: HashMap<String, PaymentProcessorTokenStatus>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n        let tokens_key = Self::get_connector_customer_tokens_key(connector_customer_id);\n\n        // allocate capacity up-front to avoid rehashing\n        let mut serialized_payment_processor_tokens: HashMap<String, String> =\n            HashMap::with_capacity(payment_processor_token_info_map.len());\n\n        // serialize all tokens, preserving explicit error handling and attachable diagnostics\n        for (payment_processor_token_id, payment_processor_token_status) in\n            payment_processor_token_info_map\n        {\n            let serialized = serde_json::to_string(&payment_processor_token_status)\n                .change_context(errors::StorageError::SerializationFailed)\n                .attach_printable(\"Failed to serialize token status\")?;\n\n            serialized_payment_processor_tokens.insert(payment_processor_token_id, serialized);\n        }\n        let seconds = &state.conf.revenue_recovery.redis_ttl_in_seconds;\n\n        // Update or add tokens\n        redis_conn\n            .set_hash_fields(\n                &tokens_key.into(),\n                serialized_payment_processor_tokens,\n                Some(*seconds),\n            )\n            .await\n            .change_context(errors::StorageError::RedisError(\n                errors::RedisError::SetHashFieldFailed.into(),\n            ))?;\n\n        tracing::info!(\n            connector_customer_id = %connector_customer_id,\n            \"Successfully updated or added customer tokens\",\n        );\n\n        Ok(())\n    }\n\n    /// Get current date in `yyyy-mm-dd` format.\n    pub fn get_current_date() -> String {\n        let today = date_time::now().date();\n\n        let (year, month, day) = (today.year(), today.month(), today.day());\n\n        format!(\"{year:04}-{month:02}-{day:02}\",)\n    }\n\n    /// Normalize retry window to exactly `RETRY_WINDOW_DAYS` days (today to `RETRY_WINDOW_DAYS - 1` days ago).\n    pub fn normalize_retry_window(\n        payment_processor_token: &mut PaymentProcessorTokenStatus,\n        today: Date,\n    ) {\n        let mut normalized_retry_history: HashMap<Date, i32> = HashMap::new();\n\n        for days_ago in 0..RETRY_WINDOW_DAYS {\n            let date = today - Duration::days(days_ago.into());\n\n            payment_processor_token\n                .daily_retry_history\n                .get(&date)\n                .map(|&retry_count| {\n                    normalized_retry_history.insert(date, retry_count);\n                });\n        }\n\n        payment_processor_token.daily_retry_history = normalized_retry_history;\n    }\n\n    /// Get all payment processor tokens with retry information and wait times.\n    pub fn get_tokens_with_retry_metadata(\n        state: &SessionState,\n        payment_processor_token_info_map: &HashMap<String, PaymentProcessorTokenStatus>,\n    ) -> HashMap<String, PaymentProcessorTokenWithRetryInfo> {\n        let today = OffsetDateTime::now_utc().date();\n        let card_config = &state.conf.revenue_recovery.card_config;\n\n        let mut result: HashMap<String, PaymentProcessorTokenWithRetryInfo> =\n            HashMap::with_capacity(payment_processor_token_info_map.len());\n\n        for (payment_processor_token_id, payment_processor_token_status) in\n            payment_processor_token_info_map.iter()\n        {\n            let card_network = payment_processor_token_status\n                .payment_processor_token_details\n                .card_network\n                .clone();\n\n            // Calculate retry information.\n            let retry_info = Self::payment_processor_token_retry_info(\n                state,\n                payment_processor_token_status,\n                today,\n                card_network.clone(),\n            );\n\n            // Determine the wait time (max of monthly and daily wait hours).\n            let retry_wait_time_hours = retry_info\n                .monthly_wait_hours\n                .max(retry_info.daily_wait_hours);\n\n            // Obtain network-specific limits and compute remaining monthly retries.\n            let card_network_config = card_config.get_network_config(card_network);\n\n            let monthly_retry_remaining = std::cmp::max(\n                0,\n                card_network_config.max_retry_count_for_thirty_day\n                    - retry_info.total_30_day_retries,\n            );\n\n            // Build the per-token result struct.\n            let token_with_retry_info = PaymentProcessorTokenWithRetryInfo {\n                token_status: payment_processor_token_status.clone(),\n                retry_wait_time_hours,\n                monthly_retry_remaining,\n                total_30_day_retries: retry_info.total_30_day_retries,\n            };\n\n            result.insert(payment_processor_token_id.clone(), token_with_retry_info);\n        }\n        tracing::debug!(\"Fetched payment processor tokens with retry metadata\",);\n\n        result\n    }\n\n    /// Sum retries over exactly the last 30 days\n    fn calculate_total_30_day_retries(token: &PaymentProcessorTokenStatus, today: Date) -> i32 {\n        (0..RETRY_WINDOW_DAYS)\n            .map(|i| {\n                let date = today - Duration::days(i.into());\n                token\n                    .daily_retry_history\n                    .get(&date)\n                    .copied()\n                    .unwrap_or(INITIAL_RETRY_COUNT)\n            })\n            .sum()\n    }\n\n    /// Calculate wait hours\n    fn calculate_wait_hours(target_date: Date, now: OffsetDateTime) -> i64 {\n        let expiry_time = target_date.midnight().assume_utc();\n        (expiry_time - now).whole_hours().max(0)\n    }\n\n    /// Calculate retry counts for exactly the last 30 days\n    pub fn payment_processor_token_retry_info(\n        state: &SessionState,\n        token: &PaymentProcessorTokenStatus,\n        today: Date,\n        network_type: Option<CardNetwork>,\n    ) -> TokenRetryInfo {\n        let card_config = &state.conf.revenue_recovery.card_config;\n        let card_network_config = card_config.get_network_config(network_type);\n\n        let now = OffsetDateTime::now_utc();\n\n        let total_30_day_retries = Self::calculate_total_30_day_retries(token, today);\n\n        let monthly_wait_hours =\n            if total_30_day_retries >= card_network_config.max_retry_count_for_thirty_day {\n                let mut accumulated_retries = 0;\n\n                // Iterate from most recent to oldest\n                (0..RETRY_WINDOW_DAYS)\n                    .map(|days_ago| today - Duration::days(days_ago.into()))\n                    .find(|date| {\n                        let retries = token.daily_retry_history.get(date).copied().unwrap_or(0);\n                        accumulated_retries += retries;\n                        accumulated_retries >= card_network_config.max_retry_count_for_thirty_day\n                    })\n                    .map(|breach_date| {\n                        Self::calculate_wait_hours(breach_date + Duration::days(31), now)\n                    })\n                    .unwrap_or(0)\n            } else {\n                0\n            };\n\n        let today_retries = token\n            .daily_retry_history\n            .get(&today)\n            .copied()\n            .unwrap_or(INITIAL_RETRY_COUNT);\n\n        let daily_wait_hours = if today_retries >= card_network_config.max_retries_per_day {\n            Self::calculate_wait_hours(today + Duration::days(1), now)\n        } else {\n            0\n        };\n\n        TokenRetryInfo {\n            monthly_wait_hours,\n            daily_wait_hours,\n            total_30_day_retries,\n        }\n    }\n\n    // Upsert payment processor token\n    #[instrument(skip_all)]\n    pub async fn upsert_payment_processor_token(\n        state: &SessionState,\n        connector_customer_id: &str,\n        token_data: PaymentProcessorTokenStatus,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let mut token_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n\n        let token_id = token_data\n            .payment_processor_token_details\n            .payment_processor_token\n            .clone();\n\n        let was_existing = token_map.contains_key(&token_id);\n\n        let error_code = token_data.error_code.clone();\n\n        let last_external_attempt_at = token_data.modified_at;\n\n        let today = OffsetDateTime::now_utc().date();\n\n        token_map\n            .get_mut(&token_id)\n            .map(|existing_token| {\n                Self::normalize_retry_window(existing_token, today);\n\n                for (date, &value) in &token_data.daily_retry_history {\n                    existing_token\n                        .daily_retry_history\n                        .entry(*date)\n                        .and_modify(|v| *v += value)\n                        .or_insert(value);\n                }\n\n                existing_token\n                    .modified_at\n                    .zip(last_external_attempt_at)\n                    .and_then(|(existing_token_modified_at, last_external_attempt_at)| {\n                        (last_external_attempt_at > existing_token_modified_at)\n                            .then_some(last_external_attempt_at)\n                    })\n                    .or_else(|| {\n                        existing_token\n                            .modified_at\n                            .is_none()\n                            .then_some(last_external_attempt_at)\n                            .flatten()\n                    })\n                    .map(|last_external_attempt_at| {\n                        existing_token.modified_at = Some(last_external_attempt_at);\n                        existing_token.error_code = error_code;\n                        existing_token.is_hard_decline = token_data.is_hard_decline;\n                        token_data\n                            .is_active\n                            .map(|is_active| existing_token.is_active = Some(is_active));\n                    });\n            })\n            .or_else(|| {\n                token_map.insert(token_id.clone(), token_data);\n                None\n            });\n\n        Self::update_or_add_connector_customer_payment_processor_tokens(\n            state,\n            connector_customer_id,\n            token_map,\n        )\n        .await?;\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Upsert payment processor tokens\",\n        );\n\n        Ok(!was_existing)\n    }\n\n    // Update payment processor token error code with billing connector response\n    #[instrument(skip_all)]\n    pub async fn update_payment_processor_token_error_code_from_process_tracker(\n        state: &SessionState,\n        connector_customer_id: &str,\n        error_code: &Option<String>,\n        is_hard_decline: &Option<bool>,\n        payment_processor_token_id: Option<&str>,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let today = OffsetDateTime::now_utc().date();\n        let updated_token = match payment_processor_token_id {\n            Some(token_id) => {\n                Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                    .await?\n                    .values()\n                    .find(|status| {\n                        status\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            == token_id\n                    })\n                    .map(|status| PaymentProcessorTokenStatus {\n                        payment_processor_token_details: status\n                            .payment_processor_token_details\n                            .clone(),\n                        inserted_by_attempt_id: status.inserted_by_attempt_id.clone(),\n                        error_code: error_code.clone(),\n                        daily_retry_history: status.daily_retry_history.clone(),\n                        scheduled_at: None,\n                        is_hard_decline: *is_hard_decline,\n                        modified_at: Some(PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        )),\n                        is_active: status.is_active,\n                        account_update_history: status.account_update_history.clone(),\n                    })\n            }\n            None => None,\n        };\n\n        match updated_token {\n            Some(mut token) => {\n                Self::normalize_retry_window(&mut token, today);\n\n                match token.error_code {\n                    None => token.daily_retry_history.clear(),\n                    Some(_) => {\n                        let current_count = token\n                            .daily_retry_history\n                            .get(&today)\n                            .copied()\n                            .unwrap_or(INITIAL_RETRY_COUNT);\n                        token.daily_retry_history.insert(today, current_count + 1);\n                    }\n                }\n\n                let mut tokens_map = HashMap::new();\n                tokens_map.insert(\n                    token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    token.clone(),\n                );\n\n                Self::update_or_add_connector_customer_payment_processor_tokens(\n                    state,\n                    connector_customer_id,\n                    tokens_map,\n                )\n                .await?;\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"Updated payment processor tokens with error code\",\n                );\n                Ok(true)\n            }\n            None => {\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"No Token found with token id to update error code\",\n                );\n                Ok(false)\n            }\n        }\n    }\n\n    // Update all payment processor token schedule time to None\n    #[instrument(skip_all)]\n    pub async fn update_payment_processor_tokens_schedule_time_to_none(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<(), errors::StorageError> {\n        let tokens_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n\n        let mut updated_tokens_map = HashMap::new();\n\n        for (token_id, status) in tokens_map {\n            let updated_status = PaymentProcessorTokenStatus {\n                payment_processor_token_details: status.payment_processor_token_details.clone(),\n                inserted_by_attempt_id: status.inserted_by_attempt_id.clone(),\n                error_code: status.error_code.clone(),\n                daily_retry_history: status.daily_retry_history.clone(),\n                scheduled_at: None,\n                is_hard_decline: status.is_hard_decline,\n                modified_at: Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                )),\n                is_active: status.is_active,\n                account_update_history: status.account_update_history.clone(),\n            };\n            updated_tokens_map.insert(token_id, updated_status);\n        }\n\n        Self::update_or_add_connector_customer_payment_processor_tokens(\n            state,\n            connector_customer_id,\n            updated_tokens_map,\n        )\n        .await?;\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Updated all payment processor tokens schedule time to None\",\n        );\n\n        Ok(())\n    }\n\n    // Update payment processor token schedule time\n    #[instrument(skip_all)]\n    pub async fn update_payment_processor_token_schedule_time(\n        state: &SessionState,\n        connector_customer_id: &str,\n        payment_processor_token: &str,\n        schedule_time: Option<PrimitiveDateTime>,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let updated_token =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?\n                .values()\n                .find(|status| {\n                    status\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        == payment_processor_token\n                })\n                .map(|status| PaymentProcessorTokenStatus {\n                    payment_processor_token_details: status.payment_processor_token_details.clone(),\n                    inserted_by_attempt_id: status.inserted_by_attempt_id.clone(),\n                    error_code: status.error_code.clone(),\n                    daily_retry_history: status.daily_retry_history.clone(),\n                    scheduled_at: schedule_time,\n                    is_hard_decline: status.is_hard_decline,\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: status.is_active,\n                    account_update_history: status.account_update_history.clone(),\n                });\n\n        match updated_token {\n            Some(token) => {\n                let mut tokens_map = HashMap::new();\n                tokens_map.insert(\n                    token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    token.clone(),\n                );\n                Self::update_or_add_connector_customer_payment_processor_tokens(\n                    state,\n                    connector_customer_id,\n                    tokens_map,\n                )\n                .await?;\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"Updated payment processor tokens with schedule time\",\n                );\n                Ok(true)\n            }\n            None => {\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"Payment processor tokens not found\",\n                );\n                Ok(false)\n            }\n        }\n    }\n\n    // Get payment processor token with schedule time\n    #[instrument(skip_all)]\n    pub async fn get_payment_processor_token_with_schedule_time(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<Option<PaymentProcessorTokenStatus>, errors::StorageError> {\n        let tokens =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n\n        let scheduled_token = tokens\n            .values()\n            .find(|status| status.scheduled_at.is_some())\n            .cloned();\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Fetched payment processor token with schedule time\",\n        );\n\n        Ok(scheduled_token)\n    }\n\n    // Get payment processor token using token id\n    #[instrument(skip_all)]\n    pub async fn get_payment_processor_token_using_token_id(\n        state: &SessionState,\n        connector_customer_id: &str,\n        payment_processor_token: &str,\n    ) -> CustomResult<Option<PaymentProcessorTokenStatus>, errors::StorageError> {\n        // Get all tokens for the customer\n        let tokens_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n        let token_details = tokens_map.get(payment_processor_token).cloned();\n\n        tracing::debug!(\n            token_found = token_details.is_some(),\n            customer_id = connector_customer_id,\n            \"Fetched payment processor token & Checked existence \",\n        );\n\n        Ok(token_details)\n    }\n\n    // Check if all tokens are hard declined or no token found for the customer\n    #[instrument(skip_all)]\n    pub async fn are_all_tokens_hard_declined(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let tokens_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n        let all_hard_declined = tokens_map\n            .values()\n            .all(|token| token.is_hard_decline.unwrap_or(false));\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            all_hard_declined,\n            \"Checked if all tokens are hard declined or no token found for the customer\",\n        );\n\n        Ok(all_hard_declined)\n    }\n\n    // Get token based on retry type\n    pub async fn get_token_based_on_retry_type(\n        state: &SessionState,\n        connector_customer_id: &str,\n        retry_algorithm_type: RevenueRecoveryAlgorithmType,\n        last_token_used: Option<&str>,\n    ) -> CustomResult<Option<PaymentProcessorTokenStatus>, errors::StorageError> {\n        let mut token = None;\n        match retry_algorithm_type {\n            RevenueRecoveryAlgorithmType::Monitoring => {\n                logger::error!(\"Monitoring type found for Revenue Recovery retry payment\");\n            }\n\n            RevenueRecoveryAlgorithmType::Cascading => {\n                token = match last_token_used {\n                    Some(token_id) => {\n                        Self::get_payment_processor_token_using_token_id(\n                            state,\n                            connector_customer_id,\n                            token_id,\n                        )\n                        .await?\n                    }\n                    None => None,\n                };\n            }\n\n            RevenueRecoveryAlgorithmType::Smart => {\n                token = Self::get_payment_processor_token_with_schedule_time(\n                    state,\n                    connector_customer_id,\n                )\n                .await?;\n            }\n        }\n\n        let token = match token {\n            Some(t) => {\n                if t.is_hard_decline.unwrap_or(false) {\n                    // Update the schedule time to None for hard declined tokens\n\n                    logger::warn!(\n                        connector_customer_id = connector_customer_id,\n                        \"Token is hard declined, setting schedule time to None\"\n                    );\n\n                    Self::update_payment_processor_token_schedule_time(\n                        state,\n                        connector_customer_id,\n                        &t.payment_processor_token_details.payment_processor_token,\n                        None,\n                    )\n                    .await?;\n\n                    None\n                } else {\n                    Some(t)\n                }\n            }\n            None => {\n                logger::warn!(\n                    connector_customer_id = connector_customer_id,\n                    \"No token found for the customer\",\n                );\n                None\n            }\n        };\n\n        Ok(token)\n    }\n\n    /// Get Redis key data for revenue recovery\n    #[instrument(skip_all)]\n    pub async fn get_redis_key_data_raw(\n        state: &SessionState,\n        connector_customer_id: &str,\n        key_type: &RedisKeyType,\n    ) -> CustomResult<(bool, i64, Option<serde_json::Value>), errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n\n        let redis_key = match key_type {\n            RedisKeyType::Status => Self::get_connector_customer_lock_key(connector_customer_id),\n            RedisKeyType::Tokens => Self::get_connector_customer_tokens_key(connector_customer_id),\n        };\n\n        // Get TTL\n        let ttl = redis_conn\n            .get_ttl(&redis_key.clone().into())\n            .await\n            .map_err(|error| {\n                tracing::error!(operation = \"get_ttl\", err = ?error);\n                errors::StorageError::RedisError(errors::RedisError::GetHashFieldFailed.into())\n            })?;\n\n        // Get data based on key type and determine existence\n        let (key_exists, data) = match key_type {\n            RedisKeyType::Status => match redis_conn.get_key::<String>(&redis_key.into()).await {\n                Ok(status_value) => (true, serde_json::Value::String(status_value)),\n                Err(error) => {\n                    tracing::error!(operation = \"get_status_key\", err = ?error);\n                    (\n                        false,\n                        serde_json::Value::String(format!(\n                            \"Error retrieving status key: {}\",\n                            error\n                        )),\n                    )\n                }\n            },\n            RedisKeyType::Tokens => {\n                match redis_conn\n                    .get_hash_fields::<HashMap<String, String>>(&redis_key.into())\n                    .await\n                {\n                    Ok(hash_fields) => {\n                        let exists = !hash_fields.is_empty();\n                        let data = if exists {\n                            serde_json::to_value(hash_fields).unwrap_or(serde_json::Value::Null)\n                        } else {\n                            serde_json::Value::Object(serde_json::Map::new())\n                        };\n                        (exists, data)\n                    }\n                    Err(error) => {\n                        tracing::error!(operation = \"get_tokens_hash\", err = ?error);\n                        (false, serde_json::Value::Null)\n                    }\n                }\n            }\n        };\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            key_type = ?key_type,\n            exists = key_exists,\n            ttl = ttl,\n            \"Retrieved Redis key data\"\n        );\n\n        Ok((key_exists, ttl, Some(data)))\n    }\n\n    /// Update Redis token with comprehensive card data\n    #[instrument(skip_all)]\n    pub async fn update_redis_token_with_comprehensive_card_data(\n        state: &SessionState,\n        customer_id: &str,\n        token: &str,\n        card_data: &revenue_recovery_data_backfill::ComprehensiveCardData,\n        cutoff_datetime: Option<PrimitiveDateTime>,\n    ) -> CustomResult<(), errors::StorageError> {\n        // Get existing token data\n        let mut token_map =\n            Self::get_connector_customer_payment_processor_tokens(state, customer_id).await?;\n\n        // Find the token to update\n        let existing_token = token_map.get_mut(token).ok_or_else(|| {\n            tracing::warn!(\n                customer_id = customer_id,\n                \"Token not found in parsed Redis data - may be corrupted or missing for \"\n            );\n            error_stack::Report::new(errors::StorageError::ValueNotFound(\n                \"Token not found in Redis\".to_string(),\n            ))\n        })?;\n\n        // Update the token details with new card data\n        card_data.card_type.as_ref().map(|card_type| {\n            existing_token.payment_processor_token_details.card_type = Some(card_type.clone())\n        });\n\n        card_data.card_exp_month.as_ref().map(|exp_month| {\n            existing_token.payment_processor_token_details.expiry_month = Some(exp_month.clone())\n        });\n\n        card_data.card_exp_year.as_ref().map(|exp_year| {\n            existing_token.payment_processor_token_details.expiry_year = Some(exp_year.clone())\n        });\n\n        card_data.card_network.as_ref().map(|card_network| {\n            existing_token.payment_processor_token_details.card_network = Some(card_network.clone())\n        });\n\n        card_data.card_issuer.as_ref().map(|card_issuer| {\n            existing_token.payment_processor_token_details.card_issuer = Some(card_issuer.clone())\n        });\n\n        // Update daily retry history if provided\n        card_data\n            .daily_retry_history\n            .as_ref()\n            .map(|retry_history| existing_token.daily_retry_history = retry_history.clone());\n\n        // If cutoff_datetime is provided and existing scheduled_at < cutoff_datetime, set to None\n        // If no scheduled_at value exists, leave it as None\n        existing_token.scheduled_at = existing_token\n            .scheduled_at\n            .and_then(|existing_scheduled_at| {\n                cutoff_datetime\n                    .map(|cutoff| {\n                        if existing_scheduled_at < cutoff {\n                            tracing::info!(\n                                customer_id = customer_id,\n                                existing_scheduled_at = %existing_scheduled_at,\n                                cutoff_datetime = %cutoff,\n                                \"Set scheduled_at to None because existing time is before cutoff time\"\n                            );\n                            None\n                        } else {\n                            Some(existing_scheduled_at)\n                        }\n                    })\n                    .unwrap_or(Some(existing_scheduled_at)) // No cutoff provided, keep existing value\n            });\n\n        existing_token.modified_at = Some(PrimitiveDateTime::new(\n            OffsetDateTime::now_utc().date(),\n            OffsetDateTime::now_utc().time(),\n        ));\n\n        // Update account_update_history if provided\n        if let Some(history) = &card_data.account_update_history {\n            // Convert api_models::AccountUpdateHistoryRecord to storage::AccountUpdateHistoryRecord\n            let converted_history: Vec<AccountUpdateHistoryRecord> = history\n                .iter()\n                .map(|api_record| AccountUpdateHistoryRecord {\n                    old_token: api_record.old_token.clone(),\n                    new_token: api_record.new_token.clone(),\n                    updated_at: api_record.updated_at,\n                    old_token_info: api_record.old_token_info.clone(),\n                    new_token_info: api_record.new_token_info.clone(),\n                })\n                .collect();\n            existing_token.account_update_history = Some(converted_history);\n        }\n\n        // Update is_active if provided\n        card_data.is_active.map(|is_active| {\n            existing_token.is_active = Some(is_active);\n        });\n\n        // Save the updated token map back to Redis\n        Self::update_or_add_connector_customer_payment_processor_tokens(\n            state,\n            customer_id,\n            token_map,\n        )\n        .await?;\n\n        tracing::info!(\n            customer_id = customer_id,\n            \"Updated Redis token data with comprehensive card data using struct\"\n        );\n\n        Ok(())\n    }\n    pub async fn get_payment_processor_metadata_for_connector_customer(\n        state: &SessionState,\n        customer_id: &str,\n    ) -> CustomResult<HashMap<String, PaymentProcessorTokenWithRetryInfo>, errors::StorageError>\n    {\n        let token_map =\n            Self::get_connector_customer_payment_processor_tokens(state, customer_id).await?;\n\n        let token_data = Self::get_tokens_with_retry_metadata(state, &token_map);\n\n        Ok(token_data)\n    }\n\n    pub async fn handle_account_updater_token_update(\n        state: &SessionState,\n        customer_id: &str,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        mandate_data: Option<api_models::payments::MandateIds>,\n        payment_attempt_id: &id_type::GlobalAttemptId,\n    ) -> CustomResult<bool, errors::StorageError> {\n        match mandate_data {\n            Some(data) => {\n                logger::info!(\n                    customer_id = customer_id,\n                    \"Mandate data provided, proceeding with token update.\"\n                );\n\n                let old_token_id = scheduled_token\n                    .payment_processor_token_details\n                    .payment_processor_token\n                    .clone();\n\n                let account_updater_action =\n                    Self::determine_account_updater_action_based_on_old_token_and_mandate_data(\n                        old_token_id.as_str(),\n                        data,\n                    )?;\n\n                account_updater_action\n                    .handle_account_updater_action(\n                        state,\n                        customer_id,\n                        &account_updater_action,\n                        scheduled_token,\n                        payment_attempt_id,\n                    )\n                    .await?;\n\n                logger::info!(\n                    customer_id = customer_id,\n                    \"Successfully updated token with mandate data.\"\n                );\n\n                Ok(true)\n            }\n            None => {\n                logger::info!(\n                    customer_id = customer_id,\n                    \"Skipping token update. Since we didn't get any updated mandate data\"\n                );\n                Ok(false)\n            }\n        }\n    }\n\n    fn determine_account_updater_action_based_on_old_token_and_mandate_data(\n        old_token: &str,\n        mandate_data: api_models::payments::MandateIds,\n    ) -> CustomResult<AccountUpdaterAction, errors::StorageError> {\n        let new_token = mandate_data.get_connector_mandate_id();\n        let account_updater_action = match new_token {\n            Some(new_token) => {\n                logger::info!(\"Found token in mandate data, comparing with old token\");\n                let is_token_equal = (new_token == old_token);\n\n                logger::info!(\n                    \"Old token and new token comparison result: {}\",\n                    is_token_equal\n                );\n\n                if is_token_equal {\n                    logger::info!(\"Old token and new token are equal. Checking for expiry update\");\n                    match mandate_data.get_updated_mandate_details_of_connector_mandate_id() {\n                        Some(metadata) => {\n                            logger::info!(\"Mandate metadata found for expiry update.\");\n                            AccountUpdaterAction::ExpiryUpdate(metadata)\n                        }\n                        None => {\n                            logger::info!(\"No mandate metadata found for expiry update.\");\n                            AccountUpdaterAction::ExistingToken\n                        }\n                    }\n                } else {\n                    logger::info!(\"Old token and new token are not equal.\");\n                    match mandate_data.get_updated_mandate_details_of_connector_mandate_id() {\n                        Some(metadata) => {\n                            logger::info!(\"Mandate metadata found for token update.\");\n                            AccountUpdaterAction::TokenUpdate(new_token, metadata)\n                        }\n                        None => {\n                            logger::warn!(\"No mandate metadata found for token update. No further action is taken\");\n                            AccountUpdaterAction::NoAction\n                        }\n                    }\n                }\n            }\n            None => {\n                logger::warn!(\"No new token found in mandate data while comparing with old token.\");\n                AccountUpdaterAction::NoAction\n            }\n        };\n\n        Ok(account_updater_action)\n    }\n}",
+      "after_code": "impl RedisTokenManager {\n    fn get_connector_customer_lock_key(connector_customer_id: &str) -> String {\n        format!(\"customer:{connector_customer_id}:status\")\n    }\n\n    fn get_connector_customer_tokens_key(connector_customer_id: &str) -> String {\n        format!(\"customer:{connector_customer_id}:tokens\")\n    }\n\n    /// Lock connector customer\n    #[instrument(skip_all)]\n    pub async fn lock_connector_customer_status(\n        state: &SessionState,\n        connector_customer_id: &str,\n        payment_id: &id_type::GlobalPaymentId,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n\n        let lock_key = Self::get_connector_customer_lock_key(connector_customer_id);\n        let seconds = &state.conf.revenue_recovery.redis_ttl_in_seconds;\n\n        let result: bool = match redis_conn\n            .set_key_if_not_exists_with_expiry(\n                &lock_key.into(),\n                payment_id.get_string_repr(),\n                Some(*seconds),\n            )\n            .await\n        {\n            Ok(resp) => resp == SetnxReply::KeySet,\n            Err(error) => {\n                tracing::error!(operation = \"lock_stream\", err = ?error);\n                false\n            }\n        };\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            payment_id = payment_id.get_string_repr(),\n            lock_acquired = %result,\n            \"Connector customer lock attempt\"\n        );\n\n        Ok(result)\n    }\n    #[instrument(skip_all)]\n    pub async fn update_connector_customer_lock_ttl(\n        state: &SessionState,\n        connector_customer_id: &str,\n        exp_in_seconds: i64,\n    ) -> CustomResult<(), errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n\n        let lock_key = Self::get_connector_customer_lock_key(connector_customer_id);\n\n        let result: bool = redis_conn\n            .set_expiry(&lock_key.clone().into(), exp_in_seconds)\n            .await\n            .map_or_else(\n                |error| {\n                    tracing::error!(operation = \"update_lock_ttl\", err = ?error);\n                    false\n                },\n                |_| true,\n            );\n\n        if result {\n            tracing::debug!(\n                lock_key = %lock_key,\n                new_ttl_in_seconds = exp_in_seconds,\n                \"Redis key TTL updated successfully\"\n            );\n        } else {\n            tracing::error!(\n                lock_key = %lock_key,\n                \"Failed to update TTL: key not found or error occurred\"\n            );\n        }\n\n        Ok(())\n    }\n\n    /// Unlock connector customer status\n    #[instrument(skip_all)]\n    pub async fn unlock_connector_customer_status(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n\n        let lock_key = Self::get_connector_customer_lock_key(connector_customer_id);\n\n        match redis_conn.delete_key(&lock_key.into()).await {\n            Ok(DelReply::KeyDeleted) => {\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"Connector customer unlocked\"\n                );\n                Ok(true)\n            }\n            Ok(DelReply::KeyNotDeleted) => {\n                tracing::debug!(\"Tried to unlock a stream which is already unlocked\");\n                Ok(false)\n            }\n            Err(err) => {\n                tracing::error!(?err, \"Failed to delete lock key\");\n                Ok(false)\n            }\n        }\n    }\n\n    /// Get all payment processor tokens for a connector customer\n    #[instrument(skip_all)]\n    pub async fn get_connector_customer_payment_processor_tokens(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<HashMap<String, PaymentProcessorTokenStatus>, errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n        let tokens_key = Self::get_connector_customer_tokens_key(connector_customer_id);\n\n        let get_hash_err =\n            errors::StorageError::RedisError(errors::RedisError::GetHashFieldFailed.into());\n\n        let payment_processor_tokens: HashMap<String, String> = redis_conn\n            .get_hash_fields(&tokens_key.into())\n            .await\n            .change_context(get_hash_err)?;\n\n        let payment_processor_token_info_map: HashMap<String, PaymentProcessorTokenStatus> =\n            payment_processor_tokens\n                .into_iter()\n                .filter_map(|(token_id, token_data)| {\n                    match serde_json::from_str::<PaymentProcessorTokenStatus>(&token_data) {\n                        Ok(token_status) => Some((token_id, token_status)),\n                        Err(err) => {\n                            tracing::warn!(\n                                connector_customer_id = %connector_customer_id,\n                                token_id = %token_id,\n                                error = %err,\n                                \"Failed to deserialize token data, skipping\",\n                            );\n                            None\n                        }\n                    }\n                })\n                .collect();\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Fetched payment processor tokens\",\n        );\n\n        Ok(payment_processor_token_info_map)\n    }\n\n    /// Update connector customer payment processor tokens or add if doesn't exist\n    #[instrument(skip_all)]\n    pub async fn update_or_add_connector_customer_payment_processor_tokens(\n        state: &SessionState,\n        connector_customer_id: &str,\n        payment_processor_token_info_map: HashMap<String, PaymentProcessorTokenStatus>,\n    ) -> CustomResult<(), errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n        let tokens_key = Self::get_connector_customer_tokens_key(connector_customer_id);\n\n        // allocate capacity up-front to avoid rehashing\n        let mut serialized_payment_processor_tokens: HashMap<String, String> =\n            HashMap::with_capacity(payment_processor_token_info_map.len());\n\n        // serialize all tokens, preserving explicit error handling and attachable diagnostics\n        for (payment_processor_token_id, payment_processor_token_status) in\n            payment_processor_token_info_map\n        {\n            let serialized = serde_json::to_string(&payment_processor_token_status)\n                .change_context(errors::StorageError::SerializationFailed)\n                .attach_printable(\"Failed to serialize token status\")?;\n\n            serialized_payment_processor_tokens.insert(payment_processor_token_id, serialized);\n        }\n        let seconds = &state.conf.revenue_recovery.redis_ttl_in_seconds;\n\n        // Update or add tokens\n        redis_conn\n            .set_hash_fields(\n                &tokens_key.into(),\n                serialized_payment_processor_tokens,\n                Some(*seconds),\n            )\n            .await\n            .change_context(errors::StorageError::RedisError(\n                errors::RedisError::SetHashFieldFailed.into(),\n            ))?;\n\n        tracing::info!(\n            connector_customer_id = %connector_customer_id,\n            \"Successfully updated or added customer tokens\",\n        );\n\n        Ok(())\n    }\n\n    /// Get current date in `yyyy-mm-dd` format.\n    pub fn get_current_date() -> String {\n        let today = date_time::now().date();\n\n        let (year, month, day) = (today.year(), today.month(), today.day());\n\n        format!(\"{year:04}-{month:02}-{day:02}\",)\n    }\n\n    /// Normalize retry window to exactly `RETRY_WINDOW_DAYS` days (today to `RETRY_WINDOW_DAYS - 1` days ago).\n    pub fn normalize_retry_window(\n        payment_processor_token: &mut PaymentProcessorTokenStatus,\n        today: Date,\n    ) {\n        let mut normalized_retry_history: HashMap<Date, i32> = HashMap::new();\n\n        for days_ago in 0..RETRY_WINDOW_DAYS {\n            let date = today - Duration::days(days_ago.into());\n\n            payment_processor_token\n                .daily_retry_history\n                .get(&date)\n                .map(|&retry_count| {\n                    normalized_retry_history.insert(date, retry_count);\n                });\n        }\n\n        payment_processor_token.daily_retry_history = normalized_retry_history;\n    }\n\n    /// Get all payment processor tokens with retry information and wait times.\n    pub fn get_tokens_with_retry_metadata(\n        state: &SessionState,\n        payment_processor_token_info_map: &HashMap<String, PaymentProcessorTokenStatus>,\n    ) -> HashMap<String, PaymentProcessorTokenWithRetryInfo> {\n        let today = OffsetDateTime::now_utc().date();\n        let card_config = &state.conf.revenue_recovery.card_config;\n\n        let mut result: HashMap<String, PaymentProcessorTokenWithRetryInfo> =\n            HashMap::with_capacity(payment_processor_token_info_map.len());\n\n        for (payment_processor_token_id, payment_processor_token_status) in\n            payment_processor_token_info_map.iter()\n        {\n            let card_network = payment_processor_token_status\n                .payment_processor_token_details\n                .card_network\n                .clone();\n\n            // Calculate retry information.\n            let retry_info = Self::payment_processor_token_retry_info(\n                state,\n                payment_processor_token_status,\n                today,\n                card_network.clone(),\n            );\n\n            // Determine the wait time (max of monthly and daily wait hours).\n            let retry_wait_time_hours = retry_info\n                .monthly_wait_hours\n                .max(retry_info.daily_wait_hours);\n\n            // Obtain network-specific limits and compute remaining monthly retries.\n            let card_network_config = card_config.get_network_config(card_network);\n\n            let monthly_retry_remaining = std::cmp::max(\n                0,\n                card_network_config.max_retry_count_for_thirty_day\n                    - retry_info.total_30_day_retries,\n            );\n\n            // Build the per-token result struct.\n            let token_with_retry_info = PaymentProcessorTokenWithRetryInfo {\n                token_status: payment_processor_token_status.clone(),\n                retry_wait_time_hours,\n                monthly_retry_remaining,\n                total_30_day_retries: retry_info.total_30_day_retries,\n            };\n\n            result.insert(payment_processor_token_id.clone(), token_with_retry_info);\n        }\n        tracing::debug!(\"Fetched payment processor tokens with retry metadata\",);\n\n        result\n    }\n\n    /// Sum retries over exactly the last 30 days\n    fn calculate_total_30_day_retries(token: &PaymentProcessorTokenStatus, today: Date) -> i32 {\n        (0..RETRY_WINDOW_DAYS)\n            .map(|i| {\n                let date = today - Duration::days(i.into());\n                token\n                    .daily_retry_history\n                    .get(&date)\n                    .copied()\n                    .unwrap_or(INITIAL_RETRY_COUNT)\n            })\n            .sum()\n    }\n\n    /// Calculate wait hours\n    fn calculate_wait_hours(target_date: Date, now: OffsetDateTime) -> i64 {\n        let expiry_time = target_date.midnight().assume_utc();\n        (expiry_time - now).whole_hours().max(0)\n    }\n\n    /// Calculate retry counts for exactly the last 30 days\n    pub fn payment_processor_token_retry_info(\n        state: &SessionState,\n        token: &PaymentProcessorTokenStatus,\n        today: Date,\n        network_type: Option<CardNetwork>,\n    ) -> TokenRetryInfo {\n        let card_config = &state.conf.revenue_recovery.card_config;\n        let card_network_config = card_config.get_network_config(network_type);\n\n        let now = OffsetDateTime::now_utc();\n\n        let total_30_day_retries = Self::calculate_total_30_day_retries(token, today);\n\n        let monthly_wait_hours =\n            if total_30_day_retries >= card_network_config.max_retry_count_for_thirty_day {\n                let mut accumulated_retries = 0;\n\n                // Iterate from most recent to oldest\n                (0..RETRY_WINDOW_DAYS)\n                    .map(|days_ago| today - Duration::days(days_ago.into()))\n                    .find(|date| {\n                        let retries = token.daily_retry_history.get(date).copied().unwrap_or(0);\n                        accumulated_retries += retries;\n                        accumulated_retries >= card_network_config.max_retry_count_for_thirty_day\n                    })\n                    .map(|breach_date| {\n                        Self::calculate_wait_hours(breach_date + Duration::days(31), now)\n                    })\n                    .unwrap_or(0)\n            } else {\n                0\n            };\n\n        let today_retries = token\n            .daily_retry_history\n            .get(&today)\n            .copied()\n            .unwrap_or(INITIAL_RETRY_COUNT);\n\n        let daily_wait_hours = if today_retries >= card_network_config.max_retries_per_day {\n            Self::calculate_wait_hours(today + Duration::days(1), now)\n        } else {\n            0\n        };\n\n        TokenRetryInfo {\n            monthly_wait_hours,\n            daily_wait_hours,\n            total_30_day_retries,\n        }\n    }\n\n    // Upsert payment processor token\n    #[instrument(skip_all)]\n    pub async fn upsert_payment_processor_token(\n        state: &SessionState,\n        connector_customer_id: &str,\n        token_data: PaymentProcessorTokenStatus,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let mut token_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n\n        let token_id = token_data\n            .payment_processor_token_details\n            .payment_processor_token\n            .clone();\n\n        let was_existing = token_map.contains_key(&token_id);\n\n        let error_code = token_data.error_code.clone();\n\n        let last_external_attempt_at = token_data.modified_at;\n\n        let today = OffsetDateTime::now_utc().date();\n\n        token_map\n            .get_mut(&token_id)\n            .map(|existing_token| {\n                Self::normalize_retry_window(existing_token, today);\n\n                for (date, &value) in &token_data.daily_retry_history {\n                    existing_token\n                        .daily_retry_history\n                        .entry(*date)\n                        .and_modify(|v| *v += value)\n                        .or_insert(value);\n                }\n                existing_token.account_update_history = token_data.account_update_history.clone();\n                existing_token.payment_processor_token_details = token_data\n                    .payment_processor_token_details\n                    .clone();\n\n                existing_token\n                    .modified_at\n                    .zip(last_external_attempt_at)\n                    .and_then(|(existing_token_modified_at, last_external_attempt_at)| {\n                        (last_external_attempt_at > existing_token_modified_at)\n                            .then_some(last_external_attempt_at)\n                    })\n                    .or_else(|| {\n                        existing_token\n                            .modified_at\n                            .is_none()\n                            .then_some(last_external_attempt_at)\n                            .flatten()\n                    })\n                    .map(|last_external_attempt_at| {\n                        existing_token.modified_at = Some(last_external_attempt_at);\n                        existing_token.error_code = error_code;\n                        existing_token.is_hard_decline = token_data.is_hard_decline;\n                        token_data\n                            .is_active\n                            .map(|is_active| existing_token.is_active = Some(is_active));                        \n                    });\n            })\n            .or_else(|| {\n                token_map.insert(token_id.clone(), token_data);\n                None\n            });\n\n        Self::update_or_add_connector_customer_payment_processor_tokens(\n            state,\n            connector_customer_id,\n            token_map,\n        )\n        .await?;\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Upsert payment processor tokens\",\n        );\n\n        Ok(!was_existing)\n    }\n\n    // Update payment processor token error code with billing connector response\n    #[instrument(skip_all)]\n    pub async fn update_payment_processor_token_error_code_from_process_tracker(\n        state: &SessionState,\n        connector_customer_id: &str,\n        error_code: &Option<String>,\n        is_hard_decline: &Option<bool>,\n        payment_processor_token_id: Option<&str>,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let today = OffsetDateTime::now_utc().date();\n        let updated_token = match payment_processor_token_id {\n            Some(token_id) => {\n                Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                    .await?\n                    .values()\n                    .find(|status| {\n                        status\n                            .payment_processor_token_details\n                            .payment_processor_token\n                            == token_id\n                    })\n                    .map(|status| PaymentProcessorTokenStatus {\n                        payment_processor_token_details: status\n                            .payment_processor_token_details\n                            .clone(),\n                        inserted_by_attempt_id: status.inserted_by_attempt_id.clone(),\n                        error_code: error_code.clone(),\n                        daily_retry_history: status.daily_retry_history.clone(),\n                        scheduled_at: None,\n                        is_hard_decline: *is_hard_decline,\n                        modified_at: Some(PrimitiveDateTime::new(\n                            OffsetDateTime::now_utc().date(),\n                            OffsetDateTime::now_utc().time(),\n                        )),\n                        is_active: status.is_active,\n                        account_update_history: status.account_update_history.clone(),\n                    })\n            }\n            None => None,\n        };\n\n        match updated_token {\n            Some(mut token) => {\n                Self::normalize_retry_window(&mut token, today);\n\n                match token.error_code {\n                    None => token.daily_retry_history.clear(),\n                    Some(_) => {\n                        let current_count = token\n                            .daily_retry_history\n                            .get(&today)\n                            .copied()\n                            .unwrap_or(INITIAL_RETRY_COUNT);\n                        token.daily_retry_history.insert(today, current_count + 1);\n                    }\n                }\n\n                let mut tokens_map = HashMap::new();\n                tokens_map.insert(\n                    token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    token.clone(),\n                );\n\n                Self::update_or_add_connector_customer_payment_processor_tokens(\n                    state,\n                    connector_customer_id,\n                    tokens_map,\n                )\n                .await?;\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"Updated payment processor tokens with error code\",\n                );\n                Ok(true)\n            }\n            None => {\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"No Token found with token id to update error code\",\n                );\n                Ok(false)\n            }\n        }\n    }\n\n    // Update all payment processor token schedule time to None\n    #[instrument(skip_all)]\n    pub async fn update_payment_processor_tokens_schedule_time_to_none(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<(), errors::StorageError> {\n        let tokens_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n\n        let mut updated_tokens_map = HashMap::new();\n\n        for (token_id, status) in tokens_map {\n            let updated_status = PaymentProcessorTokenStatus {\n                payment_processor_token_details: status.payment_processor_token_details.clone(),\n                inserted_by_attempt_id: status.inserted_by_attempt_id.clone(),\n                error_code: status.error_code.clone(),\n                daily_retry_history: status.daily_retry_history.clone(),\n                scheduled_at: None,\n                is_hard_decline: status.is_hard_decline,\n                modified_at: Some(PrimitiveDateTime::new(\n                    OffsetDateTime::now_utc().date(),\n                    OffsetDateTime::now_utc().time(),\n                )),\n                is_active: status.is_active,\n                account_update_history: status.account_update_history.clone(),\n            };\n            updated_tokens_map.insert(token_id, updated_status);\n        }\n\n        Self::update_or_add_connector_customer_payment_processor_tokens(\n            state,\n            connector_customer_id,\n            updated_tokens_map,\n        )\n        .await?;\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Updated all payment processor tokens schedule time to None\",\n        );\n\n        Ok(())\n    }\n\n    // Update payment processor token schedule time\n    #[instrument(skip_all)]\n    pub async fn update_payment_processor_token_schedule_time(\n        state: &SessionState,\n        connector_customer_id: &str,\n        payment_processor_token: &str,\n        schedule_time: Option<PrimitiveDateTime>,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let updated_token =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?\n                .values()\n                .find(|status| {\n                    status\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        == payment_processor_token\n                })\n                .map(|status| PaymentProcessorTokenStatus {\n                    payment_processor_token_details: status.payment_processor_token_details.clone(),\n                    inserted_by_attempt_id: status.inserted_by_attempt_id.clone(),\n                    error_code: status.error_code.clone(),\n                    daily_retry_history: status.daily_retry_history.clone(),\n                    scheduled_at: schedule_time,\n                    is_hard_decline: status.is_hard_decline,\n                    modified_at: Some(PrimitiveDateTime::new(\n                        OffsetDateTime::now_utc().date(),\n                        OffsetDateTime::now_utc().time(),\n                    )),\n                    is_active: status.is_active,\n                    account_update_history: status.account_update_history.clone(),\n                });\n\n        match updated_token {\n            Some(token) => {\n                let mut tokens_map = HashMap::new();\n                tokens_map.insert(\n                    token\n                        .payment_processor_token_details\n                        .payment_processor_token\n                        .clone(),\n                    token.clone(),\n                );\n                Self::update_or_add_connector_customer_payment_processor_tokens(\n                    state,\n                    connector_customer_id,\n                    tokens_map,\n                )\n                .await?;\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"Updated payment processor tokens with schedule time\",\n                );\n                Ok(true)\n            }\n            None => {\n                tracing::debug!(\n                    connector_customer_id = connector_customer_id,\n                    \"Payment processor tokens not found\",\n                );\n                Ok(false)\n            }\n        }\n    }\n\n    // Get payment processor token with schedule time\n    #[instrument(skip_all)]\n    pub async fn get_payment_processor_token_with_schedule_time(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<Option<PaymentProcessorTokenStatus>, errors::StorageError> {\n        let tokens =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n\n        let scheduled_token = tokens\n            .values()\n            .find(|status| status.scheduled_at.is_some())\n            .cloned();\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Fetched payment processor token with schedule time\",\n        );\n\n        Ok(scheduled_token)\n    }\n\n    // Get payment processor token using token id\n    #[instrument(skip_all)]\n    pub async fn get_payment_processor_token_using_token_id(\n        state: &SessionState,\n        connector_customer_id: &str,\n        payment_processor_token: &str,\n    ) -> CustomResult<Option<PaymentProcessorTokenStatus>, errors::StorageError> {\n        // Get all tokens for the customer\n        let tokens_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n        let token_details = tokens_map.get(payment_processor_token).cloned();\n\n        tracing::debug!(\n            token_found = token_details.is_some(),\n            customer_id = connector_customer_id,\n            \"Fetched payment processor token & Checked existence \",\n        );\n\n        Ok(token_details)\n    }\n\n    // Check if all tokens are hard declined or no token found for the customer\n    #[instrument(skip_all)]\n    pub async fn are_all_tokens_hard_declined(\n        state: &SessionState,\n        connector_customer_id: &str,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let tokens_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n        let all_hard_declined = tokens_map\n            .values()\n            .all(|token| token.is_hard_decline.unwrap_or(false));\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            all_hard_declined,\n            \"Checked if all tokens are hard declined or no token found for the customer\",\n        );\n\n        Ok(all_hard_declined)\n    }\n\n    // Get token based on retry type\n    pub async fn get_token_based_on_retry_type(\n        state: &SessionState,\n        connector_customer_id: &str,\n        retry_algorithm_type: RevenueRecoveryAlgorithmType,\n        last_token_used: Option<&str>,\n    ) -> CustomResult<Option<PaymentProcessorTokenStatus>, errors::StorageError> {\n        let mut token = None;\n        match retry_algorithm_type {\n            RevenueRecoveryAlgorithmType::Monitoring => {\n                logger::error!(\"Monitoring type found for Revenue Recovery retry payment\");\n            }\n\n            RevenueRecoveryAlgorithmType::Cascading => {\n                token = match last_token_used {\n                    Some(token_id) => {\n                        Self::get_payment_processor_token_using_token_id(\n                            state,\n                            connector_customer_id,\n                            token_id,\n                        )\n                        .await?\n                    }\n                    None => None,\n                };\n            }\n\n            RevenueRecoveryAlgorithmType::Smart => {\n                token = Self::get_payment_processor_token_with_schedule_time(\n                    state,\n                    connector_customer_id,\n                )\n                .await?;\n            }\n        }\n\n        let token = match token {\n            Some(t) => {\n                if t.is_hard_decline.unwrap_or(false) {\n                    // Update the schedule time to None for hard declined tokens\n\n                    logger::warn!(\n                        connector_customer_id = connector_customer_id,\n                        \"Token is hard declined, setting schedule time to None\"\n                    );\n\n                    Self::update_payment_processor_token_schedule_time(\n                        state,\n                        connector_customer_id,\n                        &t.payment_processor_token_details.payment_processor_token,\n                        None,\n                    )\n                    .await?;\n\n                    None\n                } else {\n                    Some(t)\n                }\n            }\n            None => {\n                logger::warn!(\n                    connector_customer_id = connector_customer_id,\n                    \"No token found for the customer\",\n                );\n                None\n            }\n        };\n\n        Ok(token)\n    }\n\n    /// Get Redis key data for revenue recovery\n    #[instrument(skip_all)]\n    pub async fn get_redis_key_data_raw(\n        state: &SessionState,\n        connector_customer_id: &str,\n        key_type: &RedisKeyType,\n    ) -> CustomResult<(bool, i64, Option<serde_json::Value>), errors::StorageError> {\n        let redis_conn =\n            state\n                .store\n                .get_redis_conn()\n                .change_context(errors::StorageError::RedisError(\n                    errors::RedisError::RedisConnectionError.into(),\n                ))?;\n\n        let redis_key = match key_type {\n            RedisKeyType::Status => Self::get_connector_customer_lock_key(connector_customer_id),\n            RedisKeyType::Tokens => Self::get_connector_customer_tokens_key(connector_customer_id),\n        };\n\n        // Get TTL\n        let ttl = redis_conn\n            .get_ttl(&redis_key.clone().into())\n            .await\n            .map_err(|error| {\n                tracing::error!(operation = \"get_ttl\", err = ?error);\n                errors::StorageError::RedisError(errors::RedisError::GetHashFieldFailed.into())\n            })?;\n\n        // Get data based on key type and determine existence\n        let (key_exists, data) = match key_type {\n            RedisKeyType::Status => match redis_conn.get_key::<String>(&redis_key.into()).await {\n                Ok(status_value) => (true, serde_json::Value::String(status_value)),\n                Err(error) => {\n                    tracing::error!(operation = \"get_status_key\", err = ?error);\n                    (\n                        false,\n                        serde_json::Value::String(format!(\n                            \"Error retrieving status key: {}\",\n                            error\n                        )),\n                    )\n                }\n            },\n            RedisKeyType::Tokens => {\n                match redis_conn\n                    .get_hash_fields::<HashMap<String, String>>(&redis_key.into())\n                    .await\n                {\n                    Ok(hash_fields) => {\n                        let exists = !hash_fields.is_empty();\n                        let data = if exists {\n                            serde_json::to_value(hash_fields).unwrap_or(serde_json::Value::Null)\n                        } else {\n                            serde_json::Value::Object(serde_json::Map::new())\n                        };\n                        (exists, data)\n                    }\n                    Err(error) => {\n                        tracing::error!(operation = \"get_tokens_hash\", err = ?error);\n                        (false, serde_json::Value::Null)\n                    }\n                }\n            }\n        };\n\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            key_type = ?key_type,\n            exists = key_exists,\n            ttl = ttl,\n            \"Retrieved Redis key data\"\n        );\n\n        Ok((key_exists, ttl, Some(data)))\n    }\n\n    /// Update Redis token with comprehensive card data\n    #[instrument(skip_all)]\n    pub async fn update_redis_token_with_comprehensive_card_data(\n        state: &SessionState,\n        customer_id: &str,\n        token: &str,\n        card_data: &revenue_recovery_data_backfill::ComprehensiveCardData,\n        cutoff_datetime: Option<PrimitiveDateTime>,\n    ) -> CustomResult<(), errors::StorageError> {\n        // Get existing token data\n        let mut token_map =\n            Self::get_connector_customer_payment_processor_tokens(state, customer_id).await?;\n\n        // Find the token to update\n        let existing_token = token_map.get_mut(token).ok_or_else(|| {\n            tracing::warn!(\n                customer_id = customer_id,\n                \"Token not found in parsed Redis data - may be corrupted or missing for \"\n            );\n            error_stack::Report::new(errors::StorageError::ValueNotFound(\n                \"Token not found in Redis\".to_string(),\n            ))\n        })?;\n\n        // Update the token details with new card data\n        card_data.card_type.as_ref().map(|card_type| {\n            existing_token.payment_processor_token_details.card_type = Some(card_type.clone())\n        });\n\n        card_data.card_exp_month.as_ref().map(|exp_month| {\n            existing_token.payment_processor_token_details.expiry_month = Some(exp_month.clone())\n        });\n\n        card_data.card_exp_year.as_ref().map(|exp_year| {\n            existing_token.payment_processor_token_details.expiry_year = Some(exp_year.clone())\n        });\n\n        card_data.card_network.as_ref().map(|card_network| {\n            existing_token.payment_processor_token_details.card_network = Some(card_network.clone())\n        });\n\n        card_data.card_issuer.as_ref().map(|card_issuer| {\n            existing_token.payment_processor_token_details.card_issuer = Some(card_issuer.clone())\n        });\n\n        // Update daily retry history if provided\n        card_data\n            .daily_retry_history\n            .as_ref()\n            .map(|retry_history| existing_token.daily_retry_history = retry_history.clone());\n\n        // If cutoff_datetime is provided and existing scheduled_at < cutoff_datetime, set to None\n        // If no scheduled_at value exists, leave it as None\n        existing_token.scheduled_at = existing_token\n            .scheduled_at\n            .and_then(|existing_scheduled_at| {\n                cutoff_datetime\n                    .map(|cutoff| {\n                        if existing_scheduled_at < cutoff {\n                            tracing::info!(\n                                customer_id = customer_id,\n                                existing_scheduled_at = %existing_scheduled_at,\n                                cutoff_datetime = %cutoff,\n                                \"Set scheduled_at to None because existing time is before cutoff time\"\n                            );\n                            None\n                        } else {\n                            Some(existing_scheduled_at)\n                        }\n                    })\n                    .unwrap_or(Some(existing_scheduled_at)) // No cutoff provided, keep existing value\n            });\n\n        existing_token.modified_at = Some(PrimitiveDateTime::new(\n            OffsetDateTime::now_utc().date(),\n            OffsetDateTime::now_utc().time(),\n        ));\n\n        // Update account_update_history if provided\n        if let Some(history) = &card_data.account_update_history {\n            // Convert api_models::AccountUpdateHistoryRecord to storage::AccountUpdateHistoryRecord\n            let converted_history: Vec<AccountUpdateHistoryRecord> = history\n                .iter()\n                .map(|api_record| AccountUpdateHistoryRecord {\n                    old_token: api_record.old_token.clone(),\n                    new_token: api_record.new_token.clone(),\n                    updated_at: api_record.updated_at,\n                    old_token_info: api_record.old_token_info.clone(),\n                    new_token_info: api_record.new_token_info.clone(),\n                })\n                .collect();\n            existing_token.account_update_history = Some(converted_history);\n        }\n\n        // Update is_active if provided\n        card_data.is_active.map(|is_active| {\n            existing_token.is_active = Some(is_active);\n        });\n\n        // Save the updated token map back to Redis\n        Self::update_or_add_connector_customer_payment_processor_tokens(\n            state,\n            customer_id,\n            token_map,\n        )\n        .await?;\n\n        tracing::info!(\n            customer_id = customer_id,\n            \"Updated Redis token data with comprehensive card data using struct\"\n        );\n\n        Ok(())\n    }\n    pub async fn get_payment_processor_metadata_for_connector_customer(\n        state: &SessionState,\n        customer_id: &str,\n    ) -> CustomResult<HashMap<String, PaymentProcessorTokenWithRetryInfo>, errors::StorageError>\n    {\n        let token_map =\n            Self::get_connector_customer_payment_processor_tokens(state, customer_id).await?;\n\n        let token_data = Self::get_tokens_with_retry_metadata(state, &token_map);\n\n        Ok(token_data)\n    }\n\n    pub async fn handle_account_updater_token_update(\n        state: &SessionState,\n        customer_id: &str,\n        scheduled_token: &PaymentProcessorTokenStatus,\n        mandate_data: Option<api_models::payments::MandateIds>,\n        payment_attempt_id: &id_type::GlobalAttemptId,\n    ) -> CustomResult<bool, errors::StorageError> {\n        match mandate_data {\n            Some(data) => {\n                logger::info!(\n                    customer_id = customer_id,\n                    \"Mandate data provided, proceeding with token update.\"\n                );\n\n                let old_token_id = scheduled_token\n                    .payment_processor_token_details\n                    .payment_processor_token\n                    .clone();\n\n                let account_updater_action =\n                    Self::determine_account_updater_action_based_on_old_token_and_mandate_data(\n                        old_token_id.as_str(),\n                        data,\n                    )?;\n\n                account_updater_action\n                    .handle_account_updater_action(\n                        state,\n                        customer_id,\n                        &account_updater_action,\n                        scheduled_token,\n                        payment_attempt_id,\n                    )\n                    .await?;\n\n                logger::info!(\n                    customer_id = customer_id,\n                    \"Successfully updated token with mandate data.\"\n                );\n\n                Ok(true)\n            }\n            None => {\n                logger::info!(\n                    customer_id = customer_id,\n                    \"Skipping token update. Since we didn't get any updated mandate data\"\n                );\n                Ok(false)\n            }\n        }\n    }\n\n    fn determine_account_updater_action_based_on_old_token_and_mandate_data(\n        old_token: &str,\n        mandate_data: api_models::payments::MandateIds,\n    ) -> CustomResult<AccountUpdaterAction, errors::StorageError> {\n        let new_token = mandate_data.get_connector_mandate_id();\n        let account_updater_action = match new_token {\n            Some(new_token) => {\n                logger::info!(\"Found token in mandate data, comparing with old token\");\n                let is_token_equal = (new_token == old_token);\n\n                logger::info!(\n                    \"Old token and new token comparison result: {}\",\n                    is_token_equal\n                );\n\n                if is_token_equal {\n                    logger::info!(\"Old token and new token are equal. Checking for expiry update\");\n                    match mandate_data.get_updated_mandate_details_of_connector_mandate_id() {\n                        Some(metadata) => {\n                            logger::info!(\"Mandate metadata found for expiry update.\");\n                            AccountUpdaterAction::ExpiryUpdate(metadata)\n                        }\n                        None => {\n                            logger::info!(\"No mandate metadata found for expiry update.\");\n                            AccountUpdaterAction::ExistingToken\n                        }\n                    }\n                } else {\n                    logger::info!(\"Old token and new token are not equal.\");\n                    match mandate_data.get_updated_mandate_details_of_connector_mandate_id() {\n                        Some(metadata) => {\n                            logger::info!(\"Mandate metadata found for token update.\");\n                            AccountUpdaterAction::TokenUpdate(new_token, metadata)\n                        }\n                        None => {\n                            logger::warn!(\"No mandate metadata found for token update. No further action is taken\");\n                            AccountUpdaterAction::NoAction\n                        }\n                    }\n                }\n            }\n            None => {\n                logger::warn!(\"No new token found in mandate data while comparing with old token.\");\n                AccountUpdaterAction::NoAction\n            }\n        };\n\n        Ok(account_updater_action)\n    }\n}",
+      "diff_span": {
+        "before": "                        token_data\n                            .is_active\n                            .map(|is_active| existing_token.is_active = Some(is_active));\n                    });\n            })",
+        "after": "                        .or_insert(value);\n                }\n                existing_token.account_update_history = token_data.account_update_history.clone();\n                existing_token.payment_processor_token_details = token_data\n                    .payment_processor_token_details\n                    .clone();\n\n                existing_token\n                    .modified_at\n                    .zip(last_external_attempt_at)\n                    .and_then(|(existing_token_modified_at, last_external_attempt_at)| {\n                        (last_external_attempt_at > existing_token_modified_at)\n                            .then_some(last_external_attempt_at)\n                    })\n                    .or_else(|| {\n                        existing_token\n                            .modified_at\n                            .is_none()\n                            .then_some(last_external_attempt_at)\n                            .flatten()\n                    })\n                    .map(|last_external_attempt_at| {\n                        existing_token.modified_at = Some(last_external_attempt_at);\n                        existing_token.error_code = error_code;\n                        existing_token.is_hard_decline = token_data.is_hard_decline;\n                        token_data\n                            .is_active\n                            .map(|is_active| existing_token.is_active = Some(is_active));                        \n                    });\n            })"
+      },
+      "commit_sha": "e2383f4ea26f5108df81d36c2d8d651d6b1cee34"
+    },
+    {
+      "id": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs::RedisTokenManager::function::upsert_payment_processor_token",
+      "file": "crates/router/src/types/storage/revenue_recovery_redis_operation.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn upsert_payment_processor_token(\n        state: &SessionState,\n        connector_customer_id: &str,\n        token_data: PaymentProcessorTokenStatus,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let mut token_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n\n        let token_id = token_data\n            .payment_processor_token_details\n            .payment_processor_token\n            .clone();\n\n        let was_existing = token_map.contains_key(&token_id);\n\n        let error_code = token_data.error_code.clone();\n\n        let last_external_attempt_at = token_data.modified_at;\n\n        let today = OffsetDateTime::now_utc().date();\n\n        token_map\n            .get_mut(&token_id)\n            .map(|existing_token| {\n                Self::normalize_retry_window(existing_token, today);\n\n                for (date, &value) in &token_data.daily_retry_history {\n                    existing_token\n                        .daily_retry_history\n                        .entry(*date)\n                        .and_modify(|v| *v += value)\n                        .or_insert(value);\n                }\n\n                existing_token\n                    .modified_at\n                    .zip(last_external_attempt_at)\n                    .and_then(|(existing_token_modified_at, last_external_attempt_at)| {\n                        (last_external_attempt_at > existing_token_modified_at)\n                            .then_some(last_external_attempt_at)\n                    })\n                    .or_else(|| {\n                        existing_token\n                            .modified_at\n                            .is_none()\n                            .then_some(last_external_attempt_at)\n                            .flatten()\n                    })\n                    .map(|last_external_attempt_at| {\n                        existing_token.modified_at = Some(last_external_attempt_at);\n                        existing_token.error_code = error_code;\n                        existing_token.is_hard_decline = token_data.is_hard_decline;\n                        token_data\n                            .is_active\n                            .map(|is_active| existing_token.is_active = Some(is_active));\n                    });\n            })\n            .or_else(|| {\n                token_map.insert(token_id.clone(), token_data);\n                None\n            });\n\n        Self::update_or_add_connector_customer_payment_processor_tokens(\n            state,\n            connector_customer_id,\n            token_map,\n        )\n        .await?;\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Upsert payment processor tokens\",\n        );\n\n        Ok(!was_existing)\n    }",
+      "after_code": "pub async fn upsert_payment_processor_token(\n        state: &SessionState,\n        connector_customer_id: &str,\n        token_data: PaymentProcessorTokenStatus,\n    ) -> CustomResult<bool, errors::StorageError> {\n        let mut token_map =\n            Self::get_connector_customer_payment_processor_tokens(state, connector_customer_id)\n                .await?;\n\n        let token_id = token_data\n            .payment_processor_token_details\n            .payment_processor_token\n            .clone();\n\n        let was_existing = token_map.contains_key(&token_id);\n\n        let error_code = token_data.error_code.clone();\n\n        let last_external_attempt_at = token_data.modified_at;\n\n        let today = OffsetDateTime::now_utc().date();\n\n        token_map\n            .get_mut(&token_id)\n            .map(|existing_token| {\n                Self::normalize_retry_window(existing_token, today);\n\n                for (date, &value) in &token_data.daily_retry_history {\n                    existing_token\n                        .daily_retry_history\n                        .entry(*date)\n                        .and_modify(|v| *v += value)\n                        .or_insert(value);\n                }\n                existing_token.account_update_history = token_data.account_update_history.clone();\n                existing_token.payment_processor_token_details = token_data\n                    .payment_processor_token_details\n                    .clone();\n\n                existing_token\n                    .modified_at\n                    .zip(last_external_attempt_at)\n                    .and_then(|(existing_token_modified_at, last_external_attempt_at)| {\n                        (last_external_attempt_at > existing_token_modified_at)\n                            .then_some(last_external_attempt_at)\n                    })\n                    .or_else(|| {\n                        existing_token\n                            .modified_at\n                            .is_none()\n                            .then_some(last_external_attempt_at)\n                            .flatten()\n                    })\n                    .map(|last_external_attempt_at| {\n                        existing_token.modified_at = Some(last_external_attempt_at);\n                        existing_token.error_code = error_code;\n                        existing_token.is_hard_decline = token_data.is_hard_decline;\n                        token_data\n                            .is_active\n                            .map(|is_active| existing_token.is_active = Some(is_active));                        \n                    });\n            })\n            .or_else(|| {\n                token_map.insert(token_id.clone(), token_data);\n                None\n            });\n\n        Self::update_or_add_connector_customer_payment_processor_tokens(\n            state,\n            connector_customer_id,\n            token_map,\n        )\n        .await?;\n        tracing::debug!(\n            connector_customer_id = connector_customer_id,\n            \"Upsert payment processor tokens\",\n        );\n\n        Ok(!was_existing)\n    }",
+      "diff_span": {
+        "before": "                        token_data\n                            .is_active\n                            .map(|is_active| existing_token.is_active = Some(is_active));\n                    });\n            })",
+        "after": "                        .or_insert(value);\n                }\n                existing_token.account_update_history = token_data.account_update_history.clone();\n                existing_token.payment_processor_token_details = token_data\n                    .payment_processor_token_details\n                    .clone();\n\n                existing_token\n                    .modified_at\n                    .zip(last_external_attempt_at)\n                    .and_then(|(existing_token_modified_at, last_external_attempt_at)| {\n                        (last_external_attempt_at > existing_token_modified_at)\n                            .then_some(last_external_attempt_at)\n                    })\n                    .or_else(|| {\n                        existing_token\n                            .modified_at\n                            .is_none()\n                            .then_some(last_external_attempt_at)\n                            .flatten()\n                    })\n                    .map(|last_external_attempt_at| {\n                        existing_token.modified_at = Some(last_external_attempt_at);\n                        existing_token.error_code = error_code;\n                        existing_token.is_hard_decline = token_data.is_hard_decline;\n                        token_data\n                            .is_active\n                            .map(|is_active| existing_token.is_active = Some(is_active));                        \n                    });\n            })"
+      },
+      "commit_sha": "e2383f4ea26f5108df81d36c2d8d651d6b1cee34"
+    }
+  ]
+}

diffs/pr_10112/eafded2/diff.json

@@ -0,0 +1,87 @@
+{
+  "commit_sha": "eafded2a3f0f244a33c9e9ed24d687c71dcdc48c",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/api_models/src/payments.rs",
+    "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs",
+    "crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs",
+    "crates/hyperswitch_connectors/src/connectors/stripe/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs::impl::PaymentsExtendAuthorizationRouterData",
+      "file": "crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<PaymentsExtendAuthorizationResponseRouterData<PaypalExtendedAuthResponse>>\n    for PaymentsExtendAuthorizationRouterData\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: PaymentsExtendAuthorizationResponseRouterData<PaypalExtendedAuthResponse>,\n    ) -> Result<Self, Self::Error> {\n        let extend_authorization_response = ExtendedAuthorizationResponseData {\n            extended_authentication_applied: is_extend_authorization_applied(\n                item.response.status.clone(),\n            ),\n            capture_before: item.response.expiration_time,\n            extended_authorization_last_applied_at: item.response.create_time,\n        };\n\n        let connector_response = Some(ConnectorResponseData::new(\n            None,\n            None,\n            Some(extend_authorization_response),\n            None\n        ));\n\n        let status = common_enums::AttemptStatus::from(item.response.status.clone());\n        let response = if is_payment_failure(status) {\n            let reason = item\n                .response\n                .status_details\n                .and_then(|status_details| status_details.reason.map(|reason| reason.to_string()));\n\n            Err(ErrorResponse {\n                code: reason\n                    .clone()\n                    .unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                message: reason\n                    .clone()\n                    .unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),\n                reason,\n                status_code: item.http_code,\n                attempt_status: None,\n                connector_transaction_id: None,\n                network_advice_code: None,\n                network_decline_code: None,\n                network_error_message: None,\n                connector_metadata: None,\n                mandate_reference: None,\n            })\n        } else {\n            Ok(PaymentsResponseData::TransactionResponse {\n                resource_id: ResponseId::NoResponseId,\n                redirection_data: Box::new(None),\n                mandate_reference: Box::new(None),\n                connector_metadata: None,\n                network_txn_id: None,\n                connector_response_reference_id: None,\n                incremental_authorization_allowed: None,\n                charges: None,\n            })\n        };\n\n        Ok(Self {\n            status,\n            response,\n            connector_response,\n            ..item.data\n        })\n    }\n}",
+      "after_code": "impl TryFrom<PaymentsExtendAuthorizationResponseRouterData<PaypalExtendedAuthResponse>>\n    for PaymentsExtendAuthorizationRouterData\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: PaymentsExtendAuthorizationResponseRouterData<PaypalExtendedAuthResponse>,\n    ) -> Result<Self, Self::Error> {\n        let extend_authorization_response = ExtendedAuthorizationResponseData {\n            extended_authentication_applied: is_extend_authorization_applied(\n                item.response.status.clone(),\n            ),\n            capture_before: item.response.expiration_time,\n            extended_authorization_last_applied_at: item.response.create_time,\n        };\n\n        let connector_response = Some(ConnectorResponseData::new(\n            None,\n            None,\n            Some(extend_authorization_response),\n            None,\n        ));\n\n        let status = common_enums::AttemptStatus::from(item.response.status.clone());\n        let response = if is_payment_failure(status) {\n            let reason = item\n                .response\n                .status_details\n                .and_then(|status_details| status_details.reason.map(|reason| reason.to_string()));\n\n            Err(ErrorResponse {\n                code: reason\n                    .clone()\n                    .unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                message: reason\n                    .clone()\n                    .unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),\n                reason,\n                status_code: item.http_code,\n                attempt_status: None,\n                connector_transaction_id: None,\n                network_advice_code: None,\n                network_decline_code: None,\n                network_error_message: None,\n                connector_metadata: None,\n                mandate_reference: None,\n            })\n        } else {\n            Ok(PaymentsResponseData::TransactionResponse {\n                resource_id: ResponseId::NoResponseId,\n                redirection_data: Box::new(None),\n                mandate_reference: Box::new(None),\n                connector_metadata: None,\n                network_txn_id: None,\n                connector_response_reference_id: None,\n                incremental_authorization_allowed: None,\n                charges: None,\n            })\n        };\n\n        Ok(Self {\n            status,\n            response,\n            connector_response,\n            ..item.data\n        })\n    }\n}",
+      "diff_span": {
+        "before": "            None,\n            Some(extend_authorization_response),\n            None\n        ));\n",
+        "after": "            None,\n            Some(extend_authorization_response),\n            None,\n        ));\n"
+      },
+      "commit_sha": "eafded2a3f0f244a33c9e9ed24d687c71dcdc48c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs::PaymentsExtendAuthorizationRouterData::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/paypal/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: PaymentsExtendAuthorizationResponseRouterData<PaypalExtendedAuthResponse>,\n    ) -> Result<Self, Self::Error> {\n        let extend_authorization_response = ExtendedAuthorizationResponseData {\n            extended_authentication_applied: is_extend_authorization_applied(\n                item.response.status.clone(),\n            ),\n            capture_before: item.response.expiration_time,\n            extended_authorization_last_applied_at: item.response.create_time,\n        };\n\n        let connector_response = Some(ConnectorResponseData::new(\n            None,\n            None,\n            Some(extend_authorization_response),\n            None\n        ));\n\n        let status = common_enums::AttemptStatus::from(item.response.status.clone());\n        let response = if is_payment_failure(status) {\n            let reason = item\n                .response\n                .status_details\n                .and_then(|status_details| status_details.reason.map(|reason| reason.to_string()));\n\n            Err(ErrorResponse {\n                code: reason\n                    .clone()\n                    .unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                message: reason\n                    .clone()\n                    .unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),\n                reason,\n                status_code: item.http_code,\n                attempt_status: None,\n                connector_transaction_id: None,\n                network_advice_code: None,\n                network_decline_code: None,\n                network_error_message: None,\n                connector_metadata: None,\n                mandate_reference: None,\n            })\n        } else {\n            Ok(PaymentsResponseData::TransactionResponse {\n                resource_id: ResponseId::NoResponseId,\n                redirection_data: Box::new(None),\n                mandate_reference: Box::new(None),\n                connector_metadata: None,\n                network_txn_id: None,\n                connector_response_reference_id: None,\n                incremental_authorization_allowed: None,\n                charges: None,\n            })\n        };\n\n        Ok(Self {\n            status,\n            response,\n            connector_response,\n            ..item.data\n        })\n    }",
+      "after_code": "fn try_from(\n        item: PaymentsExtendAuthorizationResponseRouterData<PaypalExtendedAuthResponse>,\n    ) -> Result<Self, Self::Error> {\n        let extend_authorization_response = ExtendedAuthorizationResponseData {\n            extended_authentication_applied: is_extend_authorization_applied(\n                item.response.status.clone(),\n            ),\n            capture_before: item.response.expiration_time,\n            extended_authorization_last_applied_at: item.response.create_time,\n        };\n\n        let connector_response = Some(ConnectorResponseData::new(\n            None,\n            None,\n            Some(extend_authorization_response),\n            None,\n        ));\n\n        let status = common_enums::AttemptStatus::from(item.response.status.clone());\n        let response = if is_payment_failure(status) {\n            let reason = item\n                .response\n                .status_details\n                .and_then(|status_details| status_details.reason.map(|reason| reason.to_string()));\n\n            Err(ErrorResponse {\n                code: reason\n                    .clone()\n                    .unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                message: reason\n                    .clone()\n                    .unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),\n                reason,\n                status_code: item.http_code,\n                attempt_status: None,\n                connector_transaction_id: None,\n                network_advice_code: None,\n                network_decline_code: None,\n                network_error_message: None,\n                connector_metadata: None,\n                mandate_reference: None,\n            })\n        } else {\n            Ok(PaymentsResponseData::TransactionResponse {\n                resource_id: ResponseId::NoResponseId,\n                redirection_data: Box::new(None),\n                mandate_reference: Box::new(None),\n                connector_metadata: None,\n                network_txn_id: None,\n                connector_response_reference_id: None,\n                incremental_authorization_allowed: None,\n                charges: None,\n            })\n        };\n\n        Ok(Self {\n            status,\n            response,\n            connector_response,\n            ..item.data\n        })\n    }",
+      "diff_span": {
+        "before": "            None,\n            Some(extend_authorization_response),\n            None\n        ));\n",
+        "after": "            None,\n            Some(extend_authorization_response),\n            None,\n        ));\n"
+      },
+      "commit_sha": "eafded2a3f0f244a33c9e9ed24d687c71dcdc48c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/stripe/transformers.rs::function::extract_payment_method_connector_response_from_latest_charge",
+      "file": "crates/hyperswitch_connectors/src/connectors/stripe/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn extract_payment_method_connector_response_from_latest_charge(\n    stripe_charge_enum: &StripeChargeEnum,\n    created_at: Option<PrimitiveDateTime>,\n) -> Option<ConnectorResponseData> {\n    let is_overcapture_enabled = stripe_charge_enum.get_overcapture_status();\n    let additional_payment_method_details =\n        if let StripeChargeEnum::ChargeObject(charge_object) = stripe_charge_enum {\n            charge_object\n                .payment_method_details\n                .as_ref()\n                .and_then(StripePaymentMethodDetailsResponse::get_additional_payment_method_data)\n        } else {\n            None\n        };\n\n    let additional_payment_method_data = additional_payment_method_details\n        .as_ref()\n        .map(AdditionalPaymentMethodConnectorResponse::from);\n    let extended_authorization_data =\n        additional_payment_method_details\n            .as_ref()\n            .and_then(|additional_payment_methods_details| {\n                get_extended_authorization_data(additional_payment_methods_details, created_at)\n            });\n\n    if additional_payment_method_data.is_some()\n        || extended_authorization_data.is_some()\n        || is_overcapture_enabled.is_some()\n    {\n        Some(ConnectorResponseData::new(\n            additional_payment_method_data,\n            is_overcapture_enabled,\n            extended_authorization_data,\n            None\n        ))\n    } else {\n        None\n    }\n}",
+      "after_code": "fn extract_payment_method_connector_response_from_latest_charge(\n    stripe_charge_enum: &StripeChargeEnum,\n    created_at: Option<PrimitiveDateTime>,\n) -> Option<ConnectorResponseData> {\n    let is_overcapture_enabled = stripe_charge_enum.get_overcapture_status();\n    let additional_payment_method_details =\n        if let StripeChargeEnum::ChargeObject(charge_object) = stripe_charge_enum {\n            charge_object\n                .payment_method_details\n                .as_ref()\n                .and_then(StripePaymentMethodDetailsResponse::get_additional_payment_method_data)\n        } else {\n            None\n        };\n\n    let additional_payment_method_data = additional_payment_method_details\n        .as_ref()\n        .map(AdditionalPaymentMethodConnectorResponse::from);\n    let extended_authorization_data =\n        additional_payment_method_details\n            .as_ref()\n            .and_then(|additional_payment_methods_details| {\n                get_extended_authorization_data(additional_payment_methods_details, created_at)\n            });\n\n    if additional_payment_method_data.is_some()\n        || extended_authorization_data.is_some()\n        || is_overcapture_enabled.is_some()\n    {\n        Some(ConnectorResponseData::new(\n            additional_payment_method_data,\n            is_overcapture_enabled,\n            extended_authorization_data,\n            None,\n        ))\n    } else {\n        None\n    }\n}",
+      "diff_span": {
+        "before": "            is_overcapture_enabled,\n            extended_authorization_data,\n            None\n        ))\n    } else {",
+        "after": "            is_overcapture_enabled,\n            extended_authorization_data,\n            None,\n        ))\n    } else {"
+      },
+      "commit_sha": "eafded2a3f0f244a33c9e9ed24d687c71dcdc48c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs::function::build_connector_response",
+      "file": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn build_connector_response(\n    adyen_webhook_response: &AdyenWebhookResponse,\n) -> Option<ConnectorResponseData> {\n    let extended_authentication_applied = match adyen_webhook_response.status {\n        AdyenWebhookStatus::AdjustedAuthorization => {\n            Some(common_types::primitive_wrappers::ExtendedAuthorizationAppliedBool::from(true))\n        }\n        AdyenWebhookStatus::AdjustAuthorizationFailed => {\n            Some(common_types::primitive_wrappers::ExtendedAuthorizationAppliedBool::from(false))\n        }\n        _ => None,\n    };\n\n    let extended_authorization_last_applied_at = extended_authentication_applied\n        .filter(|val| *val.deref())\n        .and(adyen_webhook_response.event_date);\n\n    let extend_authorization_response = ExtendedAuthorizationResponseData {\n        extended_authentication_applied,\n        capture_before: None,\n        extended_authorization_last_applied_at,\n    };\n\n    Some(ConnectorResponseData::new(\n        None,\n        None,\n        Some(extend_authorization_response),\n        None\n    ))\n}",
+      "after_code": "fn build_connector_response(\n    adyen_webhook_response: &AdyenWebhookResponse,\n) -> Option<ConnectorResponseData> {\n    let extended_authentication_applied = match adyen_webhook_response.status {\n        AdyenWebhookStatus::AdjustedAuthorization => {\n            Some(common_types::primitive_wrappers::ExtendedAuthorizationAppliedBool::from(true))\n        }\n        AdyenWebhookStatus::AdjustAuthorizationFailed => {\n            Some(common_types::primitive_wrappers::ExtendedAuthorizationAppliedBool::from(false))\n        }\n        _ => None,\n    };\n\n    let extended_authorization_last_applied_at = extended_authentication_applied\n        .filter(|val| *val.deref())\n        .and(adyen_webhook_response.event_date);\n\n    let extend_authorization_response = ExtendedAuthorizationResponseData {\n        extended_authentication_applied,\n        capture_before: None,\n        extended_authorization_last_applied_at,\n    };\n\n    Some(ConnectorResponseData::new(\n        None,\n        None,\n        Some(extend_authorization_response),\n        None,\n    ))\n}",
+      "diff_span": {
+        "before": "        None,\n        Some(extend_authorization_response),\n        None\n    ))\n}",
+        "after": "        None,\n        Some(extend_authorization_response),\n        None,\n    ))\n}"
+      },
+      "commit_sha": "eafded2a3f0f244a33c9e9ed24d687c71dcdc48c"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::MandateIds::function::get_updated_mandate_details_of_connector_mandate_id",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_updated_mandate_details_of_connector_mandate_id(&self) -> Option<UpdatedMandateDetails>{\n        match &self.mandate_reference_id {\n            Some(MandateReferenceId::ConnectorMandateId(data)) => data.updated_mandate_details.clone(),\n            _ => None,\n        }\n    }",
+      "after_code": "pub fn get_updated_mandate_details_of_connector_mandate_id(\n        &self,\n    ) -> Option<UpdatedMandateDetails> {\n        match &self.mandate_reference_id {\n            Some(MandateReferenceId::ConnectorMandateId(data)) => {\n                data.updated_mandate_details.clone()\n            }\n            _ => None,\n        }\n    }",
+      "diff_span": {
+        "before": "pub fn get_updated_mandate_details_of_connector_mandate_id(&self) -> Option<UpdatedMandateDetails>{\n        match &self.mandate_reference_id {\n            Some(MandateReferenceId::ConnectorMandateId(data)) => data.updated_mandate_details.clone(),\n            _ => None,\n        }",
+        "after": "pub fn get_updated_mandate_details_of_connector_mandate_id(\n        &self,\n    ) -> Option<UpdatedMandateDetails> {\n        match &self.mandate_reference_id {\n            Some(MandateReferenceId::ConnectorMandateId(data)) => {\n                data.updated_mandate_details.clone()\n            }\n            _ => None,\n        }"
+      },
+      "commit_sha": "eafded2a3f0f244a33c9e9ed24d687c71dcdc48c"
+    }
+  ]
+}

diffs/pr_10112/ebffba6/diff.json

@@ -0,0 +1,49 @@
+{
+  "commit_sha": "ebffba69f8cfcd4d6a4ea91fb7d9461d58bf34b8",
+  "pr_number": 10112,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {\n            (Some(sale_response), None) => {\n                let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;\n\n                // While making an authorize flow call to WorldpayVantiv, if Account Updater is enabled then we well get new card token info in response.\n                // We are extracting that new card token info here to be sent back in mandate_id in router_data.\n                let mandate_reference_data = match item.data.request.is_mandate_payment() {\n                    true => {\n                        if let Some(account_updater) = sale_response.account_updater.as_ref() {\n                            account_updater\n                                .new_card_token_info\n                                .clone()\n                                .map(MandateReference::from)\n                        } else {\n                            sale_response\n                                .token_response\n                                .clone()\n                                .map(MandateReference::from)\n                        }\n                    }\n                    false => sale_response\n                        .token_response\n                        .clone()\n                        .map(MandateReference::from)\n                };\n\n\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .sale_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| sale_response.message.clone());\n\n\n                    Ok(Self {\n                        connector_response: Some(ConnectorResponseData::new(None, None,None, mandate_reference_data.clone())),\n                        status,\n                        response: Err(ErrorResponse {\n                            code: sale_response.response.to_string(),\n                            message: sale_response.message.clone(),\n                            reason: Some(sale_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(sale_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(sale_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),\n                        minor_amount_captured: sale_response.approved_amount,\n                        ..item.data\n                    })\n                }\n            },\n            (None, Some(auth_response)) => {\n                let payment_flow_type = if item.data.request.is_auto_capture()? {\n                    WorldpayvantivPaymentFlow::Sale\n                } else {\n                    WorldpayvantivPaymentFlow::Auth\n                };\n\n                let status = get_attempt_status(payment_flow_type, auth_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .authorization_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| auth_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: auth_response.response.to_string(),\n                            message: auth_response.message.clone(),\n                            reason: Some(auth_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(auth_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);\n                    let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(auth_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)\n                        } else {\n                            None\n                        },\n                        minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        ..item.data\n                    })\n                }\n            },\n            (None, None) => {\n                Ok(Self {\n                status: common_enums::AttemptStatus::Failure,\n                response: Err(ErrorResponse {\n                    code: item.response.response_code.clone(),\n                    message: item.response.message.clone(),\n                    reason: Some(item.response.message.clone()),\n                    status_code: item.http_code,\n                    attempt_status: None,\n                    connector_transaction_id: None, // Transaction id not created at connector\n                    network_advice_code: None,\n                    network_decline_code: None,\n                    network_error_message: None,\n                    connector_metadata: None,\n                }),\n                ..item.data\n            })},\n            (_, _) => {  Err(errors::ConnectorError::UnexpectedResponseError(\n                bytes::Bytes::from(\"Only one of 'sale_response' or 'authorisation_response' is expected, but both were received\".to_string()),           \n             ))?\n            },\n    }\n    }",
+      "after_code": "fn try_from(\n        item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {\n            (Some(sale_response), None) => {\n                let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;\n\n                // While making an authorize flow call to WorldpayVantiv, if Account Updater is enabled then we well get new card token info in response.\n                // We are extracting that new card token info here to be sent back in mandate_id in router_data.\n                let mandate_reference_data = match item.data.request.is_mandate_payment() {\n                    true => {\n                        if let Some(account_updater) = sale_response.account_updater.as_ref() {\n                            account_updater\n                                .new_card_token_info\n                                .clone()\n                                .map(MandateReference::from)\n                        } else {\n                            sale_response\n                                .token_response\n                                .clone()\n                                .map(MandateReference::from)\n                        }\n                    }\n                    false => sale_response\n                        .token_response\n                        .clone()\n                        .map(MandateReference::from)\n                };\n\n\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .sale_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| sale_response.message.clone());\n\n\n                    Ok(Self {\n                        connector_response: Some(ConnectorResponseData::new(None, None,None, mandate_reference_data.clone())),\n                        status,\n                        response: Err(ErrorResponse {\n                            code: sale_response.response.to_string(),\n                            message: sale_response.message.clone(),\n                            reason: Some(sale_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(sale_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let additional_payment_method_connector_response = sale_response.fraud_result.as_ref().map(get_additional_payment_method_connector_response);\n                    let connector_response = Some(ConnectorResponseData::new(\n                        additional_payment_method_connector_response,\n                        None,\n                        None,\n                        mandate_reference_data.clone(),\n                    ));\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(sale_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),\n                        minor_amount_captured: sale_response.approved_amount,\n                        ..item.data\n                    })\n                }\n            },\n            (None, Some(auth_response)) => {\n                let payment_flow_type = if item.data.request.is_auto_capture()? {\n                    WorldpayvantivPaymentFlow::Sale\n                } else {\n                    WorldpayvantivPaymentFlow::Auth\n                };\n\n                let status = get_attempt_status(payment_flow_type, auth_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .authorization_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| auth_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: auth_response.response.to_string(),\n                            message: auth_response.message.clone(),\n                            reason: Some(auth_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(auth_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);\n                    let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(auth_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)\n                        } else {\n                            None\n                        },\n                        minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        ..item.data\n                    })\n                }\n            },\n            (None, None) => {\n                Ok(Self {\n                status: common_enums::AttemptStatus::Failure,\n                response: Err(ErrorResponse {\n                    code: item.response.response_code.clone(),\n                    message: item.response.message.clone(),\n                    reason: Some(item.response.message.clone()),\n                    status_code: item.http_code,\n                    attempt_status: None,\n                    connector_transaction_id: None, // Transaction id not created at connector\n                    network_advice_code: None,\n                    network_decline_code: None,\n                    network_error_message: None,\n                    connector_metadata: None,\n                }),\n                ..item.data\n            })},\n            (_, _) => {  Err(errors::ConnectorError::UnexpectedResponseError(\n                bytes::Bytes::from(\"Only one of 'sale_response' or 'authorisation_response' is expected, but both were received\".to_string()),           \n             ))?\n            },\n    }\n    }",
+      "diff_span": {
+        "before": "                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {",
+        "after": "                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let additional_payment_method_connector_response = sale_response.fraud_result.as_ref().map(get_additional_payment_method_connector_response);\n                    let connector_response = Some(ConnectorResponseData::new(\n                        additional_payment_method_connector_response,\n                        None,\n                        None,\n                        mandate_reference_data.clone(),\n                    ));\n\n                    Ok(Self {"
+      },
+      "commit_sha": "ebffba69f8cfcd4d6a4ea91fb7d9461d58bf34b8"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::impl::RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F>\n    TryFrom<ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>>\n    for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {\n            (Some(sale_response), None) => {\n                let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;\n\n                // While making an authorize flow call to WorldpayVantiv, if Account Updater is enabled then we well get new card token info in response.\n                // We are extracting that new card token info here to be sent back in mandate_id in router_data.\n                let mandate_reference_data = match item.data.request.is_mandate_payment() {\n                    true => {\n                        if let Some(account_updater) = sale_response.account_updater.as_ref() {\n                            account_updater\n                                .new_card_token_info\n                                .clone()\n                                .map(MandateReference::from)\n                        } else {\n                            sale_response\n                                .token_response\n                                .clone()\n                                .map(MandateReference::from)\n                        }\n                    }\n                    false => sale_response\n                        .token_response\n                        .clone()\n                        .map(MandateReference::from)\n                };\n\n\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .sale_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| sale_response.message.clone());\n\n\n                    Ok(Self {\n                        connector_response: Some(ConnectorResponseData::new(None, None,None, mandate_reference_data.clone())),\n                        status,\n                        response: Err(ErrorResponse {\n                            code: sale_response.response.to_string(),\n                            message: sale_response.message.clone(),\n                            reason: Some(sale_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(sale_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(sale_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),\n                        minor_amount_captured: sale_response.approved_amount,\n                        ..item.data\n                    })\n                }\n            },\n            (None, Some(auth_response)) => {\n                let payment_flow_type = if item.data.request.is_auto_capture()? {\n                    WorldpayvantivPaymentFlow::Sale\n                } else {\n                    WorldpayvantivPaymentFlow::Auth\n                };\n\n                let status = get_attempt_status(payment_flow_type, auth_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .authorization_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| auth_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: auth_response.response.to_string(),\n                            message: auth_response.message.clone(),\n                            reason: Some(auth_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(auth_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);\n                    let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(auth_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)\n                        } else {\n                            None\n                        },\n                        minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        ..item.data\n                    })\n                }\n            },\n            (None, None) => {\n                Ok(Self {\n                status: common_enums::AttemptStatus::Failure,\n                response: Err(ErrorResponse {\n                    code: item.response.response_code.clone(),\n                    message: item.response.message.clone(),\n                    reason: Some(item.response.message.clone()),\n                    status_code: item.http_code,\n                    attempt_status: None,\n                    connector_transaction_id: None, // Transaction id not created at connector\n                    network_advice_code: None,\n                    network_decline_code: None,\n                    network_error_message: None,\n                    connector_metadata: None,\n                }),\n                ..item.data\n            })},\n            (_, _) => {  Err(errors::ConnectorError::UnexpectedResponseError(\n                bytes::Bytes::from(\"Only one of 'sale_response' or 'authorisation_response' is expected, but both were received\".to_string()),           \n             ))?\n            },\n    }\n    }\n}",
+      "after_code": "impl<F>\n    TryFrom<ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>>\n    for RouterData<F, PaymentsAuthorizeData, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: ResponseRouterData<F, CnpOnlineResponse, PaymentsAuthorizeData, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match (item.response.sale_response.as_ref(), item.response.authorization_response.as_ref()) {\n            (Some(sale_response), None) => {\n                let status = get_attempt_status(WorldpayvantivPaymentFlow::Sale, sale_response.response)?;\n\n                // While making an authorize flow call to WorldpayVantiv, if Account Updater is enabled then we well get new card token info in response.\n                // We are extracting that new card token info here to be sent back in mandate_id in router_data.\n                let mandate_reference_data = match item.data.request.is_mandate_payment() {\n                    true => {\n                        if let Some(account_updater) = sale_response.account_updater.as_ref() {\n                            account_updater\n                                .new_card_token_info\n                                .clone()\n                                .map(MandateReference::from)\n                        } else {\n                            sale_response\n                                .token_response\n                                .clone()\n                                .map(MandateReference::from)\n                        }\n                    }\n                    false => sale_response\n                        .token_response\n                        .clone()\n                        .map(MandateReference::from)\n                };\n\n\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .sale_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| sale_response.message.clone());\n\n\n                    Ok(Self {\n                        connector_response: Some(ConnectorResponseData::new(None, None,None, mandate_reference_data.clone())),\n                        status,\n                        response: Err(ErrorResponse {\n                            code: sale_response.response.to_string(),\n                            message: sale_response.message.clone(),\n                            reason: Some(sale_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(sale_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(sale_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let additional_payment_method_connector_response = sale_response.fraud_result.as_ref().map(get_additional_payment_method_connector_response);\n                    let connector_response = Some(ConnectorResponseData::new(\n                        additional_payment_method_connector_response,\n                        None,\n                        None,\n                        mandate_reference_data.clone(),\n                    ));\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(sale_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: sale_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(sale_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: sale_response.approved_amount.map(MinorUnit::get_amount_as_i64),\n                        minor_amount_captured: sale_response.approved_amount,\n                        ..item.data\n                    })\n                }\n            },\n            (None, Some(auth_response)) => {\n                let payment_flow_type = if item.data.request.is_auto_capture()? {\n                    WorldpayvantivPaymentFlow::Sale\n                } else {\n                    WorldpayvantivPaymentFlow::Auth\n                };\n\n                let status = get_attempt_status(payment_flow_type, auth_response.response)?;\n                if connector_utils::is_payment_failure(status) {\n                    let network_decline_code = item\n                    .response\n                    .authorization_response\n                    .as_ref()\n                    .and_then(|pr| pr.enhanced_auth_response.as_ref())\n                    .and_then(|ea| ea.network_response.as_ref())\n                    .and_then(|nr| {\n                        nr.network_fields\n                            .iter()\n                            .find(|f| f.field_number == *worldpayvantiv_constants::MAC_FIELD_NUMBER)\n                            .and_then(|f| f.field_value.clone())\n                    });\n\n                let network_error_message = network_decline_code\n                    .as_ref()\n                    .map(|_| auth_response.message.clone());\n                    Ok(Self {\n                        status,\n                        response: Err(ErrorResponse {\n                            code: auth_response.response.to_string(),\n                            message: auth_response.message.clone(),\n                            reason: Some(auth_response.message.clone()),\n                            status_code: item.http_code,\n                            attempt_status: None,\n                            connector_transaction_id: Some(auth_response.cnp_txn_id.clone()),\n                            network_advice_code: None,\n                            network_decline_code,\n                            network_error_message,\n                            connector_metadata: None,\n                        }),\n                        ..item.data\n                    })\n                } else {\n                    let report_group = WorldpayvantivPaymentMetadata {\n                        report_group: Some(auth_response.report_group.clone()),\n                    };\n                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let mandate_reference_data = auth_response.token_response.clone().map(MandateReference::from);\n                    let connector_response = auth_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {\n                        status,\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(auth_response.cnp_txn_id.clone()),\n                            redirection_data: Box::new(None),\n                            mandate_reference: Box::new(mandate_reference_data),\n                            connector_metadata,\n                            network_txn_id: auth_response.network_transaction_id.clone().map(|network_transaction_id| network_transaction_id.expose()),\n                            connector_response_reference_id: Some(auth_response.order_id.clone()),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        connector_response,\n                        amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount.map(MinorUnit::get_amount_as_i64)\n                        } else {\n                            None\n                        },\n                        minor_amount_capturable: if payment_flow_type == WorldpayvantivPaymentFlow::Auth {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        minor_amount_captured: if payment_flow_type == WorldpayvantivPaymentFlow::Sale {\n                            auth_response.approved_amount\n                        } else {\n                            None\n                        },\n                        ..item.data\n                    })\n                }\n            },\n            (None, None) => {\n                Ok(Self {\n                status: common_enums::AttemptStatus::Failure,\n                response: Err(ErrorResponse {\n                    code: item.response.response_code.clone(),\n                    message: item.response.message.clone(),\n                    reason: Some(item.response.message.clone()),\n                    status_code: item.http_code,\n                    attempt_status: None,\n                    connector_transaction_id: None, // Transaction id not created at connector\n                    network_advice_code: None,\n                    network_decline_code: None,\n                    network_error_message: None,\n                    connector_metadata: None,\n                }),\n                ..item.data\n            })},\n            (_, _) => {  Err(errors::ConnectorError::UnexpectedResponseError(\n                bytes::Bytes::from(\"Only one of 'sale_response' or 'authorisation_response' is expected, but both were received\".to_string()),           \n             ))?\n            },\n    }\n    }\n}",
+      "diff_span": {
+        "before": "                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let connector_response = sale_response.fraud_result.as_ref().map(get_connector_response);\n\n                    Ok(Self {",
+        "after": "                    let connector_metadata =   Some(report_group.encode_to_value()\n                    .change_context(errors::ConnectorError::ResponseHandlingFailed)?);\n                    let additional_payment_method_connector_response = sale_response.fraud_result.as_ref().map(get_additional_payment_method_connector_response);\n                    let connector_response = Some(ConnectorResponseData::new(\n                        additional_payment_method_connector_response,\n                        None,\n                        None,\n                        mandate_reference_data.clone(),\n                    ));\n\n                    Ok(Self {"
+      },
+      "commit_sha": "ebffba69f8cfcd4d6a4ea91fb7d9461d58bf34b8"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs::function::get_additional_payment_method_connector_response",
+      "file": "crates/hyperswitch_connectors/src/connectors/worldpayvantiv/transformers.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_additional_payment_method_connector_response(\n    payment_response: &FraudResult,\n) -> AdditionalPaymentMethodConnectorResponse {\n    let payment_checks = Some(serde_json::json!({\n        \"avs_result\": payment_response.avs_result,\n        \"card_validation_result\": payment_response.card_validation_result,\n        \"authentication_result\": payment_response.authentication_result,\n        \"advanced_a_v_s_result\": payment_response.advanced_a_v_s_result,\n    }));\n\n    AdditionalPaymentMethodConnectorResponse::Card {\n        authentication_data: None,\n        payment_checks,\n        card_network: None,\n        domestic_network: None,\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "ebffba69f8cfcd4d6a4ea91fb7d9461d58bf34b8"
+    }
+  ]
+}

diffs/pr_10198/dd9c33d/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "dd9c33df6c23a34dae0281bc053c8e58ec635ad4",
+  "pr_number": 10198,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10409/6c8501d/diff.json

@@ -0,0 +1,105 @@
+{
+  "commit_sha": "6c8501db6097b9297de2253ca21bce93a0c232e8",
+  "pr_number": 10409,
+  "rust_files": [
+    "crates/common_enums/src/enums.rs",
+    "crates/router/src/core/webhooks/incoming.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/common_enums/src/enums.rs::impl::PayoutStatus",
+      "file": "crates/common_enums/src/enums.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl PayoutStatus {\n    pub fn is_payout_failure(&self) -> bool {\n        matches!(\n            self,\n            Self::Failed | Self::Cancelled | Self::Expired | Self::Ineligible\n        )\n    }\n}",
+      "after_code": "impl PayoutStatus {\n    pub fn is_payout_failure(&self) -> bool {\n        matches!(\n            self,\n            Self::Failed | Self::Cancelled | Self::Expired | Self::Ineligible\n        )\n    }\n\n    pub fn is_non_terminal_status(&self) -> bool {\n        !matches!(\n            self,\n            Self::Success | Self::Failed | Self::Cancelled | Self::Expired | Self::Reversed\n        )\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        )\n    }\n\n    pub fn is_non_terminal_status(&self) -> bool {\n        !matches!(\n            self,\n            Self::Success | Self::Failed | Self::Cancelled | Self::Expired | Self::Reversed\n        )\n    }\n}"
+      },
+      "commit_sha": "6c8501db6097b9297de2253ca21bce93a0c232e8"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::payouts_incoming_webhook_flow",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "async fn payouts_incoming_webhook_flow(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    business_profile: domain::Profile,\n    webhook_details: api::IncomingWebhookDetails,\n    event_type: webhooks::IncomingWebhookEvent,\n    source_verified: bool,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_METRIC.add(1, &[]);\n    let db = &*state.store;\n    //find payout_attempt by object_reference_id\n    let payout_attempt = match webhook_details.object_reference_id {\n        webhooks::ObjectReferenceId::PayoutId(payout_id_type) => match payout_id_type {\n            webhooks::PayoutIdType::PayoutAttemptId(id) => db\n                .find_payout_attempt_by_merchant_id_payout_attempt_id(\n                    merchant_context.get_merchant_account().get_id(),\n                    &id,\n                    merchant_context.get_merchant_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n            webhooks::PayoutIdType::ConnectorPayoutId(id) => db\n                .find_payout_attempt_by_merchant_id_connector_payout_id(\n                    merchant_context.get_merchant_account().get_id(),\n                    &id,\n                    merchant_context.get_merchant_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n        },\n        _ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"received a non-payout id when processing payout webhooks\")?,\n    };\n\n    let payouts = db\n        .find_payout_by_merchant_id_payout_id(\n            merchant_context.get_merchant_account().get_id(),\n            &payout_attempt.payout_id,\n            merchant_context.get_merchant_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n        .attach_printable(\"Failed to fetch the payout\")?;\n    let action_req =\n        payout_models::PayoutRequest::PayoutActionRequest(payout_models::PayoutActionRequest {\n            payout_id: payouts.payout_id.clone(),\n        });\n\n    let mut payout_data = Box::pin(payouts::make_payout_data(\n        &state,\n        &merchant_context,\n        None,\n        &action_req,\n        common_utils::consts::DEFAULT_LOCALE,\n    ))\n    .await?;\n\n    if source_verified {\n        let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n            .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"failed payout status mapping from event type\")?;\n\n        let payout_webhook_details = connector\n            .get_payout_webhook_details(request_details)\n            .switch()\n            .attach_printable(\"Failed to get error object for payouts\")?;\n\n        // if status is failure then update the error_code and error_message as well\n        let payout_attempt_update = if status.is_payout_failure() {\n            PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_attempt.connector_payout_id.clone(),\n                status,\n                error_message: payout_webhook_details.error_message,\n                error_code: payout_webhook_details.error_code,\n                is_eligible: payout_attempt.is_eligible,\n                unified_code: None,\n                unified_message: None,\n                payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n            }\n        } else {\n            PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_attempt.connector_payout_id.clone(),\n                status,\n                error_message: None,\n                error_code: None,\n                is_eligible: payout_attempt.is_eligible,\n                unified_code: None,\n                unified_message: None,\n                payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n            }\n        };\n\n        let updated_payout_attempt = db\n            .update_payout_attempt(\n                &payout_attempt,\n                payout_attempt_update,\n                &payout_data.payouts,\n                merchant_context.get_merchant_account().storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n            .attach_printable_lazy(|| {\n                format!(\n                    \"Failed while updating payout attempt: payout_attempt_id: {}\",\n                    payout_attempt.payout_attempt_id\n                )\n            })?;\n        payout_data.payout_attempt = updated_payout_attempt;\n\n        let event_type: Option<enums::EventType> = payout_data.payout_attempt.status.into();\n\n        // If event is NOT an UnsupportedEvent, trigger Outgoing Webhook\n        if let Some(outgoing_event_type) = event_type {\n            let payout_create_response =\n                payouts::response_handler(&state, &merchant_context, &payout_data).await?;\n\n            Box::pin(super::create_event_and_trigger_outgoing_webhook(\n                state,\n                merchant_context,\n                business_profile,\n                outgoing_event_type,\n                enums::EventClass::Payouts,\n                payout_data\n                    .payout_attempt\n                    .payout_id\n                    .get_string_repr()\n                    .to_string(),\n                enums::EventObjectType::PayoutDetails,\n                api::OutgoingWebhookContent::PayoutDetails(Box::new(payout_create_response)),\n                Some(payout_data.payout_attempt.created_at),\n            ))\n            .await?;\n        }\n\n        Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        })\n    } else {\n        metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n        // Form connector data\n        let connector_data = match &payout_attempt.connector {\n            Some(connector) => ConnectorData::get_payout_connector_by_name(\n                &state.conf.connectors,\n                connector,\n                GetToken::Connector,\n                payout_attempt.merchant_connector_id.clone(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get the connector data\")?,\n            _ => Err(errors::ApplicationError::InvalidConfigurationValueError(\n                \"Connector not found in payout_attempt - should not reach here.\".to_string(),\n            ))\n            .change_context(errors::ApiErrorResponse::MissingRequiredField {\n                field_name: \"connector\",\n            })\n            .attach_printable(\"Connector not found for payout fulfillment\")?,\n        };\n\n        Box::pin(payouts::create_payout_retrieve(\n            &state,\n            &merchant_context,\n            &connector_data,\n            &mut payout_data,\n        ))\n        .await\n        .attach_printable(\"Payout retrieval failed for given Payout request\")?;\n\n        Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        })\n    }\n}",
+      "after_code": "async fn payouts_incoming_webhook_flow(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    business_profile: domain::Profile,\n    webhook_details: api::IncomingWebhookDetails,\n    event_type: webhooks::IncomingWebhookEvent,\n    source_verified: bool,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_METRIC.add(1, &[]);\n    let db = &*state.store;\n    //find payout_attempt by object_reference_id\n    let payout_attempt = match webhook_details.object_reference_id {\n        webhooks::ObjectReferenceId::PayoutId(payout_id_type) => match payout_id_type {\n            webhooks::PayoutIdType::PayoutAttemptId(id) => db\n                .find_payout_attempt_by_merchant_id_payout_attempt_id(\n                    merchant_context.get_merchant_account().get_id(),\n                    &id,\n                    merchant_context.get_merchant_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n            webhooks::PayoutIdType::ConnectorPayoutId(id) => db\n                .find_payout_attempt_by_merchant_id_connector_payout_id(\n                    merchant_context.get_merchant_account().get_id(),\n                    &id,\n                    merchant_context.get_merchant_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n        },\n        _ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"received a non-payout id when processing payout webhooks\")?,\n    };\n\n    let payouts = db\n        .find_payout_by_merchant_id_payout_id(\n            merchant_context.get_merchant_account().get_id(),\n            &payout_attempt.payout_id,\n            merchant_context.get_merchant_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n        .attach_printable(\"Failed to fetch the payout\")?;\n    let action_req =\n        payout_models::PayoutRequest::PayoutActionRequest(payout_models::PayoutActionRequest {\n            payout_id: payouts.payout_id.clone(),\n        });\n\n    let mut payout_data = Box::pin(payouts::make_payout_data(\n        &state,\n        &merchant_context,\n        None,\n        &action_req,\n        common_utils::consts::DEFAULT_LOCALE,\n    ))\n    .await?;\n\n    let payout_webhook_action = get_payout_webhook_action(\n        payout_attempt.status.is_non_terminal_status(),\n        source_verified,\n    );\n    match payout_webhook_action {\n        PaoyoutWebhookAction::UpdateStatus => {\n            payout_incoming_webhook_update_status(\n                state,\n                merchant_context,\n                business_profile,\n                event_type,\n                request_details,\n                connector,\n                payout_attempt,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::RetrieveStatus => {\n            payout_incoming_webhook_retrieve_status(\n                state,\n                merchant_context,\n                payout_attempt,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::NoAction => Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        }),\n    }\n}",
+      "diff_span": {
+        "before": "    .await?;\n\n    if source_verified {\n        let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n            .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"failed payout status mapping from event type\")?;\n\n        let payout_webhook_details = connector\n            .get_payout_webhook_details(request_details)\n            .switch()\n            .attach_printable(\"Failed to get error object for payouts\")?;\n\n        // if status is failure then update the error_code and error_message as well\n        let payout_attempt_update = if status.is_payout_failure() {\n            PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_attempt.connector_payout_id.clone(),\n                status,\n                error_message: payout_webhook_details.error_message,\n                error_code: payout_webhook_details.error_code,\n                is_eligible: payout_attempt.is_eligible,\n                unified_code: None,\n                unified_message: None,\n                payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n            }\n        } else {\n            PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_attempt.connector_payout_id.clone(),\n                status,\n                error_message: None,\n                error_code: None,\n                is_eligible: payout_attempt.is_eligible,\n                unified_code: None,\n                unified_message: None,\n                payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n            }\n        };\n\n        let updated_payout_attempt = db\n            .update_payout_attempt(\n                &payout_attempt,\n                payout_attempt_update,\n                &payout_data.payouts,\n                merchant_context.get_merchant_account().storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n            .attach_printable_lazy(|| {\n                format!(\n                    \"Failed while updating payout attempt: payout_attempt_id: {}\",\n                    payout_attempt.payout_attempt_id\n                )\n            })?;\n        payout_data.payout_attempt = updated_payout_attempt;\n\n        let event_type: Option<enums::EventType> = payout_data.payout_attempt.status.into();\n\n        // If event is NOT an UnsupportedEvent, trigger Outgoing Webhook\n        if let Some(outgoing_event_type) = event_type {\n            let payout_create_response =\n                payouts::response_handler(&state, &merchant_context, &payout_data).await?;\n\n            Box::pin(super::create_event_and_trigger_outgoing_webhook(\n                state,\n                merchant_context,\n                business_profile,\n                outgoing_event_type,\n                enums::EventClass::Payouts,\n                payout_data\n                    .payout_attempt\n                    .payout_id\n                    .get_string_repr()\n                    .to_string(),\n                enums::EventObjectType::PayoutDetails,\n                api::OutgoingWebhookContent::PayoutDetails(Box::new(payout_create_response)),\n                Some(payout_data.payout_attempt.created_at),\n            ))\n            .await?;\n        }\n\n        Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        })\n    } else {\n        metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n        // Form connector data\n        let connector_data = match &payout_attempt.connector {\n            Some(connector) => ConnectorData::get_payout_connector_by_name(\n                &state.conf.connectors,\n                connector,\n                GetToken::Connector,\n                payout_attempt.merchant_connector_id.clone(),\n            )\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get the connector data\")?,\n            _ => Err(errors::ApplicationError::InvalidConfigurationValueError(\n                \"Connector not found in payout_attempt - should not reach here.\".to_string(),\n            ))\n            .change_context(errors::ApiErrorResponse::MissingRequiredField {\n                field_name: \"connector\",\n            })\n            .attach_printable(\"Connector not found for payout fulfillment\")?,\n        };\n\n        Box::pin(payouts::create_payout_retrieve(\n            &state,\n            &merchant_context,\n            &connector_data,\n            &mut payout_data,\n        ))\n        .await\n        .attach_printable(\"Payout retrieval failed for given Payout request\")?;\n\n        Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        })\n    }\n}",
+        "after": "    .await?;\n\n    let payout_webhook_action = get_payout_webhook_action(\n        payout_attempt.status.is_non_terminal_status(),\n        source_verified,\n    );\n    match payout_webhook_action {\n        PaoyoutWebhookAction::UpdateStatus => {\n            payout_incoming_webhook_update_status(\n                state,\n                merchant_context,\n                business_profile,\n                event_type,\n                request_details,\n                connector,\n                payout_attempt,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::RetrieveStatus => {\n            payout_incoming_webhook_retrieve_status(\n                state,\n                merchant_context,\n                payout_attempt,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::NoAction => Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        }),\n    }\n}"
+      },
+      "commit_sha": "6c8501db6097b9297de2253ca21bce93a0c232e8",
+      "before_imports": [
+        "use common_utils::{\n    errors::ReportSwitchExt,\n    events::ApiEventsType,\n    ext_traits::{AsyncExt, ByteSliceExt},\n    types::{AmountConvertor, StringMinorUnitForConnector},\n};",
+        "use hyperswitch_interfaces::webhooks::{IncomingWebhookFlowError, IncomingWebhookRequestDetails};",
+        "use hyperswitch_domain_models::{\n    mandates::CommonMandateReference,\n    payments::{payment_attempt::PaymentAttempt, HeaderPayload},\n    router_request_types::VerifyWebhookSourceRequestData,\n    router_response_types::{VerifyWebhookSourceResponseData, VerifyWebhookStatus},\n};",
+        "use super::{types, utils, MERCHANT_ID};",
+        "use api_models::{\n    enums::Connector,\n    webhooks::{self, WebhookResponseTracker},\n};"
+      ],
+      "after_imports": [
+        "use common_utils::{\n    errors::ReportSwitchExt,\n    events::ApiEventsType,\n    ext_traits::{AsyncExt, ByteSliceExt},\n    types::{AmountConvertor, StringMinorUnitForConnector},\n};",
+        "use hyperswitch_interfaces::webhooks::{IncomingWebhookFlowError, IncomingWebhookRequestDetails};",
+        "use hyperswitch_domain_models::payouts::payout_attempt::PayoutAttempt;",
+        "use hyperswitch_domain_models::{\n    mandates::CommonMandateReference,\n    payments::{payment_attempt::PaymentAttempt, HeaderPayload},\n    router_request_types::VerifyWebhookSourceRequestData,\n    router_response_types::{VerifyWebhookSourceResponseData, VerifyWebhookStatus},\n};",
+        "use super::{types, utils, MERCHANT_ID};",
+        "use api_models::{\n    enums::Connector,\n    webhooks::{self, WebhookResponseTracker},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::payout_incoming_webhook_retrieve_status",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "async fn payout_incoming_webhook_retrieve_status(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    payout_attempt: PayoutAttempt,\n    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n    // Form connector data\n    let connector_data = match &payout_attempt.connector {\n        Some(connector) => ConnectorData::get_payout_connector_by_name(\n            &state.conf.connectors,\n            connector,\n            GetToken::Connector,\n            payout_attempt.merchant_connector_id.clone(),\n        )\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get the connector data\")?,\n        _ => Err(errors::ApplicationError::InvalidConfigurationValueError(\n            \"Connector not found in payout_attempt - should not reach here.\".to_string(),\n        ))\n        .change_context(errors::ApiErrorResponse::MissingRequiredField {\n            field_name: \"connector\",\n        })\n        .attach_printable(\"Connector not found for payout fulfillment\")?,\n    };\n\n    Box::pin(payouts::create_payout_retrieve(\n        &state,\n        &merchant_context,\n        &connector_data,\n        payout_data,\n    ))\n    .await\n    .attach_printable(\"Payout retrieval failed for given Payout request\")?;\n\n    Ok(WebhookResponseTracker::Payout {\n        payout_id: payout_data.payout_attempt.payout_id.clone(),\n        status: payout_data.payout_attempt.status,\n    })\n}",
+      "diff_span": null,
+      "commit_sha": "6c8501db6097b9297de2253ca21bce93a0c232e8"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::get_payout_webhook_action",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_payout_webhook_action(\n    is_non_terminal_status: bool,\n    is_source_verified: bool,\n) -> PaoyoutWebhookAction {\n    match (is_non_terminal_status, is_source_verified) {\n        (true, true) => PaoyoutWebhookAction::UpdateStatus,\n        (true, false) => PaoyoutWebhookAction::RetrieveStatus,\n        (false, true) | (false, false) => PaoyoutWebhookAction::NoAction,\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "6c8501db6097b9297de2253ca21bce93a0c232e8"
+    },
+    {
+      "id": "crates/common_enums/src/enums.rs::PayoutStatus::function::is_non_terminal_status",
+      "file": "crates/common_enums/src/enums.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn is_non_terminal_status(&self) -> bool {\n        !matches!(\n            self,\n            Self::Success | Self::Failed | Self::Cancelled | Self::Expired | Self::Reversed\n        )\n    }",
+      "diff_span": null,
+      "commit_sha": "6c8501db6097b9297de2253ca21bce93a0c232e8"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::payout_incoming_webhook_update_status",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "async fn payout_incoming_webhook_update_status(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    business_profile: domain::Profile,\n    event_type: webhooks::IncomingWebhookEvent,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n    payout_attempt: PayoutAttempt,\n    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    let db = &*state.store;\n    let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable(\"failed payout status mapping from event type\")?;\n\n    let payout_webhook_details = connector\n        .get_payout_webhook_details(request_details)\n        .switch()\n        .attach_printable(\"Failed to get error object for payouts\")?;\n\n    // if status is failure then update the error_code and error_message as well\n    let payout_attempt_update = if status.is_payout_failure() {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: payout_webhook_details.error_message,\n            error_code: payout_webhook_details.error_code,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    } else {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: None,\n            error_code: None,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    };\n\n    let updated_payout_attempt = db\n        .update_payout_attempt(\n            &payout_attempt,\n            payout_attempt_update,\n            &payout_data.payouts,\n            merchant_context.get_merchant_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating payout attempt: payout_attempt_id: {}\",\n                payout_attempt.payout_attempt_id\n            )\n        })?;\n    payout_data.payout_attempt = updated_payout_attempt;\n\n    let event_type: Option<enums::EventType> = payout_data.payout_attempt.status.into();\n\n    // If event is NOT an UnsupportedEvent, trigger Outgoing Webhook\n    if let Some(outgoing_event_type) = event_type {\n        let payout_create_response =\n            payouts::response_handler(&state, &merchant_context, payout_data).await?;\n\n        Box::pin(super::create_event_and_trigger_outgoing_webhook(\n            state,\n            merchant_context,\n            business_profile,\n            outgoing_event_type,\n            enums::EventClass::Payouts,\n            payout_data\n                .payout_attempt\n                .payout_id\n                .get_string_repr()\n                .to_string(),\n            enums::EventObjectType::PayoutDetails,\n            api::OutgoingWebhookContent::PayoutDetails(Box::new(payout_create_response)),\n            Some(payout_data.payout_attempt.created_at),\n        ))\n        .await?;\n    }\n\n    Ok(WebhookResponseTracker::Payout {\n        payout_id: payout_data.payout_attempt.payout_id.clone(),\n        status: payout_data.payout_attempt.status,\n    })\n}",
+      "diff_span": null,
+      "commit_sha": "6c8501db6097b9297de2253ca21bce93a0c232e8"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::enum::PaoyoutWebhookAction",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "enum_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "enum PaoyoutWebhookAction {\n    UpdateStatus,\n    RetrieveStatus,\n    NoAction,\n}",
+      "diff_span": null,
+      "commit_sha": "6c8501db6097b9297de2253ca21bce93a0c232e8"
+    }
+  ]
+}

diffs/pr_10650/f1d81ad/diff.json

@@ -0,0 +1,137 @@
+{
+  "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda",
+  "pr_number": 10650,
+  "rust_files": [
+    "crates/router/src/core/webhooks/incoming.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::payouts_incoming_webhook_flow",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn payouts_incoming_webhook_flow(\n    state: SessionState,\n    platform: domain::Platform,\n    business_profile: domain::Profile,\n    webhook_details: api::IncomingWebhookDetails,\n    event_type: webhooks::IncomingWebhookEvent,\n    source_verified: bool,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_METRIC.add(1, &[]);\n    let db = &*state.store;\n    //find payout_attempt by object_reference_id\n    let payout_attempt = match webhook_details.object_reference_id {\n        webhooks::ObjectReferenceId::PayoutId(payout_id_type) => match payout_id_type {\n            webhooks::PayoutIdType::PayoutAttemptId(id) => db\n                .find_payout_attempt_by_merchant_id_payout_attempt_id(\n                    platform.get_processor().get_account().get_id(),\n                    &id,\n                    platform.get_processor().get_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n            webhooks::PayoutIdType::ConnectorPayoutId(id) => db\n                .find_payout_attempt_by_merchant_id_connector_payout_id(\n                    platform.get_processor().get_account().get_id(),\n                    &id,\n                    platform.get_processor().get_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n        },\n        _ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"received a non-payout id when processing payout webhooks\")?,\n    };\n\n    let payouts = db\n        .find_payout_by_merchant_id_payout_id(\n            platform.get_processor().get_account().get_id(),\n            &payout_attempt.payout_id,\n            platform.get_processor().get_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n        .attach_printable(\"Failed to fetch the payout\")?;\n    let action_req =\n        payout_models::PayoutRequest::PayoutActionRequest(payout_models::PayoutActionRequest {\n            payout_id: payouts.payout_id.clone(),\n        });\n\n    let mut payout_data = Box::pin(payouts::make_payout_data(\n        &state,\n        &platform,\n        None,\n        &action_req,\n        common_utils::consts::DEFAULT_LOCALE,\n    ))\n    .await?;\n\n    let payout_webhook_action = get_payout_webhook_action(\n        payout_attempt.status.is_non_terminal_status(),\n        source_verified,\n    );\n    match payout_webhook_action {\n        PaoyoutWebhookAction::UpdateStatus => {\n            payout_incoming_webhook_update_status(\n                state,\n                platform,\n                business_profile,\n                event_type,\n                request_details,\n                connector,\n                payout_attempt,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::RetrieveStatus => {\n            payout_incoming_webhook_retrieve_status(\n                state,\n                platform,\n                payout_attempt,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::NoAction => Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        }),\n    }\n}",
+      "after_code": "async fn payouts_incoming_webhook_flow(\n    state: SessionState,\n    platform: domain::Platform,\n    business_profile: domain::Profile,\n    webhook_details: api::IncomingWebhookDetails,\n    event_type: webhooks::IncomingWebhookEvent,\n    source_verified: bool,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    let payout_id =\n        get_payout_id_from_object_reference_id(&state, &platform, &webhook_details).await?;\n\n    let lock_action = api_locking::LockAction::Hold {\n        input: api_locking::LockingInput {\n            unique_locking_key: payout_id.get_string_repr().to_owned(),\n            api_identifier: lock_utils::ApiIdentifier::Payouts,\n            override_lock_retries: None,\n        },\n    };\n\n    lock_action\n        .clone()\n        .perform_locking_action(\n            &state,\n            platform.get_processor().get_account().get_id().to_owned(),\n        )\n        .await?;\n\n    let payout_response = Box::pin(process_payout_incoming_webhook(\n        state.clone(),\n        platform.clone(),\n        business_profile,\n        event_type,\n        payout_id,\n        source_verified,\n        request_details,\n        connector,\n    ))\n    .await;\n\n    lock_action\n        .free_lock_action(\n            &state,\n            platform.get_processor().get_account().get_id().to_owned(),\n        )\n        .await?;\n\n    payout_response\n}",
+      "diff_span": {
+        "before": "    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_METRIC.add(1, &[]);\n    let db = &*state.store;\n    //find payout_attempt by object_reference_id\n    let payout_attempt = match webhook_details.object_reference_id {\n        webhooks::ObjectReferenceId::PayoutId(payout_id_type) => match payout_id_type {\n            webhooks::PayoutIdType::PayoutAttemptId(id) => db\n                .find_payout_attempt_by_merchant_id_payout_attempt_id(\n                    platform.get_processor().get_account().get_id(),\n                    &id,\n                    platform.get_processor().get_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n            webhooks::PayoutIdType::ConnectorPayoutId(id) => db\n                .find_payout_attempt_by_merchant_id_connector_payout_id(\n                    platform.get_processor().get_account().get_id(),\n                    &id,\n                    platform.get_processor().get_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n        },\n        _ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"received a non-payout id when processing payout webhooks\")?,\n    };\n\n    let payouts = db\n        .find_payout_by_merchant_id_payout_id(\n            platform.get_processor().get_account().get_id(),\n            &payout_attempt.payout_id,\n            platform.get_processor().get_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n        .attach_printable(\"Failed to fetch the payout\")?;\n    let action_req =\n        payout_models::PayoutRequest::PayoutActionRequest(payout_models::PayoutActionRequest {\n            payout_id: payouts.payout_id.clone(),\n        });\n\n    let mut payout_data = Box::pin(payouts::make_payout_data(\n        &state,\n        &platform,\n        None,\n        &action_req,\n        common_utils::consts::DEFAULT_LOCALE,\n    ))\n    .await?;\n\n    let payout_webhook_action = get_payout_webhook_action(\n        payout_attempt.status.is_non_terminal_status(),\n        source_verified,\n    );\n    match payout_webhook_action {\n        PaoyoutWebhookAction::UpdateStatus => {\n            payout_incoming_webhook_update_status(\n                state,\n                platform,\n                business_profile,\n                event_type,\n                request_details,\n                connector,\n                payout_attempt,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::RetrieveStatus => {\n            payout_incoming_webhook_retrieve_status(\n                state,\n                platform,\n                payout_attempt,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::NoAction => Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        }),\n    }\n}",
+        "after": "    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    let payout_id =\n        get_payout_id_from_object_reference_id(&state, &platform, &webhook_details).await?;\n\n    let lock_action = api_locking::LockAction::Hold {\n        input: api_locking::LockingInput {\n            unique_locking_key: payout_id.get_string_repr().to_owned(),\n            api_identifier: lock_utils::ApiIdentifier::Payouts,\n            override_lock_retries: None,\n        },\n    };\n\n    lock_action\n        .clone()\n        .perform_locking_action(\n            &state,\n            platform.get_processor().get_account().get_id().to_owned(),\n        )\n        .await?;\n\n    let payout_response = Box::pin(process_payout_incoming_webhook(\n        state.clone(),\n        platform.clone(),\n        business_profile,\n        event_type,\n        payout_id,\n        source_verified,\n        request_details,\n        connector,\n    ))\n    .await;\n\n    lock_action\n        .free_lock_action(\n            &state,\n            platform.get_processor().get_account().get_id().to_owned(),\n        )\n        .await?;\n\n    payout_response\n}"
+      },
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::payout_incoming_webhook_update_status",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "async fn payout_incoming_webhook_update_status(\n    state: SessionState,\n    platform: domain::Platform,\n    business_profile: domain::Profile,\n    event_type: webhooks::IncomingWebhookEvent,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n    payout_attempt: PayoutAttempt,\n    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    let db = &*state.store;\n    let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable(\"failed payout status mapping from event type\")?;\n\n    let payout_webhook_details = connector\n        .get_payout_webhook_details(request_details)\n        .switch()\n        .attach_printable(\"Failed to get error object for payouts\")?;\n\n    let payouts_update = PayoutsUpdate::StatusUpdate { status };\n\n    let updated_payouts = db\n        .update_payout(\n            &payout_data.payouts,\n            payouts_update,\n            &payout_attempt,\n            platform.get_processor().get_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating payouts: payout_id: {}\",\n                payout_data.payouts.payout_id.get_string_repr()\n            )\n        })?;\n    payout_data.payouts = updated_payouts;\n\n    // if status is failure then update the error_code and error_message as well\n    let payout_attempt_update = if status.is_payout_failure() {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: payout_webhook_details.error_message,\n            error_code: payout_webhook_details.error_code,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    } else {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: None,\n            error_code: None,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    };\n\n    let updated_payout_attempt = db\n        .update_payout_attempt(\n            &payout_attempt,\n            payout_attempt_update,\n            &payout_data.payouts,\n            platform.get_processor().get_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating payout attempt: payout_attempt_id: {}\",\n                payout_attempt.payout_attempt_id\n            )\n        })?;\n    payout_data.payout_attempt = updated_payout_attempt;\n\n    let event_type: Option<enums::EventType> = payout_data.payout_attempt.status.into();\n\n    // If event is NOT an UnsupportedEvent, trigger Outgoing Webhook\n    if let Some(outgoing_event_type) = event_type {\n        let payout_create_response =\n            payouts::response_handler(&state, &platform, payout_data).await?;\n\n        Box::pin(super::create_event_and_trigger_outgoing_webhook(\n            state,\n            platform,\n            business_profile,\n            outgoing_event_type,\n            enums::EventClass::Payouts,\n            payout_data\n                .payout_attempt\n                .payout_id\n                .get_string_repr()\n                .to_string(),\n            enums::EventObjectType::PayoutDetails,\n            api::OutgoingWebhookContent::PayoutDetails(Box::new(payout_create_response)),\n            Some(payout_data.payout_attempt.created_at),\n        ))\n        .await?;\n    }\n\n    Ok(WebhookResponseTracker::Payout {\n        payout_id: payout_data.payout_attempt.payout_id.clone(),\n        status: payout_data.payout_attempt.status,\n    })\n}",
+      "after_code": "async fn payout_incoming_webhook_update_status(\n    state: SessionState,\n    platform: domain::Platform,\n    business_profile: domain::Profile,\n    event_type: webhooks::IncomingWebhookEvent,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    let payout_attempt = &payout_data.payout_attempt;\n    let db = &*state.store;\n    let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable(\"failed payout status mapping from event type\")?;\n\n    let payout_webhook_details = connector\n        .get_payout_webhook_details(request_details)\n        .switch()\n        .attach_printable(\"Failed to get error object for payouts\")?;\n\n    let payouts_update = PayoutsUpdate::StatusUpdate { status };\n\n    let updated_payouts = db\n        .update_payout(\n            &payout_data.payouts,\n            payouts_update,\n            payout_attempt,\n            platform.get_processor().get_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating payouts: payout_id: {}\",\n                payout_data.payouts.payout_id.get_string_repr()\n            )\n        })?;\n    payout_data.payouts = updated_payouts;\n\n    // if status is failure then update the error_code and error_message as well\n    let payout_attempt_update = if status.is_payout_failure() {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: payout_webhook_details.error_message,\n            error_code: payout_webhook_details.error_code,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    } else {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: None,\n            error_code: None,\n            is_eligible: payout_data.payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    };\n\n    let updated_payout_attempt = db\n        .update_payout_attempt(\n            payout_attempt,\n            payout_attempt_update,\n            &payout_data.payouts,\n            platform.get_processor().get_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating payout attempt: payout_attempt_id: {}\",\n                payout_attempt.payout_attempt_id\n            )\n        })?;\n    payout_data.payout_attempt = updated_payout_attempt;\n\n    let event_type: Option<enums::EventType> = payout_data.payout_attempt.status.into();\n\n    // If event is NOT an UnsupportedEvent, trigger Outgoing Webhook\n    if let Some(outgoing_event_type) = event_type {\n        let payout_create_response =\n            payouts::response_handler(&state, &platform, payout_data).await?;\n\n        Box::pin(super::create_event_and_trigger_outgoing_webhook(\n            state,\n            platform,\n            business_profile,\n            outgoing_event_type,\n            enums::EventClass::Payouts,\n            payout_data\n                .payout_attempt\n                .payout_id\n                .get_string_repr()\n                .to_string(),\n            enums::EventObjectType::PayoutDetails,\n            api::OutgoingWebhookContent::PayoutDetails(Box::new(payout_create_response)),\n            Some(payout_data.payout_attempt.created_at),\n        ))\n        .await?;\n    }\n\n    Ok(WebhookResponseTracker::Payout {\n        payout_id: payout_data.payout_attempt.payout_id.clone(),\n        status: payout_data.payout_attempt.status,\n    })\n}",
+      "diff_span": {
+        "before": "    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n    payout_attempt: PayoutAttempt,\n    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    let db = &*state.store;\n    let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable(\"failed payout status mapping from event type\")?;\n\n    let payout_webhook_details = connector\n        .get_payout_webhook_details(request_details)\n        .switch()\n        .attach_printable(\"Failed to get error object for payouts\")?;\n\n    let payouts_update = PayoutsUpdate::StatusUpdate { status };\n\n    let updated_payouts = db\n        .update_payout(\n            &payout_data.payouts,\n            payouts_update,\n            &payout_attempt,\n            platform.get_processor().get_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating payouts: payout_id: {}\",\n                payout_data.payouts.payout_id.get_string_repr()\n            )\n        })?;\n    payout_data.payouts = updated_payouts;\n\n    // if status is failure then update the error_code and error_message as well\n    let payout_attempt_update = if status.is_payout_failure() {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: payout_webhook_details.error_message,\n            error_code: payout_webhook_details.error_code,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    } else {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: None,\n            error_code: None,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    };\n\n    let updated_payout_attempt = db\n        .update_payout_attempt(\n            &payout_attempt,\n            payout_attempt_update,\n            &payout_data.payouts,",
+        "after": "    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    let payout_attempt = &payout_data.payout_attempt;\n    let db = &*state.store;\n    let status = common_enums::PayoutStatus::foreign_try_from(event_type)\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable(\"failed payout status mapping from event type\")?;\n\n    let payout_webhook_details = connector\n        .get_payout_webhook_details(request_details)\n        .switch()\n        .attach_printable(\"Failed to get error object for payouts\")?;\n\n    let payouts_update = PayoutsUpdate::StatusUpdate { status };\n\n    let updated_payouts = db\n        .update_payout(\n            &payout_data.payouts,\n            payouts_update,\n            payout_attempt,\n            platform.get_processor().get_account().storage_scheme,\n        )\n        .await\n        .change_context(errors::ApiErrorResponse::WebhookProcessingFailure)\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating payouts: payout_id: {}\",\n                payout_data.payouts.payout_id.get_string_repr()\n            )\n        })?;\n    payout_data.payouts = updated_payouts;\n\n    // if status is failure then update the error_code and error_message as well\n    let payout_attempt_update = if status.is_payout_failure() {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: payout_webhook_details.error_message,\n            error_code: payout_webhook_details.error_code,\n            is_eligible: payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    } else {\n        PayoutAttemptUpdate::StatusUpdate {\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            status,\n            error_message: None,\n            error_code: None,\n            is_eligible: payout_data.payout_attempt.is_eligible,\n            unified_code: None,\n            unified_message: None,\n            payout_connector_metadata: payout_attempt.payout_connector_metadata.clone(),\n        }\n    };\n\n    let updated_payout_attempt = db\n        .update_payout_attempt(\n            payout_attempt,\n            payout_attempt_update,\n            &payout_data.payouts,"
+      },
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda",
+      "before_imports": [
+        "use api_models::{\n    enums::Connector,\n    webhooks::{self, WebhookResponseTracker},\n};",
+        "use hyperswitch_domain_models::{\n    mandates::CommonMandateReference,\n    merchant_key_store::MerchantKeyStore,\n    payments::{payment_attempt::PaymentAttempt, HeaderPayload},\n    router_request_types::VerifyWebhookSourceRequestData,\n    router_response_types::{VerifyWebhookSourceResponseData, VerifyWebhookStatus},\n};",
+        "use common_utils::{\n    errors::ReportSwitchExt,\n    events::ApiEventsType,\n    ext_traits::{AsyncExt, ByteSliceExt},\n    types::{AmountConvertor, StringMinorUnitForConnector},\n};",
+        "use hyperswitch_interfaces::webhooks::{IncomingWebhookFlowError, IncomingWebhookRequestDetails};"
+      ],
+      "after_imports": [
+        "use common_utils::{\n    errors::ReportSwitchExt,\n    events::ApiEventsType,\n    ext_traits::{AsyncExt, ByteSliceExt},\n    types::{AmountConvertor, StringMinorUnitForConnector},\n};",
+        "use hyperswitch_domain_models::payouts::payouts::PayoutsUpdate;",
+        "use hyperswitch_domain_models::{\n    mandates::CommonMandateReference,\n    merchant_key_store::MerchantKeyStore,\n    payments::{payment_attempt::PaymentAttempt, HeaderPayload},\n    router_request_types::VerifyWebhookSourceRequestData,\n    router_response_types::{VerifyWebhookSourceResponseData, VerifyWebhookStatus},\n};",
+        "use hyperswitch_interfaces::webhooks::{IncomingWebhookFlowError, IncomingWebhookRequestDetails};",
+        "use api_models::{\n    enums::Connector,\n    webhooks::{self, WebhookResponseTracker},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::payout_incoming_webhook_retrieve_status",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn payout_incoming_webhook_retrieve_status(\n    state: SessionState,\n    platform: domain::Platform,\n    payout_attempt: PayoutAttempt,\n    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n    // Form connector data\n    let connector_data = match &payout_attempt.connector {\n        Some(connector) => ConnectorData::get_payout_connector_by_name(\n            &state.conf.connectors,\n            connector,\n            GetToken::Connector,\n            payout_attempt.merchant_connector_id.clone(),\n        )\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get the connector data\")?,\n        _ => Err(errors::ApplicationError::InvalidConfigurationValueError(\n            \"Connector not found in payout_attempt - should not reach here.\".to_string(),\n        ))\n        .change_context(errors::ApiErrorResponse::MissingRequiredField {\n            field_name: \"connector\",\n        })\n        .attach_printable(\"Connector not found for payout fulfillment\")?,\n    };\n\n    Box::pin(payouts::create_payout_retrieve(\n        &state,\n        &platform,\n        &connector_data,\n        payout_data,\n    ))\n    .await\n    .attach_printable(\"Payout retrieval failed for given Payout request\")?;\n\n    Ok(WebhookResponseTracker::Payout {\n        payout_id: payout_data.payout_attempt.payout_id.clone(),\n        status: payout_data.payout_attempt.status,\n    })\n}",
+      "after_code": "async fn payout_incoming_webhook_retrieve_status(\n    state: SessionState,\n    platform: domain::Platform,\n    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n    // Form connector data\n    let connector_data = match &payout_data.payout_attempt.connector {\n        Some(connector) => ConnectorData::get_payout_connector_by_name(\n            &state.conf.connectors,\n            connector,\n            GetToken::Connector,\n            payout_data.payout_attempt.merchant_connector_id.clone(),\n        )\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get the connector data\")?,\n        _ => Err(errors::ApplicationError::InvalidConfigurationValueError(\n            \"Connector not found in payout_attempt - should not reach here.\".to_string(),\n        ))\n        .change_context(errors::ApiErrorResponse::MissingRequiredField {\n            field_name: \"connector\",\n        })\n        .attach_printable(\"Connector not found for payout fulfillment\")?,\n    };\n\n    Box::pin(payouts::create_payout_retrieve(\n        &state,\n        &platform,\n        &connector_data,\n        payout_data,\n    ))\n    .await\n    .attach_printable(\"Payout retrieval failed for given Payout request\")?;\n\n    Ok(WebhookResponseTracker::Payout {\n        payout_id: payout_data.payout_attempt.payout_id.clone(),\n        status: payout_data.payout_attempt.status,\n    })\n}",
+      "diff_span": {
+        "before": "    state: SessionState,\n    platform: domain::Platform,\n    payout_attempt: PayoutAttempt,\n    payout_data: &mut payouts::PayoutData,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n    // Form connector data\n    let connector_data = match &payout_attempt.connector {\n        Some(connector) => ConnectorData::get_payout_connector_by_name(\n            &state.conf.connectors,\n            connector,\n            GetToken::Connector,\n            payout_attempt.merchant_connector_id.clone(),\n        )\n        .change_context(errors::ApiErrorResponse::InternalServerError)",
+        "after": "    metrics::INCOMING_PAYOUT_WEBHOOK_SIGNATURE_FAILURE_METRIC.add(1, &[]);\n    // Form connector data\n    let connector_data = match &payout_data.payout_attempt.connector {\n        Some(connector) => ConnectorData::get_payout_connector_by_name(\n            &state.conf.connectors,\n            connector,\n            GetToken::Connector,\n            payout_data.payout_attempt.merchant_connector_id.clone(),\n        )\n        .change_context(errors::ApiErrorResponse::InternalServerError)"
+      },
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::PayoutWebhookPreCondition::function::get_payout_webhook_action",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn get_payout_webhook_action(&self) -> PaoyoutWebhookAction {\n        match (self.is_non_terminal_status, self.is_source_verified) {\n            (true, true) => PaoyoutWebhookAction::UpdateStatus,\n            (true, false) => PaoyoutWebhookAction::RetrieveStatus,\n            (false, true) | (false, false) => PaoyoutWebhookAction::NoAction,\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::process_payout_incoming_webhook",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "async fn process_payout_incoming_webhook(\n    state: SessionState,\n    platform: domain::Platform,\n    business_profile: domain::Profile,\n    event_type: webhooks::IncomingWebhookEvent,\n    payout_id: common_utils::id_type::PayoutId,\n    source_verified: bool,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n    connector: &ConnectorEnum,\n) -> CustomResult<WebhookResponseTracker, errors::ApiErrorResponse> {\n    metrics::INCOMING_PAYOUT_WEBHOOK_METRIC.add(1, &[]);\n\n    let action_req =\n        payout_models::PayoutRequest::PayoutActionRequest(payout_models::PayoutActionRequest {\n            payout_id,\n        });\n\n    let mut payout_data = Box::pin(payouts::make_payout_data(\n        &state,\n        &platform,\n        None,\n        &action_req,\n        common_utils::consts::DEFAULT_LOCALE,\n    ))\n    .await?;\n\n    let payout_webhook_action = PayoutWebhookPreCondition::new(\n        payout_data.payout_attempt.status.is_non_terminal_status(),\n        source_verified,\n    )\n    .get_payout_webhook_action();\n    match payout_webhook_action {\n        PaoyoutWebhookAction::UpdateStatus => {\n            payout_incoming_webhook_update_status(\n                state,\n                platform,\n                business_profile,\n                event_type,\n                request_details,\n                connector,\n                &mut payout_data,\n            )\n            .await\n        }\n        PaoyoutWebhookAction::RetrieveStatus => {\n            payout_incoming_webhook_retrieve_status(state, platform, &mut payout_data).await\n        }\n        PaoyoutWebhookAction::NoAction => Ok(WebhookResponseTracker::Payout {\n            payout_id: payout_data.payout_attempt.payout_id,\n            status: payout_data.payout_attempt.status,\n        }),\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::PayoutWebhookPreCondition::function::new",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn new(is_non_terminal_status: bool, is_source_verified: bool) -> Self {\n        Self {\n            is_non_terminal_status,\n            is_source_verified,\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::struct::PayoutWebhookPreCondition",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "struct PayoutWebhookPreCondition {\n    is_non_terminal_status: bool,\n    is_source_verified: bool,\n}",
+      "diff_span": null,
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::get_payout_id_from_object_reference_id",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "async fn get_payout_id_from_object_reference_id(\n    state: &SessionState,\n    platform: &domain::Platform,\n    webhook_details: &api::IncomingWebhookDetails,\n) -> CustomResult<common_utils::id_type::PayoutId, errors::ApiErrorResponse> {\n    let db = &*state.store;\n    let payout_attempt = match webhook_details.object_reference_id.clone() {\n        webhooks::ObjectReferenceId::PayoutId(payout_id_type) => match payout_id_type {\n            webhooks::PayoutIdType::PayoutAttemptId(id) => db\n                .find_payout_attempt_by_merchant_id_payout_attempt_id(\n                    platform.get_processor().get_account().get_id(),\n                    &id,\n                    platform.get_processor().get_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n            webhooks::PayoutIdType::ConnectorPayoutId(id) => db\n                .find_payout_attempt_by_merchant_id_connector_payout_id(\n                    platform.get_processor().get_account().get_id(),\n                    &id,\n                    platform.get_processor().get_account().storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::WebhookResourceNotFound)\n                .attach_printable(\"Failed to fetch the payout attempt\")?,\n        },\n        _ => Err(errors::ApiErrorResponse::WebhookProcessingFailure)\n            .attach_printable(\"received a non-payout id when processing payout webhooks\")?,\n    };\n\n    Ok(payout_attempt.payout_id)\n}",
+      "diff_span": null,
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::impl::PayoutWebhookPreCondition",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl PayoutWebhookPreCondition {\n    pub fn new(is_non_terminal_status: bool, is_source_verified: bool) -> Self {\n        Self {\n            is_non_terminal_status,\n            is_source_verified,\n        }\n    }\n\n    // only update if the payout is in non-terminal status\n    // if source verified, update the payout attempt and trigger outgoing webhook\n    // if not source verified, do a payout retrieve call and update the status\n    pub fn get_payout_webhook_action(&self) -> PaoyoutWebhookAction {\n        match (self.is_non_terminal_status, self.is_source_verified) {\n            (true, true) => PaoyoutWebhookAction::UpdateStatus,\n            (true, false) => PaoyoutWebhookAction::RetrieveStatus,\n            (false, true) | (false, false) => PaoyoutWebhookAction::NoAction,\n        }\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::get_payout_webhook_action",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_payout_webhook_action(\n    is_non_terminal_status: bool,\n    is_source_verified: bool,\n) -> PaoyoutWebhookAction {\n    match (is_non_terminal_status, is_source_verified) {\n        (true, true) => PaoyoutWebhookAction::UpdateStatus,\n        (true, false) => PaoyoutWebhookAction::RetrieveStatus,\n        (false, true) | (false, false) => PaoyoutWebhookAction::NoAction,\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "f1d81ad46a14ddb20490b9174d5299a1b8b52cda"
+    }
+  ]
+}

diffs/pr_6677/9e8e72a/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "9e8e72a6efbc4fbb047e4af9106844283c95f33b",
+  "pr_number": 6677,
+  "rust_files": [
+    "crates/router/src/core/user.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/user.rs::function::handle_existing_user_invitation",
+      "file": "crates/router/src/core/user.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn handle_existing_user_invitation(\n    state: &SessionState,\n    user_from_token: &auth::UserFromToken,\n    request: &user_api::InviteUserRequest,\n    invitee_user_from_db: domain::UserFromStorage,\n    role_info: roles::RoleInfo,\n    auth_id: &Option<String>,\n) -> UserResult<InviteMultipleUserResponse> {\n    let now = common_utils::date_time::now();\n\n    if state\n        .global_store\n        .find_user_role_by_user_id_and_lineage(\n            invitee_user_from_db.get_user_id(),\n            &user_from_token.org_id,\n            &user_from_token.merchant_id,\n            &user_from_token.profile_id,\n            UserRoleVersion::V1,\n        )\n        .await\n        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    if state\n        .global_store\n        .find_user_role_by_user_id_and_lineage(\n            invitee_user_from_db.get_user_id(),\n            &user_from_token.org_id,\n            &user_from_token.merchant_id,\n            &user_from_token.profile_id,\n            UserRoleVersion::V2,\n        )\n        .await\n        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    let (org_id, merchant_id, profile_id) = match role_info.get_entity_type() {\n        EntityType::Organization => (Some(&user_from_token.org_id), None, None),\n        EntityType::Merchant => (\n            Some(&user_from_token.org_id),\n            Some(&user_from_token.merchant_id),\n            None,\n        ),\n        EntityType::Profile => (\n            Some(&user_from_token.org_id),\n            Some(&user_from_token.merchant_id),\n            Some(&user_from_token.profile_id),\n        ),\n    };\n\n    if state\n        .global_store\n        .list_user_roles_by_user_id(ListUserRolesByUserIdPayload {\n            user_id: invitee_user_from_db.get_user_id(),\n            org_id,\n            merchant_id,\n            profile_id,\n            entity_id: None,\n            version: None,\n            status: None,\n            limit: Some(1),\n        })\n        .await\n        .is_ok_and(|data| data.len() > 0)\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    let user_role = domain::NewUserRole {\n        user_id: invitee_user_from_db.get_user_id().to_owned(),\n        role_id: request.role_id.clone(),\n        status: {\n            if cfg!(feature = \"email\") {\n                UserStatus::InvitationSent\n            } else {\n                UserStatus::Active\n            }\n        },\n        created_by: user_from_token.user_id.clone(),\n        last_modified_by: user_from_token.user_id.clone(),\n        created_at: now,\n        last_modified: now,\n        entity: domain::NoLevel,\n    };\n\n    let _user_role = match role_info.get_entity_type() {\n        EntityType::Organization => {\n            user_role\n                .add_entity(domain::OrganizationLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n        EntityType::Merchant => {\n            user_role\n                .add_entity(domain::MerchantLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                    merchant_id: user_from_token.merchant_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n        EntityType::Profile => {\n            user_role\n                .add_entity(domain::ProfileLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                    merchant_id: user_from_token.merchant_id.clone(),\n                    profile_id: user_from_token.profile_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n    };\n\n    let is_email_sent;\n    #[cfg(feature = \"email\")]\n    {\n        let invitee_email = domain::UserEmail::from_pii_email(request.email.clone())?;\n        let entity = match role_info.get_entity_type() {\n            EntityType::Organization => email_types::Entity {\n                entity_id: user_from_token.org_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Organization,\n            },\n            EntityType::Merchant => email_types::Entity {\n                entity_id: user_from_token.merchant_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Merchant,\n            },\n            EntityType::Profile => email_types::Entity {\n                entity_id: user_from_token.profile_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Profile,\n            },\n        };\n\n        let email_contents = email_types::InviteUser {\n            recipient_email: invitee_email,\n            user_name: domain::UserName::new(invitee_user_from_db.get_name())?,\n            settings: state.conf.clone(),\n            subject: consts::user::EMAIL_SUBJECT_INVITATION,\n            entity,\n            auth_id: auth_id.clone(),\n        };\n\n        is_email_sent = state\n            .email_client\n            .compose_and_send_email(\n                Box::new(email_contents),\n                state.conf.proxy.https_url.as_ref(),\n            )\n            .await\n            .map(|email_result| logger::info!(?email_result))\n            .map_err(|email_result| logger::error!(?email_result))\n            .is_ok();\n    }\n    #[cfg(not(feature = \"email\"))]\n    {\n        is_email_sent = false;\n    }\n\n    Ok(InviteMultipleUserResponse {\n        email: request.email.clone(),\n        is_email_sent,\n        password: None,\n        error: None,\n    })\n}",
+      "after_code": "async fn handle_existing_user_invitation(\n    state: &SessionState,\n    user_from_token: &auth::UserFromToken,\n    request: &user_api::InviteUserRequest,\n    invitee_user_from_db: domain::UserFromStorage,\n    role_info: roles::RoleInfo,\n    auth_id: &Option<String>,\n) -> UserResult<InviteMultipleUserResponse> {\n    let now = common_utils::date_time::now();\n\n    if state\n        .global_store\n        .find_user_role_by_user_id_and_lineage(\n            invitee_user_from_db.get_user_id(),\n            &user_from_token.org_id,\n            &user_from_token.merchant_id,\n            &user_from_token.profile_id,\n            UserRoleVersion::V1,\n        )\n        .await\n        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    if state\n        .global_store\n        .find_user_role_by_user_id_and_lineage(\n            invitee_user_from_db.get_user_id(),\n            &user_from_token.org_id,\n            &user_from_token.merchant_id,\n            &user_from_token.profile_id,\n            UserRoleVersion::V2,\n        )\n        .await\n        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    let (org_id, merchant_id, profile_id) = match role_info.get_entity_type() {\n        EntityType::Organization => (Some(&user_from_token.org_id), None, None),\n        EntityType::Merchant => (\n            Some(&user_from_token.org_id),\n            Some(&user_from_token.merchant_id),\n            None,\n        ),\n        EntityType::Profile => (\n            Some(&user_from_token.org_id),\n            Some(&user_from_token.merchant_id),\n            Some(&user_from_token.profile_id),\n        ),\n    };\n\n    if state\n        .global_store\n        .list_user_roles_by_user_id(ListUserRolesByUserIdPayload {\n            user_id: invitee_user_from_db.get_user_id(),\n            org_id,\n            merchant_id,\n            profile_id,\n            entity_id: None,\n            version: None,\n            status: None,\n            limit: Some(1),\n        })\n        .await\n        .is_ok_and(|data| data.is_empty().not())\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    let user_role = domain::NewUserRole {\n        user_id: invitee_user_from_db.get_user_id().to_owned(),\n        role_id: request.role_id.clone(),\n        status: {\n            if cfg!(feature = \"email\") {\n                UserStatus::InvitationSent\n            } else {\n                UserStatus::Active\n            }\n        },\n        created_by: user_from_token.user_id.clone(),\n        last_modified_by: user_from_token.user_id.clone(),\n        created_at: now,\n        last_modified: now,\n        entity: domain::NoLevel,\n    };\n\n    let _user_role = match role_info.get_entity_type() {\n        EntityType::Organization => {\n            user_role\n                .add_entity(domain::OrganizationLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n        EntityType::Merchant => {\n            user_role\n                .add_entity(domain::MerchantLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                    merchant_id: user_from_token.merchant_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n        EntityType::Profile => {\n            user_role\n                .add_entity(domain::ProfileLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                    merchant_id: user_from_token.merchant_id.clone(),\n                    profile_id: user_from_token.profile_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n    };\n\n    let is_email_sent;\n    #[cfg(feature = \"email\")]\n    {\n        let invitee_email = domain::UserEmail::from_pii_email(request.email.clone())?;\n        let entity = match role_info.get_entity_type() {\n            EntityType::Organization => email_types::Entity {\n                entity_id: user_from_token.org_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Organization,\n            },\n            EntityType::Merchant => email_types::Entity {\n                entity_id: user_from_token.merchant_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Merchant,\n            },\n            EntityType::Profile => email_types::Entity {\n                entity_id: user_from_token.profile_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Profile,\n            },\n        };\n\n        let email_contents = email_types::InviteUser {\n            recipient_email: invitee_email,\n            user_name: domain::UserName::new(invitee_user_from_db.get_name())?,\n            settings: state.conf.clone(),\n            subject: consts::user::EMAIL_SUBJECT_INVITATION,\n            entity,\n            auth_id: auth_id.clone(),\n        };\n\n        is_email_sent = state\n            .email_client\n            .compose_and_send_email(\n                Box::new(email_contents),\n                state.conf.proxy.https_url.as_ref(),\n            )\n            .await\n            .map(|email_result| logger::info!(?email_result))\n            .map_err(|email_result| logger::error!(?email_result))\n            .is_ok();\n    }\n    #[cfg(not(feature = \"email\"))]\n    {\n        is_email_sent = false;\n    }\n\n    Ok(InviteMultipleUserResponse {\n        email: request.email.clone(),\n        is_email_sent,\n        password: None,\n        error: None,\n    })\n}",
+      "diff_span": {
+        "before": "        })\n        .await\n        .is_ok_and(|data| data.len() > 0)\n    {\n        return Err(UserErrors::UserExists.into());",
+        "after": "        })\n        .await\n        .is_ok_and(|data| data.is_empty().not())\n    {\n        return Err(UserErrors::UserExists.into());"
+      },
+      "commit_sha": "9e8e72a6efbc4fbb047e4af9106844283c95f33b"
+    }
+  ]
+}

diffs/pr_6677/b10e6d1/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "b10e6d1db83a8cc0db70ea7ad0b667934e0de318",
+  "pr_number": 6677,
+  "rust_files": [
+    "crates/router/src/core/user.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/user.rs::function::handle_existing_user_invitation",
+      "file": "crates/router/src/core/user.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn handle_existing_user_invitation(\n    state: &SessionState,\n    user_from_token: &auth::UserFromToken,\n    request: &user_api::InviteUserRequest,\n    invitee_user_from_db: domain::UserFromStorage,\n    role_info: roles::RoleInfo,\n    auth_id: &Option<String>,\n) -> UserResult<InviteMultipleUserResponse> {\n    let now = common_utils::date_time::now();\n\n    if state\n        .global_store\n        .find_user_role_by_user_id_and_lineage(\n            invitee_user_from_db.get_user_id(),\n            &user_from_token.org_id,\n            &user_from_token.merchant_id,\n            &user_from_token.profile_id,\n            UserRoleVersion::V1,\n        )\n        .await\n        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    if state\n        .global_store\n        .find_user_role_by_user_id_and_lineage(\n            invitee_user_from_db.get_user_id(),\n            &user_from_token.org_id,\n            &user_from_token.merchant_id,\n            &user_from_token.profile_id,\n            UserRoleVersion::V2,\n        )\n        .await\n        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    let user_role = domain::NewUserRole {\n        user_id: invitee_user_from_db.get_user_id().to_owned(),\n        role_id: request.role_id.clone(),\n        status: {\n            if cfg!(feature = \"email\") {\n                UserStatus::InvitationSent\n            } else {\n                UserStatus::Active\n            }\n        },\n        created_by: user_from_token.user_id.clone(),\n        last_modified_by: user_from_token.user_id.clone(),\n        created_at: now,\n        last_modified: now,\n        entity: domain::NoLevel,\n    };\n\n    let _user_role = match role_info.get_entity_type() {\n        EntityType::Organization => {\n            user_role\n                .add_entity(domain::OrganizationLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n        EntityType::Merchant => {\n            user_role\n                .add_entity(domain::MerchantLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                    merchant_id: user_from_token.merchant_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n        EntityType::Profile => {\n            user_role\n                .add_entity(domain::ProfileLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                    merchant_id: user_from_token.merchant_id.clone(),\n                    profile_id: user_from_token.profile_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n    };\n\n    let is_email_sent;\n    #[cfg(feature = \"email\")]\n    {\n        let invitee_email = domain::UserEmail::from_pii_email(request.email.clone())?;\n        let entity = match role_info.get_entity_type() {\n            EntityType::Organization => email_types::Entity {\n                entity_id: user_from_token.org_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Organization,\n            },\n            EntityType::Merchant => email_types::Entity {\n                entity_id: user_from_token.merchant_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Merchant,\n            },\n            EntityType::Profile => email_types::Entity {\n                entity_id: user_from_token.profile_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Profile,\n            },\n        };\n\n        let email_contents = email_types::InviteUser {\n            recipient_email: invitee_email,\n            user_name: domain::UserName::new(invitee_user_from_db.get_name())?,\n            settings: state.conf.clone(),\n            subject: consts::user::EMAIL_SUBJECT_INVITATION,\n            entity,\n            auth_id: auth_id.clone(),\n        };\n\n        is_email_sent = state\n            .email_client\n            .compose_and_send_email(\n                Box::new(email_contents),\n                state.conf.proxy.https_url.as_ref(),\n            )\n            .await\n            .map(|email_result| logger::info!(?email_result))\n            .map_err(|email_result| logger::error!(?email_result))\n            .is_ok();\n    }\n    #[cfg(not(feature = \"email\"))]\n    {\n        is_email_sent = false;\n    }\n\n    Ok(InviteMultipleUserResponse {\n        email: request.email.clone(),\n        is_email_sent,\n        password: None,\n        error: None,\n    })\n}",
+      "after_code": "async fn handle_existing_user_invitation(\n    state: &SessionState,\n    user_from_token: &auth::UserFromToken,\n    request: &user_api::InviteUserRequest,\n    invitee_user_from_db: domain::UserFromStorage,\n    role_info: roles::RoleInfo,\n    auth_id: &Option<String>,\n) -> UserResult<InviteMultipleUserResponse> {\n    let now = common_utils::date_time::now();\n\n    if state\n        .global_store\n        .find_user_role_by_user_id_and_lineage(\n            invitee_user_from_db.get_user_id(),\n            &user_from_token.org_id,\n            &user_from_token.merchant_id,\n            &user_from_token.profile_id,\n            UserRoleVersion::V1,\n        )\n        .await\n        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    if state\n        .global_store\n        .find_user_role_by_user_id_and_lineage(\n            invitee_user_from_db.get_user_id(),\n            &user_from_token.org_id,\n            &user_from_token.merchant_id,\n            &user_from_token.profile_id,\n            UserRoleVersion::V2,\n        )\n        .await\n        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    let (org_id, merchant_id, profile_id) = match role_info.get_entity_type() {\n        EntityType::Organization => (Some(&user_from_token.org_id), None, None),\n        EntityType::Merchant => (\n            Some(&user_from_token.org_id),\n            Some(&user_from_token.merchant_id),\n            None,\n        ),\n        EntityType::Profile => (\n            Some(&user_from_token.org_id),\n            Some(&user_from_token.merchant_id),\n            Some(&user_from_token.profile_id),\n        ),\n    };\n\n    if state\n        .global_store\n        .list_user_roles_by_user_id(ListUserRolesByUserIdPayload {\n            user_id: invitee_user_from_db.get_user_id(),\n            org_id,\n            merchant_id,\n            profile_id,\n            entity_id: None,\n            version: None,\n            status: None,\n            limit: Some(1),\n        })\n        .await\n        .is_ok_and(|data| data.len() > 0)\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    let user_role = domain::NewUserRole {\n        user_id: invitee_user_from_db.get_user_id().to_owned(),\n        role_id: request.role_id.clone(),\n        status: {\n            if cfg!(feature = \"email\") {\n                UserStatus::InvitationSent\n            } else {\n                UserStatus::Active\n            }\n        },\n        created_by: user_from_token.user_id.clone(),\n        last_modified_by: user_from_token.user_id.clone(),\n        created_at: now,\n        last_modified: now,\n        entity: domain::NoLevel,\n    };\n\n    let _user_role = match role_info.get_entity_type() {\n        EntityType::Organization => {\n            user_role\n                .add_entity(domain::OrganizationLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n        EntityType::Merchant => {\n            user_role\n                .add_entity(domain::MerchantLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                    merchant_id: user_from_token.merchant_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n        EntityType::Profile => {\n            user_role\n                .add_entity(domain::ProfileLevel {\n                    tenant_id: user_from_token\n                        .tenant_id\n                        .clone()\n                        .unwrap_or(state.tenant.tenant_id.clone()),\n                    org_id: user_from_token.org_id.clone(),\n                    merchant_id: user_from_token.merchant_id.clone(),\n                    profile_id: user_from_token.profile_id.clone(),\n                })\n                .insert_in_v2(state)\n                .await?\n        }\n    };\n\n    let is_email_sent;\n    #[cfg(feature = \"email\")]\n    {\n        let invitee_email = domain::UserEmail::from_pii_email(request.email.clone())?;\n        let entity = match role_info.get_entity_type() {\n            EntityType::Organization => email_types::Entity {\n                entity_id: user_from_token.org_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Organization,\n            },\n            EntityType::Merchant => email_types::Entity {\n                entity_id: user_from_token.merchant_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Merchant,\n            },\n            EntityType::Profile => email_types::Entity {\n                entity_id: user_from_token.profile_id.get_string_repr().to_owned(),\n                entity_type: EntityType::Profile,\n            },\n        };\n\n        let email_contents = email_types::InviteUser {\n            recipient_email: invitee_email,\n            user_name: domain::UserName::new(invitee_user_from_db.get_name())?,\n            settings: state.conf.clone(),\n            subject: consts::user::EMAIL_SUBJECT_INVITATION,\n            entity,\n            auth_id: auth_id.clone(),\n        };\n\n        is_email_sent = state\n            .email_client\n            .compose_and_send_email(\n                Box::new(email_contents),\n                state.conf.proxy.https_url.as_ref(),\n            )\n            .await\n            .map(|email_result| logger::info!(?email_result))\n            .map_err(|email_result| logger::error!(?email_result))\n            .is_ok();\n    }\n    #[cfg(not(feature = \"email\"))]\n    {\n        is_email_sent = false;\n    }\n\n    Ok(InviteMultipleUserResponse {\n        email: request.email.clone(),\n        is_email_sent,\n        password: None,\n        error: None,\n    })\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        .is_err_and(|err| err.current_context().is_db_not_found())\n        .not()\n    {\n        return Err(UserErrors::UserExists.into());\n    }\n\n    let (org_id, merchant_id, profile_id) = match role_info.get_entity_type() {\n        EntityType::Organization => (Some(&user_from_token.org_id), None, None),\n        EntityType::Merchant => (\n            Some(&user_from_token.org_id),\n            Some(&user_from_token.merchant_id),\n            None,\n        ),\n        EntityType::Profile => (\n            Some(&user_from_token.org_id),\n            Some(&user_from_token.merchant_id),\n            Some(&user_from_token.profile_id),\n        ),\n    };\n\n    if state\n        .global_store\n        .list_user_roles_by_user_id(ListUserRolesByUserIdPayload {\n            user_id: invitee_user_from_db.get_user_id(),\n            org_id,\n            merchant_id,\n            profile_id,\n            entity_id: None,\n            version: None,\n            status: None,\n            limit: Some(1),\n        })\n        .await\n        .is_ok_and(|data| data.len() > 0)\n    {\n        return Err(UserErrors::UserExists.into());"
+      },
+      "commit_sha": "b10e6d1db83a8cc0db70ea7ad0b667934e0de318"
+    }
+  ]
+}