Add files using upload-large-folder tool

diffs/pr_10026/30a176d/diff.json

@@ -0,0 +1,134 @@
+{
+  "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c",
+  "pr_number": 10026,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::TransactionRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        (item, wallet_data): (\n            &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n            &WalletData,\n        ),\n    ) -> Result<Self, Self::Error> {\n        let profile = if item\n            .router_data\n            .request\n            .is_customer_initiated_mandate_payment()\n        {\n            let connector_customer_id =\n                Secret::new(item.router_data.connector_customer.clone().ok_or(\n                    errors::ConnectorError::MissingConnectorRelatedTransactionID {\n                        id: \"connector_customer_id\".to_string(),\n                    },\n                )?);\n            Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {\n                create_profile: true,\n                customer_profile_id: Some(connector_customer_id),\n            }))\n        } else {\n            None\n        };\n\n        let customer = if !item\n            .router_data\n            .request\n            .is_customer_initiated_mandate_payment()\n        {\n            item.router_data.customer_id.as_ref().and_then(|customer| {\n                let customer_id = customer.get_string_repr();\n                (customer_id.len() <= MAX_ID_LENGTH).then_some(CustomerDetails {\n                    id: customer_id.to_string(),\n                    email: item.router_data.request.get_optional_email(),\n                })\n            })\n        } else {\n            None\n        };\n\n        Ok(Self {\n            transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,\n            amount: item.amount,\n            currency_code: item.router_data.request.currency,\n            payment: Some(get_wallet_data(\n                wallet_data,\n                &item.router_data.request.complete_authorize_url,\n            )?),\n            profile,\n            order: Order {\n                invoice_number: match &item.router_data.request.merchant_order_reference_id {\n                    Some(merchant_order_reference_id) => {\n                        if merchant_order_reference_id.len() <= MAX_ID_LENGTH {\n                            merchant_order_reference_id.to_string()\n                        } else {\n                            get_random_string()\n                        }\n                    }\n                    None => get_random_string(),\n                },\n\n                description: item.router_data.connector_request_reference_id.clone(),\n            },\n            customer,\n            bill_to: item\n                .router_data\n                .get_optional_billing()\n                .and_then(|billing_address| billing_address.address.as_ref())\n                .map(|address| BillTo {\n                    first_name: address.first_name.clone(),\n                    last_name: address.last_name.clone(),\n                    address: address.line1.clone(),\n                    city: address.city.clone(),\n                    state: address.state.clone(),\n                    zip: address.zip.clone(),\n                    country: address.country,\n                }),\n            user_fields: match item.router_data.request.metadata.clone() {\n                Some(metadata) => Some(UserFields {\n                    user_field: Vec::<UserField>::foreign_try_from(metadata)?,\n                }),\n                None => None,\n            },\n            processing_options: None,\n            subsequent_auth_information: None,\n            authorization_indicator_type: match item.router_data.request.capture_method {\n                Some(capture_method) => Some(AuthorizationIndicator {\n                    authorization_indicator: capture_method.try_into()?,\n                }),\n                None => None,\n            },\n        })\n    }",
+      "after_code": "fn try_from(\n        (item, wallet_data): (\n            &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n            &WalletData,\n        ),\n    ) -> Result<Self, Self::Error> {\n        let profile = if item\n            .router_data\n            .request\n            .is_customer_initiated_mandate_payment()\n        {\n            let connector_customer_id =\n                Secret::new(item.router_data.connector_customer.clone().ok_or(\n                    errors::ConnectorError::MissingConnectorRelatedTransactionID {\n                        id: \"connector_customer_id\".to_string(),\n                    },\n                )?);\n            Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {\n                create_profile: true,\n                customer_profile_id: Some(connector_customer_id),\n            }))\n        } else {\n            None\n        };\n\n        let customer = if !item\n            .router_data\n            .request\n            .is_customer_initiated_mandate_payment()\n        {\n            item.router_data.customer_id.as_ref().and_then(|customer| {\n                let customer_id = customer.get_string_repr();\n                (customer_id.len() <= MAX_ID_LENGTH).then_some(CustomerDetails {\n                    id: customer_id.to_string(),\n                    email: item.router_data.request.get_optional_email(),\n                })\n            })\n        } else {\n            None\n        };\n\n        Ok(Self {\n            transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,\n            amount: item.amount,\n            currency_code: item.router_data.request.currency,\n            payment: Some(get_wallet_data(\n                wallet_data,\n                &item.router_data.request.complete_authorize_url,\n            )?),\n            profile,\n            order: Order {\n                invoice_number: match &item.router_data.request.merchant_order_reference_id {\n                    Some(merchant_order_reference_id) => {\n                        if merchant_order_reference_id.len() <= MAX_ID_LENGTH {\n                            merchant_order_reference_id.to_string()\n                        } else {\n                            get_random_string()\n                        }\n                    }\n                    None => get_random_string(),\n                },\n\n                description: item.router_data.connector_request_reference_id.clone(),\n            },\n            customer,\n            bill_to: item\n                .router_data\n                .get_optional_billing()\n                .and_then(|billing_address| billing_address.address.as_ref())\n                .map(|address| {\n\n                    BillTo {\n                    first_name: address.first_name.clone(),\n                    last_name: address.last_name.clone(),\n                    address: get_address_line(&address.line1, &address.line2, &address.line3),\n                    city: address.city.clone(),\n                    state: address.state.clone(),\n                    zip: address.zip.clone(),\n                    country: address.country,\n                }}),\n            user_fields: match item.router_data.request.metadata.clone() {\n                Some(metadata) => Some(UserFields {\n                    user_field: Vec::<UserField>::foreign_try_from(metadata)?,\n                }),\n                None => None,\n            },\n            processing_options: None,\n            subsequent_auth_information: None,\n            authorization_indicator_type: match item.router_data.request.capture_method {\n                Some(capture_method) => Some(AuthorizationIndicator {\n                    authorization_indicator: capture_method.try_into()?,\n                }),\n                None => None,\n            },\n        })\n    }",
+      "diff_span": {
+        "before": "                .get_optional_billing()\n                .and_then(|billing_address| billing_address.address.as_ref())\n                .map(|address| BillTo {\n                    first_name: address.first_name.clone(),\n                    last_name: address.last_name.clone(),\n                    address: address.line1.clone(),\n                    city: address.city.clone(),\n                    state: address.state.clone(),\n                    zip: address.zip.clone(),\n                    country: address.country,\n                }),\n            user_fields: match item.router_data.request.metadata.clone() {\n                Some(metadata) => Some(UserFields {",
+        "after": "                .get_optional_billing()\n                .and_then(|billing_address| billing_address.address.as_ref())\n                .map(|address| {\n\n                    BillTo {\n                    first_name: address.first_name.clone(),\n                    last_name: address.last_name.clone(),\n                    address: get_address_line(&address.line1, &address.line2, &address.line3),\n                    city: address.city.clone(),\n                    state: address.state.clone(),\n                    zip: address.zip.clone(),\n                    country: address.country,\n                }}),\n            user_fields: match item.router_data.request.metadata.clone() {\n                Some(metadata) => Some(UserFields {"
+      },
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::CreateCustomerPaymentProfileRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;\n        let validation_mode = match item.test_mode {\n            Some(true) | None => ValidationMode::TestMode,\n            Some(false) => ValidationMode::LiveMode,\n        };\n        let customer_profile_id = item.get_connector_customer_id()?.into();\n\n        let bill_to = item\n            .get_optional_billing()\n            .and_then(|billing_address| billing_address.address.as_ref())\n            .map(|address| BillTo {\n                first_name: address.first_name.clone(),\n                last_name: address.last_name.clone(),\n                address: address.line1.clone(),\n                city: address.city.clone(),\n                state: address.state.clone(),\n                zip: address.zip.clone(),\n                country: address.country,\n            });\n        let payment_profile = match item.request.payment_method_data.clone() {\n            PaymentMethodData::Card(ccard) => Ok(PaymentProfile {\n                bill_to,\n                payment: PaymentDetails::CreditCard(CreditCardDetails {\n                    card_number: (*ccard.card_number).clone(),\n                    expiration_date: ccard.get_expiry_date_as_yyyymm(\"-\"),\n                    card_code: Some(ccard.card_cvc.clone()),\n                }),\n            }),\n            PaymentMethodData::Wallet(wallet_data) => match wallet_data {\n                WalletData::GooglePay(_) => Ok(PaymentProfile {\n                    bill_to,\n                    payment: PaymentDetails::OpaqueData(WalletDetails {\n                        data_descriptor: WalletMethod::Googlepay,\n                        data_value: Secret::new(wallet_data.get_encoded_wallet_token()?),\n                    }),\n                }),\n                WalletData::ApplePay(applepay_token) => {\n                    let apple_pay_encrypted_data = applepay_token\n                        .payment_data\n                        .get_encrypted_apple_pay_payment_data_mandatory()\n                        .change_context(errors::ConnectorError::MissingRequiredField {\n                            field_name: \"Apple pay encrypted data\",\n                        })?;\n\n                    Ok(PaymentProfile {\n                        bill_to,\n                        payment: PaymentDetails::OpaqueData(WalletDetails {\n                            data_descriptor: WalletMethod::Applepay,\n                            data_value: Secret::new(apple_pay_encrypted_data.clone()),\n                        }),\n                    })\n                }\n\n                WalletData::AliPayQr(_)\n                | WalletData::AliPayRedirect(_)\n                | WalletData::AliPayHkRedirect(_)\n                | WalletData::AmazonPayRedirect(_)\n                | WalletData::Paysera(_)\n                | WalletData::BluecodeRedirect {}\n                | WalletData::Skrill(_)\n                | WalletData::MomoRedirect(_)\n                | WalletData::KakaoPayRedirect(_)\n                | WalletData::GoPayRedirect(_)\n                | WalletData::GcashRedirect(_)\n                | WalletData::ApplePayRedirect(_)\n                | WalletData::ApplePayThirdPartySdk(_)\n                | WalletData::DanaRedirect {}\n                | WalletData::GooglePayRedirect(_)\n                | WalletData::GooglePayThirdPartySdk(_)\n                | WalletData::MbWayRedirect(_)\n                | WalletData::MobilePayRedirect(_)\n                | WalletData::PaypalRedirect(_)\n                | WalletData::AmazonPay(_)\n                | WalletData::PaypalSdk(_)\n                | WalletData::Paze(_)\n                | WalletData::SamsungPay(_)\n                | WalletData::TwintRedirect {}\n                | WalletData::VippsRedirect {}\n                | WalletData::TouchNGoRedirect(_)\n                | WalletData::WeChatPayRedirect(_)\n                | WalletData::WeChatPayQr(_)\n                | WalletData::CashappQr(_)\n                | WalletData::SwishQr(_)\n                | WalletData::Mifinity(_)\n                | WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                )),\n            },\n            PaymentMethodData::CardRedirect(_)\n            | PaymentMethodData::PayLater(_)\n            | PaymentMethodData::BankRedirect(_)\n            | PaymentMethodData::BankDebit(_)\n            | PaymentMethodData::BankTransfer(_)\n            | PaymentMethodData::Crypto(_)\n            | PaymentMethodData::MandatePayment\n            | PaymentMethodData::Reward\n            | PaymentMethodData::RealTimePayment(_)\n            | PaymentMethodData::MobilePayment(_)\n            | PaymentMethodData::Upi(_)\n            | PaymentMethodData::Voucher(_)\n            | PaymentMethodData::GiftCard(_)\n            | PaymentMethodData::OpenBanking(_)\n            | PaymentMethodData::CardToken(_)\n            | PaymentMethodData::NetworkToken(_)\n            | PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {\n                Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                ))\n            }\n        }?;\n        Ok(Self {\n            create_customer_payment_profile_request: AuthorizedotnetPaymentProfileRequest {\n                merchant_authentication,\n                customer_profile_id,\n                payment_profile,\n                validation_mode,\n            },\n        })\n    }",
+      "after_code": "fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;\n        let validation_mode = match item.test_mode {\n            Some(true) | None => ValidationMode::TestMode,\n            Some(false) => ValidationMode::LiveMode,\n        };\n        let customer_profile_id = item.get_connector_customer_id()?.into();\n\n        let bill_to = item\n            .get_optional_billing()\n            .and_then(|billing_address| billing_address.address.as_ref())\n            .map(|address| {\n\n                BillTo {\n                first_name: address.first_name.clone(),\n                last_name: address.last_name.clone(),\n                address: get_address_line(&address.line1, &address.line2, &address.line3),\n                city: address.city.clone(),\n                state: address.state.clone(),\n                zip: address.zip.clone(),\n                country: address.country,\n            }});\n        let payment_profile = match item.request.payment_method_data.clone() {\n            PaymentMethodData::Card(ccard) => Ok(PaymentProfile {\n                bill_to,\n                payment: PaymentDetails::CreditCard(CreditCardDetails {\n                    card_number: (*ccard.card_number).clone(),\n                    expiration_date: ccard.get_expiry_date_as_yyyymm(\"-\"),\n                    card_code: Some(ccard.card_cvc.clone()),\n                }),\n            }),\n            PaymentMethodData::Wallet(wallet_data) => match wallet_data {\n                WalletData::GooglePay(_) => Ok(PaymentProfile {\n                    bill_to,\n                    payment: PaymentDetails::OpaqueData(WalletDetails {\n                        data_descriptor: WalletMethod::Googlepay,\n                        data_value: Secret::new(wallet_data.get_encoded_wallet_token()?),\n                    }),\n                }),\n                WalletData::ApplePay(applepay_token) => {\n                    let apple_pay_encrypted_data = applepay_token\n                        .payment_data\n                        .get_encrypted_apple_pay_payment_data_mandatory()\n                        .change_context(errors::ConnectorError::MissingRequiredField {\n                            field_name: \"Apple pay encrypted data\",\n                        })?;\n\n                    Ok(PaymentProfile {\n                        bill_to,\n                        payment: PaymentDetails::OpaqueData(WalletDetails {\n                            data_descriptor: WalletMethod::Applepay,\n                            data_value: Secret::new(apple_pay_encrypted_data.clone()),\n                        }),\n                    })\n                }\n\n                WalletData::AliPayQr(_)\n                | WalletData::AliPayRedirect(_)\n                | WalletData::AliPayHkRedirect(_)\n                | WalletData::AmazonPayRedirect(_)\n                | WalletData::Paysera(_)\n                | WalletData::BluecodeRedirect {}\n                | WalletData::Skrill(_)\n                | WalletData::MomoRedirect(_)\n                | WalletData::KakaoPayRedirect(_)\n                | WalletData::GoPayRedirect(_)\n                | WalletData::GcashRedirect(_)\n                | WalletData::ApplePayRedirect(_)\n                | WalletData::ApplePayThirdPartySdk(_)\n                | WalletData::DanaRedirect {}\n                | WalletData::GooglePayRedirect(_)\n                | WalletData::GooglePayThirdPartySdk(_)\n                | WalletData::MbWayRedirect(_)\n                | WalletData::MobilePayRedirect(_)\n                | WalletData::PaypalRedirect(_)\n                | WalletData::AmazonPay(_)\n                | WalletData::PaypalSdk(_)\n                | WalletData::Paze(_)\n                | WalletData::SamsungPay(_)\n                | WalletData::TwintRedirect {}\n                | WalletData::VippsRedirect {}\n                | WalletData::TouchNGoRedirect(_)\n                | WalletData::WeChatPayRedirect(_)\n                | WalletData::WeChatPayQr(_)\n                | WalletData::CashappQr(_)\n                | WalletData::SwishQr(_)\n                | WalletData::Mifinity(_)\n                | WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                )),\n            },\n            PaymentMethodData::CardRedirect(_)\n            | PaymentMethodData::PayLater(_)\n            | PaymentMethodData::BankRedirect(_)\n            | PaymentMethodData::BankDebit(_)\n            | PaymentMethodData::BankTransfer(_)\n            | PaymentMethodData::Crypto(_)\n            | PaymentMethodData::MandatePayment\n            | PaymentMethodData::Reward\n            | PaymentMethodData::RealTimePayment(_)\n            | PaymentMethodData::MobilePayment(_)\n            | PaymentMethodData::Upi(_)\n            | PaymentMethodData::Voucher(_)\n            | PaymentMethodData::GiftCard(_)\n            | PaymentMethodData::OpenBanking(_)\n            | PaymentMethodData::CardToken(_)\n            | PaymentMethodData::NetworkToken(_)\n            | PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {\n                Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                ))\n            }\n        }?;\n        Ok(Self {\n            create_customer_payment_profile_request: AuthorizedotnetPaymentProfileRequest {\n                merchant_authentication,\n                customer_profile_id,\n                payment_profile,\n                validation_mode,\n            },\n        })\n    }",
+      "diff_span": {
+        "before": "            .get_optional_billing()\n            .and_then(|billing_address| billing_address.address.as_ref())\n            .map(|address| BillTo {\n                first_name: address.first_name.clone(),\n                last_name: address.last_name.clone(),\n                address: address.line1.clone(),\n                city: address.city.clone(),\n                state: address.state.clone(),\n                zip: address.zip.clone(),\n                country: address.country,\n            });\n        let payment_profile = match item.request.payment_method_data.clone() {\n            PaymentMethodData::Card(ccard) => Ok(PaymentProfile {",
+        "after": "            .get_optional_billing()\n            .and_then(|billing_address| billing_address.address.as_ref())\n            .map(|address| {\n\n                BillTo {\n                first_name: address.first_name.clone(),\n                last_name: address.last_name.clone(),\n                address: get_address_line(&address.line1, &address.line2, &address.line3),\n                city: address.city.clone(),\n                state: address.state.clone(),\n                zip: address.zip.clone(),\n                country: address.country,\n            }});\n        let payment_profile = match item.request.payment_method_data.clone() {\n            PaymentMethodData::Card(ccard) => Ok(PaymentProfile {"
+      },
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::impl::RouterData<F, Req, PaymentsResponseData>",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F, Req> TryFrom<ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>>\n    for RouterData<F, Req, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n\n    fn try_from(\n        item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match item.response.transaction {\n            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                if utils::is_payment_failure(payment_status) {\n                Ok(Self {\n                    response: Ok(PaymentsResponseData::TransactionResponse {\n                        resource_id: ResponseId::ConnectorTransactionId(\n                            transaction.transaction_id.clone(),\n                        ),\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: Some(transaction.transaction_id.clone()),\n                        incremental_authorization_allowed: None,\n                        charges: None,\n                    }),\n                    status: payment_status,\n                    ..item.data\n                })\n            }\n            else {\n                    Ok(Self {\n                        status: payment_status,\n                        response:  Ok(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                            message:  transaction.response_reason_description.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string())\n                            reason:  transaction.response_reason_description.clone(),\n                            status_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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" |  msg.code == \"E00104\" )\n            {\n                Some(_) => Ok(item.data),\n                None => Ok(Self {\n                    response: Err(get_err_response(item.http_code, item.response.messages)?),\n                    ..item.data\n                }),\n            },\n        }\n    }\n}",
+      "after_code": "impl<F, Req> TryFrom<ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>>\n    for RouterData<F, Req, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n\n    fn try_from(\n        item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match item.response.transaction {\n            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                if utils::is_payment_failure(payment_status) {\n                Ok(Self {\n                    response: Ok(PaymentsResponseData::TransactionResponse {\n                        resource_id: ResponseId::ConnectorTransactionId(\n                            transaction.transaction_id.clone(),\n                        ),\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: Some(transaction.transaction_id.clone()),\n                        incremental_authorization_allowed: None,\n                        charges: None,\n                    }),\n                    status: payment_status,\n                    ..item.data\n                })\n            }\n            else {\n                    Ok(Self {\n                        status: payment_status,\n                        response:  Err(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                            message:  transaction.response_reason_description.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),\n                            reason:  transaction.response_reason_description.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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" ||  msg.code == \"E00104\" )\n            {\n                Some(_) => Ok(item.data),\n                None => Ok(Self {\n                    response: Err(get_err_response(item.http_code, item.response.messages)?),\n                    ..item.data\n                }),\n            },\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                    Ok(Self {\n                        status: payment_status,\n                        response:  Ok(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                            message:  transaction.response_reason_description.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string())\n                            reason:  transaction.response_reason_description.clone(),\n                            status_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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" |  msg.code == \"E00104\" )\n            {\n                Some(_) => Ok(item.data),",
+        "after": "                    Ok(Self {\n                        status: payment_status,\n                        response:  Err(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                            message:  transaction.response_reason_description.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),\n                            reason:  transaction.response_reason_description.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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" ||  msg.code == \"E00104\" )\n            {\n                Some(_) => Ok(item.data),"
+      },
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::RouterData<F, Req, PaymentsResponseData>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match item.response.transaction {\n            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                if utils::is_payment_failure(payment_status) {\n                Ok(Self {\n                    response: Ok(PaymentsResponseData::TransactionResponse {\n                        resource_id: ResponseId::ConnectorTransactionId(\n                            transaction.transaction_id.clone(),\n                        ),\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: Some(transaction.transaction_id.clone()),\n                        incremental_authorization_allowed: None,\n                        charges: None,\n                    }),\n                    status: payment_status,\n                    ..item.data\n                })\n            }\n            else {\n                    Ok(Self {\n                        status: payment_status,\n                        response:  Ok(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                            message:  transaction.response_reason_description.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string())\n                            reason:  transaction.response_reason_description.clone(),\n                            status_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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" |  msg.code == \"E00104\" )\n            {\n                Some(_) => Ok(item.data),\n                None => Ok(Self {\n                    response: Err(get_err_response(item.http_code, item.response.messages)?),\n                    ..item.data\n                }),\n            },\n        }\n    }",
+      "after_code": "fn try_from(\n        item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match item.response.transaction {\n            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                if utils::is_payment_failure(payment_status) {\n                Ok(Self {\n                    response: Ok(PaymentsResponseData::TransactionResponse {\n                        resource_id: ResponseId::ConnectorTransactionId(\n                            transaction.transaction_id.clone(),\n                        ),\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: Some(transaction.transaction_id.clone()),\n                        incremental_authorization_allowed: None,\n                        charges: None,\n                    }),\n                    status: payment_status,\n                    ..item.data\n                })\n            }\n            else {\n                    Ok(Self {\n                        status: payment_status,\n                        response:  Err(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                            message:  transaction.response_reason_description.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),\n                            reason:  transaction.response_reason_description.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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" ||  msg.code == \"E00104\" )\n            {\n                Some(_) => Ok(item.data),\n                None => Ok(Self {\n                    response: Err(get_err_response(item.http_code, item.response.messages)?),\n                    ..item.data\n                }),\n            },\n        }\n    }",
+      "diff_span": {
+        "before": "                    Ok(Self {\n                        status: payment_status,\n                        response:  Ok(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                            message:  transaction.response_reason_description.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string())\n                            reason:  transaction.response_reason_description.clone(),\n                            status_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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" |  msg.code == \"E00104\" )\n            {\n                Some(_) => Ok(item.data),",
+        "after": "                    Ok(Self {\n                        status: payment_status,\n                        response:  Err(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string()),\n                            message:  transaction.response_reason_description.clone().unwrap_or(hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string()),\n                            reason:  transaction.response_reason_description.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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" ||  msg.code == \"E00104\" )\n            {\n                Some(_) => Ok(item.data),"
+      },
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::impl::TransactionRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl\n    TryFrom<(\n        &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n        &WalletData,\n    )> for TransactionRequest\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        (item, wallet_data): (\n            &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n            &WalletData,\n        ),\n    ) -> Result<Self, Self::Error> {\n        let profile = if item\n            .router_data\n            .request\n            .is_customer_initiated_mandate_payment()\n        {\n            let connector_customer_id =\n                Secret::new(item.router_data.connector_customer.clone().ok_or(\n                    errors::ConnectorError::MissingConnectorRelatedTransactionID {\n                        id: \"connector_customer_id\".to_string(),\n                    },\n                )?);\n            Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {\n                create_profile: true,\n                customer_profile_id: Some(connector_customer_id),\n            }))\n        } else {\n            None\n        };\n\n        let customer = if !item\n            .router_data\n            .request\n            .is_customer_initiated_mandate_payment()\n        {\n            item.router_data.customer_id.as_ref().and_then(|customer| {\n                let customer_id = customer.get_string_repr();\n                (customer_id.len() <= MAX_ID_LENGTH).then_some(CustomerDetails {\n                    id: customer_id.to_string(),\n                    email: item.router_data.request.get_optional_email(),\n                })\n            })\n        } else {\n            None\n        };\n\n        Ok(Self {\n            transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,\n            amount: item.amount,\n            currency_code: item.router_data.request.currency,\n            payment: Some(get_wallet_data(\n                wallet_data,\n                &item.router_data.request.complete_authorize_url,\n            )?),\n            profile,\n            order: Order {\n                invoice_number: match &item.router_data.request.merchant_order_reference_id {\n                    Some(merchant_order_reference_id) => {\n                        if merchant_order_reference_id.len() <= MAX_ID_LENGTH {\n                            merchant_order_reference_id.to_string()\n                        } else {\n                            get_random_string()\n                        }\n                    }\n                    None => get_random_string(),\n                },\n\n                description: item.router_data.connector_request_reference_id.clone(),\n            },\n            customer,\n            bill_to: item\n                .router_data\n                .get_optional_billing()\n                .and_then(|billing_address| billing_address.address.as_ref())\n                .map(|address| BillTo {\n                    first_name: address.first_name.clone(),\n                    last_name: address.last_name.clone(),\n                    address: address.line1.clone(),\n                    city: address.city.clone(),\n                    state: address.state.clone(),\n                    zip: address.zip.clone(),\n                    country: address.country,\n                }),\n            user_fields: match item.router_data.request.metadata.clone() {\n                Some(metadata) => Some(UserFields {\n                    user_field: Vec::<UserField>::foreign_try_from(metadata)?,\n                }),\n                None => None,\n            },\n            processing_options: None,\n            subsequent_auth_information: None,\n            authorization_indicator_type: match item.router_data.request.capture_method {\n                Some(capture_method) => Some(AuthorizationIndicator {\n                    authorization_indicator: capture_method.try_into()?,\n                }),\n                None => None,\n            },\n        })\n    }\n}",
+      "after_code": "impl\n    TryFrom<(\n        &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n        &WalletData,\n    )> for TransactionRequest\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        (item, wallet_data): (\n            &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n            &WalletData,\n        ),\n    ) -> Result<Self, Self::Error> {\n        let profile = if item\n            .router_data\n            .request\n            .is_customer_initiated_mandate_payment()\n        {\n            let connector_customer_id =\n                Secret::new(item.router_data.connector_customer.clone().ok_or(\n                    errors::ConnectorError::MissingConnectorRelatedTransactionID {\n                        id: \"connector_customer_id\".to_string(),\n                    },\n                )?);\n            Some(ProfileDetails::CreateProfileDetails(CreateProfileDetails {\n                create_profile: true,\n                customer_profile_id: Some(connector_customer_id),\n            }))\n        } else {\n            None\n        };\n\n        let customer = if !item\n            .router_data\n            .request\n            .is_customer_initiated_mandate_payment()\n        {\n            item.router_data.customer_id.as_ref().and_then(|customer| {\n                let customer_id = customer.get_string_repr();\n                (customer_id.len() <= MAX_ID_LENGTH).then_some(CustomerDetails {\n                    id: customer_id.to_string(),\n                    email: item.router_data.request.get_optional_email(),\n                })\n            })\n        } else {\n            None\n        };\n\n        Ok(Self {\n            transaction_type: TransactionType::try_from(item.router_data.request.capture_method)?,\n            amount: item.amount,\n            currency_code: item.router_data.request.currency,\n            payment: Some(get_wallet_data(\n                wallet_data,\n                &item.router_data.request.complete_authorize_url,\n            )?),\n            profile,\n            order: Order {\n                invoice_number: match &item.router_data.request.merchant_order_reference_id {\n                    Some(merchant_order_reference_id) => {\n                        if merchant_order_reference_id.len() <= MAX_ID_LENGTH {\n                            merchant_order_reference_id.to_string()\n                        } else {\n                            get_random_string()\n                        }\n                    }\n                    None => get_random_string(),\n                },\n\n                description: item.router_data.connector_request_reference_id.clone(),\n            },\n            customer,\n            bill_to: item\n                .router_data\n                .get_optional_billing()\n                .and_then(|billing_address| billing_address.address.as_ref())\n                .map(|address| {\n\n                    BillTo {\n                    first_name: address.first_name.clone(),\n                    last_name: address.last_name.clone(),\n                    address: get_address_line(&address.line1, &address.line2, &address.line3),\n                    city: address.city.clone(),\n                    state: address.state.clone(),\n                    zip: address.zip.clone(),\n                    country: address.country,\n                }}),\n            user_fields: match item.router_data.request.metadata.clone() {\n                Some(metadata) => Some(UserFields {\n                    user_field: Vec::<UserField>::foreign_try_from(metadata)?,\n                }),\n                None => None,\n            },\n            processing_options: None,\n            subsequent_auth_information: None,\n            authorization_indicator_type: match item.router_data.request.capture_method {\n                Some(capture_method) => Some(AuthorizationIndicator {\n                    authorization_indicator: capture_method.try_into()?,\n                }),\n                None => None,\n            },\n        })\n    }\n}",
+      "diff_span": {
+        "before": "                .get_optional_billing()\n                .and_then(|billing_address| billing_address.address.as_ref())\n                .map(|address| BillTo {\n                    first_name: address.first_name.clone(),\n                    last_name: address.last_name.clone(),\n                    address: address.line1.clone(),\n                    city: address.city.clone(),\n                    state: address.state.clone(),\n                    zip: address.zip.clone(),\n                    country: address.country,\n                }),\n            user_fields: match item.router_data.request.metadata.clone() {\n                Some(metadata) => Some(UserFields {",
+        "after": "                .get_optional_billing()\n                .and_then(|billing_address| billing_address.address.as_ref())\n                .map(|address| {\n\n                    BillTo {\n                    first_name: address.first_name.clone(),\n                    last_name: address.last_name.clone(),\n                    address: get_address_line(&address.line1, &address.line2, &address.line3),\n                    city: address.city.clone(),\n                    state: address.state.clone(),\n                    zip: address.zip.clone(),\n                    country: address.country,\n                }}),\n            user_fields: match item.router_data.request.metadata.clone() {\n                Some(metadata) => Some(UserFields {"
+      },
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::impl::CreateCustomerPaymentProfileRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&SetupMandateRouterData> for CreateCustomerPaymentProfileRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;\n        let validation_mode = match item.test_mode {\n            Some(true) | None => ValidationMode::TestMode,\n            Some(false) => ValidationMode::LiveMode,\n        };\n        let customer_profile_id = item.get_connector_customer_id()?.into();\n\n        let bill_to = item\n            .get_optional_billing()\n            .and_then(|billing_address| billing_address.address.as_ref())\n            .map(|address| BillTo {\n                first_name: address.first_name.clone(),\n                last_name: address.last_name.clone(),\n                address: address.line1.clone(),\n                city: address.city.clone(),\n                state: address.state.clone(),\n                zip: address.zip.clone(),\n                country: address.country,\n            });\n        let payment_profile = match item.request.payment_method_data.clone() {\n            PaymentMethodData::Card(ccard) => Ok(PaymentProfile {\n                bill_to,\n                payment: PaymentDetails::CreditCard(CreditCardDetails {\n                    card_number: (*ccard.card_number).clone(),\n                    expiration_date: ccard.get_expiry_date_as_yyyymm(\"-\"),\n                    card_code: Some(ccard.card_cvc.clone()),\n                }),\n            }),\n            PaymentMethodData::Wallet(wallet_data) => match wallet_data {\n                WalletData::GooglePay(_) => Ok(PaymentProfile {\n                    bill_to,\n                    payment: PaymentDetails::OpaqueData(WalletDetails {\n                        data_descriptor: WalletMethod::Googlepay,\n                        data_value: Secret::new(wallet_data.get_encoded_wallet_token()?),\n                    }),\n                }),\n                WalletData::ApplePay(applepay_token) => {\n                    let apple_pay_encrypted_data = applepay_token\n                        .payment_data\n                        .get_encrypted_apple_pay_payment_data_mandatory()\n                        .change_context(errors::ConnectorError::MissingRequiredField {\n                            field_name: \"Apple pay encrypted data\",\n                        })?;\n\n                    Ok(PaymentProfile {\n                        bill_to,\n                        payment: PaymentDetails::OpaqueData(WalletDetails {\n                            data_descriptor: WalletMethod::Applepay,\n                            data_value: Secret::new(apple_pay_encrypted_data.clone()),\n                        }),\n                    })\n                }\n\n                WalletData::AliPayQr(_)\n                | WalletData::AliPayRedirect(_)\n                | WalletData::AliPayHkRedirect(_)\n                | WalletData::AmazonPayRedirect(_)\n                | WalletData::Paysera(_)\n                | WalletData::BluecodeRedirect {}\n                | WalletData::Skrill(_)\n                | WalletData::MomoRedirect(_)\n                | WalletData::KakaoPayRedirect(_)\n                | WalletData::GoPayRedirect(_)\n                | WalletData::GcashRedirect(_)\n                | WalletData::ApplePayRedirect(_)\n                | WalletData::ApplePayThirdPartySdk(_)\n                | WalletData::DanaRedirect {}\n                | WalletData::GooglePayRedirect(_)\n                | WalletData::GooglePayThirdPartySdk(_)\n                | WalletData::MbWayRedirect(_)\n                | WalletData::MobilePayRedirect(_)\n                | WalletData::PaypalRedirect(_)\n                | WalletData::AmazonPay(_)\n                | WalletData::PaypalSdk(_)\n                | WalletData::Paze(_)\n                | WalletData::SamsungPay(_)\n                | WalletData::TwintRedirect {}\n                | WalletData::VippsRedirect {}\n                | WalletData::TouchNGoRedirect(_)\n                | WalletData::WeChatPayRedirect(_)\n                | WalletData::WeChatPayQr(_)\n                | WalletData::CashappQr(_)\n                | WalletData::SwishQr(_)\n                | WalletData::Mifinity(_)\n                | WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                )),\n            },\n            PaymentMethodData::CardRedirect(_)\n            | PaymentMethodData::PayLater(_)\n            | PaymentMethodData::BankRedirect(_)\n            | PaymentMethodData::BankDebit(_)\n            | PaymentMethodData::BankTransfer(_)\n            | PaymentMethodData::Crypto(_)\n            | PaymentMethodData::MandatePayment\n            | PaymentMethodData::Reward\n            | PaymentMethodData::RealTimePayment(_)\n            | PaymentMethodData::MobilePayment(_)\n            | PaymentMethodData::Upi(_)\n            | PaymentMethodData::Voucher(_)\n            | PaymentMethodData::GiftCard(_)\n            | PaymentMethodData::OpenBanking(_)\n            | PaymentMethodData::CardToken(_)\n            | PaymentMethodData::NetworkToken(_)\n            | PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {\n                Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                ))\n            }\n        }?;\n        Ok(Self {\n            create_customer_payment_profile_request: AuthorizedotnetPaymentProfileRequest {\n                merchant_authentication,\n                customer_profile_id,\n                payment_profile,\n                validation_mode,\n            },\n        })\n    }\n}",
+      "after_code": "impl TryFrom<&SetupMandateRouterData> for CreateCustomerPaymentProfileRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        let merchant_authentication = AuthorizedotnetAuthType::try_from(&item.connector_auth_type)?;\n        let validation_mode = match item.test_mode {\n            Some(true) | None => ValidationMode::TestMode,\n            Some(false) => ValidationMode::LiveMode,\n        };\n        let customer_profile_id = item.get_connector_customer_id()?.into();\n\n        let bill_to = item\n            .get_optional_billing()\n            .and_then(|billing_address| billing_address.address.as_ref())\n            .map(|address| {\n\n                BillTo {\n                first_name: address.first_name.clone(),\n                last_name: address.last_name.clone(),\n                address: get_address_line(&address.line1, &address.line2, &address.line3),\n                city: address.city.clone(),\n                state: address.state.clone(),\n                zip: address.zip.clone(),\n                country: address.country,\n            }});\n        let payment_profile = match item.request.payment_method_data.clone() {\n            PaymentMethodData::Card(ccard) => Ok(PaymentProfile {\n                bill_to,\n                payment: PaymentDetails::CreditCard(CreditCardDetails {\n                    card_number: (*ccard.card_number).clone(),\n                    expiration_date: ccard.get_expiry_date_as_yyyymm(\"-\"),\n                    card_code: Some(ccard.card_cvc.clone()),\n                }),\n            }),\n            PaymentMethodData::Wallet(wallet_data) => match wallet_data {\n                WalletData::GooglePay(_) => Ok(PaymentProfile {\n                    bill_to,\n                    payment: PaymentDetails::OpaqueData(WalletDetails {\n                        data_descriptor: WalletMethod::Googlepay,\n                        data_value: Secret::new(wallet_data.get_encoded_wallet_token()?),\n                    }),\n                }),\n                WalletData::ApplePay(applepay_token) => {\n                    let apple_pay_encrypted_data = applepay_token\n                        .payment_data\n                        .get_encrypted_apple_pay_payment_data_mandatory()\n                        .change_context(errors::ConnectorError::MissingRequiredField {\n                            field_name: \"Apple pay encrypted data\",\n                        })?;\n\n                    Ok(PaymentProfile {\n                        bill_to,\n                        payment: PaymentDetails::OpaqueData(WalletDetails {\n                            data_descriptor: WalletMethod::Applepay,\n                            data_value: Secret::new(apple_pay_encrypted_data.clone()),\n                        }),\n                    })\n                }\n\n                WalletData::AliPayQr(_)\n                | WalletData::AliPayRedirect(_)\n                | WalletData::AliPayHkRedirect(_)\n                | WalletData::AmazonPayRedirect(_)\n                | WalletData::Paysera(_)\n                | WalletData::BluecodeRedirect {}\n                | WalletData::Skrill(_)\n                | WalletData::MomoRedirect(_)\n                | WalletData::KakaoPayRedirect(_)\n                | WalletData::GoPayRedirect(_)\n                | WalletData::GcashRedirect(_)\n                | WalletData::ApplePayRedirect(_)\n                | WalletData::ApplePayThirdPartySdk(_)\n                | WalletData::DanaRedirect {}\n                | WalletData::GooglePayRedirect(_)\n                | WalletData::GooglePayThirdPartySdk(_)\n                | WalletData::MbWayRedirect(_)\n                | WalletData::MobilePayRedirect(_)\n                | WalletData::PaypalRedirect(_)\n                | WalletData::AmazonPay(_)\n                | WalletData::PaypalSdk(_)\n                | WalletData::Paze(_)\n                | WalletData::SamsungPay(_)\n                | WalletData::TwintRedirect {}\n                | WalletData::VippsRedirect {}\n                | WalletData::TouchNGoRedirect(_)\n                | WalletData::WeChatPayRedirect(_)\n                | WalletData::WeChatPayQr(_)\n                | WalletData::CashappQr(_)\n                | WalletData::SwishQr(_)\n                | WalletData::Mifinity(_)\n                | WalletData::RevolutPay(_) => Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                )),\n            },\n            PaymentMethodData::CardRedirect(_)\n            | PaymentMethodData::PayLater(_)\n            | PaymentMethodData::BankRedirect(_)\n            | PaymentMethodData::BankDebit(_)\n            | PaymentMethodData::BankTransfer(_)\n            | PaymentMethodData::Crypto(_)\n            | PaymentMethodData::MandatePayment\n            | PaymentMethodData::Reward\n            | PaymentMethodData::RealTimePayment(_)\n            | PaymentMethodData::MobilePayment(_)\n            | PaymentMethodData::Upi(_)\n            | PaymentMethodData::Voucher(_)\n            | PaymentMethodData::GiftCard(_)\n            | PaymentMethodData::OpenBanking(_)\n            | PaymentMethodData::CardToken(_)\n            | PaymentMethodData::NetworkToken(_)\n            | PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {\n                Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                ))\n            }\n        }?;\n        Ok(Self {\n            create_customer_payment_profile_request: AuthorizedotnetPaymentProfileRequest {\n                merchant_authentication,\n                customer_profile_id,\n                payment_profile,\n                validation_mode,\n            },\n        })\n    }\n}",
+      "diff_span": {
+        "before": "            .get_optional_billing()\n            .and_then(|billing_address| billing_address.address.as_ref())\n            .map(|address| BillTo {\n                first_name: address.first_name.clone(),\n                last_name: address.last_name.clone(),\n                address: address.line1.clone(),\n                city: address.city.clone(),\n                state: address.state.clone(),\n                zip: address.zip.clone(),\n                country: address.country,\n            });\n        let payment_profile = match item.request.payment_method_data.clone() {\n            PaymentMethodData::Card(ccard) => Ok(PaymentProfile {",
+        "after": "            .get_optional_billing()\n            .and_then(|billing_address| billing_address.address.as_ref())\n            .map(|address| {\n\n                BillTo {\n                first_name: address.first_name.clone(),\n                last_name: address.last_name.clone(),\n                address: get_address_line(&address.line1, &address.line2, &address.line3),\n                city: address.city.clone(),\n                state: address.state.clone(),\n                zip: address.zip.clone(),\n                country: address.country,\n            }});\n        let payment_profile = match item.request.payment_method_data.clone() {\n            PaymentMethodData::Card(ccard) => Ok(PaymentProfile {"
+      },
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::struct::SyncTransactionResponse",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct SyncTransactionResponse {\n    #[serde(rename = \"transId\")]\n    transaction_id: String,\n    transaction_status: SyncStatus,\n    response_reason_code: Option<String>,\n    response_reason_description: Option<String>,\n}",
+      "after_code": "pub struct SyncTransactionResponse {\n    #[serde(rename = \"transId\")]\n    transaction_id: String,\n    transaction_status: SyncStatus,\n}",
+      "diff_span": {
+        "before": "    transaction_id: String,\n    transaction_status: SyncStatus,\n    response_reason_code: Option<String>,\n    response_reason_description: Option<String>,\n}",
+        "after": ""
+      },
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::const::ADDRESS_MAX_LENGTH",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "const_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "const ADDRESS_MAX_LENGTH: usize = 60;",
+      "diff_span": null,
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::function::get_address_line",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_address_line(\n    address_line1: &Option<Secret<String>>,\n    address_line2: &Option<Secret<String>>,\n    address_line3: &Option<Secret<String>>,\n) -> Option<Secret<String>> {\n    for lines in [\n        vec![address_line1, address_line2, address_line3],\n        vec![address_line1, address_line2],\n    ] {\n        let combined: String = lines.into_iter()\n            .flatten()\n            .map(|s| s.clone().expose())\n            .collect::<Vec<_>>()\n            .join(\" \");\n        \n        if !combined.is_empty() && combined.len() <= ADDRESS_MAX_LENGTH {\n            return Some(Secret::new(combined));\n        }\n    }\n    address_line1.clone()\n}",
+      "diff_span": null,
+      "commit_sha": "30a176d8bb71a4096200ab91a115fc2b1f54cc8c"
+    }
+  ]
+}

diffs/pr_10026/49a30d1/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "49a30d1fc7cdd1070c560d8390f289d53dab51b8",
+  "pr_number": 10026,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::impl::RouterData<F, Req, PaymentsResponseData>",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F, Req> TryFrom<ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>>\n    for RouterData<F, Req, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n\n    fn try_from(\n        item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match item.response.transaction {\n            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                if utils::is_payment_failure(payment_status) {\n                    Ok(Self {\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(\n                                transaction.transaction_id.clone(),\n                            ),\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: Some(\n                                transaction.transaction_id.clone(),\n                            ),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        status: payment_status,\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        status: payment_status,\n                        response: Err(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(\n                                hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),\n                            ),\n                            message: transaction.response_reason_description.clone().unwrap_or(\n                                hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string(),\n                            ),\n                            reason: transaction.response_reason_description.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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" || msg.code == \"E00104\")\n            {\n                Some(_) => Ok(item.data),\n                None => Ok(Self {\n                    response: Err(get_err_response(item.http_code, item.response.messages)?),\n                    ..item.data\n                }),\n            },\n        }\n    }\n}",
+      "after_code": "impl<F, Req> TryFrom<ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>>\n    for RouterData<F, Req, PaymentsResponseData>\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n\n    fn try_from(\n        item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match item.response.transaction {\n            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                Ok(Self {\n                    response: Ok(PaymentsResponseData::TransactionResponse {\n                        resource_id: ResponseId::ConnectorTransactionId(\n                            transaction.transaction_id.clone(),\n                        ),\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: Some(transaction.transaction_id.clone()),\n                        incremental_authorization_allowed: None,\n                        charges: None,\n                    }),\n                    status: payment_status,\n                    ..item.data\n                })\n            }\n\n            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" || msg.code == \"E00104\")\n            {\n                Some(_) => Ok(item.data),\n                None => Ok(Self {\n                    response: Err(get_err_response(item.http_code, item.response.messages)?),\n                    ..item.data\n                }),\n            },\n        }\n    }\n}",
+      "diff_span": {
+        "before": "            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                if utils::is_payment_failure(payment_status) {\n                    Ok(Self {\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(\n                                transaction.transaction_id.clone(),\n                            ),\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: Some(\n                                transaction.transaction_id.clone(),\n                            ),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        status: payment_status,\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        status: payment_status,\n                        response: Err(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(\n                                hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),\n                            ),\n                            message: transaction.response_reason_description.clone().unwrap_or(\n                                hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string(),\n                            ),\n                            reason: transaction.response_reason_description.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": "            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                Ok(Self {\n                    response: Ok(PaymentsResponseData::TransactionResponse {\n                        resource_id: ResponseId::ConnectorTransactionId(\n                            transaction.transaction_id.clone(),\n                        ),\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: Some(transaction.transaction_id.clone()),\n                        incremental_authorization_allowed: None,\n                        charges: None,\n                    }),\n                    status: payment_status,\n                    ..item.data\n                })\n            }\n"
+      },
+      "commit_sha": "49a30d1fc7cdd1070c560d8390f289d53dab51b8"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::RouterData<F, Req, PaymentsResponseData>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match item.response.transaction {\n            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                if utils::is_payment_failure(payment_status) {\n                    Ok(Self {\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(\n                                transaction.transaction_id.clone(),\n                            ),\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: Some(\n                                transaction.transaction_id.clone(),\n                            ),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        status: payment_status,\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        status: payment_status,\n                        response: Err(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(\n                                hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),\n                            ),\n                            message: transaction.response_reason_description.clone().unwrap_or(\n                                hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string(),\n                            ),\n                            reason: transaction.response_reason_description.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            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" || msg.code == \"E00104\")\n            {\n                Some(_) => Ok(item.data),\n                None => Ok(Self {\n                    response: Err(get_err_response(item.http_code, item.response.messages)?),\n                    ..item.data\n                }),\n            },\n        }\n    }",
+      "after_code": "fn try_from(\n        item: ResponseRouterData<F, AuthorizedotnetSyncResponse, Req, PaymentsResponseData>,\n    ) -> Result<Self, Self::Error> {\n        match item.response.transaction {\n            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                Ok(Self {\n                    response: Ok(PaymentsResponseData::TransactionResponse {\n                        resource_id: ResponseId::ConnectorTransactionId(\n                            transaction.transaction_id.clone(),\n                        ),\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: Some(transaction.transaction_id.clone()),\n                        incremental_authorization_allowed: None,\n                        charges: None,\n                    }),\n                    status: payment_status,\n                    ..item.data\n                })\n            }\n\n            // E00053 indicates \"server too busy\"\n            // E00104 indicates \"Server in maintenance\"\n            // If the server is too busy or Server in maintenance, we return the already available data\n            None => match item\n                .response\n                .messages\n                .message\n                .iter()\n                .find(|msg| msg.code == \"E00053\" || msg.code == \"E00104\")\n            {\n                Some(_) => Ok(item.data),\n                None => Ok(Self {\n                    response: Err(get_err_response(item.http_code, item.response.messages)?),\n                    ..item.data\n                }),\n            },\n        }\n    }",
+      "diff_span": {
+        "before": "            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                if utils::is_payment_failure(payment_status) {\n                    Ok(Self {\n                        response: Ok(PaymentsResponseData::TransactionResponse {\n                            resource_id: ResponseId::ConnectorTransactionId(\n                                transaction.transaction_id.clone(),\n                            ),\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: Some(\n                                transaction.transaction_id.clone(),\n                            ),\n                            incremental_authorization_allowed: None,\n                            charges: None,\n                        }),\n                        status: payment_status,\n                        ..item.data\n                    })\n                } else {\n                    Ok(Self {\n                        status: payment_status,\n                        response: Err(ErrorResponse {\n                            code: transaction.response_reason_code.clone().unwrap_or(\n                                hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),\n                            ),\n                            message: transaction.response_reason_description.clone().unwrap_or(\n                                hyperswitch_interfaces::consts::NO_ERROR_MESSAGE.to_string(),\n                            ),\n                            reason: transaction.response_reason_description.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": "            Some(transaction) => {\n                let payment_status = enums::AttemptStatus::from(transaction.transaction_status);\n                Ok(Self {\n                    response: Ok(PaymentsResponseData::TransactionResponse {\n                        resource_id: ResponseId::ConnectorTransactionId(\n                            transaction.transaction_id.clone(),\n                        ),\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: Some(transaction.transaction_id.clone()),\n                        incremental_authorization_allowed: None,\n                        charges: None,\n                    }),\n                    status: payment_status,\n                    ..item.data\n                })\n            }\n"
+      },
+      "commit_sha": "49a30d1fc7cdd1070c560d8390f289d53dab51b8"
+    }
+  ]
+}

diffs/pr_10026/5bcc3de/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "5bcc3de290eff3e8f363f2a4433742c6cc5f0744",
+  "pr_number": 10026,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::CreateTransactionRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let merchant_authentication =\n            AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;\n\n        let ref_id = if item.router_data.connector_request_reference_id.len() <= MAX_ID_LENGTH {\n            Some(item.router_data.connector_request_reference_id.clone())\n        } else {\n            None\n        };\n\n        let transaction_request = match item\n            .router_data\n            .request\n            .mandate_id\n            .clone()\n            .and_then(|mandate_ids| mandate_ids.mandate_reference_id)\n        {\n            Some(api_models::payments::MandateReferenceId::NetworkMandateId(network_trans_id)) => {\n                TransactionRequest::try_from((item, network_trans_id))?\n            }\n            Some(api_models::payments::MandateReferenceId::ConnectorMandateId(\n                connector_mandate_id,\n            )) => TransactionRequest::try_from((item, connector_mandate_id))?,\n            Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_)) => {\n                Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                ))?\n            }\n            None => {\n                match &item.router_data.request.payment_method_data {\n                    PaymentMethodData::Card(ccard) => TransactionRequest::try_from((item, ccard)),\n                    PaymentMethodData::Wallet(wallet_data) => {\n                        TransactionRequest::try_from((item, wallet_data))\n                    }\n                    PaymentMethodData::CardRedirect(_)\n                    | PaymentMethodData::PayLater(_)\n                    | PaymentMethodData::BankRedirect(_)\n                    | PaymentMethodData::BankDebit(_)\n                    | PaymentMethodData::BankTransfer(_)\n                    | PaymentMethodData::Crypto(_)\n                    | PaymentMethodData::MandatePayment\n                    | PaymentMethodData::Reward\n                    | PaymentMethodData::RealTimePayment(_)\n                    | PaymentMethodData::MobilePayment(_)\n                    | PaymentMethodData::Upi(_)\n                    | PaymentMethodData::Voucher(_)\n                    | PaymentMethodData::GiftCard(_)\n                    | PaymentMethodData::OpenBanking(_)\n                    | PaymentMethodData::CardToken(_)\n                    | PaymentMethodData::NetworkToken(_)\n                    | PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {\n                        Err(errors::ConnectorError::NotImplemented(\n                            utils::get_unimplemented_payment_method_error_message(\n                                \"authorizedotnet\",\n                            ),\n                        ))?\n                    }\n                }\n            }?,\n        };\n        Ok(Self {\n            create_transaction_request: AuthorizedotnetPaymentsRequest {\n                merchant_authentication,\n                ref_id,\n                transaction_request,\n            },\n        })\n    }",
+      "after_code": "fn try_from(\n        item: &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        if item.router_data.is_three_ds() {\n            return Err(errors::ConnectorError::NotSupported {\n                message: \"3DS flow\".to_string(),\n                connector: \"Authorizedotnet\",\n            }\n            .into());\n        };\n\n        let merchant_authentication =\n            AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;\n\n        let ref_id = if item.router_data.connector_request_reference_id.len() <= MAX_ID_LENGTH {\n            Some(item.router_data.connector_request_reference_id.clone())\n        } else {\n            None\n        };\n\n        let transaction_request = match item\n            .router_data\n            .request\n            .mandate_id\n            .clone()\n            .and_then(|mandate_ids| mandate_ids.mandate_reference_id)\n        {\n            Some(api_models::payments::MandateReferenceId::NetworkMandateId(network_trans_id)) => {\n                TransactionRequest::try_from((item, network_trans_id))?\n            }\n            Some(api_models::payments::MandateReferenceId::ConnectorMandateId(\n                connector_mandate_id,\n            )) => TransactionRequest::try_from((item, connector_mandate_id))?,\n            Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_)) => {\n                Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                ))?\n            }\n            None => {\n                match &item.router_data.request.payment_method_data {\n                    PaymentMethodData::Card(ccard) => TransactionRequest::try_from((item, ccard)),\n                    PaymentMethodData::Wallet(wallet_data) => {\n                        TransactionRequest::try_from((item, wallet_data))\n                    }\n                    PaymentMethodData::CardRedirect(_)\n                    | PaymentMethodData::PayLater(_)\n                    | PaymentMethodData::BankRedirect(_)\n                    | PaymentMethodData::BankDebit(_)\n                    | PaymentMethodData::BankTransfer(_)\n                    | PaymentMethodData::Crypto(_)\n                    | PaymentMethodData::MandatePayment\n                    | PaymentMethodData::Reward\n                    | PaymentMethodData::RealTimePayment(_)\n                    | PaymentMethodData::MobilePayment(_)\n                    | PaymentMethodData::Upi(_)\n                    | PaymentMethodData::Voucher(_)\n                    | PaymentMethodData::GiftCard(_)\n                    | PaymentMethodData::OpenBanking(_)\n                    | PaymentMethodData::CardToken(_)\n                    | PaymentMethodData::NetworkToken(_)\n                    | PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {\n                        Err(errors::ConnectorError::NotImplemented(\n                            utils::get_unimplemented_payment_method_error_message(\n                                \"authorizedotnet\",\n                            ),\n                        ))?\n                    }\n                }\n            }?,\n        };\n        Ok(Self {\n            create_transaction_request: AuthorizedotnetPaymentsRequest {\n                merchant_authentication,\n                ref_id,\n                transaction_request,\n            },\n        })\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "        item: &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        if item.router_data.is_three_ds() {\n            return Err(errors::ConnectorError::NotSupported {\n                message: \"3DS flow\".to_string(),\n                connector: \"Authorizedotnet\",\n            }\n            .into());\n        };\n\n        let merchant_authentication =\n            AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;"
+      },
+      "commit_sha": "5bcc3de290eff3e8f363f2a4433742c6cc5f0744"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::impl::CreateTransactionRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>>\n    for CreateTransactionRequest\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let merchant_authentication =\n            AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;\n\n        let ref_id = if item.router_data.connector_request_reference_id.len() <= MAX_ID_LENGTH {\n            Some(item.router_data.connector_request_reference_id.clone())\n        } else {\n            None\n        };\n\n        let transaction_request = match item\n            .router_data\n            .request\n            .mandate_id\n            .clone()\n            .and_then(|mandate_ids| mandate_ids.mandate_reference_id)\n        {\n            Some(api_models::payments::MandateReferenceId::NetworkMandateId(network_trans_id)) => {\n                TransactionRequest::try_from((item, network_trans_id))?\n            }\n            Some(api_models::payments::MandateReferenceId::ConnectorMandateId(\n                connector_mandate_id,\n            )) => TransactionRequest::try_from((item, connector_mandate_id))?,\n            Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_)) => {\n                Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                ))?\n            }\n            None => {\n                match &item.router_data.request.payment_method_data {\n                    PaymentMethodData::Card(ccard) => TransactionRequest::try_from((item, ccard)),\n                    PaymentMethodData::Wallet(wallet_data) => {\n                        TransactionRequest::try_from((item, wallet_data))\n                    }\n                    PaymentMethodData::CardRedirect(_)\n                    | PaymentMethodData::PayLater(_)\n                    | PaymentMethodData::BankRedirect(_)\n                    | PaymentMethodData::BankDebit(_)\n                    | PaymentMethodData::BankTransfer(_)\n                    | PaymentMethodData::Crypto(_)\n                    | PaymentMethodData::MandatePayment\n                    | PaymentMethodData::Reward\n                    | PaymentMethodData::RealTimePayment(_)\n                    | PaymentMethodData::MobilePayment(_)\n                    | PaymentMethodData::Upi(_)\n                    | PaymentMethodData::Voucher(_)\n                    | PaymentMethodData::GiftCard(_)\n                    | PaymentMethodData::OpenBanking(_)\n                    | PaymentMethodData::CardToken(_)\n                    | PaymentMethodData::NetworkToken(_)\n                    | PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {\n                        Err(errors::ConnectorError::NotImplemented(\n                            utils::get_unimplemented_payment_method_error_message(\n                                \"authorizedotnet\",\n                            ),\n                        ))?\n                    }\n                }\n            }?,\n        };\n        Ok(Self {\n            create_transaction_request: AuthorizedotnetPaymentsRequest {\n                merchant_authentication,\n                ref_id,\n                transaction_request,\n            },\n        })\n    }\n}",
+      "after_code": "impl TryFrom<&AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>>\n    for CreateTransactionRequest\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        if item.router_data.is_three_ds() {\n            return Err(errors::ConnectorError::NotSupported {\n                message: \"3DS flow\".to_string(),\n                connector: \"Authorizedotnet\",\n            }\n            .into());\n        };\n\n        let merchant_authentication =\n            AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;\n\n        let ref_id = if item.router_data.connector_request_reference_id.len() <= MAX_ID_LENGTH {\n            Some(item.router_data.connector_request_reference_id.clone())\n        } else {\n            None\n        };\n\n        let transaction_request = match item\n            .router_data\n            .request\n            .mandate_id\n            .clone()\n            .and_then(|mandate_ids| mandate_ids.mandate_reference_id)\n        {\n            Some(api_models::payments::MandateReferenceId::NetworkMandateId(network_trans_id)) => {\n                TransactionRequest::try_from((item, network_trans_id))?\n            }\n            Some(api_models::payments::MandateReferenceId::ConnectorMandateId(\n                connector_mandate_id,\n            )) => TransactionRequest::try_from((item, connector_mandate_id))?,\n            Some(api_models::payments::MandateReferenceId::NetworkTokenWithNTI(_)) => {\n                Err(errors::ConnectorError::NotImplemented(\n                    utils::get_unimplemented_payment_method_error_message(\"authorizedotnet\"),\n                ))?\n            }\n            None => {\n                match &item.router_data.request.payment_method_data {\n                    PaymentMethodData::Card(ccard) => TransactionRequest::try_from((item, ccard)),\n                    PaymentMethodData::Wallet(wallet_data) => {\n                        TransactionRequest::try_from((item, wallet_data))\n                    }\n                    PaymentMethodData::CardRedirect(_)\n                    | PaymentMethodData::PayLater(_)\n                    | PaymentMethodData::BankRedirect(_)\n                    | PaymentMethodData::BankDebit(_)\n                    | PaymentMethodData::BankTransfer(_)\n                    | PaymentMethodData::Crypto(_)\n                    | PaymentMethodData::MandatePayment\n                    | PaymentMethodData::Reward\n                    | PaymentMethodData::RealTimePayment(_)\n                    | PaymentMethodData::MobilePayment(_)\n                    | PaymentMethodData::Upi(_)\n                    | PaymentMethodData::Voucher(_)\n                    | PaymentMethodData::GiftCard(_)\n                    | PaymentMethodData::OpenBanking(_)\n                    | PaymentMethodData::CardToken(_)\n                    | PaymentMethodData::NetworkToken(_)\n                    | PaymentMethodData::CardDetailsForNetworkTransactionId(_) => {\n                        Err(errors::ConnectorError::NotImplemented(\n                            utils::get_unimplemented_payment_method_error_message(\n                                \"authorizedotnet\",\n                            ),\n                        ))?\n                    }\n                }\n            }?,\n        };\n        Ok(Self {\n            create_transaction_request: AuthorizedotnetPaymentsRequest {\n                merchant_authentication,\n                ref_id,\n                transaction_request,\n            },\n        })\n    }\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        item: &AuthorizedotnetRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        if item.router_data.is_three_ds() {\n            return Err(errors::ConnectorError::NotSupported {\n                message: \"3DS flow\".to_string(),\n                connector: \"Authorizedotnet\",\n            }\n            .into());\n        };\n\n        let merchant_authentication =\n            AuthorizedotnetAuthType::try_from(&item.router_data.connector_auth_type)?;"
+      },
+      "commit_sha": "5bcc3de290eff3e8f363f2a4433742c6cc5f0744"
+    }
+  ]
+}

diffs/pr_10026/997133b/diff.json

@@ -0,0 +1,54 @@
+{
+  "commit_sha": "997133bc11343dafbf1d4dfb40bb2b05b743484c",
+  "pr_number": 10026,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::impl::AuthorizedotnetSyncResponse",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<AuthorizedotnetWebhookObjectId> for AuthorizedotnetSyncResponse {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: AuthorizedotnetWebhookObjectId) -> Result<Self, Self::Error> {\n        Ok(Self {\n            transaction: Some(SyncTransactionResponse {\n                transaction_id: get_trans_id(&item)?,\n                transaction_status: SyncStatus::from(item.event_type),\n                response_reason_code: None,\n                response_reason_description: None,\n            }),\n            messages: ResponseMessages {\n                ..Default::default()\n            },\n        })\n    }\n}",
+      "after_code": "impl TryFrom<AuthorizedotnetWebhookObjectId> for AuthorizedotnetSyncResponse {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: AuthorizedotnetWebhookObjectId) -> Result<Self, Self::Error> {\n        Ok(Self {\n            transaction: Some(SyncTransactionResponse {\n                transaction_id: get_trans_id(&item)?,\n                transaction_status: SyncStatus::from(item.event_type),\n            }),\n            messages: ResponseMessages {\n                ..Default::default()\n            },\n        })\n    }\n}",
+      "diff_span": {
+        "before": "                transaction_id: get_trans_id(&item)?,\n                transaction_status: SyncStatus::from(item.event_type),\n                response_reason_code: None,\n                response_reason_description: None,\n            }),\n            messages: ResponseMessages {",
+        "after": ""
+      },
+      "commit_sha": "997133bc11343dafbf1d4dfb40bb2b05b743484c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::AuthorizedotnetSyncResponse::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: AuthorizedotnetWebhookObjectId) -> Result<Self, Self::Error> {\n        Ok(Self {\n            transaction: Some(SyncTransactionResponse {\n                transaction_id: get_trans_id(&item)?,\n                transaction_status: SyncStatus::from(item.event_type),\n                response_reason_code: None,\n                response_reason_description: None,\n            }),\n            messages: ResponseMessages {\n                ..Default::default()\n            },\n        })\n    }",
+      "after_code": "fn try_from(item: AuthorizedotnetWebhookObjectId) -> Result<Self, Self::Error> {\n        Ok(Self {\n            transaction: Some(SyncTransactionResponse {\n                transaction_id: get_trans_id(&item)?,\n                transaction_status: SyncStatus::from(item.event_type),\n            }),\n            messages: ResponseMessages {\n                ..Default::default()\n            },\n        })\n    }",
+      "diff_span": {
+        "before": "                transaction_id: get_trans_id(&item)?,\n                transaction_status: SyncStatus::from(item.event_type),\n                response_reason_code: None,\n                response_reason_description: None,\n            }),\n            messages: ResponseMessages {",
+        "after": ""
+      },
+      "commit_sha": "997133bc11343dafbf1d4dfb40bb2b05b743484c"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs::struct::SyncTransactionResponse",
+      "file": "crates/hyperswitch_connectors/src/connectors/authorizedotnet/transformers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct SyncTransactionResponse {\n    #[serde(rename = \"transId\")]\n    transaction_id: String,\n    transaction_status: SyncStatus,\n    response_reason_code: Option<String>,\n    response_reason_description: Option<String>,\n}",
+      "after_code": "pub struct SyncTransactionResponse {\n    #[serde(rename = \"transId\")]\n    transaction_id: String,\n    transaction_status: SyncStatus,\n}",
+      "diff_span": {
+        "before": "    transaction_id: String,\n    transaction_status: SyncStatus,\n    response_reason_code: Option<String>,\n    response_reason_description: Option<String>,\n}",
+        "after": ""
+      },
+      "commit_sha": "997133bc11343dafbf1d4dfb40bb2b05b743484c"
+    }
+  ]
+}

diffs/pr_10182/201f5c8/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "201f5c87cc7f6eb35a1e3e9ac842bedfedcf6468",
+  "pr_number": 10182,
+  "rust_files": [
+    "crates/router/src/core/blocklist/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/blocklist/transformers.rs::function::call_to_locker_for_fingerprint",
+      "file": "crates/router/src/core/blocklist/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn call_to_locker_for_fingerprint(\n    state: &routes::SessionState,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let locker = &state.conf.locker;\n    let jwekey = state.conf.jwekey.get_inner();\n\n    let request = generate_fingerprint_request(jwekey, locker, payload, locker_choice).await?;\n    let response = services::call_connector_api(state, request, \"call_locker_to_get_fingerprint\")\n        .await\n        .change_context(errors::VaultError::GenerateFingerprintFailed);\n    let jwe_body: encryption::JweBody = response\n        .get_response_inner(\"JweBody\")\n        .change_context(errors::VaultError::GenerateFingerprintFailed)?;\n\n    let decrypted_payload = decrypt_generate_fingerprint_response_payload(\n        jwekey,\n        jwe_body,\n        Some(locker_choice),\n        locker.decryption_scheme.clone(),\n    )\n    .await\n    .change_context(errors::VaultError::GenerateFingerprintFailed)\n    .attach_printable(\"Error getting decrypted fingerprint response payload\")?;\n    let generate_fingerprint_response: blocklist::GenerateFingerprintResponsePayload =\n        decrypted_payload\n            .parse_struct(\"GenerateFingerprintResponse\")\n            .change_context(errors::VaultError::ResponseDeserializationFailed)?;\n\n    Ok(generate_fingerprint_response)\n}",
+      "after_code": "async fn call_to_locker_for_fingerprint(\n    state: &routes::SessionState,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let locker = &state.conf.locker;\n    let jwekey = state.conf.jwekey.get_inner();\n\n    let request = generate_fingerprint_request(\n        jwekey,\n        locker,\n        payload,\n        locker_choice,\n        state.tenant.tenant_id.clone(),\n    )\n    .await?;\n    let response = services::call_connector_api(state, request, \"call_locker_to_get_fingerprint\")\n        .await\n        .change_context(errors::VaultError::GenerateFingerprintFailed);\n    let jwe_body: encryption::JweBody = response\n        .get_response_inner(\"JweBody\")\n        .change_context(errors::VaultError::GenerateFingerprintFailed)?;\n\n    let decrypted_payload = decrypt_generate_fingerprint_response_payload(\n        jwekey,\n        jwe_body,\n        Some(locker_choice),\n        locker.decryption_scheme.clone(),\n    )\n    .await\n    .change_context(errors::VaultError::GenerateFingerprintFailed)\n    .attach_printable(\"Error getting decrypted fingerprint response payload\")?;\n    let generate_fingerprint_response: blocklist::GenerateFingerprintResponsePayload =\n        decrypted_payload\n            .parse_struct(\"GenerateFingerprintResponse\")\n            .change_context(errors::VaultError::ResponseDeserializationFailed)?;\n\n    Ok(generate_fingerprint_response)\n}",
+      "diff_span": {
+        "before": "    let jwekey = state.conf.jwekey.get_inner();\n\n    let request = generate_fingerprint_request(jwekey, locker, payload, locker_choice).await?;\n    let response = services::call_connector_api(state, request, \"call_locker_to_get_fingerprint\")\n        .await",
+        "after": "    let jwekey = state.conf.jwekey.get_inner();\n\n    let request = generate_fingerprint_request(\n        jwekey,\n        locker,\n        payload,\n        locker_choice,\n        state.tenant.tenant_id.clone(),\n    )\n    .await?;\n    let response = services::call_connector_api(state, request, \"call_locker_to_get_fingerprint\")\n        .await"
+      },
+      "commit_sha": "201f5c87cc7f6eb35a1e3e9ac842bedfedcf6468"
+    },
+    {
+      "id": "crates/router/src/core/blocklist/transformers.rs::function::generate_fingerprint_request",
+      "file": "crates/router/src/core/blocklist/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn generate_fingerprint_request(\n    jwekey: &settings::Jwekey,\n    locker: &settings::Locker,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)\n}",
+      "after_code": "async fn generate_fingerprint_request(\n    jwekey: &settings::Jwekey,\n    locker: &settings::Locker,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)\n}",
+      "diff_span": {
+        "before": "",
+        "after": "    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)"
+      },
+      "commit_sha": "201f5c87cc7f6eb35a1e3e9ac842bedfedcf6468"
+    }
+  ]
+}

diffs/pr_10182/570acef/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "570acef253c1c7ed4a423f3b280a7d4a44d7b9e7",
+  "pr_number": 10182,
+  "rust_files": [
+    "crates/router/src/core/blocklist/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/blocklist/transformers.rs::function::generate_fingerprint_request",
+      "file": "crates/router/src/core/blocklist/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn generate_fingerprint_request(\n    jwekey: &settings::Jwekey,\n    locker: &settings::Locker,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n    request_id: Option<router_env::RequestId>,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    if let Some(req_id) = request_id {\n        request.add_header(\n            headers::X_REQUEST_ID,\n            req_id.to_string().into(),\n        );\n    }\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)\n}",
+      "after_code": "async fn generate_fingerprint_request(\n    jwekey: &settings::Jwekey,\n    locker: &settings::Locker,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n    request_id: Option<router_env::RequestId>,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    if let Some(req_id) = request_id {\n        request.add_header(headers::X_REQUEST_ID, req_id.to_string().into());\n    }\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)\n}",
+      "diff_span": {
+        "before": "    );\n    if let Some(req_id) = request_id {\n        request.add_header(\n            headers::X_REQUEST_ID,\n            req_id.to_string().into(),\n        );\n    }\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));",
+        "after": "    );\n    if let Some(req_id) = request_id {\n        request.add_header(headers::X_REQUEST_ID, req_id.to_string().into());\n    }\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));"
+      },
+      "commit_sha": "570acef253c1c7ed4a423f3b280a7d4a44d7b9e7"
+    }
+  ]
+}

diffs/pr_10182/95e2348/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "95e2348ed1a1b6df11b901314c9651277e575aee",
+  "pr_number": 10182,
+  "rust_files": [
+    "crates/router/src/core/blocklist/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/blocklist/transformers.rs::function::call_to_locker_for_fingerprint",
+      "file": "crates/router/src/core/blocklist/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn call_to_locker_for_fingerprint(\n    state: &routes::SessionState,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let locker = &state.conf.locker;\n    let jwekey = state.conf.jwekey.get_inner();\n\n    let request = generate_fingerprint_request(\n        jwekey,\n        locker,\n        payload,\n        locker_choice,\n        state.tenant.tenant_id.clone(),\n        state.request_id,\n    )\n    .await?;\n    let response = services::call_connector_api(state, request, \"call_locker_to_get_fingerprint\")\n        .await\n        .change_context(errors::VaultError::GenerateFingerprintFailed);\n    let jwe_body: encryption::JweBody = response\n        .get_response_inner(\"JweBody\")\n        .change_context(errors::VaultError::GenerateFingerprintFailed)?;\n\n    let decrypted_payload = decrypt_generate_fingerprint_response_payload(\n        jwekey,\n        jwe_body,\n        Some(locker_choice),\n        locker.decryption_scheme.clone(),\n    )\n    .await\n    .change_context(errors::VaultError::GenerateFingerprintFailed)\n    .attach_printable(\"Error getting decrypted fingerprint response payload\")?;\n    let generate_fingerprint_response: blocklist::GenerateFingerprintResponsePayload =\n        decrypted_payload\n            .parse_struct(\"GenerateFingerprintResponse\")\n            .change_context(errors::VaultError::ResponseDeserializationFailed)?;\n\n    Ok(generate_fingerprint_response)\n}",
+      "after_code": "async fn call_to_locker_for_fingerprint(\n    state: &routes::SessionState,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let locker = &state.conf.locker;\n    let jwekey = state.conf.jwekey.get_inner();\n\n    let request = generate_fingerprint_request(\n        jwekey,\n        locker,\n        payload,\n        locker_choice,\n        state.tenant.tenant_id.clone(),\n        state.request_id.clone(),\n    )\n    .await?;\n    let response = services::call_connector_api(state, request, \"call_locker_to_get_fingerprint\")\n        .await\n        .change_context(errors::VaultError::GenerateFingerprintFailed);\n    let jwe_body: encryption::JweBody = response\n        .get_response_inner(\"JweBody\")\n        .change_context(errors::VaultError::GenerateFingerprintFailed)?;\n\n    let decrypted_payload = decrypt_generate_fingerprint_response_payload(\n        jwekey,\n        jwe_body,\n        Some(locker_choice),\n        locker.decryption_scheme.clone(),\n    )\n    .await\n    .change_context(errors::VaultError::GenerateFingerprintFailed)\n    .attach_printable(\"Error getting decrypted fingerprint response payload\")?;\n    let generate_fingerprint_response: blocklist::GenerateFingerprintResponsePayload =\n        decrypted_payload\n            .parse_struct(\"GenerateFingerprintResponse\")\n            .change_context(errors::VaultError::ResponseDeserializationFailed)?;\n\n    Ok(generate_fingerprint_response)\n}",
+      "diff_span": {
+        "before": "        locker_choice,\n        state.tenant.tenant_id.clone(),\n        state.request_id,\n    )\n    .await?;",
+        "after": "        locker_choice,\n        state.tenant.tenant_id.clone(),\n        state.request_id.clone(),\n    )\n    .await?;"
+      },
+      "commit_sha": "95e2348ed1a1b6df11b901314c9651277e575aee"
+    },
+    {
+      "id": "crates/router/src/core/blocklist/transformers.rs::function::generate_fingerprint_request",
+      "file": "crates/router/src/core/blocklist/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn generate_fingerprint_request(\n    jwekey: &settings::Jwekey,\n    locker: &settings::Locker,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n    request_id: Option<RequestId>,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    if let Some(req_id) = request_id {\n        request.add_header(\n            headers::X_REQUEST_ID,\n            req_id.as_hyphenated().to_string().into(),\n        );\n    }\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)\n}",
+      "after_code": "async fn generate_fingerprint_request(\n    jwekey: &settings::Jwekey,\n    locker: &settings::Locker,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n    request_id: Option<router_env::RequestId>,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    if let Some(req_id) = request_id {\n        request.add_header(\n            headers::X_REQUEST_ID,\n            req_id.to_string().into(),\n        );\n    }\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)\n}",
+      "diff_span": {
+        "before": "    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n    request_id: Option<RequestId>,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    if let Some(req_id) = request_id {\n        request.add_header(\n            headers::X_REQUEST_ID,\n            req_id.as_hyphenated().to_string().into(),\n        );\n    }",
+        "after": "    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n    request_id: Option<router_env::RequestId>,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    if let Some(req_id) = request_id {\n        request.add_header(\n            headers::X_REQUEST_ID,\n            req_id.to_string().into(),\n        );\n    }"
+      },
+      "commit_sha": "95e2348ed1a1b6df11b901314c9651277e575aee"
+    }
+  ]
+}

diffs/pr_10182/d8865fb/diff.json

@@ -0,0 +1,116 @@
+{
+  "commit_sha": "d8865fbce6d4568558517f0d893e4c2250383c2e",
+  "pr_number": 10182,
+  "rust_files": [
+    "crates/api_models/src/blocklist.rs",
+    "crates/router/src/core/blocklist/transformers.rs",
+    "crates/router/src/core/blocklist/utils.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/blocklist/utils.rs::function::should_payment_be_blocked",
+      "file": "crates/router/src/core/blocklist/utils.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn should_payment_be_blocked(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    payment_method_data: &Option<domain::PaymentMethodData>,\n) -> CustomResult<bool, errors::ApiErrorResponse> {\n    let db = &state.store;\n    let merchant_id = merchant_context.get_merchant_account().get_id();\n    let merchant_fingerprint_secret = get_merchant_fingerprint_secret(state, merchant_id).await?;\n\n    // Hashed Fingerprint to check whether or not this payment should be blocked.\n    let card_number_fingerprint =\n        if let Some(domain::PaymentMethodData::Card(card)) = payment_method_data {\n            generate_fingerprint(\n                state,\n                StrongSecret::new(card.card_number.get_card_no()),\n                StrongSecret::new(merchant_fingerprint_secret.clone()),\n                api_models::enums::LockerChoice::HyperswitchCardVault,\n            )\n            .await\n            .attach_printable(\"error in pm fingerprint creation\")\n            .map_or_else(\n                |error| {\n                    logger::error!(?error);\n                    None\n                },\n                Some,\n            )\n            .map(|payload| payload.card_fingerprint)\n        } else {\n            None\n        };\n\n    // Hashed Cardbin to check whether or not this payment should be blocked.\n    let card_bin_fingerprint = payment_method_data\n        .as_ref()\n        .and_then(|pm_data| match pm_data {\n            domain::PaymentMethodData::Card(card) => Some(card.card_number.get_card_isin()),\n            _ => None,\n        });\n\n    // Hashed Extended Cardbin to check whether or not this payment should be blocked.\n    let extended_card_bin_fingerprint =\n        payment_method_data\n            .as_ref()\n            .and_then(|pm_data| match pm_data {\n                domain::PaymentMethodData::Card(card) => {\n                    Some(card.card_number.get_extended_card_bin())\n                }\n                _ => None,\n            });\n\n    //validating the payment method.\n    let mut blocklist_futures = Vec::new();\n    if let Some(card_number_fingerprint) = card_number_fingerprint.as_ref() {\n        blocklist_futures.push(db.find_blocklist_entry_by_merchant_id_fingerprint_id(\n            merchant_id,\n            card_number_fingerprint,\n        ));\n    }\n\n    if let Some(card_bin_fingerprint) = card_bin_fingerprint.as_ref() {\n        blocklist_futures.push(\n            db.find_blocklist_entry_by_merchant_id_fingerprint_id(\n                merchant_id,\n                card_bin_fingerprint,\n            ),\n        );\n    }\n\n    if let Some(extended_card_bin_fingerprint) = extended_card_bin_fingerprint.as_ref() {\n        blocklist_futures.push(db.find_blocklist_entry_by_merchant_id_fingerprint_id(\n            merchant_id,\n            extended_card_bin_fingerprint,\n        ));\n    }\n\n    let blocklist_lookups = futures::future::join_all(blocklist_futures).await;\n\n    let mut should_payment_be_blocked = false;\n    for lookup in blocklist_lookups {\n        match lookup {\n            Ok(_) => {\n                should_payment_be_blocked = true;\n            }\n            Err(e) => {\n                logger::error!(blocklist_db_error=?e, \"failed db operations for blocklist\");\n            }\n        }\n    }\n    Ok(should_payment_be_blocked)\n}",
+      "after_code": "pub async fn should_payment_be_blocked(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    payment_method_data: &Option<domain::PaymentMethodData>,\n) -> CustomResult<bool, errors::ApiErrorResponse> {\n    let db = &state.store;\n    let merchant_id = merchant_context.get_merchant_account().get_id();\n    let merchant_fingerprint_secret = get_merchant_fingerprint_secret(state, merchant_id).await?;\n\n    // Hashed Fingerprint to check whether or not this payment should be blocked.\n    let card_number_fingerprint =\n        if let Some(domain::PaymentMethodData::Card(card)) = payment_method_data {\n            generate_fingerprint(\n                state,\n                StrongSecret::new(card.card_number.get_card_no()),\n                StrongSecret::new(merchant_fingerprint_secret.clone()),\n                api_models::enums::LockerChoice::HyperswitchCardVault,\n            )\n            .await\n            .attach_printable(\"error in pm fingerprint creation\")\n            .map_or_else(\n                |error| {\n                    logger::error!(?error);\n                    None\n                },\n                Some,\n            )\n            .map(|payload| payload.fingerprint_id)\n        } else {\n            None\n        };\n\n    // Hashed Cardbin to check whether or not this payment should be blocked.\n    let card_bin_fingerprint = payment_method_data\n        .as_ref()\n        .and_then(|pm_data| match pm_data {\n            domain::PaymentMethodData::Card(card) => Some(card.card_number.get_card_isin()),\n            _ => None,\n        });\n\n    // Hashed Extended Cardbin to check whether or not this payment should be blocked.\n    let extended_card_bin_fingerprint =\n        payment_method_data\n            .as_ref()\n            .and_then(|pm_data| match pm_data {\n                domain::PaymentMethodData::Card(card) => {\n                    Some(card.card_number.get_extended_card_bin())\n                }\n                _ => None,\n            });\n\n    //validating the payment method.\n    let mut blocklist_futures = Vec::new();\n    if let Some(card_number_fingerprint) = card_number_fingerprint.as_ref() {\n        blocklist_futures.push(db.find_blocklist_entry_by_merchant_id_fingerprint_id(\n            merchant_id,\n            card_number_fingerprint,\n        ));\n    }\n\n    if let Some(card_bin_fingerprint) = card_bin_fingerprint.as_ref() {\n        blocklist_futures.push(\n            db.find_blocklist_entry_by_merchant_id_fingerprint_id(\n                merchant_id,\n                card_bin_fingerprint,\n            ),\n        );\n    }\n\n    if let Some(extended_card_bin_fingerprint) = extended_card_bin_fingerprint.as_ref() {\n        blocklist_futures.push(db.find_blocklist_entry_by_merchant_id_fingerprint_id(\n            merchant_id,\n            extended_card_bin_fingerprint,\n        ));\n    }\n\n    let blocklist_lookups = futures::future::join_all(blocklist_futures).await;\n\n    let mut should_payment_be_blocked = false;\n    for lookup in blocklist_lookups {\n        match lookup {\n            Ok(_) => {\n                should_payment_be_blocked = true;\n            }\n            Err(e) => {\n                logger::error!(blocklist_db_error=?e, \"failed db operations for blocklist\");\n            }\n        }\n    }\n    Ok(should_payment_be_blocked)\n}",
+      "diff_span": {
+        "before": "                Some,\n            )\n            .map(|payload| payload.card_fingerprint)\n        } else {\n            None",
+        "after": "                Some,\n            )\n            .map(|payload| payload.fingerprint_id)\n        } else {\n            None"
+      },
+      "commit_sha": "d8865fbce6d4568558517f0d893e4c2250383c2e"
+    },
+    {
+      "id": "crates/router/src/core/blocklist/transformers.rs::function::generate_fingerprint_request",
+      "file": "crates/router/src/core/blocklist/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn generate_fingerprint_request(\n    jwekey: &settings::Jwekey,\n    locker: &settings::Locker,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)\n}",
+      "after_code": "async fn generate_fingerprint_request(\n    jwekey: &settings::Jwekey,\n    locker: &settings::Locker,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n    request_id: Option<RequestId>,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    if let Some(req_id) = request_id {\n        request.add_header(\n            headers::X_REQUEST_ID,\n            req_id.as_hyphenated().to_string().into(),\n        );\n    }\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)\n}",
+      "diff_span": {
+        "before": "",
+        "after": "    locker_choice: api_enums::LockerChoice,\n    tenant_id: id_type::TenantId,\n    request_id: Option<RequestId>,\n) -> CustomResult<services::Request, errors::VaultError> {\n    let payload = payload\n        .encode_to_vec()\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let private_key = jwekey.vault_private_key.peek().as_bytes();\n\n    let jws = encryption::jws_sign_payload(&payload, &locker.locker_signing_key_id, private_key)\n        .await\n        .change_context(errors::VaultError::RequestEncodingFailed)?;\n\n    let jwe_payload = generate_jwe_payload_for_request(jwekey, &jws, locker_choice).await?;\n    let mut url = match locker_choice {\n        api_enums::LockerChoice::HyperswitchCardVault => locker.host.to_owned(),\n    };\n    url.push_str(LOCKER_FINGERPRINT_PATH);\n    let mut request = services::Request::new(services::Method::Post, &url);\n    request.add_header(headers::CONTENT_TYPE, \"application/json\".into());\n    request.add_header(\n        headers::X_TENANT_ID,\n        tenant_id.get_string_repr().to_owned().into(),\n    );\n    if let Some(req_id) = request_id {\n        request.add_header(\n            headers::X_REQUEST_ID,\n            req_id.as_hyphenated().to_string().into(),\n        );\n    }\n    request.set_body(RequestContent::Json(Box::new(jwe_payload)));\n    Ok(request)"
+      },
+      "commit_sha": "d8865fbce6d4568558517f0d893e4c2250383c2e"
+    },
+    {
+      "id": "crates/router/src/core/blocklist/transformers.rs::function::call_to_locker_for_fingerprint",
+      "file": "crates/router/src/core/blocklist/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn call_to_locker_for_fingerprint(\n    state: &routes::SessionState,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let locker = &state.conf.locker;\n    let jwekey = state.conf.jwekey.get_inner();\n\n    let request = generate_fingerprint_request(\n        jwekey,\n        locker,\n        payload,\n        locker_choice,\n        state.tenant.tenant_id.clone(),\n    )\n    .await?;\n    let response = services::call_connector_api(state, request, \"call_locker_to_get_fingerprint\")\n        .await\n        .change_context(errors::VaultError::GenerateFingerprintFailed);\n    let jwe_body: encryption::JweBody = response\n        .get_response_inner(\"JweBody\")\n        .change_context(errors::VaultError::GenerateFingerprintFailed)?;\n\n    let decrypted_payload = decrypt_generate_fingerprint_response_payload(\n        jwekey,\n        jwe_body,\n        Some(locker_choice),\n        locker.decryption_scheme.clone(),\n    )\n    .await\n    .change_context(errors::VaultError::GenerateFingerprintFailed)\n    .attach_printable(\"Error getting decrypted fingerprint response payload\")?;\n    let generate_fingerprint_response: blocklist::GenerateFingerprintResponsePayload =\n        decrypted_payload\n            .parse_struct(\"GenerateFingerprintResponse\")\n            .change_context(errors::VaultError::ResponseDeserializationFailed)?;\n\n    Ok(generate_fingerprint_response)\n}",
+      "after_code": "async fn call_to_locker_for_fingerprint(\n    state: &routes::SessionState,\n    payload: &blocklist::GenerateFingerprintRequest,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let locker = &state.conf.locker;\n    let jwekey = state.conf.jwekey.get_inner();\n\n    let request = generate_fingerprint_request(\n        jwekey,\n        locker,\n        payload,\n        locker_choice,\n        state.tenant.tenant_id.clone(),\n        state.request_id,\n    )\n    .await?;\n    let response = services::call_connector_api(state, request, \"call_locker_to_get_fingerprint\")\n        .await\n        .change_context(errors::VaultError::GenerateFingerprintFailed);\n    let jwe_body: encryption::JweBody = response\n        .get_response_inner(\"JweBody\")\n        .change_context(errors::VaultError::GenerateFingerprintFailed)?;\n\n    let decrypted_payload = decrypt_generate_fingerprint_response_payload(\n        jwekey,\n        jwe_body,\n        Some(locker_choice),\n        locker.decryption_scheme.clone(),\n    )\n    .await\n    .change_context(errors::VaultError::GenerateFingerprintFailed)\n    .attach_printable(\"Error getting decrypted fingerprint response payload\")?;\n    let generate_fingerprint_response: blocklist::GenerateFingerprintResponsePayload =\n        decrypted_payload\n            .parse_struct(\"GenerateFingerprintResponse\")\n            .change_context(errors::VaultError::ResponseDeserializationFailed)?;\n\n    Ok(generate_fingerprint_response)\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        locker_choice,\n        state.tenant.tenant_id.clone(),\n        state.request_id,\n    )\n    .await?;"
+      },
+      "commit_sha": "d8865fbce6d4568558517f0d893e4c2250383c2e"
+    },
+    {
+      "id": "crates/api_models/src/blocklist.rs::struct::GenerateFingerprintRequest",
+      "file": "crates/api_models/src/blocklist.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct GenerateFingerprintRequest {\n    pub card: Card,\n    pub hash_key: StrongSecret<String>,\n}",
+      "after_code": "pub struct GenerateFingerprintRequest {\n    pub data: StrongSecret<String>,\n    pub key: StrongSecret<String>,\n}",
+      "diff_span": {
+        "before": "pub struct GenerateFingerprintRequest {\n    pub card: Card,\n    pub hash_key: StrongSecret<String>,\n}",
+        "after": "pub struct GenerateFingerprintRequest {\n    pub data: StrongSecret<String>,\n    pub key: StrongSecret<String>,\n}"
+      },
+      "commit_sha": "d8865fbce6d4568558517f0d893e4c2250383c2e"
+    },
+    {
+      "id": "crates/api_models/src/blocklist.rs::struct::GenerateFingerprintResponsePayload",
+      "file": "crates/api_models/src/blocklist.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct GenerateFingerprintResponsePayload {\n    pub card_fingerprint: String,\n}",
+      "after_code": "pub struct GenerateFingerprintResponsePayload {\n    pub fingerprint_id: String,\n}",
+      "diff_span": {
+        "before": "pub struct GenerateFingerprintResponsePayload {\n    pub card_fingerprint: String,\n}",
+        "after": "pub struct GenerateFingerprintResponsePayload {\n    pub fingerprint_id: String,\n}"
+      },
+      "commit_sha": "d8865fbce6d4568558517f0d893e4c2250383c2e"
+    },
+    {
+      "id": "crates/router/src/core/blocklist/transformers.rs::function::generate_fingerprint",
+      "file": "crates/router/src/core/blocklist/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn generate_fingerprint(\n    state: &routes::SessionState,\n    card_number: StrongSecret<String>,\n    hash_key: StrongSecret<String>,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let payload = blocklist::GenerateFingerprintRequest {\n        card: blocklist::Card { card_number },\n        hash_key,\n    };\n\n    let generate_fingerprint_resp =\n        call_to_locker_for_fingerprint(state, &payload, locker_choice).await?;\n\n    Ok(generate_fingerprint_resp)\n}",
+      "after_code": "pub async fn generate_fingerprint(\n    state: &routes::SessionState,\n    card_number: StrongSecret<String>,\n    hash_key: StrongSecret<String>,\n    locker_choice: api_enums::LockerChoice,\n) -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let payload = blocklist::GenerateFingerprintRequest {\n        data: card_number,\n        key: hash_key,\n    };\n\n    let generate_fingerprint_resp =\n        call_to_locker_for_fingerprint(state, &payload, locker_choice).await?;\n\n    Ok(generate_fingerprint_resp)\n}",
+      "diff_span": {
+        "before": ") -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let payload = blocklist::GenerateFingerprintRequest {\n        card: blocklist::Card { card_number },\n        hash_key,\n    };\n",
+        "after": ") -> CustomResult<blocklist::GenerateFingerprintResponsePayload, errors::VaultError> {\n    let payload = blocklist::GenerateFingerprintRequest {\n        data: card_number,\n        key: hash_key,\n    };\n"
+      },
+      "commit_sha": "d8865fbce6d4568558517f0d893e4c2250383c2e"
+    },
+    {
+      "id": "crates/router/src/core/blocklist/utils.rs::function::generate_payment_fingerprint",
+      "file": "crates/router/src/core/blocklist/utils.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn generate_payment_fingerprint(\n    state: &SessionState,\n    merchant_id: common_utils::id_type::MerchantId,\n    payment_method_data: Option<domain::PaymentMethodData>,\n) -> CustomResult<Option<String>, errors::ApiErrorResponse> {\n    let merchant_fingerprint_secret = get_merchant_fingerprint_secret(state, &merchant_id).await?;\n\n    Ok(\n        if let Some(domain::PaymentMethodData::Card(card)) = payment_method_data.as_ref() {\n            generate_fingerprint(\n                state,\n                StrongSecret::new(card.card_number.get_card_no()),\n                StrongSecret::new(merchant_fingerprint_secret),\n                api_models::enums::LockerChoice::HyperswitchCardVault,\n            )\n            .await\n            .attach_printable(\"error in pm fingerprint creation\")\n            .map_or_else(\n                |error| {\n                    logger::error!(?error);\n                    None\n                },\n                Some,\n            )\n            .map(|payload| payload.card_fingerprint)\n        } else {\n            logger::error!(\"failed to retrieve card fingerprint\");\n            None\n        },\n    )\n}",
+      "after_code": "pub async fn generate_payment_fingerprint(\n    state: &SessionState,\n    merchant_id: common_utils::id_type::MerchantId,\n    payment_method_data: Option<domain::PaymentMethodData>,\n) -> CustomResult<Option<String>, errors::ApiErrorResponse> {\n    let merchant_fingerprint_secret = get_merchant_fingerprint_secret(state, &merchant_id).await?;\n\n    Ok(\n        if let Some(domain::PaymentMethodData::Card(card)) = payment_method_data.as_ref() {\n            generate_fingerprint(\n                state,\n                StrongSecret::new(card.card_number.get_card_no()),\n                StrongSecret::new(merchant_fingerprint_secret),\n                api_models::enums::LockerChoice::HyperswitchCardVault,\n            )\n            .await\n            .attach_printable(\"error in pm fingerprint creation\")\n            .map_or_else(\n                |error| {\n                    logger::error!(?error);\n                    None\n                },\n                Some,\n            )\n            .map(|payload| payload.fingerprint_id)\n        } else {\n            logger::error!(\"failed to retrieve card fingerprint\");\n            None\n        },\n    )\n}",
+      "diff_span": {
+        "before": "                Some,\n            )\n            .map(|payload| payload.card_fingerprint)\n        } else {\n            logger::error!(\"failed to retrieve card fingerprint\");",
+        "after": "                Some,\n            )\n            .map(|payload| payload.fingerprint_id)\n        } else {\n            logger::error!(\"failed to retrieve card fingerprint\");"
+      },
+      "commit_sha": "d8865fbce6d4568558517f0d893e4c2250383c2e"
+    }
+  ]
+}

diffs/pr_10192/3b1dcd0/diff.json

@@ -0,0 +1,123 @@
+{
+  "commit_sha": "3b1dcd02afe5f76006795c4fcca1fa1fe2c6bf2c",
+  "pr_number": 10192,
+  "rust_files": [
+    "crates/router/src/core/payments.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments.rs::function::call_connector_service",
+      "file": "crates/router/src/core/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn call_connector_service<F, RouterDReq, ApiRequest, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_context: &domain::MerchantContext,\n    connector: api::ConnectorData,\n    operation: &BoxedOperation<'_, F, ApiRequest, D>,\n    payment_data: &mut D,\n    customer: &Option<domain::Customer>,\n    call_connector_action: CallConnectorAction,\n    schedule_time: Option<time::PrimitiveDateTime>,\n    header_payload: HeaderPayload,\n    frm_suggestion: Option<storage_enums::FrmSuggestion>,\n    business_profile: &domain::Profile,\n    is_retry_payment: bool,\n    should_retry_with_pan: bool,\n    return_raw_connector_response: Option<bool>,\n    merchant_connector_account_type_details: domain::MerchantConnectorAccountTypeDetails,\n    mut router_data: RouterData<F, RouterDReq, router_types::PaymentsResponseData>,\n    updated_customer: Option<storage::CustomerUpdate>,\n    tokenization_action: TokenizationAction,\n) -> RouterResult<RouterData<F, RouterDReq, router_types::PaymentsResponseData>>\nwhere\n    F: Send + Clone + Sync,\n    RouterDReq: Send + Sync,\n\n    // To create connector flow specific interface data\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n    D: ConstructFlowSpecificData<F, RouterDReq, router_types::PaymentsResponseData>,\n    RouterData<F, RouterDReq, router_types::PaymentsResponseData>: Feature<F, RouterDReq> + Send,\n    // To construct connector flow specific api\n    dyn api::Connector: services::api::ConnectorIntegration<F, RouterDReq, router_types::PaymentsResponseData>\n        + Send\n        + Sync,\n{\n    let add_access_token_result = router_data\n        .add_access_token(\n            state,\n            &connector,\n            merchant_context,\n            payment_data.get_creds_identifier(),\n        )\n        .await?;\n\n    router_data = router_data.add_session_token(state, &connector).await?;\n\n    let should_continue_further = access_token::update_router_data_with_access_token_result(\n        &add_access_token_result,\n        &mut router_data,\n        &call_connector_action,\n    );\n    let payment_method_token_response = router_data\n        .add_payment_method_token(\n            state,\n            &connector,\n            &tokenization_action,\n            should_continue_further,\n        )\n        .await?;\n    let should_continue_further = tokenization::update_router_data_with_payment_method_token_result(\n        payment_method_token_response,\n        &mut router_data,\n        is_retry_payment,\n        should_continue_further,\n    );\n    let should_continue = match router_data\n        .create_order_at_connector(state, &connector, should_continue_further)\n        .await?\n    {\n        Some(create_order_response) => {\n            if let Ok(order_id) = create_order_response.clone().create_order_result {\n                payment_data.set_connector_response_reference_id(Some(order_id))\n            }\n\n            // Set the response in routerdata response to carry forward\n            router_data\n                .update_router_data_with_create_order_response(create_order_response.clone());\n            create_order_response.create_order_result.ok().map(|_| ())\n        }\n        // If create order is not required, then we can proceed with further processing\n        None => Some(()),\n    };\n\n    // In case of authorize flow, pre-task and post-tasks are being called in build request\n    // if we do not want to proceed further, then the function will return Ok(None, false)\n    let (connector_request, should_continue_further) = match should_continue {\n        Some(_) => {\n            router_data\n                .build_flow_specific_connector_request(\n                    state,\n                    &connector,\n                    call_connector_action.clone(),\n                )\n                .await?\n        }\n        None => (None, false),\n    };\n\n    // Update the payment trackers just before calling the connector\n    // Since the request is already built in the previous step,\n    // there should be no error in request construction from hyperswitch end\n    (_, *payment_data) = operation\n        .to_update_tracker()?\n        .update_trackers(\n            state,\n            req_state,\n            payment_data.clone(),\n            customer.clone(),\n            merchant_context.get_merchant_account().storage_scheme,\n            updated_customer,\n            merchant_context.get_merchant_key_store(),\n            frm_suggestion,\n            header_payload.clone(),\n        )\n        .await?;\n\n    let router_data = if should_continue_further {\n        // The status of payment_attempt and intent will be updated in the previous step\n        // update this in router_data.\n        // This is added because few connector integrations do not update the status,\n        // and rely on previous status set in router_data\n        // TODO: status is already set when constructing payment data, why should this be done again?\n        // router_data.status = payment_data.get_payment_attempt().status;\n        let gateway_context = gateway_context::RouterGatewayContext {\n            creds_identifier: payment_data.get_creds_identifier().map(|id| id.to_string()),\n            merchant_context: merchant_context.clone(),\n            header_payload: header_payload.clone(),\n            lineage_ids,\n            merchant_connector_account: merchant_connector_account.clone(),\n            execution_path: ExecutionPath::Direct,\n            execution_mode: ExecutionMode::NotApplicable,\n        };\n        router_data\n            .decide_flows(\n                state,\n                &connector,\n                call_connector_action,\n                connector_request,\n                business_profile,\n                header_payload.clone(),\n                return_raw_connector_response,\n                gateway_context,\n            )\n            .await\n    } else {\n        Ok(router_data)\n    }?;\n\n    Ok(router_data)\n}",
+      "after_code": "pub async fn call_connector_service<F, RouterDReq, ApiRequest, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_context: &domain::MerchantContext,\n    connector: api::ConnectorData,\n    operation: &BoxedOperation<'_, F, ApiRequest, D>,\n    payment_data: &mut D,\n    customer: &Option<domain::Customer>,\n    call_connector_action: CallConnectorAction,\n    schedule_time: Option<time::PrimitiveDateTime>,\n    header_payload: HeaderPayload,\n    frm_suggestion: Option<storage_enums::FrmSuggestion>,\n    business_profile: &domain::Profile,\n    is_retry_payment: bool,\n    should_retry_with_pan: bool,\n    return_raw_connector_response: Option<bool>,\n    merchant_connector_account_type_details: domain::MerchantConnectorAccountTypeDetails,\n    mut router_data: RouterData<F, RouterDReq, router_types::PaymentsResponseData>,\n    updated_customer: Option<storage::CustomerUpdate>,\n    tokenization_action: TokenizationAction,\n) -> RouterResult<RouterData<F, RouterDReq, router_types::PaymentsResponseData>>\nwhere\n    F: Send + Clone + Sync,\n    RouterDReq: Send + Sync,\n\n    // To create connector flow specific interface data\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n    D: ConstructFlowSpecificData<F, RouterDReq, router_types::PaymentsResponseData>,\n    RouterData<F, RouterDReq, router_types::PaymentsResponseData>: Feature<F, RouterDReq> + Send,\n    // To construct connector flow specific api\n    dyn api::Connector: services::api::ConnectorIntegration<F, RouterDReq, router_types::PaymentsResponseData>\n        + Send\n        + Sync,\n{\n    let add_access_token_result = router_data\n        .add_access_token(\n            state,\n            &connector,\n            merchant_context,\n            payment_data.get_creds_identifier(),\n        )\n        .await?;\n\n    router_data = router_data.add_session_token(state, &connector).await?;\n\n    let should_continue_further = access_token::update_router_data_with_access_token_result(\n        &add_access_token_result,\n        &mut router_data,\n        &call_connector_action,\n    );\n    let payment_method_token_response = router_data\n        .add_payment_method_token(\n            state,\n            &connector,\n            &tokenization_action,\n            should_continue_further,\n        )\n        .await?;\n    let should_continue_further = tokenization::update_router_data_with_payment_method_token_result(\n        payment_method_token_response,\n        &mut router_data,\n        is_retry_payment,\n        should_continue_further,\n    );\n    let should_continue = match router_data\n        .create_order_at_connector(state, &connector, should_continue_further)\n        .await?\n    {\n        Some(create_order_response) => {\n            if let Ok(order_id) = create_order_response.clone().create_order_result {\n                payment_data.set_connector_response_reference_id(Some(order_id))\n            }\n\n            // Set the response in routerdata response to carry forward\n            router_data\n                .update_router_data_with_create_order_response(create_order_response.clone());\n            create_order_response.create_order_result.ok().map(|_| ())\n        }\n        // If create order is not required, then we can proceed with further processing\n        None => Some(()),\n    };\n\n    // In case of authorize flow, pre-task and post-tasks are being called in build request\n    // if we do not want to proceed further, then the function will return Ok(None, false)\n    let (connector_request, should_continue_further) = match should_continue {\n        Some(_) => {\n            router_data\n                .build_flow_specific_connector_request(\n                    state,\n                    &connector,\n                    call_connector_action.clone(),\n                )\n                .await?\n        }\n        None => (None, false),\n    };\n\n    // Update the payment trackers just before calling the connector\n    // Since the request is already built in the previous step,\n    // there should be no error in request construction from hyperswitch end\n    (_, *payment_data) = operation\n        .to_update_tracker()?\n        .update_trackers(\n            state,\n            req_state,\n            payment_data.clone(),\n            customer.clone(),\n            merchant_context.get_merchant_account().storage_scheme,\n            updated_customer,\n            merchant_context.get_merchant_key_store(),\n            frm_suggestion,\n            header_payload.clone(),\n        )\n        .await?;\n\n    let router_data = if should_continue_further {\n        // The status of payment_attempt and intent will be updated in the previous step\n        // update this in router_data.\n        // This is added because few connector integrations do not update the status,\n        // and rely on previous status set in router_data\n        // TODO: status is already set when constructing payment data, why should this be done again?\n        // router_data.status = payment_data.get_payment_attempt().status;\n        let lineage_ids = grpc_client::LineageIds::new(\n            business_profile.merchant_id.clone(),\n            business_profile.get_id().clone(),\n        );\n        let gateway_context = gateway_context::RouterGatewayContext {\n            creds_identifier: payment_data.get_creds_identifier().map(|id| id.to_string()),\n            merchant_context: merchant_context.clone(),\n            header_payload: header_payload.clone(),\n            lineage_ids,\n            merchant_connector_account: merchant_connector_account_type_details,\n            execution_path: ExecutionPath::Direct,\n            execution_mode: ExecutionMode::NotApplicable,\n        };\n        router_data\n            .decide_flows(\n                state,\n                &connector,\n                call_connector_action,\n                connector_request,\n                business_profile,\n                header_payload.clone(),\n                return_raw_connector_response,\n                gateway_context,\n            )\n            .await\n    } else {\n        Ok(router_data)\n    }?;\n\n    Ok(router_data)\n}",
+      "diff_span": {
+        "before": "            header_payload: header_payload.clone(),\n            lineage_ids,\n            merchant_connector_account: merchant_connector_account.clone(),\n            execution_path: ExecutionPath::Direct,\n            execution_mode: ExecutionMode::NotApplicable,",
+        "after": "        // TODO: status is already set when constructing payment data, why should this be done again?\n        // router_data.status = payment_data.get_payment_attempt().status;\n        let lineage_ids = grpc_client::LineageIds::new(\n            business_profile.merchant_id.clone(),\n            business_profile.get_id().clone(),\n        );\n        let gateway_context = gateway_context::RouterGatewayContext {\n            creds_identifier: payment_data.get_creds_identifier().map(|id| id.to_string()),\n            merchant_context: merchant_context.clone(),\n            header_payload: header_payload.clone(),\n            lineage_ids,\n            merchant_connector_account: merchant_connector_account_type_details,\n            execution_path: ExecutionPath::Direct,\n            execution_mode: ExecutionMode::NotApplicable,"
+      },
+      "commit_sha": "3b1dcd02afe5f76006795c4fcca1fa1fe2c6bf2c",
+      "before_imports": [
+        "pub use common_enums::enums::{CallConnectorAction, ExecutionMode, ExecutionPath, GatewaySystem};",
+        "use crate::core::payments::helpers::{\n    process_through_direct, process_through_direct_with_shadow_unified_connector_service,\n    process_through_ucs,\n};",
+        "use hyperswitch_domain_models::{\n        payments::PaymentConfirmData,\n        router_flow_types::{Authorize, SetupMandate},\n    };",
+        "use self::{\n    conditional_configs::perform_decision_management,\n    flows::{ConstructFlowSpecificData, Feature},\n    gateway::context as gateway_context,\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    routing::{self as self_routing, SessionFlowRoutingInput},\n};",
+        "pub use self::operations::{\n    PaymentApprove, PaymentCancel, PaymentCancelPostCapture, PaymentCapture, PaymentConfirm,\n    PaymentCreate, PaymentExtendAuthorization, PaymentIncrementalAuthorization,\n    PaymentPostSessionTokens, PaymentReject, PaymentSession, PaymentSessionUpdate, PaymentStatus,\n    PaymentUpdate, PaymentUpdateMetadata,\n};",
+        "use api_models::{\n    self, enums,\n    mandates::RecurringDetails,\n    payments::{self as payments_api},\n};",
+        "use common_utils::{\n    ext_traits::{AsyncExt, StringExt},\n    id_type, pii,\n    types::{AmountConvertor, MinorUnit, Surcharge},\n};",
+        "use hyperswitch_domain_models::payments::{\n    PaymentAttemptListData, PaymentCancelData, PaymentCaptureData, PaymentConfirmData,\n    PaymentIntentData, PaymentStatusData,\n};"
+      ],
+      "after_imports": [
+        "pub use common_enums::enums::{CallConnectorAction, ExecutionMode, ExecutionPath, GatewaySystem};",
+        "use crate::core::payments::helpers::{\n    process_through_direct, process_through_direct_with_shadow_unified_connector_service,\n    process_through_ucs,\n};",
+        "use hyperswitch_domain_models::{\n        payments::PaymentConfirmData,\n        router_flow_types::{Authorize, SetupMandate},\n    };",
+        "use self::{\n    conditional_configs::perform_decision_management,\n    flows::{ConstructFlowSpecificData, Feature},\n    gateway::context as gateway_context,\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    routing::{self as self_routing, SessionFlowRoutingInput},\n};",
+        "pub use self::operations::{\n    PaymentApprove, PaymentCancel, PaymentCancelPostCapture, PaymentCapture, PaymentConfirm,\n    PaymentCreate, PaymentExtendAuthorization, PaymentIncrementalAuthorization,\n    PaymentPostSessionTokens, PaymentReject, PaymentSession, PaymentSessionUpdate, PaymentStatus,\n    PaymentUpdate, PaymentUpdateMetadata,\n};",
+        "use api_models::{\n    self, enums,\n    mandates::RecurringDetails,\n    payments::{self as payments_api},\n};",
+        "use common_utils::{\n    ext_traits::{AsyncExt, StringExt},\n    id_type, pii,\n    types::{AmountConvertor, MinorUnit, Surcharge},\n};",
+        "use hyperswitch_domain_models::payments::{\n    PaymentAttemptListData, PaymentCancelData, PaymentCaptureData, PaymentConfirmData,\n    PaymentIntentData, PaymentStatusData,\n};",
+        "use external_services::grpc_client;"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payments.rs::function::proxy_for_call_connector_service",
+      "file": "crates/router/src/core/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn proxy_for_call_connector_service<F, RouterDReq, ApiRequest, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_context: &domain::MerchantContext,\n    connector: api::ConnectorData,\n    operation: &BoxedOperation<'_, F, ApiRequest, D>,\n    payment_data: &mut D,\n    call_connector_action: CallConnectorAction,\n    header_payload: HeaderPayload,\n    business_profile: &domain::Profile,\n    return_raw_connector_response: Option<bool>,\n) -> RouterResult<RouterData<F, RouterDReq, router_types::PaymentsResponseData>>\nwhere\n    F: Send + Clone + Sync,\n    RouterDReq: Send + Sync,\n\n    // To create connector flow specific interface data\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n    D: ConstructFlowSpecificData<F, RouterDReq, router_types::PaymentsResponseData>,\n    RouterData<F, RouterDReq, router_types::PaymentsResponseData>: Feature<F, RouterDReq> + Send,\n    // To construct connector flow specific api\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, RouterDReq, router_types::PaymentsResponseData>,\n{\n    let stime_connector = Instant::now();\n\n    let merchant_connector_account =\n        domain::MerchantConnectorAccountTypeDetails::MerchantConnectorAccount(Box::new(\n            helpers::get_merchant_connector_account_v2(\n                state,\n                merchant_context.get_merchant_key_store(),\n                connector.merchant_connector_id.as_ref(),\n            )\n            .await?,\n        ));\n    operation\n        .to_domain()?\n        .populate_payment_data(\n            state,\n            payment_data,\n            merchant_context,\n            business_profile,\n            &connector,\n        )\n        .await?;\n\n    let mut router_data = payment_data\n        .construct_router_data(\n            state,\n            connector.connector.id(),\n            merchant_context,\n            &None,\n            &merchant_connector_account,\n            None,\n            Some(header_payload.clone()),\n        )\n        .await?;\n\n    let add_access_token_result = router_data\n        .add_access_token(\n            state,\n            &connector,\n            merchant_context,\n            payment_data.get_creds_identifier(),\n        )\n        .await?;\n\n    router_data = router_data.add_session_token(state, &connector).await?;\n\n    let mut should_continue_further = access_token::update_router_data_with_access_token_result(\n        &add_access_token_result,\n        &mut router_data,\n        &call_connector_action,\n    );\n\n    let (connector_request, should_continue_further) = if should_continue_further {\n        router_data\n            .build_flow_specific_connector_request(state, &connector, call_connector_action.clone())\n            .await?\n    } else {\n        (None, false)\n    };\n\n    (_, *payment_data) = operation\n        .to_update_tracker()?\n        .update_trackers(\n            state,\n            req_state,\n            payment_data.clone(),\n            None,\n            merchant_context.get_merchant_account().storage_scheme,\n            None,\n            merchant_context.get_merchant_key_store(),\n            None,\n            header_payload.clone(),\n        )\n        .await?;\n\n    let gateway_context = gateway_context::RouterGatewayContext {\n        creds_identifier: payment_data.get_creds_identifier().map(|id| id.to_string()),\n        merchant_context: merchant_context.clone(),\n        header_payload: header_payload.clone(),\n        lineage_ids,\n        merchant_connector_account: merchant_connector_account.clone(),\n        execution_path: ExecutionPath::Direct,\n        execution_mode: ExecutionMode::NotApplicable,\n    };\n\n    let router_data = if should_continue_further {\n        router_data\n            .decide_flows(\n                state,\n                &connector,\n                call_connector_action,\n                connector_request,\n                business_profile,\n                header_payload.clone(),\n                return_raw_connector_response,\n                gateway_context,\n            )\n            .await\n    } else {\n        Ok(router_data)\n    }?;\n\n    let etime_connector = Instant::now();\n    let duration_connector = etime_connector.saturating_duration_since(stime_connector);\n    tracing::info!(duration = format!(\"Duration taken: {}\", duration_connector.as_millis()));\n\n    Ok(router_data)\n}",
+      "after_code": "pub async fn proxy_for_call_connector_service<F, RouterDReq, ApiRequest, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_context: &domain::MerchantContext,\n    connector: api::ConnectorData,\n    operation: &BoxedOperation<'_, F, ApiRequest, D>,\n    payment_data: &mut D,\n    call_connector_action: CallConnectorAction,\n    header_payload: HeaderPayload,\n    business_profile: &domain::Profile,\n    return_raw_connector_response: Option<bool>,\n) -> RouterResult<RouterData<F, RouterDReq, router_types::PaymentsResponseData>>\nwhere\n    F: Send + Clone + Sync,\n    RouterDReq: Send + Sync,\n\n    // To create connector flow specific interface data\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n    D: ConstructFlowSpecificData<F, RouterDReq, router_types::PaymentsResponseData>,\n    RouterData<F, RouterDReq, router_types::PaymentsResponseData>: Feature<F, RouterDReq> + Send,\n    // To construct connector flow specific api\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, RouterDReq, router_types::PaymentsResponseData>,\n{\n    let stime_connector = Instant::now();\n\n    let merchant_connector_account =\n        domain::MerchantConnectorAccountTypeDetails::MerchantConnectorAccount(Box::new(\n            helpers::get_merchant_connector_account_v2(\n                state,\n                merchant_context.get_merchant_key_store(),\n                connector.merchant_connector_id.as_ref(),\n            )\n            .await?,\n        ));\n    operation\n        .to_domain()?\n        .populate_payment_data(\n            state,\n            payment_data,\n            merchant_context,\n            business_profile,\n            &connector,\n        )\n        .await?;\n\n    let mut router_data = payment_data\n        .construct_router_data(\n            state,\n            connector.connector.id(),\n            merchant_context,\n            &None,\n            &merchant_connector_account,\n            None,\n            Some(header_payload.clone()),\n        )\n        .await?;\n\n    let add_access_token_result = router_data\n        .add_access_token(\n            state,\n            &connector,\n            merchant_context,\n            payment_data.get_creds_identifier(),\n        )\n        .await?;\n\n    router_data = router_data.add_session_token(state, &connector).await?;\n\n    let mut should_continue_further = access_token::update_router_data_with_access_token_result(\n        &add_access_token_result,\n        &mut router_data,\n        &call_connector_action,\n    );\n\n    let (connector_request, should_continue_further) = if should_continue_further {\n        router_data\n            .build_flow_specific_connector_request(state, &connector, call_connector_action.clone())\n            .await?\n    } else {\n        (None, false)\n    };\n\n    (_, *payment_data) = operation\n        .to_update_tracker()?\n        .update_trackers(\n            state,\n            req_state,\n            payment_data.clone(),\n            None,\n            merchant_context.get_merchant_account().storage_scheme,\n            None,\n            merchant_context.get_merchant_key_store(),\n            None,\n            header_payload.clone(),\n        )\n        .await?;\n    let lineage_ids = grpc_client::LineageIds::new(\n        business_profile.merchant_id.clone(),\n        business_profile.get_id().clone(),\n    );\n\n    let gateway_context = gateway_context::RouterGatewayContext {\n        creds_identifier: payment_data.get_creds_identifier().map(|id| id.to_string()),\n        merchant_context: merchant_context.clone(),\n        header_payload: header_payload.clone(),\n        lineage_ids,\n        merchant_connector_account: merchant_connector_account.clone(),\n        execution_path: ExecutionPath::Direct,\n        execution_mode: ExecutionMode::NotApplicable,\n    };\n\n    let router_data = if should_continue_further {\n        router_data\n            .decide_flows(\n                state,\n                &connector,\n                call_connector_action,\n                connector_request,\n                business_profile,\n                header_payload.clone(),\n                return_raw_connector_response,\n                gateway_context,\n            )\n            .await\n    } else {\n        Ok(router_data)\n    }?;\n\n    let etime_connector = Instant::now();\n    let duration_connector = etime_connector.saturating_duration_since(stime_connector);\n    tracing::info!(duration = format!(\"Duration taken: {}\", duration_connector.as_millis()));\n\n    Ok(router_data)\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        )\n        .await?;\n    let lineage_ids = grpc_client::LineageIds::new(\n        business_profile.merchant_id.clone(),\n        business_profile.get_id().clone(),\n    );\n\n    let gateway_context = gateway_context::RouterGatewayContext {"
+      },
+      "commit_sha": "3b1dcd02afe5f76006795c4fcca1fa1fe2c6bf2c",
+      "before_imports": [
+        "pub use common_enums::enums::{CallConnectorAction, ExecutionMode, ExecutionPath, GatewaySystem};",
+        "use crate::core::payments::helpers::{\n    process_through_direct, process_through_direct_with_shadow_unified_connector_service,\n    process_through_ucs,\n};",
+        "use router_env::{instrument, tracing};",
+        "use hyperswitch_domain_models::{\n        payments::PaymentConfirmData,\n        router_flow_types::{Authorize, SetupMandate},\n    };",
+        "use self::{\n    conditional_configs::perform_decision_management,\n    flows::{ConstructFlowSpecificData, Feature},\n    gateway::context as gateway_context,\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    routing::{self as self_routing, SessionFlowRoutingInput},\n};",
+        "pub use self::operations::{\n    PaymentApprove, PaymentCancel, PaymentCancelPostCapture, PaymentCapture, PaymentConfirm,\n    PaymentCreate, PaymentExtendAuthorization, PaymentIncrementalAuthorization,\n    PaymentPostSessionTokens, PaymentReject, PaymentSession, PaymentSessionUpdate, PaymentStatus,\n    PaymentUpdate, PaymentUpdateMetadata,\n};",
+        "use api_models::{\n    self, enums,\n    mandates::RecurringDetails,\n    payments::{self as payments_api},\n};",
+        "use common_utils::{\n    ext_traits::{AsyncExt, StringExt},\n    id_type, pii,\n    types::{AmountConvertor, MinorUnit, Surcharge},\n};",
+        "use hyperswitch_domain_models::payments::{\n    PaymentAttemptListData, PaymentCancelData, PaymentCaptureData, PaymentConfirmData,\n    PaymentIntentData, PaymentStatusData,\n};"
+      ],
+      "after_imports": [
+        "pub use common_enums::enums::{CallConnectorAction, ExecutionMode, ExecutionPath, GatewaySystem};",
+        "use crate::core::payments::helpers::{\n    process_through_direct, process_through_direct_with_shadow_unified_connector_service,\n    process_through_ucs,\n};",
+        "use router_env::{instrument, tracing};",
+        "use hyperswitch_domain_models::{\n        payments::PaymentConfirmData,\n        router_flow_types::{Authorize, SetupMandate},\n    };",
+        "use self::{\n    conditional_configs::perform_decision_management,\n    flows::{ConstructFlowSpecificData, Feature},\n    gateway::context as gateway_context,\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    routing::{self as self_routing, SessionFlowRoutingInput},\n};",
+        "pub use self::operations::{\n    PaymentApprove, PaymentCancel, PaymentCancelPostCapture, PaymentCapture, PaymentConfirm,\n    PaymentCreate, PaymentExtendAuthorization, PaymentIncrementalAuthorization,\n    PaymentPostSessionTokens, PaymentReject, PaymentSession, PaymentSessionUpdate, PaymentStatus,\n    PaymentUpdate, PaymentUpdateMetadata,\n};",
+        "use api_models::{\n    self, enums,\n    mandates::RecurringDetails,\n    payments::{self as payments_api},\n};",
+        "use common_utils::{\n    ext_traits::{AsyncExt, StringExt},\n    id_type, pii,\n    types::{AmountConvertor, MinorUnit, Surcharge},\n};",
+        "use hyperswitch_domain_models::payments::{\n    PaymentAttemptListData, PaymentCancelData, PaymentCaptureData, PaymentConfirmData,\n    PaymentIntentData, PaymentStatusData,\n};",
+        "use external_services::grpc_client;"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payments.rs::function::call_connector_service_for_external_vault_proxy",
+      "file": "crates/router/src/core/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn call_connector_service_for_external_vault_proxy<F, RouterDReq, ApiRequest, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_context: &domain::MerchantContext,\n    connector: api::ConnectorData,\n    operation: &BoxedOperation<'_, F, ApiRequest, D>,\n    payment_data: &mut D,\n    call_connector_action: CallConnectorAction,\n    header_payload: HeaderPayload,\n    business_profile: &domain::Profile,\n    return_raw_connector_response: Option<bool>,\n) -> RouterResult<RouterData<F, RouterDReq, router_types::PaymentsResponseData>>\nwhere\n    F: Send + Clone + Sync,\n    RouterDReq: Send + Sync,\n\n    // To create connector flow specific interface data\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n    D: ConstructFlowSpecificData<F, RouterDReq, router_types::PaymentsResponseData>,\n    RouterData<F, RouterDReq, router_types::PaymentsResponseData>: Feature<F, RouterDReq> + Send,\n    // To construct connector flow specific api\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, RouterDReq, router_types::PaymentsResponseData>,\n{\n    let stime_connector = Instant::now();\n\n    let merchant_connector_account =\n        domain::MerchantConnectorAccountTypeDetails::MerchantConnectorAccount(Box::new(\n            helpers::get_merchant_connector_account_v2(\n                state,\n                merchant_context.get_merchant_key_store(),\n                connector.merchant_connector_id.as_ref(),\n            )\n            .await?,\n        ));\n    operation\n        .to_domain()?\n        .populate_payment_data(\n            state,\n            payment_data,\n            merchant_context,\n            business_profile,\n            &connector,\n        )\n        .await?;\n\n    let mut router_data = payment_data\n        .construct_router_data(\n            state,\n            connector.connector.id(),\n            merchant_context,\n            &None,\n            &merchant_connector_account,\n            None,\n            Some(header_payload.clone()),\n        )\n        .await?;\n\n    // let add_access_token_result = router_data\n    //     .add_access_token(\n    //         state,\n    //         &connector,\n    //         merchant_context,\n    //         payment_data.get_creds_identifier(),\n    //     )\n    //     .await?;\n\n    // router_data = router_data.add_session_token(state, &connector).await?;\n\n    // let mut should_continue_further = access_token::update_router_data_with_access_token_result(\n    //     &add_access_token_result,\n    //     &mut router_data,\n    //     &call_connector_action,\n    // );\n    let should_continue_further = true;\n\n    let (connector_request, should_continue_further) = if should_continue_further {\n        router_data\n            .build_flow_specific_connector_request(state, &connector, call_connector_action.clone())\n            .await?\n    } else {\n        (None, false)\n    };\n\n    (_, *payment_data) = operation\n        .to_update_tracker()?\n        .update_trackers(\n            state,\n            req_state,\n            payment_data.clone(),\n            None,\n            merchant_context.get_merchant_account().storage_scheme,\n            None,\n            merchant_context.get_merchant_key_store(),\n            None,\n            header_payload.clone(),\n        )\n        .await?;\n\n    let gateway_context = gateway_context::RouterGatewayContext {\n        creds_identifier: payment_data.get_creds_identifier().map(|id| id.to_string()),\n        merchant_context: merchant_context.clone(),\n        header_payload: header_payload.clone(),\n        lineage_ids,\n        merchant_connector_account: merchant_connector_account.clone(),\n        execution_path: ExecutionPath::Direct,\n        execution_mode: ExecutionMode::NotApplicable,\n    };\n\n    let router_data = if should_continue_further {\n        router_data\n            .decide_flows(\n                state,\n                &connector,\n                call_connector_action,\n                connector_request,\n                business_profile,\n                header_payload.clone(),\n                return_raw_connector_response,\n                gateway_context,\n            )\n            .await\n    } else {\n        Ok(router_data)\n    }?;\n\n    let etime_connector = Instant::now();\n    let duration_connector = etime_connector.saturating_duration_since(stime_connector);\n    tracing::info!(duration = format!(\"Duration taken: {}\", duration_connector.as_millis()));\n\n    Ok(router_data)\n}",
+      "after_code": "pub async fn call_connector_service_for_external_vault_proxy<F, RouterDReq, ApiRequest, D>(\n    state: &SessionState,\n    req_state: ReqState,\n    merchant_context: &domain::MerchantContext,\n    connector: api::ConnectorData,\n    operation: &BoxedOperation<'_, F, ApiRequest, D>,\n    payment_data: &mut D,\n    call_connector_action: CallConnectorAction,\n    header_payload: HeaderPayload,\n    business_profile: &domain::Profile,\n    return_raw_connector_response: Option<bool>,\n) -> RouterResult<RouterData<F, RouterDReq, router_types::PaymentsResponseData>>\nwhere\n    F: Send + Clone + Sync,\n    RouterDReq: Send + Sync,\n\n    // To create connector flow specific interface data\n    D: OperationSessionGetters<F> + OperationSessionSetters<F> + Send + Sync + Clone,\n    D: ConstructFlowSpecificData<F, RouterDReq, router_types::PaymentsResponseData>,\n    RouterData<F, RouterDReq, router_types::PaymentsResponseData>: Feature<F, RouterDReq> + Send,\n    // To construct connector flow specific api\n    dyn api::Connector:\n        services::api::ConnectorIntegration<F, RouterDReq, router_types::PaymentsResponseData>,\n{\n    let stime_connector = Instant::now();\n\n    let merchant_connector_account =\n        domain::MerchantConnectorAccountTypeDetails::MerchantConnectorAccount(Box::new(\n            helpers::get_merchant_connector_account_v2(\n                state,\n                merchant_context.get_merchant_key_store(),\n                connector.merchant_connector_id.as_ref(),\n            )\n            .await?,\n        ));\n    operation\n        .to_domain()?\n        .populate_payment_data(\n            state,\n            payment_data,\n            merchant_context,\n            business_profile,\n            &connector,\n        )\n        .await?;\n\n    let mut router_data = payment_data\n        .construct_router_data(\n            state,\n            connector.connector.id(),\n            merchant_context,\n            &None,\n            &merchant_connector_account,\n            None,\n            Some(header_payload.clone()),\n        )\n        .await?;\n\n    // let add_access_token_result = router_data\n    //     .add_access_token(\n    //         state,\n    //         &connector,\n    //         merchant_context,\n    //         payment_data.get_creds_identifier(),\n    //     )\n    //     .await?;\n\n    // router_data = router_data.add_session_token(state, &connector).await?;\n\n    // let mut should_continue_further = access_token::update_router_data_with_access_token_result(\n    //     &add_access_token_result,\n    //     &mut router_data,\n    //     &call_connector_action,\n    // );\n    let should_continue_further = true;\n\n    let (connector_request, should_continue_further) = if should_continue_further {\n        router_data\n            .build_flow_specific_connector_request(state, &connector, call_connector_action.clone())\n            .await?\n    } else {\n        (None, false)\n    };\n\n    (_, *payment_data) = operation\n        .to_update_tracker()?\n        .update_trackers(\n            state,\n            req_state,\n            payment_data.clone(),\n            None,\n            merchant_context.get_merchant_account().storage_scheme,\n            None,\n            merchant_context.get_merchant_key_store(),\n            None,\n            header_payload.clone(),\n        )\n        .await?;\n    let lineage_ids = grpc_client::LineageIds::new(\n        business_profile.merchant_id.clone(),\n        business_profile.get_id().clone(),\n    );\n\n    let gateway_context = gateway_context::RouterGatewayContext {\n        creds_identifier: payment_data.get_creds_identifier().map(|id| id.to_string()),\n        merchant_context: merchant_context.clone(),\n        header_payload: header_payload.clone(),\n        lineage_ids,\n        merchant_connector_account: merchant_connector_account.clone(),\n        execution_path: ExecutionPath::Direct,\n        execution_mode: ExecutionMode::NotApplicable,\n    };\n\n    let router_data = if should_continue_further {\n        router_data\n            .decide_flows(\n                state,\n                &connector,\n                call_connector_action,\n                connector_request,\n                business_profile,\n                header_payload.clone(),\n                return_raw_connector_response,\n                gateway_context,\n            )\n            .await\n    } else {\n        Ok(router_data)\n    }?;\n\n    let etime_connector = Instant::now();\n    let duration_connector = etime_connector.saturating_duration_since(stime_connector);\n    tracing::info!(duration = format!(\"Duration taken: {}\", duration_connector.as_millis()));\n\n    Ok(router_data)\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        )\n        .await?;\n    let lineage_ids = grpc_client::LineageIds::new(\n        business_profile.merchant_id.clone(),\n        business_profile.get_id().clone(),\n    );\n\n    let gateway_context = gateway_context::RouterGatewayContext {"
+      },
+      "commit_sha": "3b1dcd02afe5f76006795c4fcca1fa1fe2c6bf2c",
+      "before_imports": [
+        "pub use common_enums::enums::{CallConnectorAction, ExecutionMode, ExecutionPath, GatewaySystem};",
+        "use crate::core::payments::helpers::{\n    process_through_direct, process_through_direct_with_shadow_unified_connector_service,\n    process_through_ucs,\n};",
+        "use router_env::{instrument, tracing};",
+        "use hyperswitch_domain_models::{\n        payments::PaymentConfirmData,\n        router_flow_types::{Authorize, SetupMandate},\n    };",
+        "use self::{\n    conditional_configs::perform_decision_management,\n    flows::{ConstructFlowSpecificData, Feature},\n    gateway::context as gateway_context,\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    routing::{self as self_routing, SessionFlowRoutingInput},\n};",
+        "use crate::core::payment_methods::vault;",
+        "pub use self::operations::{\n    PaymentApprove, PaymentCancel, PaymentCancelPostCapture, PaymentCapture, PaymentConfirm,\n    PaymentCreate, PaymentExtendAuthorization, PaymentIncrementalAuthorization,\n    PaymentPostSessionTokens, PaymentReject, PaymentSession, PaymentSessionUpdate, PaymentStatus,\n    PaymentUpdate, PaymentUpdateMetadata,\n};",
+        "use api_models::{\n    self, enums,\n    mandates::RecurringDetails,\n    payments::{self as payments_api},\n};",
+        "use common_utils::{\n    ext_traits::{AsyncExt, StringExt},\n    id_type, pii,\n    types::{AmountConvertor, MinorUnit, Surcharge},\n};",
+        "use hyperswitch_domain_models::payments::{\n    PaymentAttemptListData, PaymentCancelData, PaymentCaptureData, PaymentConfirmData,\n    PaymentIntentData, PaymentStatusData,\n};"
+      ],
+      "after_imports": [
+        "pub use common_enums::enums::{CallConnectorAction, ExecutionMode, ExecutionPath, GatewaySystem};",
+        "use crate::core::payments::helpers::{\n    process_through_direct, process_through_direct_with_shadow_unified_connector_service,\n    process_through_ucs,\n};",
+        "use router_env::{instrument, tracing};",
+        "use hyperswitch_domain_models::{\n        payments::PaymentConfirmData,\n        router_flow_types::{Authorize, SetupMandate},\n    };",
+        "use self::{\n    conditional_configs::perform_decision_management,\n    flows::{ConstructFlowSpecificData, Feature},\n    gateway::context as gateway_context,\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    routing::{self as self_routing, SessionFlowRoutingInput},\n};",
+        "use crate::core::payment_methods::vault;",
+        "pub use self::operations::{\n    PaymentApprove, PaymentCancel, PaymentCancelPostCapture, PaymentCapture, PaymentConfirm,\n    PaymentCreate, PaymentExtendAuthorization, PaymentIncrementalAuthorization,\n    PaymentPostSessionTokens, PaymentReject, PaymentSession, PaymentSessionUpdate, PaymentStatus,\n    PaymentUpdate, PaymentUpdateMetadata,\n};",
+        "use api_models::{\n    self, enums,\n    mandates::RecurringDetails,\n    payments::{self as payments_api},\n};",
+        "use common_utils::{\n    ext_traits::{AsyncExt, StringExt},\n    id_type, pii,\n    types::{AmountConvertor, MinorUnit, Surcharge},\n};",
+        "use hyperswitch_domain_models::payments::{\n    PaymentAttemptListData, PaymentCancelData, PaymentCaptureData, PaymentConfirmData,\n    PaymentIntentData, PaymentStatusData,\n};",
+        "use external_services::grpc_client;"
+      ]
+    }
+  ]
+}

diffs/pr_10192/44e66a9/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "44e66a9c160b83a51b1168530eb610143b1a9fb6",
+  "pr_number": 10192,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/api/gateway.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/api/gateway.rs::function::execute_payment_gateway",
+      "file": "crates/hyperswitch_interfaces/src/api/gateway.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn execute_payment_gateway<State, ConnectorData, F, Req, Resp, Context>(\n    state: &State,\n    connector_integration: BoxedConnectorIntegrationInterface<F, ConnectorData, Req, Resp>,\n    router_data: &RouterData<F, Req, Resp>,\n    call_connector_action: CallConnectorAction,\n    connector_request: Option<Request>,\n    return_raw_connector_response: Option<bool>,\n    context: Context,\n) -> CustomResult<RouterData<F, Req, Resp>, ConnectorError>\nwhere\n    State: Clone + Send + Sync + 'static + ApiClientWrapper + helpers::GetComparisonServiceConfig,\n    ConnectorData: Clone + RouterDataConversion<F, Req, Resp> + Send + Sync + 'static,\n    F: Clone\n        + std::fmt::Debug\n        + Send\n        + Sync\n        + 'static\n        + FlowGateway<State, ConnectorData, Req, Resp, Context>,\n    Req: std::fmt::Debug + Clone + Send + Sync + serde::Serialize + 'static,\n    Resp: std::fmt::Debug + Clone + Send + Sync + serde::Serialize + 'static,\n    Context: GatewayContext + 'static,\n{\n    let execution_path = context.execution_path();\n\n    match execution_path {\n        ExecutionPath::Direct => {\n            // Use direct execution for backward compatibility\n            api_client::execute_connector_processing_step(\n                state,\n                connector_integration,\n                router_data,\n                call_connector_action,\n                connector_request,\n                return_raw_connector_response,\n            )\n            .await\n        }\n        ExecutionPath::UnifiedConnectorService => {\n            let gateway: Box<dyn PaymentGateway<State, ConnectorData, F, Req, Resp, Context>> =\n                F::get_gateway(execution_path);\n\n            // Execute through selected gateway\n            gateway\n                .execute(\n                    state,\n                    connector_integration,\n                    router_data,\n                    call_connector_action,\n                    connector_request,\n                    return_raw_connector_response,\n                    context,\n                )\n                .await\n                .attach_printable(\"Gateway execution failed\")\n        }\n        ExecutionPath::ShadowUnifiedConnectorService => {\n            let direct_router_data = api_client::execute_connector_processing_step(\n                state,\n                connector_integration.clone_box(),\n                router_data,\n                call_connector_action.clone(),\n                connector_request,\n                return_raw_connector_response,\n            )\n            .await?;\n            let state_clone = state.clone();\n            let router_data_clone = router_data.clone();\n            let direct_router_data_clone = direct_router_data.clone();\n            let return_raw_connector_response_clone = return_raw_connector_response;\n            let context_clone = context.clone();\n            tokio::spawn(async move {\n                let gateway: Box<dyn PaymentGateway<State, ConnectorData, F, Req, Resp, Context>> =\n                    F::get_gateway(execution_path);\n                let ucs_shadow_result = gateway\n                    .execute(\n                        &state_clone,\n                        connector_integration,\n                        &router_data_clone,\n                        call_connector_action,\n                        None,\n                        return_raw_connector_response_clone,\n                        context_clone,\n                    )\n                    .await\n                    .attach_printable(\"Gateway execution failed\");\n                // Send comparison data asynchronously\n                match ucs_shadow_result {\n                    Ok(ucs_router_data) => {\n                        // Send comparison data asynchronously\n                        if let Some(comparison_service_config) =\n                            state_clone.get_comparison_service_config()\n                        {\n                            let request_id = state_clone.get_request_id_str();\n                            let _ = helpers::serialize_router_data_and_send_to_comparison_service(\n                                &state_clone,\n                                direct_router_data_clone,\n                                ucs_router_data,\n                                comparison_service_config,\n                                request_id,\n                            );\n                        };\n                    }\n                    Err(e) => {\n                        logger::error!(\"UCS shadow execution failed: {:?}\", e);\n                    }\n                }\n            });\n            Ok(direct_router_data)\n        }\n    }\n}",
+      "after_code": "pub async fn execute_payment_gateway<State, ConnectorData, F, Req, Resp, Context>(\n    state: &State,\n    connector_integration: BoxedConnectorIntegrationInterface<F, ConnectorData, Req, Resp>,\n    router_data: &RouterData<F, Req, Resp>,\n    call_connector_action: CallConnectorAction,\n    connector_request: Option<Request>,\n    return_raw_connector_response: Option<bool>,\n    context: Context,\n) -> CustomResult<RouterData<F, Req, Resp>, ConnectorError>\nwhere\n    State: Clone + Send + Sync + 'static + ApiClientWrapper + helpers::GetComparisonServiceConfig,\n    ConnectorData: Clone + RouterDataConversion<F, Req, Resp> + Send + Sync + 'static,\n    F: Clone\n        + std::fmt::Debug\n        + Send\n        + Sync\n        + 'static\n        + FlowGateway<State, ConnectorData, Req, Resp, Context>,\n    Req: std::fmt::Debug + Clone + Send + Sync + serde::Serialize + 'static,\n    Resp: std::fmt::Debug + Clone + Send + Sync + serde::Serialize + 'static,\n    Context: GatewayContext + 'static,\n{\n    let execution_path = context.execution_path();\n\n    match execution_path {\n        ExecutionPath::Direct => {\n            // Use direct execution for backward compatibility\n            api_client::execute_connector_processing_step(\n                state,\n                connector_integration,\n                router_data,\n                call_connector_action,\n                connector_request,\n                return_raw_connector_response,\n            )\n            .await\n        }\n        ExecutionPath::UnifiedConnectorService => {\n            let gateway: Box<dyn PaymentGateway<State, ConnectorData, F, Req, Resp, Context>> =\n                F::get_gateway(execution_path);\n\n            // Execute through selected gateway\n            gateway\n                .execute(\n                    state,\n                    connector_integration,\n                    router_data,\n                    call_connector_action,\n                    connector_request,\n                    return_raw_connector_response,\n                    context,\n                )\n                .await\n                .attach_printable(\"Gateway execution failed\")\n        }\n        ExecutionPath::ShadowUnifiedConnectorService => {\n            let direct_router_data = api_client::execute_connector_processing_step(\n                state,\n                connector_integration.clone_box(),\n                router_data,\n                call_connector_action.clone(),\n                connector_request,\n                return_raw_connector_response,\n            )\n            .await?;\n            let state_clone = state.clone();\n            let router_data_clone = router_data.clone();\n            let direct_router_data_clone = direct_router_data.clone();\n            let return_raw_connector_response_clone = return_raw_connector_response;\n            let context_clone = context.clone();\n            tokio::spawn(async move {\n                let gateway: Box<dyn PaymentGateway<State, ConnectorData, F, Req, Resp, Context>> =\n                    F::get_gateway(execution_path);\n                let ucs_shadow_result = gateway\n                    .execute(\n                        &state_clone,\n                        connector_integration,\n                        &router_data_clone,\n                        call_connector_action,\n                        None,\n                        return_raw_connector_response_clone,\n                        context_clone,\n                    )\n                    .await\n                    .attach_printable(\"Gateway execution failed\");\n                // Send comparison data asynchronously\n                match ucs_shadow_result {\n                    Ok(ucs_router_data) => {\n                        // Send comparison data asynchronously\n                        if let Some(comparison_service_config) =\n                            state_clone.get_comparison_service_config()\n                        {\n                            let request_id = state_clone.get_request_id_str();\n                            let _ = helpers::serialize_router_data_and_send_to_comparison_service(\n                                &state_clone,\n                                direct_router_data_clone,\n                                ucs_router_data,\n                                comparison_service_config,\n                                request_id,\n                            ).await;\n                        };\n                    }\n                    Err(e) => {\n                        logger::error!(\"UCS shadow execution failed: {:?}\", e);\n                    }\n                }\n            });\n            Ok(direct_router_data)\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                                comparison_service_config,\n                                request_id,\n                            );\n                        };\n                    }",
+        "after": "                                comparison_service_config,\n                                request_id,\n                            ).await;\n                        };\n                    }"
+      },
+      "commit_sha": "44e66a9c160b83a51b1168530eb610143b1a9fb6"
+    }
+  ]
+}

diffs/pr_10192/4c1b23a/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "4c1b23a58b59e42a84adfe78eaa6f8154883c3dc",
+  "pr_number": 10192,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/api/gateway.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/api/gateway.rs::function::execute_payment_gateway",
+      "file": "crates/hyperswitch_interfaces/src/api/gateway.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn execute_payment_gateway<State, ConnectorData, F, Req, Resp, Context>(\n    state: &State,\n    connector_integration: BoxedConnectorIntegrationInterface<F, ConnectorData, Req, Resp>,\n    router_data: &RouterData<F, Req, Resp>,\n    call_connector_action: CallConnectorAction,\n    connector_request: Option<Request>,\n    return_raw_connector_response: Option<bool>,\n    context: Context,\n) -> CustomResult<RouterData<F, Req, Resp>, ConnectorError>\nwhere\n    State: Clone + Send + Sync + 'static + ApiClientWrapper + helpers::GetComparisonServiceConfig,\n    ConnectorData: Clone + RouterDataConversion<F, Req, Resp> + Send + Sync + 'static,\n    F: Clone\n        + std::fmt::Debug\n        + Send\n        + Sync\n        + 'static\n        + FlowGateway<State, ConnectorData, Req, Resp, Context>,\n    Req: std::fmt::Debug + Clone + Send + Sync + serde::Serialize + 'static,\n    Resp: std::fmt::Debug + Clone + Send + Sync + serde::Serialize + 'static,\n    Context: GatewayContext + 'static,\n{\n    let execution_path = context.execution_path();\n\n    match execution_path {\n        ExecutionPath::Direct => {\n            // Use direct execution for backward compatibility\n            api_client::execute_connector_processing_step(\n                state,\n                connector_integration,\n                router_data,\n                call_connector_action,\n                connector_request,\n                return_raw_connector_response,\n            )\n            .await\n        }\n        ExecutionPath::UnifiedConnectorService => {\n            let gateway: Box<dyn PaymentGateway<State, ConnectorData, F, Req, Resp, Context>> =\n                F::get_gateway(execution_path);\n\n            // Execute through selected gateway\n            gateway\n                .execute(\n                    state,\n                    connector_integration,\n                    router_data,\n                    call_connector_action,\n                    connector_request,\n                    return_raw_connector_response,\n                    context,\n                )\n                .await\n                .attach_printable(\"Gateway execution failed\")\n        }\n        ExecutionPath::ShadowUnifiedConnectorService => {\n            let direct_router_data = api_client::execute_connector_processing_step(\n                state,\n                connector_integration.clone_box(),\n                router_data,\n                call_connector_action.clone(),\n                connector_request,\n                return_raw_connector_response,\n            )\n            .await?;\n            let state_clone = state.clone();\n            let router_data_clone = router_data.clone();\n            let direct_router_data_clone = direct_router_data.clone();\n            let return_raw_connector_response_clone = return_raw_connector_response;\n            let context_clone = context.clone();\n            tokio::spawn(async move {\n                let gateway: Box<dyn PaymentGateway<State, ConnectorData, F, Req, Resp, Context>> =\n                    F::get_gateway(execution_path);\n                let ucs_shadow_result = gateway\n                    .execute(\n                        &state_clone,\n                        connector_integration,\n                        &router_data_clone,\n                        call_connector_action,\n                        None,\n                        return_raw_connector_response_clone,\n                        context_clone,\n                    )\n                    .await\n                    .attach_printable(\"Gateway execution failed\");\n                // Send comparison data asynchronously\n                match ucs_shadow_result {\n                    Ok(ucs_router_data) => {\n                        // Send comparison data asynchronously\n                        if let Some(comparison_service_config) =\n                            state_clone.get_comparison_service_config()\n                        {\n                            let request_id = state_clone.get_request_id_str();\n                            let _ = helpers::serialize_router_data_and_send_to_comparison_service(\n                                &state_clone,\n                                direct_router_data_clone,\n                                ucs_router_data,\n                                comparison_service_config,\n                                request_id,\n                            ).await;\n                        };\n                    }\n                    Err(e) => {\n                        logger::error!(\"UCS shadow execution failed: {:?}\", e);\n                    }\n                }\n            });\n            Ok(direct_router_data)\n        }\n    }\n}",
+      "after_code": "pub async fn execute_payment_gateway<State, ConnectorData, F, Req, Resp, Context>(\n    state: &State,\n    connector_integration: BoxedConnectorIntegrationInterface<F, ConnectorData, Req, Resp>,\n    router_data: &RouterData<F, Req, Resp>,\n    call_connector_action: CallConnectorAction,\n    connector_request: Option<Request>,\n    return_raw_connector_response: Option<bool>,\n    context: Context,\n) -> CustomResult<RouterData<F, Req, Resp>, ConnectorError>\nwhere\n    State: Clone + Send + Sync + 'static + ApiClientWrapper + helpers::GetComparisonServiceConfig,\n    ConnectorData: Clone + RouterDataConversion<F, Req, Resp> + Send + Sync + 'static,\n    F: Clone\n        + std::fmt::Debug\n        + Send\n        + Sync\n        + 'static\n        + FlowGateway<State, ConnectorData, Req, Resp, Context>,\n    Req: std::fmt::Debug + Clone + Send + Sync + serde::Serialize + 'static,\n    Resp: std::fmt::Debug + Clone + Send + Sync + serde::Serialize + 'static,\n    Context: GatewayContext + 'static,\n{\n    let execution_path = context.execution_path();\n\n    match execution_path {\n        ExecutionPath::Direct => {\n            // Use direct execution for backward compatibility\n            api_client::execute_connector_processing_step(\n                state,\n                connector_integration,\n                router_data,\n                call_connector_action,\n                connector_request,\n                return_raw_connector_response,\n            )\n            .await\n        }\n        ExecutionPath::UnifiedConnectorService => {\n            let gateway: Box<dyn PaymentGateway<State, ConnectorData, F, Req, Resp, Context>> =\n                F::get_gateway(execution_path);\n\n            // Execute through selected gateway\n            gateway\n                .execute(\n                    state,\n                    connector_integration,\n                    router_data,\n                    call_connector_action,\n                    connector_request,\n                    return_raw_connector_response,\n                    context,\n                )\n                .await\n                .attach_printable(\"Gateway execution failed\")\n        }\n        ExecutionPath::ShadowUnifiedConnectorService => {\n            let direct_router_data = api_client::execute_connector_processing_step(\n                state,\n                connector_integration.clone_box(),\n                router_data,\n                call_connector_action.clone(),\n                connector_request,\n                return_raw_connector_response,\n            )\n            .await?;\n            let state_clone = state.clone();\n            let router_data_clone = router_data.clone();\n            let direct_router_data_clone = direct_router_data.clone();\n            let return_raw_connector_response_clone = return_raw_connector_response;\n            let context_clone = context.clone();\n            tokio::spawn(async move {\n                let gateway: Box<dyn PaymentGateway<State, ConnectorData, F, Req, Resp, Context>> =\n                    F::get_gateway(execution_path);\n                let ucs_shadow_result = gateway\n                    .execute(\n                        &state_clone,\n                        connector_integration,\n                        &router_data_clone,\n                        call_connector_action,\n                        None,\n                        return_raw_connector_response_clone,\n                        context_clone,\n                    )\n                    .await\n                    .attach_printable(\"Gateway execution failed\");\n                // Send comparison data asynchronously\n                match ucs_shadow_result {\n                    Ok(ucs_router_data) => {\n                        // Send comparison data asynchronously\n                        if let Some(comparison_service_config) =\n                            state_clone.get_comparison_service_config()\n                        {\n                            let request_id = state_clone.get_request_id_str();\n                            let _ = helpers::serialize_router_data_and_send_to_comparison_service(\n                                &state_clone,\n                                direct_router_data_clone,\n                                ucs_router_data,\n                                comparison_service_config,\n                                request_id,\n                            )\n                            .await;\n                        };\n                    }\n                    Err(e) => {\n                        logger::error!(\"UCS shadow execution failed: {:?}\", e);\n                    }\n                }\n            });\n            Ok(direct_router_data)\n        }\n    }\n}",
+      "diff_span": {
+        "before": "                                comparison_service_config,\n                                request_id,\n                            ).await;\n                        };\n                    }",
+        "after": "                                comparison_service_config,\n                                request_id,\n                            )\n                            .await;\n                        };\n                    }"
+      },
+      "commit_sha": "4c1b23a58b59e42a84adfe78eaa6f8154883c3dc"
+    }
+  ]
+}

diffs/pr_10192/61df8ef/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "61df8ef0c5757b90e5cd4ee0bd3d3527cd2fe0ff",
+  "pr_number": 10192,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/helpers.rs"
+  ],
+  "diffs": []
+}

diffs/pr_10192/6ec525d/diff.json

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

diffs/pr_10192/82058bf/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "82058bf1eedaec53d506e896fb5486350b32f335",
+  "pr_number": 10192,
+  "rust_files": [
+    "crates/router/src/core/payments.rs"
+  ],
+  "diffs": []
+}

diffs/pr_10192/acc98ca/diff.json

@@ -0,0 +1,30 @@
+{
+  "commit_sha": "acc98ca066af8cd5e6819b4d800c8f23fdc41ff6",
+  "pr_number": 10192,
+  "rust_files": [
+    "crates/router/src/core/payments.rs",
+    "crates/router/src/core/payments/gateway.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments/gateway.rs::static::GRANULAR_GATEWAY_SUPPORTED_FLOWS",
+      "file": "crates/router/src/core/payments/gateway.rs",
+      "kind": "static_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub static GRANULAR_GATEWAY_SUPPORTED_FLOWS: sync::LazyLock<Vec<&'static str>> =\n    sync::LazyLock::new(|| vec![std::any::type_name::<payments::PSync>()]);",
+      "diff_span": null,
+      "commit_sha": "acc98ca066af8cd5e6819b4d800c8f23fdc41ff6"
+    },
+    {
+      "id": "crates/router/src/core/payments/gateway.rs::static::COMPOSITE_GATEWAY_SUPPORTED_FLOWS",
+      "file": "crates/router/src/core/payments/gateway.rs",
+      "kind": "static_item",
+      "status": "removed",
+      "before_code": "pub static COMPOSITE_GATEWAY_SUPPORTED_FLOWS: sync::LazyLock<Vec<&'static str>> =\n    sync::LazyLock::new(|| vec![std::any::type_name::<payments::PSync>()]);",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "acc98ca066af8cd5e6819b4d800c8f23fdc41ff6"
+    }
+  ]
+}

diffs/pr_10192/c3eb9ce/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "c3eb9ce35edd95b6cf48ac09a720c1973a01727a",
+  "pr_number": 10192,
+  "rust_files": [
+    "crates/hyperswitch_interfaces/src/consts.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_interfaces/src/consts.rs::const::X_FLOW_NAME",
+      "file": "crates/hyperswitch_interfaces/src/consts.rs",
+      "kind": "const_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub const X_FLOW_NAME: &str = \"x-flow-name\";",
+      "after_code": "pub const X_FLOW_NAME: &str = \"x-flow\";",
+      "diff_span": {
+        "before": "pub const X_FLOW_NAME: &str = \"x-flow-name\";",
+        "after": "pub const X_FLOW_NAME: &str = \"x-flow\";"
+      },
+      "commit_sha": "c3eb9ce35edd95b6cf48ac09a720c1973a01727a"
+    },
+    {
+      "id": "crates/hyperswitch_interfaces/src/consts.rs::const::CONTENT_TYPE",
+      "file": "crates/hyperswitch_interfaces/src/consts.rs",
+      "kind": "const_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub const CONTENT_TYPE: &str = \"application/json\";",
+      "after_code": "pub const CONTENT_TYPE: &str = \"Content-Type\";",
+      "diff_span": {
+        "before": "pub const CONTENT_TYPE: &str = \"application/json\";",
+        "after": "pub const CONTENT_TYPE: &str = \"Content-Type\";"
+      },
+      "commit_sha": "c3eb9ce35edd95b6cf48ac09a720c1973a01727a"
+    }
+  ]
+}

diffs/pr_10243/d710641/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "d710641b98c3220de2825de46746c3c462b08efc",
+  "pr_number": 10243,
+  "rust_files": [
+    "crates/router/src/core/payments/operations/payment_update_intent.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments/operations/payment_update_intent.rs::PaymentUpdateIntent::function::get_trackers",
+      "file": "crates/router/src/core/payments/operations/payment_update_intent.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn get_trackers<'a>(\n        &'a self,\n        state: &'a SessionState,\n        payment_id: &common_utils::id_type::GlobalPaymentId,\n        request: &PaymentsUpdateIntentRequest,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        _header_payload: &hyperswitch_domain_models::payments::HeaderPayload,\n    ) -> RouterResult<operations::GetTrackerResponse<payments::PaymentIntentData<F>>> {\n        let db = &*state.store;\n        if let Some(routing_algorithm_id) = request.routing_algorithm_id.as_ref() {\n            helpers::validate_routing_id_with_profile_id(\n                db,\n                routing_algorithm_id,\n                profile.get_id(),\n            )\n            .await?;\n        }\n        let key_manager_state = &state.into();\n        let storage_scheme = merchant_context.get_merchant_account().storage_scheme;\n        let payment_intent = db\n            .find_payment_intent_by_id(\n                key_manager_state,\n                payment_id,\n                merchant_context.get_merchant_key_store(),\n                storage_scheme,\n            )\n            .await\n            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n        self.validate_status_for_operation(payment_intent.status)?;\n\n        let PaymentsUpdateIntentRequest {\n            amount_details,\n            routing_algorithm_id,\n            capture_method,\n            authentication_type,\n            billing,\n            shipping,\n            customer_present,\n            description,\n            return_url,\n            setup_future_usage,\n            apply_mit_exemption,\n            statement_descriptor,\n            order_details,\n            allowed_payment_method_types,\n            metadata,\n            connector_metadata,\n            feature_metadata,\n            payment_link_config,\n            request_incremental_authorization,\n            session_expiry,\n            frm_metadata,\n            request_external_three_ds_authentication,\n            set_active_attempt_id,\n            enable_partial_authorization,\n        } = request.clone();\n\n        let batch_encrypted_data = domain_types::crypto_operation(\n            key_manager_state,\n            common_utils::type_name!(hyperswitch_domain_models::payments::PaymentIntent),\n            domain_types::CryptoOperation::BatchEncrypt(\n                hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::to_encryptable(\n                    hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent {\n                        shipping_address: shipping.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable(\"Failed to encode shipping address\")?.map(masking::Secret::new),\n                        billing_address: billing.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable(\"Failed to encode billing address\")?.map(masking::Secret::new),\n                        customer_details: None,\n                    },\n                ),\n            ),\n            common_utils::types::keymanager::Identifier::Merchant(merchant_context.get_merchant_account().get_id().to_owned()),\n            merchant_context.get_merchant_key_store().key.peek(),\n        )\n        .await\n        .and_then(|val| val.try_into_batchoperation())\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed while encrypting payment intent details\".to_string())?;\n\n        let decrypted_payment_intent =\n             hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::from_encryptable(batch_encrypted_data)\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed while encrypting payment intent details\")?;\n\n        let order_details = order_details.clone().map(|order_details| {\n            order_details\n                .into_iter()\n                .map(|order_detail| {\n                    masking::Secret::new(\n                        diesel_models::types::OrderDetailsWithAmount::convert_from(order_detail),\n                    )\n                })\n                .collect()\n        });\n\n        let session_expiry = session_expiry.map(|expiry| {\n            payment_intent\n                .created_at\n                .saturating_add(time::Duration::seconds(i64::from(expiry)))\n        });\n\n        let updated_amount_details = match amount_details {\n            Some(details) => payment_intent.amount_details.update_from_request(&details),\n            None => payment_intent.amount_details,\n        };\n\n        let active_attempt_id = set_active_attempt_id\n            .map(|active_attempt_req| match active_attempt_req {\n                UpdateActiveAttempt::Set(global_attempt_id) => Some(global_attempt_id),\n                UpdateActiveAttempt::Unset => None,\n            })\n            .unwrap_or(payment_intent.active_attempt_id);\n\n        let payment_intent = hyperswitch_domain_models::payments::PaymentIntent {\n            amount_details: updated_amount_details,\n            description: description.or(payment_intent.description),\n            return_url: return_url.or(payment_intent.return_url),\n            metadata: metadata.or(payment_intent.metadata),\n            statement_descriptor: statement_descriptor.or(payment_intent.statement_descriptor),\n            modified_at: common_utils::date_time::now(),\n            order_details,\n            connector_metadata: connector_metadata.or(payment_intent.connector_metadata),\n            feature_metadata: (feature_metadata\n                .map(FeatureMetadata::convert_from)\n                .or(payment_intent.feature_metadata)),\n            updated_by: storage_scheme.to_string(),\n            request_incremental_authorization: request_incremental_authorization\n                .unwrap_or(payment_intent.request_incremental_authorization),\n            session_expiry: session_expiry.unwrap_or(payment_intent.session_expiry),\n            request_external_three_ds_authentication: request_external_three_ds_authentication\n                .unwrap_or(payment_intent.request_external_three_ds_authentication),\n            frm_metadata: frm_metadata.or(payment_intent.frm_metadata),\n            billing_address: decrypted_payment_intent\n                .billing_address\n                .as_ref()\n                .map(|data| {\n                    data.clone()\n                        .deserialize_inner_value(|value| value.parse_value(\"Address\"))\n                })\n                .transpose()\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unable to decode billing address\")?,\n            shipping_address: decrypted_payment_intent\n                .shipping_address\n                .as_ref()\n                .map(|data| {\n                    data.clone()\n                        .deserialize_inner_value(|value| value.parse_value(\"Address\"))\n                })\n                .transpose()\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unable to decode shipping address\")?,\n            capture_method: capture_method.unwrap_or(payment_intent.capture_method),\n            authentication_type: authentication_type.or(payment_intent.authentication_type),\n            payment_link_config: payment_link_config\n                .map(ApiModelToDieselModelConvertor::convert_from)\n                .or(payment_intent.payment_link_config),\n            apply_mit_exemption: apply_mit_exemption.unwrap_or(payment_intent.apply_mit_exemption),\n            customer_present: customer_present.unwrap_or(payment_intent.customer_present),\n            routing_algorithm_id: routing_algorithm_id.or(payment_intent.routing_algorithm_id),\n            allowed_payment_method_types: allowed_payment_method_types\n                .or(payment_intent.allowed_payment_method_types),\n            active_attempt_id,\n            enable_partial_authorization: enable_partial_authorization\n                .or(payment_intent.enable_partial_authorization),\n            setup_future_usage: setup_future_usage\n            .unwrap_or(payment_intent.setup_future_usage),\n            ..payment_intent\n        };\n\n        let payment_data = payments::PaymentIntentData {\n            flow: PhantomData,\n            payment_intent,\n            client_secret: None,\n            sessions_token: vec![],\n            vault_session_details: None,\n            connector_customer_id: None,\n        };\n\n        let get_trackers_response = operations::GetTrackerResponse { payment_data };\n\n        Ok(get_trackers_response)\n    }",
+      "after_code": "async fn get_trackers<'a>(\n        &'a self,\n        state: &'a SessionState,\n        payment_id: &common_utils::id_type::GlobalPaymentId,\n        request: &PaymentsUpdateIntentRequest,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        _header_payload: &hyperswitch_domain_models::payments::HeaderPayload,\n    ) -> RouterResult<operations::GetTrackerResponse<payments::PaymentIntentData<F>>> {\n        let db = &*state.store;\n        if let Some(routing_algorithm_id) = request.routing_algorithm_id.as_ref() {\n            helpers::validate_routing_id_with_profile_id(\n                db,\n                routing_algorithm_id,\n                profile.get_id(),\n            )\n            .await?;\n        }\n        let key_manager_state = &state.into();\n        let storage_scheme = merchant_context.get_merchant_account().storage_scheme;\n        let payment_intent = db\n            .find_payment_intent_by_id(\n                key_manager_state,\n                payment_id,\n                merchant_context.get_merchant_key_store(),\n                storage_scheme,\n            )\n            .await\n            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n        self.validate_status_for_operation(payment_intent.status)?;\n\n        let PaymentsUpdateIntentRequest {\n            amount_details,\n            routing_algorithm_id,\n            capture_method,\n            authentication_type,\n            billing,\n            shipping,\n            customer_present,\n            description,\n            return_url,\n            setup_future_usage,\n            apply_mit_exemption,\n            statement_descriptor,\n            order_details,\n            allowed_payment_method_types,\n            metadata,\n            connector_metadata,\n            feature_metadata,\n            payment_link_config,\n            request_incremental_authorization,\n            session_expiry,\n            frm_metadata,\n            request_external_three_ds_authentication,\n            set_active_attempt_id,\n            enable_partial_authorization,\n        } = request.clone();\n\n        let batch_encrypted_data = domain_types::crypto_operation(\n            key_manager_state,\n            common_utils::type_name!(hyperswitch_domain_models::payments::PaymentIntent),\n            domain_types::CryptoOperation::BatchEncrypt(\n                hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::to_encryptable(\n                    hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent {\n                        shipping_address: shipping.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable(\"Failed to encode shipping address\")?.map(masking::Secret::new),\n                        billing_address: billing.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable(\"Failed to encode billing address\")?.map(masking::Secret::new),\n                        customer_details: None,\n                    },\n                ),\n            ),\n            common_utils::types::keymanager::Identifier::Merchant(merchant_context.get_merchant_account().get_id().to_owned()),\n            merchant_context.get_merchant_key_store().key.peek(),\n        )\n        .await\n        .and_then(|val| val.try_into_batchoperation())\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed while encrypting payment intent details\".to_string())?;\n\n        let decrypted_payment_intent =\n             hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::from_encryptable(batch_encrypted_data)\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed while encrypting payment intent details\")?;\n\n        let order_details = order_details.clone().map(|order_details| {\n            order_details\n                .into_iter()\n                .map(|order_detail| {\n                    masking::Secret::new(\n                        diesel_models::types::OrderDetailsWithAmount::convert_from(order_detail),\n                    )\n                })\n                .collect()\n        });\n\n        let session_expiry = session_expiry.map(|expiry| {\n            payment_intent\n                .created_at\n                .saturating_add(time::Duration::seconds(i64::from(expiry)))\n        });\n\n        let updated_amount_details = match amount_details {\n            Some(details) => payment_intent.amount_details.update_from_request(&details),\n            None => payment_intent.amount_details,\n        };\n\n        let active_attempt_id = set_active_attempt_id\n            .map(|active_attempt_req| match active_attempt_req {\n                UpdateActiveAttempt::Set(global_attempt_id) => Some(global_attempt_id),\n                UpdateActiveAttempt::Unset => None,\n            })\n            .unwrap_or(payment_intent.active_attempt_id);\n\n        let payment_intent = hyperswitch_domain_models::payments::PaymentIntent {\n            amount_details: updated_amount_details,\n            description: description.or(payment_intent.description),\n            return_url: return_url.or(payment_intent.return_url),\n            metadata: metadata.or(payment_intent.metadata),\n            statement_descriptor: statement_descriptor.or(payment_intent.statement_descriptor),\n            modified_at: common_utils::date_time::now(),\n            order_details,\n            connector_metadata: connector_metadata.or(payment_intent.connector_metadata),\n            feature_metadata: (feature_metadata\n                .map(FeatureMetadata::convert_from)\n                .or(payment_intent.feature_metadata)),\n            updated_by: storage_scheme.to_string(),\n            request_incremental_authorization: request_incremental_authorization\n                .unwrap_or(payment_intent.request_incremental_authorization),\n            session_expiry: session_expiry.unwrap_or(payment_intent.session_expiry),\n            request_external_three_ds_authentication: request_external_three_ds_authentication\n                .unwrap_or(payment_intent.request_external_three_ds_authentication),\n            frm_metadata: frm_metadata.or(payment_intent.frm_metadata),\n            billing_address: decrypted_payment_intent\n                .billing_address\n                .as_ref()\n                .map(|data| {\n                    data.clone()\n                        .deserialize_inner_value(|value| value.parse_value(\"Address\"))\n                })\n                .transpose()\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unable to decode billing address\")?,\n            shipping_address: decrypted_payment_intent\n                .shipping_address\n                .as_ref()\n                .map(|data| {\n                    data.clone()\n                        .deserialize_inner_value(|value| value.parse_value(\"Address\"))\n                })\n                .transpose()\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unable to decode shipping address\")?,\n            capture_method: capture_method.unwrap_or(payment_intent.capture_method),\n            authentication_type: authentication_type.or(payment_intent.authentication_type),\n            payment_link_config: payment_link_config\n                .map(ApiModelToDieselModelConvertor::convert_from)\n                .or(payment_intent.payment_link_config),\n            apply_mit_exemption: apply_mit_exemption.unwrap_or(payment_intent.apply_mit_exemption),\n            customer_present: customer_present.unwrap_or(payment_intent.customer_present),\n            routing_algorithm_id: routing_algorithm_id.or(payment_intent.routing_algorithm_id),\n            allowed_payment_method_types: allowed_payment_method_types\n                .or(payment_intent.allowed_payment_method_types),\n            active_attempt_id,\n            enable_partial_authorization: enable_partial_authorization\n                .or(payment_intent.enable_partial_authorization),\n            setup_future_usage: setup_future_usage.unwrap_or(payment_intent.setup_future_usage),\n            ..payment_intent\n        };\n\n        let payment_data = payments::PaymentIntentData {\n            flow: PhantomData,\n            payment_intent,\n            client_secret: None,\n            sessions_token: vec![],\n            vault_session_details: None,\n            connector_customer_id: None,\n        };\n\n        let get_trackers_response = operations::GetTrackerResponse { payment_data };\n\n        Ok(get_trackers_response)\n    }",
+      "diff_span": {
+        "before": "            enable_partial_authorization: enable_partial_authorization\n                .or(payment_intent.enable_partial_authorization),\n            setup_future_usage: setup_future_usage\n            .unwrap_or(payment_intent.setup_future_usage),\n            ..payment_intent\n        };",
+        "after": "            enable_partial_authorization: enable_partial_authorization\n                .or(payment_intent.enable_partial_authorization),\n            setup_future_usage: setup_future_usage.unwrap_or(payment_intent.setup_future_usage),\n            ..payment_intent\n        };"
+      },
+      "commit_sha": "d710641b98c3220de2825de46746c3c462b08efc"
+    }
+  ]
+}

diffs/pr_10243/e5438e7/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "e5438e79fabe4c994569c6605e39e9eb5b088228",
+  "pr_number": 10243,
+  "rust_files": [
+    "crates/router/src/core/payments/operations/payment_update_intent.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments/operations/payment_update_intent.rs::PaymentUpdateIntent::function::get_trackers",
+      "file": "crates/router/src/core/payments/operations/payment_update_intent.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn get_trackers<'a>(\n        &'a self,\n        state: &'a SessionState,\n        payment_id: &common_utils::id_type::GlobalPaymentId,\n        request: &PaymentsUpdateIntentRequest,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        _header_payload: &hyperswitch_domain_models::payments::HeaderPayload,\n    ) -> RouterResult<operations::GetTrackerResponse<payments::PaymentIntentData<F>>> {\n        let db = &*state.store;\n        if let Some(routing_algorithm_id) = request.routing_algorithm_id.as_ref() {\n            helpers::validate_routing_id_with_profile_id(\n                db,\n                routing_algorithm_id,\n                profile.get_id(),\n            )\n            .await?;\n        }\n        let key_manager_state = &state.into();\n        let storage_scheme = merchant_context.get_merchant_account().storage_scheme;\n        let payment_intent = db\n            .find_payment_intent_by_id(\n                key_manager_state,\n                payment_id,\n                merchant_context.get_merchant_key_store(),\n                storage_scheme,\n            )\n            .await\n            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n        self.validate_status_for_operation(payment_intent.status)?;\n\n        let PaymentsUpdateIntentRequest {\n            amount_details,\n            routing_algorithm_id,\n            capture_method,\n            authentication_type,\n            billing,\n            shipping,\n            customer_present,\n            description,\n            return_url,\n            setup_future_usage,\n            apply_mit_exemption,\n            statement_descriptor,\n            order_details,\n            allowed_payment_method_types,\n            metadata,\n            connector_metadata,\n            feature_metadata,\n            payment_link_config,\n            request_incremental_authorization,\n            session_expiry,\n            frm_metadata,\n            request_external_three_ds_authentication,\n            set_active_attempt_id,\n            enable_partial_authorization,\n        } = request.clone();\n\n        let batch_encrypted_data = domain_types::crypto_operation(\n            key_manager_state,\n            common_utils::type_name!(hyperswitch_domain_models::payments::PaymentIntent),\n            domain_types::CryptoOperation::BatchEncrypt(\n                hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::to_encryptable(\n                    hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent {\n                        shipping_address: shipping.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable(\"Failed to encode shipping address\")?.map(masking::Secret::new),\n                        billing_address: billing.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable(\"Failed to encode billing address\")?.map(masking::Secret::new),\n                        customer_details: None,\n                    },\n                ),\n            ),\n            common_utils::types::keymanager::Identifier::Merchant(merchant_context.get_merchant_account().get_id().to_owned()),\n            merchant_context.get_merchant_key_store().key.peek(),\n        )\n        .await\n        .and_then(|val| val.try_into_batchoperation())\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed while encrypting payment intent details\".to_string())?;\n\n        let decrypted_payment_intent =\n             hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::from_encryptable(batch_encrypted_data)\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed while encrypting payment intent details\")?;\n\n        let order_details = order_details.clone().map(|order_details| {\n            order_details\n                .into_iter()\n                .map(|order_detail| {\n                    masking::Secret::new(\n                        diesel_models::types::OrderDetailsWithAmount::convert_from(order_detail),\n                    )\n                })\n                .collect()\n        });\n\n        let session_expiry = session_expiry.map(|expiry| {\n            payment_intent\n                .created_at\n                .saturating_add(time::Duration::seconds(i64::from(expiry)))\n        });\n\n        let updated_amount_details = match amount_details {\n            Some(details) => payment_intent.amount_details.update_from_request(&details),\n            None => payment_intent.amount_details,\n        };\n\n        let active_attempt_id = set_active_attempt_id\n            .map(|active_attempt_req| match active_attempt_req {\n                UpdateActiveAttempt::Set(global_attempt_id) => Some(global_attempt_id),\n                UpdateActiveAttempt::Unset => None,\n            })\n            .unwrap_or(payment_intent.active_attempt_id);\n\n        let payment_intent = hyperswitch_domain_models::payments::PaymentIntent {\n            amount_details: updated_amount_details,\n            description: description.or(payment_intent.description),\n            return_url: return_url.or(payment_intent.return_url),\n            metadata: metadata.or(payment_intent.metadata),\n            statement_descriptor: statement_descriptor.or(payment_intent.statement_descriptor),\n            modified_at: common_utils::date_time::now(),\n            order_details,\n            connector_metadata: connector_metadata.or(payment_intent.connector_metadata),\n            feature_metadata: (feature_metadata\n                .map(FeatureMetadata::convert_from)\n                .or(payment_intent.feature_metadata)),\n            updated_by: storage_scheme.to_string(),\n            request_incremental_authorization: request_incremental_authorization\n                .unwrap_or(payment_intent.request_incremental_authorization),\n            session_expiry: session_expiry.unwrap_or(payment_intent.session_expiry),\n            request_external_three_ds_authentication: request_external_three_ds_authentication\n                .unwrap_or(payment_intent.request_external_three_ds_authentication),\n            frm_metadata: frm_metadata.or(payment_intent.frm_metadata),\n            billing_address: decrypted_payment_intent\n                .billing_address\n                .as_ref()\n                .map(|data| {\n                    data.clone()\n                        .deserialize_inner_value(|value| value.parse_value(\"Address\"))\n                })\n                .transpose()\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unable to decode billing address\")?,\n            shipping_address: decrypted_payment_intent\n                .shipping_address\n                .as_ref()\n                .map(|data| {\n                    data.clone()\n                        .deserialize_inner_value(|value| value.parse_value(\"Address\"))\n                })\n                .transpose()\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unable to decode shipping address\")?,\n            capture_method: capture_method.unwrap_or(payment_intent.capture_method),\n            authentication_type: authentication_type.or(payment_intent.authentication_type),\n            payment_link_config: payment_link_config\n                .map(ApiModelToDieselModelConvertor::convert_from)\n                .or(payment_intent.payment_link_config),\n            apply_mit_exemption: apply_mit_exemption.unwrap_or(payment_intent.apply_mit_exemption),\n            customer_present: customer_present.unwrap_or(payment_intent.customer_present),\n            routing_algorithm_id: routing_algorithm_id.or(payment_intent.routing_algorithm_id),\n            allowed_payment_method_types: allowed_payment_method_types\n                .or(payment_intent.allowed_payment_method_types),\n            active_attempt_id,\n            enable_partial_authorization: enable_partial_authorization\n                .or(payment_intent.enable_partial_authorization),\n            ..payment_intent\n        };\n\n        let payment_data = payments::PaymentIntentData {\n            flow: PhantomData,\n            payment_intent,\n            client_secret: None,\n            sessions_token: vec![],\n            vault_session_details: None,\n            connector_customer_id: None,\n        };\n\n        let get_trackers_response = operations::GetTrackerResponse { payment_data };\n\n        Ok(get_trackers_response)\n    }",
+      "after_code": "async fn get_trackers<'a>(\n        &'a self,\n        state: &'a SessionState,\n        payment_id: &common_utils::id_type::GlobalPaymentId,\n        request: &PaymentsUpdateIntentRequest,\n        merchant_context: &domain::MerchantContext,\n        profile: &domain::Profile,\n        _header_payload: &hyperswitch_domain_models::payments::HeaderPayload,\n    ) -> RouterResult<operations::GetTrackerResponse<payments::PaymentIntentData<F>>> {\n        let db = &*state.store;\n        if let Some(routing_algorithm_id) = request.routing_algorithm_id.as_ref() {\n            helpers::validate_routing_id_with_profile_id(\n                db,\n                routing_algorithm_id,\n                profile.get_id(),\n            )\n            .await?;\n        }\n        let key_manager_state = &state.into();\n        let storage_scheme = merchant_context.get_merchant_account().storage_scheme;\n        let payment_intent = db\n            .find_payment_intent_by_id(\n                key_manager_state,\n                payment_id,\n                merchant_context.get_merchant_key_store(),\n                storage_scheme,\n            )\n            .await\n            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n        self.validate_status_for_operation(payment_intent.status)?;\n\n        let PaymentsUpdateIntentRequest {\n            amount_details,\n            routing_algorithm_id,\n            capture_method,\n            authentication_type,\n            billing,\n            shipping,\n            customer_present,\n            description,\n            return_url,\n            setup_future_usage,\n            apply_mit_exemption,\n            statement_descriptor,\n            order_details,\n            allowed_payment_method_types,\n            metadata,\n            connector_metadata,\n            feature_metadata,\n            payment_link_config,\n            request_incremental_authorization,\n            session_expiry,\n            frm_metadata,\n            request_external_three_ds_authentication,\n            set_active_attempt_id,\n            enable_partial_authorization,\n        } = request.clone();\n\n        let batch_encrypted_data = domain_types::crypto_operation(\n            key_manager_state,\n            common_utils::type_name!(hyperswitch_domain_models::payments::PaymentIntent),\n            domain_types::CryptoOperation::BatchEncrypt(\n                hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::to_encryptable(\n                    hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent {\n                        shipping_address: shipping.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable(\"Failed to encode shipping address\")?.map(masking::Secret::new),\n                        billing_address: billing.map(|address| address.encode_to_value()).transpose().change_context(errors::ApiErrorResponse::InternalServerError).attach_printable(\"Failed to encode billing address\")?.map(masking::Secret::new),\n                        customer_details: None,\n                    },\n                ),\n            ),\n            common_utils::types::keymanager::Identifier::Merchant(merchant_context.get_merchant_account().get_id().to_owned()),\n            merchant_context.get_merchant_key_store().key.peek(),\n        )\n        .await\n        .and_then(|val| val.try_into_batchoperation())\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed while encrypting payment intent details\".to_string())?;\n\n        let decrypted_payment_intent =\n             hyperswitch_domain_models::payments::FromRequestEncryptablePaymentIntent::from_encryptable(batch_encrypted_data)\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed while encrypting payment intent details\")?;\n\n        let order_details = order_details.clone().map(|order_details| {\n            order_details\n                .into_iter()\n                .map(|order_detail| {\n                    masking::Secret::new(\n                        diesel_models::types::OrderDetailsWithAmount::convert_from(order_detail),\n                    )\n                })\n                .collect()\n        });\n\n        let session_expiry = session_expiry.map(|expiry| {\n            payment_intent\n                .created_at\n                .saturating_add(time::Duration::seconds(i64::from(expiry)))\n        });\n\n        let updated_amount_details = match amount_details {\n            Some(details) => payment_intent.amount_details.update_from_request(&details),\n            None => payment_intent.amount_details,\n        };\n\n        let active_attempt_id = set_active_attempt_id\n            .map(|active_attempt_req| match active_attempt_req {\n                UpdateActiveAttempt::Set(global_attempt_id) => Some(global_attempt_id),\n                UpdateActiveAttempt::Unset => None,\n            })\n            .unwrap_or(payment_intent.active_attempt_id);\n\n        let payment_intent = hyperswitch_domain_models::payments::PaymentIntent {\n            amount_details: updated_amount_details,\n            description: description.or(payment_intent.description),\n            return_url: return_url.or(payment_intent.return_url),\n            metadata: metadata.or(payment_intent.metadata),\n            statement_descriptor: statement_descriptor.or(payment_intent.statement_descriptor),\n            modified_at: common_utils::date_time::now(),\n            order_details,\n            connector_metadata: connector_metadata.or(payment_intent.connector_metadata),\n            feature_metadata: (feature_metadata\n                .map(FeatureMetadata::convert_from)\n                .or(payment_intent.feature_metadata)),\n            updated_by: storage_scheme.to_string(),\n            request_incremental_authorization: request_incremental_authorization\n                .unwrap_or(payment_intent.request_incremental_authorization),\n            session_expiry: session_expiry.unwrap_or(payment_intent.session_expiry),\n            request_external_three_ds_authentication: request_external_three_ds_authentication\n                .unwrap_or(payment_intent.request_external_three_ds_authentication),\n            frm_metadata: frm_metadata.or(payment_intent.frm_metadata),\n            billing_address: decrypted_payment_intent\n                .billing_address\n                .as_ref()\n                .map(|data| {\n                    data.clone()\n                        .deserialize_inner_value(|value| value.parse_value(\"Address\"))\n                })\n                .transpose()\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unable to decode billing address\")?,\n            shipping_address: decrypted_payment_intent\n                .shipping_address\n                .as_ref()\n                .map(|data| {\n                    data.clone()\n                        .deserialize_inner_value(|value| value.parse_value(\"Address\"))\n                })\n                .transpose()\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Unable to decode shipping address\")?,\n            capture_method: capture_method.unwrap_or(payment_intent.capture_method),\n            authentication_type: authentication_type.or(payment_intent.authentication_type),\n            payment_link_config: payment_link_config\n                .map(ApiModelToDieselModelConvertor::convert_from)\n                .or(payment_intent.payment_link_config),\n            apply_mit_exemption: apply_mit_exemption.unwrap_or(payment_intent.apply_mit_exemption),\n            customer_present: customer_present.unwrap_or(payment_intent.customer_present),\n            routing_algorithm_id: routing_algorithm_id.or(payment_intent.routing_algorithm_id),\n            allowed_payment_method_types: allowed_payment_method_types\n                .or(payment_intent.allowed_payment_method_types),\n            active_attempt_id,\n            enable_partial_authorization: enable_partial_authorization\n                .or(payment_intent.enable_partial_authorization),\n            setup_future_usage: setup_future_usage\n            .unwrap_or(payment_intent.setup_future_usage),\n            ..payment_intent\n        };\n\n        let payment_data = payments::PaymentIntentData {\n            flow: PhantomData,\n            payment_intent,\n            client_secret: None,\n            sessions_token: vec![],\n            vault_session_details: None,\n            connector_customer_id: None,\n        };\n\n        let get_trackers_response = operations::GetTrackerResponse { payment_data };\n\n        Ok(get_trackers_response)\n    }",
+      "diff_span": {
+        "before": "",
+        "after": "            enable_partial_authorization: enable_partial_authorization\n                .or(payment_intent.enable_partial_authorization),\n            setup_future_usage: setup_future_usage\n            .unwrap_or(payment_intent.setup_future_usage),\n            ..payment_intent\n        };"
+      },
+      "commit_sha": "e5438e79fabe4c994569c6605e39e9eb5b088228"
+    }
+  ]
+}

diffs/pr_10290/4014cd4/diff.json

@@ -0,0 +1,40 @@
+{
+  "commit_sha": "4014cd4da594989de641c4d55c017f5a1d465cf6",
+  "pr_number": 10290,
+  "rust_files": [
+    "crates/euclid/src/frontend/ast/lowering.rs",
+    "crates/euclid_wasm/src/lib.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/euclid/src/frontend/ast/lowering.rs::function::lower_comparison_inner",
+      "file": "crates/euclid/src/frontend/ast/lowering.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn lower_comparison_inner<O: EuclidDirFilter>(\n    comp: ast::Comparison,\n) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {\n    let key_enum = dir::DirKeyKind::from_str(comp.lhs.as_str())\n        .map_err(|_| AnalysisErrorType::InvalidKey(comp.lhs.clone()))?;\n\n    println!(\">>>>>>>>>>code reaches here\");\n    println!(\">>>>>>>>>> {:?}\", comp);\n    if !O::is_key_allowed(&key_enum) {\n        return Err(AnalysisErrorType::InvalidKey(key_enum.to_string()));\n    }\n\n    match (&comp.comparison, &comp.value) {\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::EnumVariant(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::EnumVariant,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::NumberArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::Number,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::EnumVariantArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::EnumVariant,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::NumberComparisonArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::Number,\n            })?;\n        }\n\n        _ => {}\n    }\n\n    let value = comp.value;\n    let comparison = comp.comparison;\n\n    println!(\">>>>>>>>>>code reaches here\");\n    match key_enum {\n        dir::DirKeyKind::PaymentMethod => lower_enum!(PaymentMethod, value),\n        dir::DirKeyKind::CardType => lower_enum!(CardType, value),\n        dir::DirKeyKind::CardNetwork => lower_enum!(CardNetwork, value),\n        dir::DirKeyKind::PayLaterType => lower_enum!(PayLaterType, value),\n        dir::DirKeyKind::WalletType => lower_enum!(WalletType, value),\n        dir::DirKeyKind::BankDebitType => lower_enum!(BankDebitType, value),\n        dir::DirKeyKind::BankRedirectType => lower_enum!(BankRedirectType, value),\n        dir::DirKeyKind::CryptoType => lower_enum!(CryptoType, value),\n        dir::DirKeyKind::PaymentType => lower_enum!(PaymentType, value),\n        dir::DirKeyKind::MandateType => lower_enum!(MandateType, value),\n        dir::DirKeyKind::MandateAcceptanceType => lower_enum!(MandateAcceptanceType, value),\n        dir::DirKeyKind::RewardType => lower_enum!(RewardType, value),\n        dir::DirKeyKind::PaymentCurrency => lower_enum!(PaymentCurrency, value),\n        dir::DirKeyKind::AuthenticationType => lower_enum!(AuthenticationType, value),\n        dir::DirKeyKind::CaptureMethod => lower_enum!(CaptureMethod, value),\n        dir::DirKeyKind::BusinessCountry => lower_enum!(BusinessCountry, value),\n        dir::DirKeyKind::BillingCountry => lower_enum!(BillingCountry, value),\n        dir::DirKeyKind::SetupFutureUsage => lower_enum!(SetupFutureUsage, value),\n        dir::DirKeyKind::UpiType => lower_enum!(UpiType, value),\n        dir::DirKeyKind::OpenBankingType => lower_enum!(OpenBankingType, value),\n        dir::DirKeyKind::VoucherType => lower_enum!(VoucherType, value),\n        dir::DirKeyKind::GiftCardType => lower_enum!(GiftCardType, value),\n        dir::DirKeyKind::BankTransferType => lower_enum!(BankTransferType, value),\n        dir::DirKeyKind::CardRedirectType => lower_enum!(CardRedirectType, value),\n        dir::DirKeyKind::MobilePaymentType => lower_enum!(MobilePaymentType, value),\n        dir::DirKeyKind::RealTimePaymentType => lower_enum!(RealTimePaymentType, value),\n        dir::DirKeyKind::CardBin => {\n            let validation_closure = |st: &String| -> Result<(), AnalysisErrorType> {\n                if st.len() == 6 && st.chars().all(|x| x.is_ascii_digit()) {\n                    Ok(())\n                } else {\n                    Err(AnalysisErrorType::InvalidValue {\n                        key: dir::DirKeyKind::CardBin,\n                        value: st.clone(),\n                        message: Some(\"Expected 6 digits\".to_string()),\n                    })\n                }\n            };\n            lower_str!(CardBin, value, validation_closure)\n        }\n        dir::DirKeyKind::ExtendedCardBin => {\n            let validation_closure = |st: &String| -> Result<(), AnalysisErrorType> {\n                if st.len() == 8 && st.chars().all(|x| x.is_ascii_digit()) {\n                    Ok(())\n                } else {\n                    Err(AnalysisErrorType::InvalidValue {\n                        key: dir::DirKeyKind::ExtendedCardBin,\n                        value: st.clone(),\n                        message: Some(\"Expected 8 digits\".to_string()),\n                    })\n                }\n            };\n            lower_str!(ExtendedCardBin, value, validation_closure)\n        }\n        dir::DirKeyKind::BusinessLabel => lower_str!(BusinessLabel, value),\n        dir::DirKeyKind::MetaData => lower_metadata!(MetaData, value),\n        dir::DirKeyKind::PaymentAmount => lower_number!(PaymentAmount, value, comparison),\n        dir::DirKeyKind::Connector => Err(AnalysisErrorType::InvalidKey(\n            dir::DirKeyKind::Connector.to_string(),\n        )),\n        dir::DirKeyKind::IssuerName => lower_str!(IssuerName, value),\n        dir::DirKeyKind::IssuerCountry => lower_enum!(IssuerCountry, value),\n        dir::DirKeyKind::CustomerDevicePlatform => lower_enum!(CustomerDevicePlatform, value),\n        dir::DirKeyKind::CustomerDeviceType => lower_enum!(CustomerDeviceType, value),\n        dir::DirKeyKind::CustomerDeviceDisplaySize => lower_enum!(CustomerDeviceDisplaySize, value),\n        dir::DirKeyKind::AcquirerCountry => lower_enum!(AcquirerCountry, value),\n        dir::DirKeyKind::AcquirerFraudRate => lower_number!(AcquirerFraudRate, value, comparison),\n    }\n}",
+      "after_code": "fn lower_comparison_inner<O: EuclidDirFilter>(\n    comp: ast::Comparison,\n) -> Result<Vec<dir::DirValue>, AnalysisErrorType> {\n    let key_enum = dir::DirKeyKind::from_str(comp.lhs.as_str())\n        .map_err(|_| AnalysisErrorType::InvalidKey(comp.lhs.clone()))?;\n\n    if !O::is_key_allowed(&key_enum) {\n        return Err(AnalysisErrorType::InvalidKey(key_enum.to_string()));\n    }\n\n    match (&comp.comparison, &comp.value) {\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::EnumVariant(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::EnumVariant,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::NumberArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::Number,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::EnumVariantArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::EnumVariant,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::NumberComparisonArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::Number,\n            })?;\n        }\n\n        _ => {}\n    }\n\n    let value = comp.value;\n    let comparison = comp.comparison;\n\n    match key_enum {\n        dir::DirKeyKind::PaymentMethod => lower_enum!(PaymentMethod, value),\n        dir::DirKeyKind::CardType => lower_enum!(CardType, value),\n        dir::DirKeyKind::CardNetwork => lower_enum!(CardNetwork, value),\n        dir::DirKeyKind::PayLaterType => lower_enum!(PayLaterType, value),\n        dir::DirKeyKind::WalletType => lower_enum!(WalletType, value),\n        dir::DirKeyKind::BankDebitType => lower_enum!(BankDebitType, value),\n        dir::DirKeyKind::BankRedirectType => lower_enum!(BankRedirectType, value),\n        dir::DirKeyKind::CryptoType => lower_enum!(CryptoType, value),\n        dir::DirKeyKind::PaymentType => lower_enum!(PaymentType, value),\n        dir::DirKeyKind::MandateType => lower_enum!(MandateType, value),\n        dir::DirKeyKind::MandateAcceptanceType => lower_enum!(MandateAcceptanceType, value),\n        dir::DirKeyKind::RewardType => lower_enum!(RewardType, value),\n        dir::DirKeyKind::PaymentCurrency => lower_enum!(PaymentCurrency, value),\n        dir::DirKeyKind::AuthenticationType => lower_enum!(AuthenticationType, value),\n        dir::DirKeyKind::CaptureMethod => lower_enum!(CaptureMethod, value),\n        dir::DirKeyKind::BusinessCountry => lower_enum!(BusinessCountry, value),\n        dir::DirKeyKind::BillingCountry => lower_enum!(BillingCountry, value),\n        dir::DirKeyKind::SetupFutureUsage => lower_enum!(SetupFutureUsage, value),\n        dir::DirKeyKind::UpiType => lower_enum!(UpiType, value),\n        dir::DirKeyKind::OpenBankingType => lower_enum!(OpenBankingType, value),\n        dir::DirKeyKind::VoucherType => lower_enum!(VoucherType, value),\n        dir::DirKeyKind::GiftCardType => lower_enum!(GiftCardType, value),\n        dir::DirKeyKind::BankTransferType => lower_enum!(BankTransferType, value),\n        dir::DirKeyKind::CardRedirectType => lower_enum!(CardRedirectType, value),\n        dir::DirKeyKind::MobilePaymentType => lower_enum!(MobilePaymentType, value),\n        dir::DirKeyKind::RealTimePaymentType => lower_enum!(RealTimePaymentType, value),\n        dir::DirKeyKind::CardBin => {\n            let validation_closure = |st: &String| -> Result<(), AnalysisErrorType> {\n                if st.len() == 6 && st.chars().all(|x| x.is_ascii_digit()) {\n                    Ok(())\n                } else {\n                    Err(AnalysisErrorType::InvalidValue {\n                        key: dir::DirKeyKind::CardBin,\n                        value: st.clone(),\n                        message: Some(\"Expected 6 digits\".to_string()),\n                    })\n                }\n            };\n            lower_str!(CardBin, value, validation_closure)\n        }\n        dir::DirKeyKind::ExtendedCardBin => {\n            let validation_closure = |st: &String| -> Result<(), AnalysisErrorType> {\n                if st.len() == 8 && st.chars().all(|x| x.is_ascii_digit()) {\n                    Ok(())\n                } else {\n                    Err(AnalysisErrorType::InvalidValue {\n                        key: dir::DirKeyKind::ExtendedCardBin,\n                        value: st.clone(),\n                        message: Some(\"Expected 8 digits\".to_string()),\n                    })\n                }\n            };\n            lower_str!(ExtendedCardBin, value, validation_closure)\n        }\n        dir::DirKeyKind::BusinessLabel => lower_str!(BusinessLabel, value),\n        dir::DirKeyKind::MetaData => lower_metadata!(MetaData, value),\n        dir::DirKeyKind::PaymentAmount => lower_number!(PaymentAmount, value, comparison),\n        dir::DirKeyKind::Connector => Err(AnalysisErrorType::InvalidKey(\n            dir::DirKeyKind::Connector.to_string(),\n        )),\n        dir::DirKeyKind::IssuerName => lower_str!(IssuerName, value),\n        dir::DirKeyKind::IssuerCountry => lower_enum!(IssuerCountry, value),\n        dir::DirKeyKind::CustomerDevicePlatform => lower_enum!(CustomerDevicePlatform, value),\n        dir::DirKeyKind::CustomerDeviceType => lower_enum!(CustomerDeviceType, value),\n        dir::DirKeyKind::CustomerDeviceDisplaySize => lower_enum!(CustomerDeviceDisplaySize, value),\n        dir::DirKeyKind::AcquirerCountry => lower_enum!(AcquirerCountry, value),\n        dir::DirKeyKind::AcquirerFraudRate => lower_number!(AcquirerFraudRate, value, comparison),\n    }\n}",
+      "diff_span": {
+        "before": "        .map_err(|_| AnalysisErrorType::InvalidKey(comp.lhs.clone()))?;\n\n    println!(\">>>>>>>>>>code reaches here\");\n    println!(\">>>>>>>>>> {:?}\", comp);\n    if !O::is_key_allowed(&key_enum) {\n        return Err(AnalysisErrorType::InvalidKey(key_enum.to_string()));\n    }\n\n    match (&comp.comparison, &comp.value) {\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::EnumVariant(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::EnumVariant,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::NumberArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::Number,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::EnumVariantArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::EnumVariant,\n            })?;\n        }\n\n        (\n            ast::ComparisonType::LessThan\n            | ast::ComparisonType::GreaterThan\n            | ast::ComparisonType::GreaterThanEqual\n            | ast::ComparisonType::LessThanEqual,\n            ast::ValueType::NumberComparisonArray(_),\n        ) => {\n            Err(AnalysisErrorType::InvalidComparison {\n                operator: comp.comparison.clone(),\n                value_type: DataType::Number,\n            })?;\n        }\n\n        _ => {}\n    }\n\n    let value = comp.value;\n    let comparison = comp.comparison;\n\n    println!(\">>>>>>>>>>code reaches here\");\n    match key_enum {\n        dir::DirKeyKind::PaymentMethod => lower_enum!(PaymentMethod, value),",
+        "after": ""
+      },
+      "commit_sha": "4014cd4da594989de641c4d55c017f5a1d465cf6"
+    },
+    {
+      "id": "crates/euclid_wasm/src/lib.rs::function::get_variant_values",
+      "file": "crates/euclid_wasm/src/lib.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_variant_values(key: &str) -> Result<JsValue, JsValue> {\n    let key = dir::DirKeyKind::from_str(key).map_err(|_| \"Invalid key received\".to_string())?;\n\n    let variants: &[&str] = match key {\n        dir::DirKeyKind::PaymentMethod => dir_enums::PaymentMethod::VARIANTS,\n        dir::DirKeyKind::CardType => dir_enums::CardType::VARIANTS,\n        dir::DirKeyKind::CardNetwork => dir_enums::CardNetwork::VARIANTS,\n        dir::DirKeyKind::PayLaterType => dir_enums::PayLaterType::VARIANTS,\n        dir::DirKeyKind::WalletType => dir_enums::WalletType::VARIANTS,\n        dir::DirKeyKind::BankRedirectType => dir_enums::BankRedirectType::VARIANTS,\n        dir::DirKeyKind::CryptoType => dir_enums::CryptoType::VARIANTS,\n        dir::DirKeyKind::RewardType => dir_enums::RewardType::VARIANTS,\n        dir::DirKeyKind::AuthenticationType => dir_enums::AuthenticationType::VARIANTS,\n        dir::DirKeyKind::CaptureMethod => dir_enums::CaptureMethod::VARIANTS,\n        dir::DirKeyKind::PaymentCurrency => dir_enums::PaymentCurrency::VARIANTS,\n        dir::DirKeyKind::BusinessCountry => dir_enums::Country::VARIANTS,\n        dir::DirKeyKind::BillingCountry => dir_enums::Country::VARIANTS,\n        dir::DirKeyKind::BankTransferType => dir_enums::BankTransferType::VARIANTS,\n        dir::DirKeyKind::UpiType => dir_enums::UpiType::VARIANTS,\n        dir::DirKeyKind::SetupFutureUsage => dir_enums::SetupFutureUsage::VARIANTS,\n        dir::DirKeyKind::PaymentType => dir_enums::PaymentType::VARIANTS,\n        dir::DirKeyKind::MandateType => dir_enums::MandateType::VARIANTS,\n        dir::DirKeyKind::MandateAcceptanceType => dir_enums::MandateAcceptanceType::VARIANTS,\n        dir::DirKeyKind::CardRedirectType => dir_enums::CardRedirectType::VARIANTS,\n        dir::DirKeyKind::GiftCardType => dir_enums::GiftCardType::VARIANTS,\n        dir::DirKeyKind::VoucherType => dir_enums::VoucherType::VARIANTS,\n        dir::DirKeyKind::BankDebitType => dir_enums::BankDebitType::VARIANTS,\n        dir::DirKeyKind::RealTimePaymentType => dir_enums::RealTimePaymentType::VARIANTS,\n        dir::DirKeyKind::OpenBankingType => dir_enums::OpenBankingType::VARIANTS,\n        dir::DirKeyKind::MobilePaymentType => dir_enums::MobilePaymentType::VARIANTS,\n        dir::DirKeyKind::IssuerCountry => dir_enums::Country::VARIANTS,\n        dir::DirKeyKind::AcquirerCountry => dir_enums::Country::VARIANTS,\n        dir::DirKeyKind::CustomerDeviceType => dir_enums::CustomerDeviceType::VARIANTS,\n        dir::DirKeyKind::CustomerDevicePlatform => dir_enums::CustomerDevicePlatform::VARIANTS,\n        dir::DirKeyKind::CustomerDeviceDisplaySize => {\n            dir_enums::CustomerDeviceDisplaySize::VARIANTS\n        }\n\n        dir::DirKeyKind::PaymentAmount\n        | dir::DirKeyKind::Connector\n        | dir::DirKeyKind::CardBin\n        | dir::DirKeyKind::BusinessLabel\n        | dir::DirKeyKind::MetaData\n        | dir::DirKeyKind::IssuerName\n        | dir::DirKeyKind::AcquirerFraudRate => Err(\"Key does not have variants\".to_string())?,\n    };\n\n    Ok(serde_wasm_bindgen::to_value(variants)?)\n}",
+      "after_code": "pub fn get_variant_values(key: &str) -> Result<JsValue, JsValue> {\n    let key = dir::DirKeyKind::from_str(key).map_err(|_| \"Invalid key received\".to_string())?;\n\n    let variants: &[&str] = match key {\n        dir::DirKeyKind::PaymentMethod => dir_enums::PaymentMethod::VARIANTS,\n        dir::DirKeyKind::CardType => dir_enums::CardType::VARIANTS,\n        dir::DirKeyKind::CardNetwork => dir_enums::CardNetwork::VARIANTS,\n        dir::DirKeyKind::PayLaterType => dir_enums::PayLaterType::VARIANTS,\n        dir::DirKeyKind::WalletType => dir_enums::WalletType::VARIANTS,\n        dir::DirKeyKind::BankRedirectType => dir_enums::BankRedirectType::VARIANTS,\n        dir::DirKeyKind::CryptoType => dir_enums::CryptoType::VARIANTS,\n        dir::DirKeyKind::RewardType => dir_enums::RewardType::VARIANTS,\n        dir::DirKeyKind::AuthenticationType => dir_enums::AuthenticationType::VARIANTS,\n        dir::DirKeyKind::CaptureMethod => dir_enums::CaptureMethod::VARIANTS,\n        dir::DirKeyKind::PaymentCurrency => dir_enums::PaymentCurrency::VARIANTS,\n        dir::DirKeyKind::BusinessCountry => dir_enums::Country::VARIANTS,\n        dir::DirKeyKind::BillingCountry => dir_enums::Country::VARIANTS,\n        dir::DirKeyKind::BankTransferType => dir_enums::BankTransferType::VARIANTS,\n        dir::DirKeyKind::UpiType => dir_enums::UpiType::VARIANTS,\n        dir::DirKeyKind::SetupFutureUsage => dir_enums::SetupFutureUsage::VARIANTS,\n        dir::DirKeyKind::PaymentType => dir_enums::PaymentType::VARIANTS,\n        dir::DirKeyKind::MandateType => dir_enums::MandateType::VARIANTS,\n        dir::DirKeyKind::MandateAcceptanceType => dir_enums::MandateAcceptanceType::VARIANTS,\n        dir::DirKeyKind::CardRedirectType => dir_enums::CardRedirectType::VARIANTS,\n        dir::DirKeyKind::GiftCardType => dir_enums::GiftCardType::VARIANTS,\n        dir::DirKeyKind::VoucherType => dir_enums::VoucherType::VARIANTS,\n        dir::DirKeyKind::BankDebitType => dir_enums::BankDebitType::VARIANTS,\n        dir::DirKeyKind::RealTimePaymentType => dir_enums::RealTimePaymentType::VARIANTS,\n        dir::DirKeyKind::OpenBankingType => dir_enums::OpenBankingType::VARIANTS,\n        dir::DirKeyKind::MobilePaymentType => dir_enums::MobilePaymentType::VARIANTS,\n        dir::DirKeyKind::IssuerCountry => dir_enums::Country::VARIANTS,\n        dir::DirKeyKind::AcquirerCountry => dir_enums::Country::VARIANTS,\n        dir::DirKeyKind::CustomerDeviceType => dir_enums::CustomerDeviceType::VARIANTS,\n        dir::DirKeyKind::CustomerDevicePlatform => dir_enums::CustomerDevicePlatform::VARIANTS,\n        dir::DirKeyKind::CustomerDeviceDisplaySize => {\n            dir_enums::CustomerDeviceDisplaySize::VARIANTS\n        }\n\n        dir::DirKeyKind::PaymentAmount\n        | dir::DirKeyKind::Connector\n        | dir::DirKeyKind::CardBin\n        | dir::DirKeyKind::ExtendedCardBin\n        | dir::DirKeyKind::BusinessLabel\n        | dir::DirKeyKind::MetaData\n        | dir::DirKeyKind::IssuerName\n        | dir::DirKeyKind::AcquirerFraudRate => Err(\"Key does not have variants\".to_string())?,\n    };\n\n    Ok(serde_wasm_bindgen::to_value(variants)?)\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        | dir::DirKeyKind::Connector\n        | dir::DirKeyKind::CardBin\n        | dir::DirKeyKind::ExtendedCardBin\n        | dir::DirKeyKind::BusinessLabel\n        | dir::DirKeyKind::MetaData"
+      },
+      "commit_sha": "4014cd4da594989de641c4d55c017f5a1d465cf6"
+    }
+  ]
+}

diffs/pr_6687/00b465a/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "00b465a6acf53b66d2429b1b9d4bf828eddc4341",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/diesel_models/src/payment_method.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::PaymentMethod::function::get_common_mandate_reference",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_common_mandate_reference(\n        connector_mandate_details: Option<serde_json::Value>,\n    ) -> Result<CommonMandateReference, ParsingError> {\n        if let Some(value) = connector_mandate_details {\n            match serde_json::from_value::<CommonMandateReference>(value.clone()) {\n                Ok(common_mandate_reference) => Ok(common_mandate_reference),\n                Err(_) => match serde_json::from_value::<PaymentsMandateReference>(value.clone()) {\n                    Ok(payment_mandate_reference) => Ok(CommonMandateReference {\n                        payments: Some(payment_mandate_reference),\n                        payouts: None,\n                    }),\n                    Err(_) => Err(ParsingError::StructParseFailure(\n                        \"Failed to deserialize PaymentMethod\",\n                    ))?,\n                },\n            }\n        } else {\n            Ok(CommonMandateReference {\n                payments: None,\n                payouts: None,\n            })\n        }\n    }",
+      "after_code": "pub fn get_common_mandate_reference(\n        connector_mandate_details: Option<serde_json::Value>,\n    ) -> Result<CommonMandateReference, ParsingError> {\n        if let Some(value) = connector_mandate_details {\n            match serde_json::from_value::<PaymentsMandateReference>(value.clone()) {\n                Ok(payment_mandate_reference) => Ok(CommonMandateReference {\n                    payments: Some(payment_mandate_reference),\n                    payouts: None,\n                }),\n                Err(_) => match serde_json::from_value::<CommonMandateReference>(value.clone()) {\n                    Ok(common_mandate_reference) => Ok(common_mandate_reference),\n                    Err(_) => Err(ParsingError::StructParseFailure(\n                        \"Failed to deserialize PaymentMethod\",\n                    ))?,\n                },\n            }\n        } else {\n            Ok(CommonMandateReference {\n                payments: None,\n                payouts: None,\n            })\n        }\n    }",
+      "diff_span": {
+        "before": "    ) -> Result<CommonMandateReference, ParsingError> {\n        if let Some(value) = connector_mandate_details {\n            match serde_json::from_value::<CommonMandateReference>(value.clone()) {\n                Ok(common_mandate_reference) => Ok(common_mandate_reference),\n                Err(_) => match serde_json::from_value::<PaymentsMandateReference>(value.clone()) {\n                    Ok(payment_mandate_reference) => Ok(CommonMandateReference {\n                        payments: Some(payment_mandate_reference),\n                        payouts: None,\n                    }),\n                    Err(_) => Err(ParsingError::StructParseFailure(\n                        \"Failed to deserialize PaymentMethod\",",
+        "after": "    ) -> Result<CommonMandateReference, ParsingError> {\n        if let Some(value) = connector_mandate_details {\n            match serde_json::from_value::<PaymentsMandateReference>(value.clone()) {\n                Ok(payment_mandate_reference) => Ok(CommonMandateReference {\n                    payments: Some(payment_mandate_reference),\n                    payouts: None,\n                }),\n                Err(_) => match serde_json::from_value::<CommonMandateReference>(value.clone()) {\n                    Ok(common_mandate_reference) => Ok(common_mandate_reference),\n                    Err(_) => Err(ParsingError::StructParseFailure(\n                        \"Failed to deserialize PaymentMethod\","
+      },
+      "commit_sha": "00b465a6acf53b66d2429b1b9d4bf828eddc4341"
+    }
+  ]
+}

diffs/pr_6687/123b29f/diff.json

@@ -0,0 +1,139 @@
+{
+  "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/api_models/src/payment_methods.rs",
+    "crates/diesel_models/src/payment_method.rs",
+    "crates/hyperswitch_domain_models/src/payment_methods.rs",
+    "crates/router/src/core/payment_methods/cards.rs",
+    "crates/router/src/core/payments/tokenization.rs",
+    "crates/router/src/core/webhooks/incoming.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::CommonMandateReference::function::to_sql",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn to_sql<'b>(\n        &'b self,\n        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,\n    ) -> diesel::serialize::Result {\n        let value = serde_json::to_value(self)?;\n        <serde_json::Value as diesel::serialize::ToSql<\n            diesel::sql_types::Jsonb,\n            diesel::pg::Pg,\n        >>::to_sql(&value, &mut out.reborrow())\n    }",
+      "after_code": "fn to_sql<'b>(\n        &'b self,\n        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,\n    ) -> diesel::serialize::Result {\n        let mut payments = serde_json::to_value(self.payments.as_ref())?;\n        let payouts = serde_json::to_value(self.payouts.as_ref())?;\n\n        if let Some(payments_object) = payments.as_object_mut() {\n            payments_object.insert(\"payouts\".to_string(), payouts);\n        }\n\n        router_env::logger::info!(\"here  : {:?}\", payments.clone());\n        <serde_json::Value as diesel::serialize::ToSql<\n            diesel::sql_types::Jsonb,\n            diesel::pg::Pg,\n        >>::to_sql(&payments, &mut out.reborrow())\n    }",
+      "diff_span": {
+        "before": "        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,\n    ) -> diesel::serialize::Result {\n        let value = serde_json::to_value(self)?;\n        <serde_json::Value as diesel::serialize::ToSql<\n            diesel::sql_types::Jsonb,\n            diesel::pg::Pg,\n        >>::to_sql(&value, &mut out.reborrow())\n    }",
+        "after": "        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,\n    ) -> diesel::serialize::Result {\n        let mut payments = serde_json::to_value(self.payments.as_ref())?;\n        let payouts = serde_json::to_value(self.payouts.as_ref())?;\n\n        if let Some(payments_object) = payments.as_object_mut() {\n            payments_object.insert(\"payouts\".to_string(), payouts);\n        }\n\n        router_env::logger::info!(\"here  : {:?}\", payments.clone());\n        <serde_json::Value as diesel::serialize::ToSql<\n            diesel::sql_types::Jsonb,\n            diesel::pg::Pg,\n        >>::to_sql(&payments, &mut out.reborrow())\n    }"
+      },
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    },
+    {
+      "id": "crates/router/src/core/payment_methods/cards.rs::function::update_payment_method_connector_mandate_details",
+      "file": "crates/router/src/core/payment_methods/cards.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn update_payment_method_connector_mandate_details(\n    state: &routes::SessionState,\n    key_store: &domain::MerchantKeyStore,\n    db: &dyn db::StorageInterface,\n    pm: domain::PaymentMethod,\n    connector_mandate_details: Option<serde_json::Value>,\n    storage_scheme: MerchantStorageScheme,\n) -> errors::CustomResult<(), errors::VaultError> {\n    let pm_update = payment_method::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n        connector_mandate_details,\n    };\n\n    db.update_payment_method(&(state.into()), key_store, pm, pm_update, storage_scheme)\n        .await\n        .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n    Ok(())\n}",
+      "after_code": "pub async fn update_payment_method_connector_mandate_details(\n    state: &routes::SessionState,\n    key_store: &domain::MerchantKeyStore,\n    db: &dyn db::StorageInterface,\n    pm: domain::PaymentMethod,\n    connector_mandate_details: Option<diesel_models::CommonMandateReference>,\n    storage_scheme: MerchantStorageScheme,\n) -> errors::CustomResult<(), errors::VaultError> {\n    let mut connector_mandate_details_value = None;\n    if let Some(common_mandate) = connector_mandate_details {\n        let mut payments = serde_json::to_value(common_mandate.payments.as_ref())\n            .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n\n        let payouts = serde_json::to_value(common_mandate.payouts.as_ref())\n            .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n\n        if let Some(payments_object) = payments.as_object_mut() {\n            payments_object.insert(\"payouts\".to_string(), payouts);\n        }\n        connector_mandate_details_value = Some(payments)\n    }\n\n    router_env::logger::info!(\"here  : {:?}\", connector_mandate_details_value.clone());\n\n    let pm_update = payment_method::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n        connector_mandate_details: connector_mandate_details_value,\n    };\n\n    db.update_payment_method(&(state.into()), key_store, pm, pm_update, storage_scheme)\n        .await\n        .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n    Ok(())\n}",
+      "diff_span": {
+        "before": "    db: &dyn db::StorageInterface,\n    pm: domain::PaymentMethod,\n    connector_mandate_details: Option<serde_json::Value>,\n    storage_scheme: MerchantStorageScheme,\n) -> errors::CustomResult<(), errors::VaultError> {\n    let pm_update = payment_method::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n        connector_mandate_details,\n    };\n",
+        "after": "    db: &dyn db::StorageInterface,\n    pm: domain::PaymentMethod,\n    connector_mandate_details: Option<diesel_models::CommonMandateReference>,\n    storage_scheme: MerchantStorageScheme,\n) -> errors::CustomResult<(), errors::VaultError> {\n    let mut connector_mandate_details_value = None;\n    if let Some(common_mandate) = connector_mandate_details {\n        let mut payments = serde_json::to_value(common_mandate.payments.as_ref())\n            .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n\n        let payouts = serde_json::to_value(common_mandate.payouts.as_ref())\n            .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n\n        if let Some(payments_object) = payments.as_object_mut() {\n            payments_object.insert(\"payouts\".to_string(), payouts);\n        }\n        connector_mandate_details_value = Some(payments)\n    }\n\n    router_env::logger::info!(\"here  : {:?}\", connector_mandate_details_value.clone());\n\n    let pm_update = payment_method::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n        connector_mandate_details: connector_mandate_details_value,\n    };\n"
+      },
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::update_connector_mandate_details",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn update_connector_mandate_details(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    object_ref_id: api::ObjectReferenceId,\n    connector: &ConnectorEnum,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n) -> CustomResult<(), errors::ApiErrorResponse> {\n    let webhook_connector_mandate_details = connector\n        .get_mandate_details(request_details)\n        .switch()\n        .attach_printable(\"Could not find connector mandate details in incoming webhook body\")?;\n\n    let webhook_connector_network_transaction_id = connector\n        .get_network_txn_id(request_details)\n        .switch()\n        .attach_printable(\n            \"Could not find connector network transaction id in incoming webhook body\",\n        )?;\n\n    // Either one OR both of the fields are present\n    if webhook_connector_mandate_details.is_some()\n        || webhook_connector_network_transaction_id.is_some()\n    {\n        let payment_attempt =\n            get_payment_attempt_from_object_reference_id(state, object_ref_id, merchant_account)\n                .await?;\n        if let Some(ref payment_method_id) = payment_attempt.payment_method_id {\n            let key_manager_state = &state.into();\n            let payment_method_info = state\n                .store\n                .find_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_id,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;\n\n            // Update connector's mandate details\n            let updated_connector_mandate_details =\n                if let Some(webhook_mandate_details) = webhook_connector_mandate_details {\n                    let mandate_details = payment_method_info\n                        .get_common_mandate_reference()\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed to deserialize to Payment Mandate Reference\")?;\n\n                    let merchant_connector_account_id = payment_attempt\n                        .merchant_connector_id\n                        .clone()\n                        .get_required_value(\"merchant_connector_id\")?;\n\n                    if mandate_details.payments.as_ref().map_or(true, |payments| {\n                        !payments.0.contains_key(&merchant_connector_account_id)\n                    }) {\n                        // Update the payment attempt to maintain consistency across tables.\n                        let (mandate_metadata, connector_mandate_request_reference_id) =\n                            payment_attempt\n                                .connector_mandate_detail\n                                .as_ref()\n                                .map(|details| {\n                                    (\n                                        details.mandate_metadata.clone(),\n                                        details.connector_mandate_request_reference_id.clone(),\n                                    )\n                                })\n                                .unwrap_or((None, None));\n\n                        let connector_mandate_reference_id = ConnectorMandateReferenceId {\n                            connector_mandate_id: Some(\n                                webhook_mandate_details\n                                    .connector_mandate_id\n                                    .peek()\n                                    .to_string(),\n                            ),\n                            payment_method_id: Some(payment_method_id.to_string()),\n                            mandate_metadata,\n                            connector_mandate_request_reference_id,\n                        };\n\n                        let attempt_update =\n                            storage::PaymentAttemptUpdate::ConnectorMandateDetailUpdate {\n                                connector_mandate_detail: Some(connector_mandate_reference_id),\n                                updated_by: merchant_account.storage_scheme.to_string(),\n                            };\n\n                        state\n                            .store\n                            .update_payment_attempt_with_attempt_id(\n                                payment_attempt.clone(),\n                                attempt_update,\n                                merchant_account.storage_scheme,\n                            )\n                            .await\n                            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n                        insert_mandate_details(\n                            &payment_attempt,\n                            &webhook_mandate_details,\n                            Some(mandate_details),\n                        )?\n                    } else {\n                        logger::info!(\n                        \"Skipping connector mandate details update since they are already present.\"\n                    );\n                        None\n                    }\n                } else {\n                    None\n                };\n\n            let pm_update = diesel_models::PaymentMethodUpdate::ConnectorNetworkTransactionIdAndMandateDetailsUpdate {\n                connector_mandate_details: updated_connector_mandate_details.map(masking::Secret::new),\n                network_transaction_id: webhook_connector_network_transaction_id\n                    .map(|webhook_network_transaction_id| webhook_network_transaction_id.get_id().clone()),\n            };\n\n            state\n                .store\n                .update_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_info,\n                    pm_update,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to update payment method in db\")?;\n        }\n    }\n    Ok(())\n}",
+      "after_code": "async fn update_connector_mandate_details(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    object_ref_id: api::ObjectReferenceId,\n    connector: &ConnectorEnum,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n) -> CustomResult<(), errors::ApiErrorResponse> {\n    let webhook_connector_mandate_details = connector\n        .get_mandate_details(request_details)\n        .switch()\n        .attach_printable(\"Could not find connector mandate details in incoming webhook body\")?;\n\n    let webhook_connector_network_transaction_id = connector\n        .get_network_txn_id(request_details)\n        .switch()\n        .attach_printable(\n            \"Could not find connector network transaction id in incoming webhook body\",\n        )?;\n\n    // Either one OR both of the fields are present\n    if webhook_connector_mandate_details.is_some()\n        || webhook_connector_network_transaction_id.is_some()\n    {\n        let payment_attempt =\n            get_payment_attempt_from_object_reference_id(state, object_ref_id, merchant_account)\n                .await?;\n        if let Some(ref payment_method_id) = payment_attempt.payment_method_id {\n            let key_manager_state = &state.into();\n            let payment_method_info = state\n                .store\n                .find_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_id,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;\n\n            // Update connector's mandate details\n            let updated_connector_mandate_details =\n                if let Some(webhook_mandate_details) = webhook_connector_mandate_details {\n                    let mandate_details = payment_method_info\n                        .get_common_mandate_reference()\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed to deserialize to Payment Mandate Reference\")?;\n\n                    let merchant_connector_account_id = payment_attempt\n                        .merchant_connector_id\n                        .clone()\n                        .get_required_value(\"merchant_connector_id\")?;\n\n                    if mandate_details.payments.as_ref().map_or(true, |payments| {\n                        !payments.0.contains_key(&merchant_connector_account_id)\n                    }) {\n                        // Update the payment attempt to maintain consistency across tables.\n                        let (mandate_metadata, connector_mandate_request_reference_id) =\n                            payment_attempt\n                                .connector_mandate_detail\n                                .as_ref()\n                                .map(|details| {\n                                    (\n                                        details.mandate_metadata.clone(),\n                                        details.connector_mandate_request_reference_id.clone(),\n                                    )\n                                })\n                                .unwrap_or((None, None));\n\n                        let connector_mandate_reference_id = ConnectorMandateReferenceId {\n                            connector_mandate_id: Some(\n                                webhook_mandate_details\n                                    .connector_mandate_id\n                                    .peek()\n                                    .to_string(),\n                            ),\n                            payment_method_id: Some(payment_method_id.to_string()),\n                            mandate_metadata,\n                            connector_mandate_request_reference_id,\n                        };\n\n                        let attempt_update =\n                            storage::PaymentAttemptUpdate::ConnectorMandateDetailUpdate {\n                                connector_mandate_detail: Some(connector_mandate_reference_id),\n                                updated_by: merchant_account.storage_scheme.to_string(),\n                            };\n\n                        state\n                            .store\n                            .update_payment_attempt_with_attempt_id(\n                                payment_attempt.clone(),\n                                attempt_update,\n                                merchant_account.storage_scheme,\n                            )\n                            .await\n                            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n                        insert_mandate_details(\n                            &payment_attempt,\n                            &webhook_mandate_details,\n                            Some(mandate_details),\n                        )?\n                    } else {\n                        logger::info!(\n                        \"Skipping connector mandate details update since they are already present.\"\n                    );\n                        None\n                    }\n                } else {\n                    None\n                };\n\n            let mut connector_mandate_details_value = None;\n            if let Some(common_mandate) = updated_connector_mandate_details {\n                let mut payments = serde_json::to_value(common_mandate.payments.as_ref())\n                    .change_context(errors::ApiErrorResponse::MandateUpdateFailed)?;\n\n                let payouts = serde_json::to_value(common_mandate.payouts.as_ref())\n                    .change_context(errors::ApiErrorResponse::MandateUpdateFailed)?;\n\n                if let Some(payments_object) = payments.as_object_mut() {\n                    payments_object.insert(\"payouts\".to_string(), payouts);\n                }\n                connector_mandate_details_value = Some(payments)\n            }\n\n            router_env::logger::info!(\"here : {:?}\", connector_mandate_details_value);\n\n            let pm_update = diesel_models::PaymentMethodUpdate::ConnectorNetworkTransactionIdAndMandateDetailsUpdate {\n                connector_mandate_details: connector_mandate_details_value.map(masking::Secret::new),\n                network_transaction_id: webhook_connector_network_transaction_id\n                    .map(|webhook_network_transaction_id| webhook_network_transaction_id.get_id().clone()),\n            };\n\n            state\n                .store\n                .update_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_info,\n                    pm_update,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to update payment method in db\")?;\n        }\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "\n            let pm_update = diesel_models::PaymentMethodUpdate::ConnectorNetworkTransactionIdAndMandateDetailsUpdate {\n                connector_mandate_details: updated_connector_mandate_details.map(masking::Secret::new),\n                network_transaction_id: webhook_connector_network_transaction_id\n                    .map(|webhook_network_transaction_id| webhook_network_transaction_id.get_id().clone()),",
+        "after": "                };\n\n            let mut connector_mandate_details_value = None;\n            if let Some(common_mandate) = updated_connector_mandate_details {\n                let mut payments = serde_json::to_value(common_mandate.payments.as_ref())\n                    .change_context(errors::ApiErrorResponse::MandateUpdateFailed)?;\n\n                let payouts = serde_json::to_value(common_mandate.payouts.as_ref())\n                    .change_context(errors::ApiErrorResponse::MandateUpdateFailed)?;\n\n                if let Some(payments_object) = payments.as_object_mut() {\n                    payments_object.insert(\"payouts\".to_string(), payouts);\n                }\n                connector_mandate_details_value = Some(payments)\n            }\n\n            router_env::logger::info!(\"here : {:?}\", connector_mandate_details_value);\n\n            let pm_update = diesel_models::PaymentMethodUpdate::ConnectorNetworkTransactionIdAndMandateDetailsUpdate {\n                connector_mandate_details: connector_mandate_details_value.map(masking::Secret::new),\n                network_transaction_id: webhook_connector_network_transaction_id\n                    .map(|webhook_network_transaction_id| webhook_network_transaction_id.get_id().clone()),"
+      },
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    },
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::CommonMandateReference::function::from_sql",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        if let Ok(payment_reference) =\n            serde_json::from_value::<PaymentsMandateReference>(value.clone())\n        {\n            return Ok(Self::from(payment_reference));\n        }\n\n        if let Ok(common_reference) = serde_json::from_value::<Self>(value) {\n            return Ok(common_reference);\n        }\n        Err(\n            report!(ParsingError::StructParseFailure(\"CommonMandateReference\")).attach_printable(\n                \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n            ),\n        )?\n    }",
+      "after_code": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        let mut payments_data = None;\n        let mut payouts_data = None;\n\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(value.clone())\n        {\n            payments_data = Some(payment_mandate_record);\n        }\n        if let Ok(payouts) = serde_json::from_value::<PayoutsMandateReferenceStruct>(value) {\n            payouts_data = Some(payouts.payouts);\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(\n                report!(ParsingError::StructParseFailure(\"CommonMandateReference\"))\n                    .attach_printable(\n                    \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n                ),\n            )?\n        } else {\n            Ok(CommonMandateReference {\n                payments: payments_data,\n                payouts: payouts_data,\n            })\n        }\n\n        // if let Ok(payment_reference) =\n        //     serde_json::from_value::<PaymentsMandateReference>(value.clone())\n        // {\n        //     return Ok(Self::from(payment_reference));\n        // }\n\n        // if let Ok(common_reference) = serde_json::from_value::<Self>(value) {\n        //     return Ok(common_reference);\n        // }\n        // Err(\n        //     report!(ParsingError::StructParseFailure(\"CommonMandateReference\")).attach_printable(\n        //         \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n        //     ),\n        // )?\n    }",
+      "diff_span": {
+        "before": "        >>::from_sql(bytes)?;\n\n        if let Ok(payment_reference) =\n            serde_json::from_value::<PaymentsMandateReference>(value.clone())\n        {\n            return Ok(Self::from(payment_reference));\n        }\n\n        if let Ok(common_reference) = serde_json::from_value::<Self>(value) {\n            return Ok(common_reference);\n        }\n        Err(\n            report!(ParsingError::StructParseFailure(\"CommonMandateReference\")).attach_printable(\n                \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n            ),\n        )?\n    }",
+        "after": "        >>::from_sql(bytes)?;\n\n        let mut payments_data = None;\n        let mut payouts_data = None;\n\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(value.clone())\n        {\n            payments_data = Some(payment_mandate_record);\n        }\n        if let Ok(payouts) = serde_json::from_value::<PayoutsMandateReferenceStruct>(value) {\n            payouts_data = Some(payouts.payouts);\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(\n                report!(ParsingError::StructParseFailure(\"CommonMandateReference\"))\n                    .attach_printable(\n                    \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n                ),\n            )?\n        } else {\n            Ok(CommonMandateReference {\n                payments: payments_data,\n                payouts: payouts_data,\n            })\n        }\n\n        // if let Ok(payment_reference) =\n        //     serde_json::from_value::<PaymentsMandateReference>(value.clone())\n        // {\n        //     return Ok(Self::from(payment_reference));\n        // }\n\n        // if let Ok(common_reference) = serde_json::from_value::<Self>(value) {\n        //     return Ok(common_reference);\n        // }\n        // Err(\n        //     report!(ParsingError::StructParseFailure(\"CommonMandateReference\")).attach_printable(\n        //         \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n        //     ),\n        // )?\n    }"
+      },
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    },
+    {
+      "id": "crates/api_models/src/payment_methods.rs::function::deserialize_connector_mandate_details",
+      "file": "crates/api_models/src/payment_methods.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn deserialize_connector_mandate_details<'de, D>(\n    deserializer: D,\n) -> Result<Option<CommonMandateReference>, D::Error>\nwhere\n    D: serde::Deserializer<'de>,\n{\n    let value: Option<serde_json::Value> =\n        <Option<serde_json::Value> as de::Deserialize>::deserialize(deserializer)?;\n    if let Some(connector_mandate_value) = value {\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(connector_mandate_value.clone())\n        {\n            Ok(Some(CommonMandateReference {\n                payments: Some(payment_mandate_record),\n                payouts: None,\n            }))\n        } else if let Ok(common_mandate) =\n            serde_json::from_value::<CommonMandateReference>(connector_mandate_value)\n        {\n            Ok(Some(common_mandate))\n        } else {\n            Err(de::Error::custom(\n                \"Failed to deserialize connector_mandate_details\",\n            ))\n        }\n    } else {\n        Ok(None)\n    }\n}",
+      "after_code": "fn deserialize_connector_mandate_details<'de, D>(\n    deserializer: D,\n) -> Result<Option<CommonMandateReference>, D::Error>\nwhere\n    D: serde::Deserializer<'de>,\n{\n    let value: Option<serde_json::Value> =\n        <Option<serde_json::Value> as de::Deserialize>::deserialize(deserializer)?;\n    if let Some(connector_mandate_value) = value {\n        let mut payments_data = None;\n        let mut payouts_data = None;\n\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(connector_mandate_value.clone())\n        {\n            payments_data = Some(payment_mandate_record);\n        }\n        if let Ok(payouts) =\n            serde_json::from_value::<PayoutsMandateReferenceStruct>(connector_mandate_value)\n        {\n            payouts_data = Some(payouts.payouts);\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(de::Error::custom(\n                \"Failed to deserialize connector_mandate_details\",\n            ))\n        } else {\n            Ok(Some(CommonMandateReference {\n                payments: payments_data,\n                payouts: payouts_data,\n            }))\n        }\n    } else {\n        Ok(None)\n    }\n}",
+      "diff_span": {
+        "before": "            serde_json::from_value::<PaymentsMandateReference>(connector_mandate_value.clone())\n        {\n            Ok(Some(CommonMandateReference {\n                payments: Some(payment_mandate_record),\n                payouts: None,\n            }))\n        } else if let Ok(common_mandate) =\n            serde_json::from_value::<CommonMandateReference>(connector_mandate_value)\n        {\n            Ok(Some(common_mandate))\n        } else {\n            Err(de::Error::custom(\n                \"Failed to deserialize connector_mandate_details\",",
+        "after": "        <Option<serde_json::Value> as de::Deserialize>::deserialize(deserializer)?;\n    if let Some(connector_mandate_value) = value {\n        let mut payments_data = None;\n        let mut payouts_data = None;\n\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(connector_mandate_value.clone())\n        {\n            payments_data = Some(payment_mandate_record);\n        }\n        if let Ok(payouts) =\n            serde_json::from_value::<PayoutsMandateReferenceStruct>(connector_mandate_value)\n        {\n            payouts_data = Some(payouts.payouts);\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(de::Error::custom(\n                \"Failed to deserialize connector_mandate_details\",\n            ))\n        } else {\n            Ok(Some(CommonMandateReference {\n                payments: payments_data,\n                payouts: payouts_data,\n            }))\n        }\n    } else {"
+      },
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::insert_mandate_details",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn insert_mandate_details(\n    payment_attempt: &PaymentAttempt,\n    webhook_mandate_details: &hyperswitch_domain_models::router_flow_types::ConnectorMandateDetails,\n    payment_method_mandate_details: Option<diesel_models::CommonMandateReference>,\n) -> CustomResult<Option<serde_json::Value>, errors::ApiErrorResponse> {\n    let (mandate_metadata, connector_mandate_request_reference_id) = payment_attempt\n        .connector_mandate_detail\n        .clone()\n        .map(|mandate_reference| {\n            (\n                mandate_reference.mandate_metadata,\n                mandate_reference.connector_mandate_request_reference_id,\n            )\n        })\n        .unwrap_or((None, None));\n    let connector_mandate_details = tokenization::update_connector_mandate_details(\n        payment_method_mandate_details,\n        payment_attempt.payment_method_type,\n        Some(\n            payment_attempt\n                .net_amount\n                .get_total_amount()\n                .get_amount_as_i64(),\n        ),\n        payment_attempt.currency,\n        payment_attempt.merchant_connector_id.clone(),\n        Some(\n            webhook_mandate_details\n                .connector_mandate_id\n                .peek()\n                .to_string(),\n        ),\n        mandate_metadata,\n        connector_mandate_request_reference_id,\n    )?;\n    Ok(connector_mandate_details)\n}",
+      "after_code": "fn insert_mandate_details(\n    payment_attempt: &PaymentAttempt,\n    webhook_mandate_details: &hyperswitch_domain_models::router_flow_types::ConnectorMandateDetails,\n    payment_method_mandate_details: Option<diesel_models::CommonMandateReference>,\n) -> CustomResult<Option<diesel_models::CommonMandateReference>, errors::ApiErrorResponse> {\n    let (mandate_metadata, connector_mandate_request_reference_id) = payment_attempt\n        .connector_mandate_detail\n        .clone()\n        .map(|mandate_reference| {\n            (\n                mandate_reference.mandate_metadata,\n                mandate_reference.connector_mandate_request_reference_id,\n            )\n        })\n        .unwrap_or((None, None));\n    let connector_mandate_details = tokenization::update_connector_mandate_details(\n        payment_method_mandate_details,\n        payment_attempt.payment_method_type,\n        Some(\n            payment_attempt\n                .net_amount\n                .get_total_amount()\n                .get_amount_as_i64(),\n        ),\n        payment_attempt.currency,\n        payment_attempt.merchant_connector_id.clone(),\n        Some(\n            webhook_mandate_details\n                .connector_mandate_id\n                .peek()\n                .to_string(),\n        ),\n        mandate_metadata,\n        connector_mandate_request_reference_id,\n    )?;\n    Ok(connector_mandate_details)\n}",
+      "diff_span": {
+        "before": "    webhook_mandate_details: &hyperswitch_domain_models::router_flow_types::ConnectorMandateDetails,\n    payment_method_mandate_details: Option<diesel_models::CommonMandateReference>,\n) -> CustomResult<Option<serde_json::Value>, errors::ApiErrorResponse> {\n    let (mandate_metadata, connector_mandate_request_reference_id) = payment_attempt\n        .connector_mandate_detail",
+        "after": "    webhook_mandate_details: &hyperswitch_domain_models::router_flow_types::ConnectorMandateDetails,\n    payment_method_mandate_details: Option<diesel_models::CommonMandateReference>,\n) -> CustomResult<Option<diesel_models::CommonMandateReference>, errors::ApiErrorResponse> {\n    let (mandate_metadata, connector_mandate_request_reference_id) = payment_attempt\n        .connector_mandate_detail"
+      },
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    },
+    {
+      "id": "crates/router/src/core/payments/tokenization.rs::function::update_connector_mandate_details",
+      "file": "crates/router/src/core/payments/tokenization.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn update_connector_mandate_details(\n    mandate_details: Option<diesel_models::CommonMandateReference>,\n    payment_method_type: Option<storage_enums::PaymentMethodType>,\n    authorized_amount: Option<i64>,\n    authorized_currency: Option<storage_enums::Currency>,\n    merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,\n    connector_mandate_id: Option<String>,\n    mandate_metadata: Option<Secret<serde_json::Value>>,\n    connector_mandate_request_reference_id: Option<String>,\n) -> RouterResult<Option<serde_json::Value>> {\n    let mandate_reference = match mandate_details\n        .as_ref()\n        .and_then(|common_mandate| common_mandate.payments.clone())\n    {\n        Some(mut payment_mandate_reference) => {\n            if let Some((mca_id, connector_mandate_id)) =\n                merchant_connector_id.clone().zip(connector_mandate_id)\n            {\n                let updated_record = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: connector_mandate_id.clone(),\n                    payment_method_type,\n                    original_payment_authorized_amount: authorized_amount,\n                    original_payment_authorized_currency: authorized_currency,\n                    mandate_metadata: mandate_metadata.clone(),\n                    connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                    connector_mandate_request_reference_id: connector_mandate_request_reference_id\n                        .clone(),\n                };\n\n                payment_mandate_reference\n                    .entry(mca_id)\n                    .and_modify(|pm| *pm = updated_record)\n                    .or_insert(diesel_models::PaymentsMandateReferenceRecord {\n                        connector_mandate_id,\n                        payment_method_type,\n                        original_payment_authorized_amount: authorized_amount,\n                        original_payment_authorized_currency: authorized_currency,\n                        mandate_metadata: mandate_metadata.clone(),\n                        connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                        connector_mandate_request_reference_id,\n                    });\n\n                let payout_data = mandate_details.and_then(|common_mandate| common_mandate.payouts);\n\n                Some(diesel_models::CommonMandateReference {\n                    payments: Some(payment_mandate_reference),\n                    payouts: payout_data,\n                })\n            } else {\n                None\n            }\n        }\n        None => add_connector_mandate_details_in_payment_method(\n            payment_method_type,\n            authorized_amount,\n            authorized_currency,\n            merchant_connector_id,\n            connector_mandate_id,\n            mandate_metadata,\n            connector_mandate_request_reference_id,\n        ),\n    };\n    let connector_mandate_details = mandate_reference\n        .map(|mand| mand.encode_to_value())\n        .transpose()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n    Ok(connector_mandate_details)\n}",
+      "after_code": "pub fn update_connector_mandate_details(\n    mandate_details: Option<diesel_models::CommonMandateReference>,\n    payment_method_type: Option<storage_enums::PaymentMethodType>,\n    authorized_amount: Option<i64>,\n    authorized_currency: Option<storage_enums::Currency>,\n    merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,\n    connector_mandate_id: Option<String>,\n    mandate_metadata: Option<Secret<serde_json::Value>>,\n    connector_mandate_request_reference_id: Option<String>,\n) -> RouterResult<Option<diesel_models::CommonMandateReference>> {\n    let mandate_reference = match mandate_details\n        .as_ref()\n        .and_then(|common_mandate| common_mandate.payments.clone())\n    {\n        Some(mut payment_mandate_reference) => {\n            if let Some((mca_id, connector_mandate_id)) =\n                merchant_connector_id.clone().zip(connector_mandate_id)\n            {\n                let updated_record = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: connector_mandate_id.clone(),\n                    payment_method_type,\n                    original_payment_authorized_amount: authorized_amount,\n                    original_payment_authorized_currency: authorized_currency,\n                    mandate_metadata: mandate_metadata.clone(),\n                    connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                    connector_mandate_request_reference_id: connector_mandate_request_reference_id\n                        .clone(),\n                };\n\n                payment_mandate_reference\n                    .entry(mca_id)\n                    .and_modify(|pm| *pm = updated_record)\n                    .or_insert(diesel_models::PaymentsMandateReferenceRecord {\n                        connector_mandate_id,\n                        payment_method_type,\n                        original_payment_authorized_amount: authorized_amount,\n                        original_payment_authorized_currency: authorized_currency,\n                        mandate_metadata: mandate_metadata.clone(),\n                        connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                        connector_mandate_request_reference_id,\n                    });\n\n                let payout_data = mandate_details.and_then(|common_mandate| common_mandate.payouts);\n\n                Some(diesel_models::CommonMandateReference {\n                    payments: Some(payment_mandate_reference),\n                    payouts: payout_data,\n                })\n            } else {\n                None\n            }\n        }\n        None => add_connector_mandate_details_in_payment_method(\n            payment_method_type,\n            authorized_amount,\n            authorized_currency,\n            merchant_connector_id,\n            connector_mandate_id,\n            mandate_metadata,\n            connector_mandate_request_reference_id,\n        ),\n    };\n    // let connector_mandate_details = mandate_reference\n    //     .map(|mand| mand.encode_to_value())\n    //     .transpose()\n    //     .change_context(errors::ApiErrorResponse::InternalServerError)\n    //     .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n    Ok(mandate_reference)\n}",
+      "diff_span": {
+        "before": "    mandate_metadata: Option<Secret<serde_json::Value>>,\n    connector_mandate_request_reference_id: Option<String>,\n) -> RouterResult<Option<serde_json::Value>> {\n    let mandate_reference = match mandate_details\n        .as_ref()\n        .and_then(|common_mandate| common_mandate.payments.clone())\n    {\n        Some(mut payment_mandate_reference) => {\n            if let Some((mca_id, connector_mandate_id)) =\n                merchant_connector_id.clone().zip(connector_mandate_id)\n            {\n                let updated_record = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: connector_mandate_id.clone(),\n                    payment_method_type,\n                    original_payment_authorized_amount: authorized_amount,\n                    original_payment_authorized_currency: authorized_currency,\n                    mandate_metadata: mandate_metadata.clone(),\n                    connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                    connector_mandate_request_reference_id: connector_mandate_request_reference_id\n                        .clone(),\n                };\n\n                payment_mandate_reference\n                    .entry(mca_id)\n                    .and_modify(|pm| *pm = updated_record)\n                    .or_insert(diesel_models::PaymentsMandateReferenceRecord {\n                        connector_mandate_id,\n                        payment_method_type,\n                        original_payment_authorized_amount: authorized_amount,\n                        original_payment_authorized_currency: authorized_currency,\n                        mandate_metadata: mandate_metadata.clone(),\n                        connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                        connector_mandate_request_reference_id,\n                    });\n\n                let payout_data = mandate_details.and_then(|common_mandate| common_mandate.payouts);\n\n                Some(diesel_models::CommonMandateReference {\n                    payments: Some(payment_mandate_reference),\n                    payouts: payout_data,\n                })\n            } else {\n                None\n            }\n        }\n        None => add_connector_mandate_details_in_payment_method(\n            payment_method_type,\n            authorized_amount,\n            authorized_currency,\n            merchant_connector_id,\n            connector_mandate_id,\n            mandate_metadata,\n            connector_mandate_request_reference_id,\n        ),\n    };\n    let connector_mandate_details = mandate_reference\n        .map(|mand| mand.encode_to_value())\n        .transpose()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n    Ok(connector_mandate_details)\n}",
+        "after": "    mandate_metadata: Option<Secret<serde_json::Value>>,\n    connector_mandate_request_reference_id: Option<String>,\n) -> RouterResult<Option<diesel_models::CommonMandateReference>> {\n    let mandate_reference = match mandate_details\n        .as_ref()\n        .and_then(|common_mandate| common_mandate.payments.clone())\n    {\n        Some(mut payment_mandate_reference) => {\n            if let Some((mca_id, connector_mandate_id)) =\n                merchant_connector_id.clone().zip(connector_mandate_id)\n            {\n                let updated_record = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: connector_mandate_id.clone(),\n                    payment_method_type,\n                    original_payment_authorized_amount: authorized_amount,\n                    original_payment_authorized_currency: authorized_currency,\n                    mandate_metadata: mandate_metadata.clone(),\n                    connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                    connector_mandate_request_reference_id: connector_mandate_request_reference_id\n                        .clone(),\n                };\n\n                payment_mandate_reference\n                    .entry(mca_id)\n                    .and_modify(|pm| *pm = updated_record)\n                    .or_insert(diesel_models::PaymentsMandateReferenceRecord {\n                        connector_mandate_id,\n                        payment_method_type,\n                        original_payment_authorized_amount: authorized_amount,\n                        original_payment_authorized_currency: authorized_currency,\n                        mandate_metadata: mandate_metadata.clone(),\n                        connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                        connector_mandate_request_reference_id,\n                    });\n\n                let payout_data = mandate_details.and_then(|common_mandate| common_mandate.payouts);\n\n                Some(diesel_models::CommonMandateReference {\n                    payments: Some(payment_mandate_reference),\n                    payouts: payout_data,\n                })\n            } else {\n                None\n            }\n        }\n        None => add_connector_mandate_details_in_payment_method(\n            payment_method_type,\n            authorized_amount,\n            authorized_currency,\n            merchant_connector_id,\n            connector_mandate_id,\n            mandate_metadata,\n            connector_mandate_request_reference_id,\n        ),\n    };\n    // let connector_mandate_details = mandate_reference\n    //     .map(|mand| mand.encode_to_value())\n    //     .transpose()\n    //     .change_context(errors::ApiErrorResponse::InternalServerError)\n    //     .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n    Ok(mandate_reference)\n}"
+      },
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    },
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::struct::PayoutsMandateReferenceStruct",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PayoutsMandateReferenceStruct {\n    pub payouts: PayoutsMandateReference,\n}",
+      "diff_span": null,
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    },
+    {
+      "id": "crates/api_models/src/payment_methods.rs::struct::PayoutsMandateReferenceStruct",
+      "file": "crates/api_models/src/payment_methods.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PayoutsMandateReferenceStruct {\n    pub payouts: PayoutsMandateReference,\n}",
+      "diff_span": null,
+      "commit_sha": "123b29fbbeee567a18e3e59ab8eaa2c554c56365"
+    }
+  ]
+}

diffs/pr_6687/15fa38c/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "15fa38c4531bc4868802d486eb9824b988705fc8",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/diesel_models/src/payment_method.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::CommonMandateReference::function::from_sql",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        let mut payments_data = None;\n        let mut payouts_data = None;\n\n        if let Some(obj) = value.clone().as_object_mut() {\n            obj.remove(\"payouts\");\n\n            if let Ok(payment_mandate_record) =\n                serde_json::from_value::<PaymentsMandateReference>(serde_json::json!(obj))\n            {\n                payments_data = Some(payment_mandate_record);\n            }\n        }\n\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<Self>(value.clone())\n        {\n            payouts_data = payment_mandate_record.payouts\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(\n                report!(ParsingError::StructParseFailure(\"CommonMandateReference\"))\n                    .attach_printable(\n                    \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n                ),\n            )?\n        } else {\n            Ok(Self {\n                payments: payments_data,\n                payouts: payouts_data,\n            })\n        }\n    }",
+      "after_code": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        let mut payments_data = None;\n        let mut payouts_data = None;\n\n        if let Some(obj) = value.clone().as_object_mut() {\n            obj.remove(\"payouts\");\n\n            if let Ok(payment_mandate_record) =\n                serde_json::from_value::<PaymentsMandateReference>(serde_json::json!(obj))\n            {\n                payments_data = Some(payment_mandate_record);\n            }\n        }\n\n        if let Ok(payment_mandate_record) = serde_json::from_value::<Self>(value.clone()) {\n            payouts_data = payment_mandate_record.payouts\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(\n                report!(ParsingError::StructParseFailure(\"CommonMandateReference\"))\n                    .attach_printable(\n                    \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n                ),\n            )?\n        } else {\n            Ok(Self {\n                payments: payments_data,\n                payouts: payouts_data,\n            })\n        }\n    }",
+      "diff_span": {
+        "before": "        }\n\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<Self>(value.clone())\n        {\n            payouts_data = payment_mandate_record.payouts\n        }",
+        "after": "        }\n\n        if let Ok(payment_mandate_record) = serde_json::from_value::<Self>(value.clone()) {\n            payouts_data = payment_mandate_record.payouts\n        }"
+      },
+      "commit_sha": "15fa38c4531bc4868802d486eb9824b988705fc8"
+    }
+  ]
+}

diffs/pr_6687/3cd9d76/diff.json

@@ -0,0 +1,174 @@
+{
+  "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/api_models/src/payment_methods.rs",
+    "crates/hyperswitch_domain_models/src/mandates.rs",
+    "crates/hyperswitch_domain_models/src/payment_methods.rs",
+    "crates/router/src/core/payment_methods/cards.rs",
+    "crates/router/src/core/payments/helpers.rs",
+    "crates/router/src/core/payouts.rs",
+    "crates/router/src/core/webhooks/incoming.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payment_methods/cards.rs::function::update_payment_method_connector_mandate_details",
+      "file": "crates/router/src/core/payment_methods/cards.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn update_payment_method_connector_mandate_details(\n    state: &routes::SessionState,\n    key_store: &domain::MerchantKeyStore,\n    db: &dyn db::StorageInterface,\n    pm: domain::PaymentMethod,\n    connector_mandate_details: Option<diesel_models::CommonMandateReference>,\n    storage_scheme: MerchantStorageScheme,\n) -> errors::CustomResult<(), errors::VaultError> {\n    let connector_mandate_details_value = connector_mandate_details\n        .map(|common_mandate| {\n            common_mandate\n                .get_mandate_details_value()\n                .map_err(|_| errors::VaultError::UpdateInPaymentMethodDataTableFailed)\n        })\n        .transpose()?;\n\n    let pm_update = payment_method::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n        connector_mandate_details: connector_mandate_details_value,\n    };\n\n    db.update_payment_method(&(state.into()), key_store, pm, pm_update, storage_scheme)\n        .await\n        .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n    Ok(())\n}",
+      "after_code": "pub async fn update_payment_method_connector_mandate_details(\n    state: &routes::SessionState,\n    key_store: &domain::MerchantKeyStore,\n    db: &dyn db::StorageInterface,\n    pm: domain::PaymentMethod,\n    connector_mandate_details: Option<diesel_models::CommonMandateReference>,\n    storage_scheme: MerchantStorageScheme,\n) -> errors::CustomResult<(), errors::VaultError> {\n    let connector_mandate_details_value = connector_mandate_details\n        .map(|common_mandate| {\n            common_mandate.get_mandate_details_value().map_err(|err| {\n                router_env::logger::error!(\"Failed to get get_mandate_details_value : {:?}\", err);\n                errors::VaultError::UpdateInPaymentMethodDataTableFailed\n            })\n        })\n        .transpose()?;\n\n    let pm_update = payment_method::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n        connector_mandate_details: connector_mandate_details_value,\n    };\n\n    db.update_payment_method(&(state.into()), key_store, pm, pm_update, storage_scheme)\n        .await\n        .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n    Ok(())\n}",
+      "diff_span": {
+        "before": "    let connector_mandate_details_value = connector_mandate_details\n        .map(|common_mandate| {\n            common_mandate\n                .get_mandate_details_value()\n                .map_err(|_| errors::VaultError::UpdateInPaymentMethodDataTableFailed)\n        })\n        .transpose()?;",
+        "after": "    let connector_mandate_details_value = connector_mandate_details\n        .map(|common_mandate| {\n            common_mandate.get_mandate_details_value().map_err(|err| {\n                router_env::logger::error!(\"Failed to get get_mandate_details_value : {:?}\", err);\n                errors::VaultError::UpdateInPaymentMethodDataTableFailed\n            })\n        })\n        .transpose()?;"
+      },
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de"
+    },
+    {
+      "id": "crates/router/src/core/payouts.rs::function::create_recipient_disburse_account",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn create_recipient_disburse_account(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n    key_store: &domain::MerchantKeyStore,\n) -> RouterResult<()> {\n    // 1. Form Router data\n    let router_data = core_utils::construct_payout_router_data(\n        state,\n        connector_data,\n        merchant_account,\n        payout_data,\n    )\n    .await?;\n\n    // 2. Fetch connector integration details\n    let connector_integration: services::BoxedPayoutConnectorIntegrationInterface<\n        api::PoRecipientAccount,\n        types::PayoutsData,\n        types::PayoutsResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    // 3. Call connector service\n    let router_data_resp = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &router_data,\n        payments::CallConnectorAction::Trigger,\n        None,\n    )\n    .await\n    .to_payout_failed_response()?;\n\n    // 4. Process data returned by the connector\n    let db = &*state.store;\n    match router_data_resp.response {\n        Ok(payout_response_data) => {\n            let payout_attempt = &payout_data.payout_attempt;\n            let status = payout_response_data\n                .status\n                .unwrap_or(payout_attempt.status.to_owned());\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_response_data.connector_payout_id.clone(),\n                status,\n                error_code: None,\n                error_message: None,\n                is_eligible: payout_response_data.payout_eligible,\n                unified_code: None,\n                unified_message: None,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n\n            if let (\n                true,\n                Some(ref payout_method_data),\n                Some(connector_payout_id),\n                Some(customer_details),\n                Some(merchant_connector_id),\n            ) = (\n                payout_data.payouts.recurring,\n                payout_data.payout_method_data.clone(),\n                payout_response_data.connector_payout_id.clone(),\n                payout_data.customer_details.clone(),\n                connector_data.merchant_connector_id.clone(),\n            ) {\n                let connector_mandate_details = HashMap::from([(\n                    merchant_connector_id.clone(),\n                    PayoutsMandateReferenceRecord {\n                        transfer_method_id: Some(connector_payout_id),\n                    },\n                )]);\n\n                let common_connector_mandate = CommonMandateReference {\n                    payments: None,\n                    payouts: Some(PayoutsMandateReference(connector_mandate_details)),\n                };\n\n                let connector_mandate_details_value = common_connector_mandate\n                    .get_mandate_details_value()\n                    .map_err(|_| errors::ApiErrorResponse::MandateUpdateFailed)?;\n\n                if let Some(pm_method) = payout_data.payment_method.clone() {\n                    let pm_update =\n                        diesel_models::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n                            #[cfg(all(\n                                any(feature = \"v1\", feature = \"v2\"),\n                                not(feature = \"payment_methods_v2\")\n                            ))]\n                            connector_mandate_details: Some(connector_mandate_details_value),\n\n                            #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n                            connector_mandate_details: Some(common_connector_mandate),\n                        };\n\n                    payout_data.payment_method = Some(\n                        db.update_payment_method(\n                            &(state.into()),\n                            key_store,\n                            pm_method,\n                            pm_update,\n                            merchant_account.storage_scheme,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n                        .attach_printable(\"Unable to find payment method\")?,\n                    );\n                } else {\n                    #[cfg(all(any(feature = \"v1\", feature = \"v2\"), not(feature = \"customer_v2\")))]\n                    let customer_id = Some(customer_details.customer_id);\n\n                    #[cfg(all(feature = \"v2\", feature = \"customer_v2\"))]\n                    let customer_id = customer_details.merchant_reference_id;\n\n                    if let Some(customer_id) = customer_id {\n                        helpers::save_payout_data_to_locker(\n                            state,\n                            payout_data,\n                            &customer_id,\n                            payout_method_data,\n                            Some(connector_mandate_details_value),\n                            merchant_account,\n                            key_store,\n                        )\n                        .await\n                        .attach_printable(\"Failed to save payout data to locker\")?;\n                    }\n                };\n            }\n        }\n        Err(err) => {\n            let (error_code, error_message) = (Some(err.code), Some(err.message));\n            let (unified_code, unified_message) = helpers::get_gsm_record(\n                state,\n                error_code.clone(),\n                error_message.clone(),\n                payout_data.payout_attempt.connector.clone(),\n                consts::PAYOUT_FLOW_STR,\n            )\n            .await\n            .map_or((None, None), |gsm| (gsm.unified_code, gsm.unified_message));\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_data.payout_attempt.connector_payout_id.to_owned(),\n                status: storage_enums::PayoutStatus::Failed,\n                error_code,\n                error_message,\n                is_eligible: None,\n                unified_code: unified_code\n                    .map(UnifiedCode::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_code\",\n                    })?,\n                unified_message: unified_message\n                    .map(UnifiedMessage::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_message\",\n                    })?,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    &payout_data.payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n        }\n    };\n\n    Ok(())\n}",
+      "after_code": "pub async fn create_recipient_disburse_account(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n    key_store: &domain::MerchantKeyStore,\n) -> RouterResult<()> {\n    // 1. Form Router data\n    let router_data = core_utils::construct_payout_router_data(\n        state,\n        connector_data,\n        merchant_account,\n        payout_data,\n    )\n    .await?;\n\n    // 2. Fetch connector integration details\n    let connector_integration: services::BoxedPayoutConnectorIntegrationInterface<\n        api::PoRecipientAccount,\n        types::PayoutsData,\n        types::PayoutsResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    // 3. Call connector service\n    let router_data_resp = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &router_data,\n        payments::CallConnectorAction::Trigger,\n        None,\n    )\n    .await\n    .to_payout_failed_response()?;\n\n    // 4. Process data returned by the connector\n    let db = &*state.store;\n    match router_data_resp.response {\n        Ok(payout_response_data) => {\n            let payout_attempt = &payout_data.payout_attempt;\n            let status = payout_response_data\n                .status\n                .unwrap_or(payout_attempt.status.to_owned());\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_response_data.connector_payout_id.clone(),\n                status,\n                error_code: None,\n                error_message: None,\n                is_eligible: payout_response_data.payout_eligible,\n                unified_code: None,\n                unified_message: None,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n\n            if let (\n                true,\n                Some(ref payout_method_data),\n                Some(connector_payout_id),\n                Some(customer_details),\n                Some(merchant_connector_id),\n            ) = (\n                payout_data.payouts.recurring,\n                payout_data.payout_method_data.clone(),\n                payout_response_data.connector_payout_id.clone(),\n                payout_data.customer_details.clone(),\n                connector_data.merchant_connector_id.clone(),\n            ) {\n                let connector_mandate_details = HashMap::from([(\n                    merchant_connector_id.clone(),\n                    PayoutsMandateReferenceRecord {\n                        transfer_method_id: Some(connector_payout_id),\n                    },\n                )]);\n\n                let common_connector_mandate = CommonMandateReference {\n                    payments: None,\n                    payouts: Some(PayoutsMandateReference(connector_mandate_details)),\n                };\n\n                let connector_mandate_details_value = common_connector_mandate\n                    .get_mandate_details_value()\n                    .map_err(|err| {\n                        router_env::logger::error!(\n                            \"Failed to get get_mandate_details_value : {:?}\",\n                            err\n                        );\n                        errors::ApiErrorResponse::MandateUpdateFailed\n                    })?;\n\n                if let Some(pm_method) = payout_data.payment_method.clone() {\n                    let pm_update =\n                        diesel_models::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n                            #[cfg(all(\n                                any(feature = \"v1\", feature = \"v2\"),\n                                not(feature = \"payment_methods_v2\")\n                            ))]\n                            connector_mandate_details: Some(connector_mandate_details_value),\n\n                            #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n                            connector_mandate_details: Some(common_connector_mandate),\n                        };\n\n                    payout_data.payment_method = Some(\n                        db.update_payment_method(\n                            &(state.into()),\n                            key_store,\n                            pm_method,\n                            pm_update,\n                            merchant_account.storage_scheme,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n                        .attach_printable(\"Unable to find payment method\")?,\n                    );\n                } else {\n                    #[cfg(all(any(feature = \"v1\", feature = \"v2\"), not(feature = \"customer_v2\")))]\n                    let customer_id = Some(customer_details.customer_id);\n\n                    #[cfg(all(feature = \"v2\", feature = \"customer_v2\"))]\n                    let customer_id = customer_details.merchant_reference_id;\n\n                    if let Some(customer_id) = customer_id {\n                        helpers::save_payout_data_to_locker(\n                            state,\n                            payout_data,\n                            &customer_id,\n                            payout_method_data,\n                            Some(connector_mandate_details_value),\n                            merchant_account,\n                            key_store,\n                        )\n                        .await\n                        .attach_printable(\"Failed to save payout data to locker\")?;\n                    }\n                };\n            }\n        }\n        Err(err) => {\n            let (error_code, error_message) = (Some(err.code), Some(err.message));\n            let (unified_code, unified_message) = helpers::get_gsm_record(\n                state,\n                error_code.clone(),\n                error_message.clone(),\n                payout_data.payout_attempt.connector.clone(),\n                consts::PAYOUT_FLOW_STR,\n            )\n            .await\n            .map_or((None, None), |gsm| (gsm.unified_code, gsm.unified_message));\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_data.payout_attempt.connector_payout_id.to_owned(),\n                status: storage_enums::PayoutStatus::Failed,\n                error_code,\n                error_message,\n                is_eligible: None,\n                unified_code: unified_code\n                    .map(UnifiedCode::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_code\",\n                    })?,\n                unified_message: unified_message\n                    .map(UnifiedMessage::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_message\",\n                    })?,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    &payout_data.payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n        }\n    };\n\n    Ok(())\n}",
+      "diff_span": {
+        "before": "                let connector_mandate_details_value = common_connector_mandate\n                    .get_mandate_details_value()\n                    .map_err(|_| errors::ApiErrorResponse::MandateUpdateFailed)?;\n\n                if let Some(pm_method) = payout_data.payment_method.clone() {",
+        "after": "                let connector_mandate_details_value = common_connector_mandate\n                    .get_mandate_details_value()\n                    .map_err(|err| {\n                        router_env::logger::error!(\n                            \"Failed to get get_mandate_details_value : {:?}\",\n                            err\n                        );\n                        errors::ApiErrorResponse::MandateUpdateFailed\n                    })?;\n\n                if let Some(pm_method) = payout_data.payment_method.clone() {"
+      },
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de",
+      "before_imports": [
+        "use diesel_models::{\n    PaymentsMandateReference, PaymentsMandateReferenceRecord as PaymentsMandateReferenceRecordV2,\n};",
+        "use hyperswitch_domain_models::payment_methods::PaymentMethod;",
+        "use diesel_models::{\n    enums as storage_enums,\n    generic_link::{GenericLinkNew, PayoutLink},\n    CommonMandateReference, PayoutsMandateReference, PayoutsMandateReferenceRecord,\n};",
+        "use crate::{\n    core::{\n        errors::{\n            self, ConnectorErrorExt, CustomResult, RouterResponse, RouterResult, StorageErrorExt,\n        },\n        payments::{self, customers, helpers as payment_helpers},\n        utils as core_utils,\n    },\n    db::StorageInterface,\n    routes::SessionState,\n    services,\n    types::{\n        self,\n        api::{self, payments as payment_api_types, payouts},\n        domain,\n        storage::{self, PaymentRoutingInfo},\n        transformers::ForeignFrom,\n    },\n    utils::{self, OptionExt},\n};",
+        "use common_utils::{\n    consts,\n    ext_traits::{AsyncExt, ValueExt},\n    id_type::CustomerId,\n    link_utils::{GenericLinkStatus, GenericLinkUiConfig, PayoutLinkData, PayoutLinkStatus},\n    types::{MinorUnit, UnifiedCode, UnifiedMessage},\n};"
+      ],
+      "after_imports": [
+        "use diesel_models::{\n    PaymentsMandateReference, PaymentsMandateReferenceRecord as PaymentsMandateReferenceRecordV2,\n};",
+        "use hyperswitch_domain_models::payment_methods::PaymentMethod;",
+        "use diesel_models::{\n    enums as storage_enums,\n    generic_link::{GenericLinkNew, PayoutLink},\n    CommonMandateReference, PayoutsMandateReference, PayoutsMandateReferenceRecord,\n};",
+        "use router_env::{instrument, logger, tracing, Env};",
+        "use common_utils::{\n    consts,\n    ext_traits::{AsyncExt, ValueExt},\n    id_type::CustomerId,\n    link_utils::{GenericLinkStatus, GenericLinkUiConfig, PayoutLinkData, PayoutLinkStatus},\n    types::{MinorUnit, UnifiedCode, UnifiedMessage},\n};",
+        "use crate::{\n    core::{\n        errors::{\n            self, ConnectorErrorExt, CustomResult, RouterResponse, RouterResult, StorageErrorExt,\n        },\n        payments::{self, customers, helpers as payment_helpers},\n        utils as core_utils,\n    },\n    db::StorageInterface,\n    routes::SessionState,\n    services,\n    types::{\n        self,\n        api::{self, payments as payment_api_types, payouts},\n        domain,\n        storage::{self, PaymentRoutingInfo},\n        transformers::ForeignFrom,\n    },\n    utils::{self, OptionExt},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::update_connector_mandate_details",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn update_connector_mandate_details(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    object_ref_id: api::ObjectReferenceId,\n    connector: &ConnectorEnum,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n) -> CustomResult<(), errors::ApiErrorResponse> {\n    let webhook_connector_mandate_details = connector\n        .get_mandate_details(request_details)\n        .switch()\n        .attach_printable(\"Could not find connector mandate details in incoming webhook body\")?;\n\n    let webhook_connector_network_transaction_id = connector\n        .get_network_txn_id(request_details)\n        .switch()\n        .attach_printable(\n            \"Could not find connector network transaction id in incoming webhook body\",\n        )?;\n\n    // Either one OR both of the fields are present\n    if webhook_connector_mandate_details.is_some()\n        || webhook_connector_network_transaction_id.is_some()\n    {\n        let payment_attempt =\n            get_payment_attempt_from_object_reference_id(state, object_ref_id, merchant_account)\n                .await?;\n        if let Some(ref payment_method_id) = payment_attempt.payment_method_id {\n            let key_manager_state = &state.into();\n            let payment_method_info = state\n                .store\n                .find_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_id,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;\n\n            // Update connector's mandate details\n            let updated_connector_mandate_details =\n                if let Some(webhook_mandate_details) = webhook_connector_mandate_details {\n                    let mandate_details = payment_method_info\n                        .get_common_mandate_reference()\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed to deserialize to Payment Mandate Reference\")?;\n\n                    let merchant_connector_account_id = payment_attempt\n                        .merchant_connector_id\n                        .clone()\n                        .get_required_value(\"merchant_connector_id\")?;\n\n                    if mandate_details.payments.as_ref().map_or(true, |payments| {\n                        !payments.0.contains_key(&merchant_connector_account_id)\n                    }) {\n                        // Update the payment attempt to maintain consistency across tables.\n                        let (mandate_metadata, connector_mandate_request_reference_id) =\n                            payment_attempt\n                                .connector_mandate_detail\n                                .as_ref()\n                                .map(|details| {\n                                    (\n                                        details.mandate_metadata.clone(),\n                                        details.connector_mandate_request_reference_id.clone(),\n                                    )\n                                })\n                                .unwrap_or((None, None));\n\n                        let connector_mandate_reference_id = ConnectorMandateReferenceId {\n                            connector_mandate_id: Some(\n                                webhook_mandate_details\n                                    .connector_mandate_id\n                                    .peek()\n                                    .to_string(),\n                            ),\n                            payment_method_id: Some(payment_method_id.to_string()),\n                            mandate_metadata,\n                            connector_mandate_request_reference_id,\n                        };\n\n                        let attempt_update =\n                            storage::PaymentAttemptUpdate::ConnectorMandateDetailUpdate {\n                                connector_mandate_detail: Some(connector_mandate_reference_id),\n                                updated_by: merchant_account.storage_scheme.to_string(),\n                            };\n\n                        state\n                            .store\n                            .update_payment_attempt_with_attempt_id(\n                                payment_attempt.clone(),\n                                attempt_update,\n                                merchant_account.storage_scheme,\n                            )\n                            .await\n                            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n                        insert_mandate_details(\n                            &payment_attempt,\n                            &webhook_mandate_details,\n                            Some(mandate_details),\n                        )?\n                    } else {\n                        logger::info!(\n                        \"Skipping connector mandate details update since they are already present.\"\n                    );\n                        None\n                    }\n                } else {\n                    None\n                };\n\n            let connector_mandate_details_value = updated_connector_mandate_details\n                .map(|common_mandate| {\n                    common_mandate\n                        .get_mandate_details_value()\n                        .map_err(|_| errors::ApiErrorResponse::MandateUpdateFailed)\n                })\n                .transpose()?;\n\n            let pm_update = diesel_models::PaymentMethodUpdate::ConnectorNetworkTransactionIdAndMandateDetailsUpdate {\n                connector_mandate_details: connector_mandate_details_value.map(masking::Secret::new),\n                network_transaction_id: webhook_connector_network_transaction_id\n                    .map(|webhook_network_transaction_id| webhook_network_transaction_id.get_id().clone()),\n            };\n\n            state\n                .store\n                .update_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_info,\n                    pm_update,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to update payment method in db\")?;\n        }\n    }\n    Ok(())\n}",
+      "after_code": "async fn update_connector_mandate_details(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    object_ref_id: api::ObjectReferenceId,\n    connector: &ConnectorEnum,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n) -> CustomResult<(), errors::ApiErrorResponse> {\n    let webhook_connector_mandate_details = connector\n        .get_mandate_details(request_details)\n        .switch()\n        .attach_printable(\"Could not find connector mandate details in incoming webhook body\")?;\n\n    let webhook_connector_network_transaction_id = connector\n        .get_network_txn_id(request_details)\n        .switch()\n        .attach_printable(\n            \"Could not find connector network transaction id in incoming webhook body\",\n        )?;\n\n    // Either one OR both of the fields are present\n    if webhook_connector_mandate_details.is_some()\n        || webhook_connector_network_transaction_id.is_some()\n    {\n        let payment_attempt =\n            get_payment_attempt_from_object_reference_id(state, object_ref_id, merchant_account)\n                .await?;\n        if let Some(ref payment_method_id) = payment_attempt.payment_method_id {\n            let key_manager_state = &state.into();\n            let payment_method_info = state\n                .store\n                .find_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_id,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;\n\n            // Update connector's mandate details\n            let updated_connector_mandate_details =\n                if let Some(webhook_mandate_details) = webhook_connector_mandate_details {\n                    let mandate_details = payment_method_info\n                        .get_common_mandate_reference()\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed to deserialize to Payment Mandate Reference\")?;\n\n                    let merchant_connector_account_id = payment_attempt\n                        .merchant_connector_id\n                        .clone()\n                        .get_required_value(\"merchant_connector_id\")?;\n\n                    if mandate_details.payments.as_ref().map_or(true, |payments| {\n                        !payments.0.contains_key(&merchant_connector_account_id)\n                    }) {\n                        // Update the payment attempt to maintain consistency across tables.\n                        let (mandate_metadata, connector_mandate_request_reference_id) =\n                            payment_attempt\n                                .connector_mandate_detail\n                                .as_ref()\n                                .map(|details| {\n                                    (\n                                        details.mandate_metadata.clone(),\n                                        details.connector_mandate_request_reference_id.clone(),\n                                    )\n                                })\n                                .unwrap_or((None, None));\n\n                        let connector_mandate_reference_id = ConnectorMandateReferenceId {\n                            connector_mandate_id: Some(\n                                webhook_mandate_details\n                                    .connector_mandate_id\n                                    .peek()\n                                    .to_string(),\n                            ),\n                            payment_method_id: Some(payment_method_id.to_string()),\n                            mandate_metadata,\n                            connector_mandate_request_reference_id,\n                        };\n\n                        let attempt_update =\n                            storage::PaymentAttemptUpdate::ConnectorMandateDetailUpdate {\n                                connector_mandate_detail: Some(connector_mandate_reference_id),\n                                updated_by: merchant_account.storage_scheme.to_string(),\n                            };\n\n                        state\n                            .store\n                            .update_payment_attempt_with_attempt_id(\n                                payment_attempt.clone(),\n                                attempt_update,\n                                merchant_account.storage_scheme,\n                            )\n                            .await\n                            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n                        insert_mandate_details(\n                            &payment_attempt,\n                            &webhook_mandate_details,\n                            Some(mandate_details),\n                        )?\n                    } else {\n                        logger::info!(\n                        \"Skipping connector mandate details update since they are already present.\"\n                    );\n                        None\n                    }\n                } else {\n                    None\n                };\n\n            let connector_mandate_details_value = updated_connector_mandate_details\n                .map(|common_mandate| {\n                    common_mandate.get_mandate_details_value().map_err(|err| {\n                        router_env::logger::error!(\n                            \"Failed to get get_mandate_details_value : {:?}\",\n                            err\n                        );\n                        errors::ApiErrorResponse::MandateUpdateFailed\n                    })\n                })\n                .transpose()?;\n\n            let pm_update = diesel_models::PaymentMethodUpdate::ConnectorNetworkTransactionIdAndMandateDetailsUpdate {\n                connector_mandate_details: connector_mandate_details_value.map(masking::Secret::new),\n                network_transaction_id: webhook_connector_network_transaction_id\n                    .map(|webhook_network_transaction_id| webhook_network_transaction_id.get_id().clone()),\n            };\n\n            state\n                .store\n                .update_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_info,\n                    pm_update,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to update payment method in db\")?;\n        }\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "            let connector_mandate_details_value = updated_connector_mandate_details\n                .map(|common_mandate| {\n                    common_mandate\n                        .get_mandate_details_value()\n                        .map_err(|_| errors::ApiErrorResponse::MandateUpdateFailed)\n                })\n                .transpose()?;",
+        "after": "            let connector_mandate_details_value = updated_connector_mandate_details\n                .map(|common_mandate| {\n                    common_mandate.get_mandate_details_value().map_err(|err| {\n                        router_env::logger::error!(\n                            \"Failed to get get_mandate_details_value : {:?}\",\n                            err\n                        );\n                        errors::ApiErrorResponse::MandateUpdateFailed\n                    })\n                })\n                .transpose()?;"
+      },
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de"
+    },
+    {
+      "id": "crates/router/src/core/payments/helpers.rs::function::validate_merchant_connector_ids_in_connector_mandate_details",
+      "file": "crates/router/src/core/payments/helpers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn validate_merchant_connector_ids_in_connector_mandate_details(\n    state: &SessionState,\n    key_store: &domain::MerchantKeyStore,\n    connector_mandate_details: &api_models::payment_methods::CommonMandateReference,\n    merchant_id: &id_type::MerchantId,\n    card_network: Option<api_enums::CardNetwork>,\n) -> CustomResult<(), errors::ApiErrorResponse> {\n    let db = &*state.store;\n    let merchant_connector_account_list = db\n        .find_merchant_connector_account_by_merchant_id_and_disabled_list(\n            &state.into(),\n            merchant_id,\n            true,\n            key_store,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::InternalServerError)?;\n\n    let merchant_connector_account_details_hash_map: std::collections::HashMap<\n        id_type::MerchantConnectorAccountId,\n        domain::MerchantConnectorAccount,\n    > = merchant_connector_account_list\n        .iter()\n        .map(|merchant_connector_account| {\n            (\n                merchant_connector_account.get_id(),\n                merchant_connector_account.clone(),\n            )\n        })\n        .collect();\n\n    if let Some(payment_mandate_reference) = &connector_mandate_details.payments {\n        let payments_map = payment_mandate_reference.0.clone();\n        for (migrating_merchant_connector_id, migrating_connector_mandate_details) in payments_map {\n            match (\n                card_network.clone(),\n                merchant_connector_account_details_hash_map.get(&migrating_merchant_connector_id),\n            ) {\n                (Some(enums::CardNetwork::Discover), Some(merchant_connector_account_details)) => {\n                    if let (\"cybersource\", None) = (\n                        merchant_connector_account_details.connector_name.as_str(),\n                        migrating_connector_mandate_details\n                            .original_payment_authorized_amount\n                            .zip(\n                                migrating_connector_mandate_details\n                                    .original_payment_authorized_currency,\n                            ),\n                    ) {\n                        Err(errors::ApiErrorResponse::MissingRequiredFields {\n                            field_names: vec![\n                                \"original_payment_authorized_currency\",\n                                \"original_payment_authorized_amount\",\n                            ],\n                        })\n                        .attach_printable(format!(\n                            \"Invalid connector_mandate_details provided for connector {:?}\",\n                            migrating_merchant_connector_id\n                        ))?\n                    }\n                }\n                (_, Some(_)) => (),\n                (_, None) => Err(errors::ApiErrorResponse::InvalidDataValue {\n                    field_name: \"merchant_connector_id\",\n                })\n                .attach_printable_lazy(|| {\n                    format!(\n                        \"{:?} invalid merchant connector id in connector_mandate_details\",\n                        migrating_merchant_connector_id\n                    )\n                })?,\n            }\n        }\n    }\n    Ok(())\n}",
+      "after_code": "pub async fn validate_merchant_connector_ids_in_connector_mandate_details(\n    state: &SessionState,\n    key_store: &domain::MerchantKeyStore,\n    connector_mandate_details: &api_models::payment_methods::CommonMandateReference,\n    merchant_id: &id_type::MerchantId,\n    card_network: Option<api_enums::CardNetwork>,\n) -> CustomResult<(), errors::ApiErrorResponse> {\n    let db = &*state.store;\n    let merchant_connector_account_list = db\n        .find_merchant_connector_account_by_merchant_id_and_disabled_list(\n            &state.into(),\n            merchant_id,\n            true,\n            key_store,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::InternalServerError)?;\n\n    let merchant_connector_account_details_hash_map: std::collections::HashMap<\n        id_type::MerchantConnectorAccountId,\n        domain::MerchantConnectorAccount,\n    > = merchant_connector_account_list\n        .iter()\n        .map(|merchant_connector_account| {\n            (\n                merchant_connector_account.get_id(),\n                merchant_connector_account.clone(),\n            )\n        })\n        .collect();\n\n    if let Some(payment_mandate_reference) = &connector_mandate_details.payments {\n        let payments_map = payment_mandate_reference.0.clone();\n        for (migrating_merchant_connector_id, migrating_connector_mandate_details) in payments_map {\n            match (\n                card_network.clone(),\n                merchant_connector_account_details_hash_map.get(&migrating_merchant_connector_id),\n            ) {\n                (Some(enums::CardNetwork::Discover), Some(merchant_connector_account_details)) => {\n                    if let (\"cybersource\", None) = (\n                        merchant_connector_account_details.connector_name.as_str(),\n                        migrating_connector_mandate_details\n                            .original_payment_authorized_amount\n                            .zip(\n                                migrating_connector_mandate_details\n                                    .original_payment_authorized_currency,\n                            ),\n                    ) {\n                        Err(errors::ApiErrorResponse::MissingRequiredFields {\n                            field_names: vec![\n                                \"original_payment_authorized_currency\",\n                                \"original_payment_authorized_amount\",\n                            ],\n                        })\n                        .attach_printable(format!(\n                            \"Invalid connector_mandate_details provided for connector {:?}\",\n                            migrating_merchant_connector_id\n                        ))?\n                    }\n                }\n                (_, Some(_)) => (),\n                (_, None) => Err(errors::ApiErrorResponse::InvalidDataValue {\n                    field_name: \"merchant_connector_id\",\n                })\n                .attach_printable_lazy(|| {\n                    format!(\n                        \"{:?} invalid merchant connector id in connector_mandate_details\",\n                        migrating_merchant_connector_id\n                    )\n                })?,\n            }\n        }\n    } else {\n        router_env::logger::error!(\"payment mandate reference not found\");\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "",
+        "after": "            }\n        }\n    } else {\n        router_env::logger::error!(\"payment mandate reference not found\");\n    }\n    Ok(())"
+      },
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de",
+      "before_imports": [
+        "use common_utils::{\n    crypto::Encryptable,\n    ext_traits::{AsyncExt, ByteSliceExt, Encode, ValueExt},\n    fp_utils, generate_id,\n    id_type::{self},\n    new_type::{MaskedIban, MaskedSortCode},\n    pii, type_name,\n    types::{\n        keymanager::{Identifier, KeyManagerState, ToEncryptable},\n        MinorUnit,\n    },\n};",
+        "use super::*;",
+        "use crate::{\n    configs::settings::{ConnectorRequestReferenceIdConfig, TempLockerEnableConfig},\n    connector,\n    consts::{self, BASE64_ENGINE},\n    core::{\n        authentication,\n        errors::{self, CustomResult, RouterResult, StorageErrorExt},\n        mandate::helpers::MandateGenericData,\n        payment_methods::{\n            self,\n            cards::{self},\n            network_tokenization, vault,\n        },\n        payments,\n        pm_auth::retrieve_payment_method_from_auth_service,\n    },\n    db::StorageInterface,\n    routes::{metrics, payment_methods as payment_methods_handler, SessionState},\n    services,\n    types::{\n        api::{self, admin, enums as api_enums, MandateValidationFieldsExt},\n        domain::{self, types},\n        storage::{self, enums as storage_enums, ephemeral_key, CardTokenData},\n        transformers::{ForeignFrom, ForeignTryFrom},\n        AdditionalMerchantData, AdditionalPaymentMethodConnectorResponse, ErrorResponse,\n        MandateReference, MerchantAccountData, MerchantRecipientData, PaymentsResponseData,\n        RecipientIdType, RecurringMandatePaymentData, RouterData,\n    },\n    utils::{\n        self,\n        crypto::{self, SignMessage},\n        OptionExt, StringExt,\n    },\n};",
+        "use openssl::{\n    derive::Deriver,\n    pkey::PKey,\n    symm::{decrypt_aead, Cipher},\n};",
+        "use diesel_models::enums;",
+        "use super::{\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    CustomerDetails, PaymentData,\n};",
+        "use api_models::{\n    mandates::RecurringDetails,\n    payments::{additional_info as payment_additional_types, RequestSurchargeDetails},\n};"
+      ],
+      "after_imports": [
+        "use common_utils::{\n    crypto::Encryptable,\n    ext_traits::{AsyncExt, ByteSliceExt, Encode, ValueExt},\n    fp_utils, generate_id,\n    id_type::{self},\n    new_type::{MaskedIban, MaskedSortCode},\n    pii, type_name,\n    types::{\n        keymanager::{Identifier, KeyManagerState, ToEncryptable},\n        MinorUnit,\n    },\n};",
+        "use super::*;",
+        "use crate::{\n    configs::settings::{ConnectorRequestReferenceIdConfig, TempLockerEnableConfig},\n    connector,\n    consts::{self, BASE64_ENGINE},\n    core::{\n        authentication,\n        errors::{self, CustomResult, RouterResult, StorageErrorExt},\n        mandate::helpers::MandateGenericData,\n        payment_methods::{\n            self,\n            cards::{self},\n            network_tokenization, vault,\n        },\n        payments,\n        pm_auth::retrieve_payment_method_from_auth_service,\n    },\n    db::StorageInterface,\n    routes::{metrics, payment_methods as payment_methods_handler, SessionState},\n    services,\n    types::{\n        api::{self, admin, enums as api_enums, MandateValidationFieldsExt},\n        domain::{self, types},\n        storage::{self, enums as storage_enums, ephemeral_key, CardTokenData},\n        transformers::{ForeignFrom, ForeignTryFrom},\n        AdditionalMerchantData, AdditionalPaymentMethodConnectorResponse, ErrorResponse,\n        MandateReference, MerchantAccountData, MerchantRecipientData, PaymentsResponseData,\n        RecipientIdType, RecurringMandatePaymentData, RouterData,\n    },\n    utils::{\n        self,\n        crypto::{self, SignMessage},\n        OptionExt, StringExt,\n    },\n};",
+        "use router_env::{instrument, logger, tracing};",
+        "use openssl::{\n    derive::Deriver,\n    pkey::PKey,\n    symm::{decrypt_aead, Cipher},\n};",
+        "use diesel_models::enums;",
+        "use super::{\n    operations::{BoxedOperation, Operation, PaymentResponse},\n    CustomerDetails, PaymentData,\n};",
+        "use api_models::{\n    mandates::RecurringDetails,\n    payments::{additional_info as payment_additional_types, RequestSurchargeDetails},\n};"
+      ]
+    },
+    {
+      "id": "crates/api_models/src/payment_methods.rs::function::deserialize_connector_mandate_details",
+      "file": "crates/api_models/src/payment_methods.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn deserialize_connector_mandate_details<'de, D>(\n    deserializer: D,\n) -> Result<Option<CommonMandateReference>, D::Error>\nwhere\n    D: serde::Deserializer<'de>,\n{\n    let value: Option<serde_json::Value> =\n        <Option<serde_json::Value> as de::Deserialize>::deserialize(deserializer)?;\n\n    let payments_data = value\n        .clone()\n        .map(|mut mandate_details| {\n            mandate_details\n                .as_object_mut()\n                .map(|obj| obj.remove(\"payouts\"));\n\n            serde_json::from_value::<PaymentsMandateReference>(mandate_details)\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize PaymentsMandateReference\"))?;\n\n    let payouts_data = value\n        .clone()\n        .map(|mandate_details| {\n            serde_json::from_value::<Option<CommonMandateReference>>(mandate_details).map(\n                |optional_common_mandate_details| {\n                    optional_common_mandate_details\n                        .and_then(|common_mandate_details| common_mandate_details.payouts)\n                },\n            )\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize CommonMandateReference\"))?\n        .flatten();\n\n    Ok(Some(CommonMandateReference {\n        payments: payments_data,\n        payouts: payouts_data,\n    }))\n}",
+      "after_code": "fn deserialize_connector_mandate_details<'de, D>(\n    deserializer: D,\n) -> Result<Option<CommonMandateReference>, D::Error>\nwhere\n    D: serde::Deserializer<'de>,\n{\n    let value: Option<serde_json::Value> =\n        <Option<serde_json::Value> as de::Deserialize>::deserialize(deserializer)?;\n\n    let payments_data = value\n        .clone()\n        .map(|mut mandate_details| {\n            mandate_details\n                .as_object_mut()\n                .map(|obj| obj.remove(\"payouts\"));\n\n            serde_json::from_value::<PaymentsMandateReference>(mandate_details)\n        })\n        .transpose()\n        .map_err(|err| {\n            let err_msg = format!(\"{err:?}\");\n            de::Error::custom(format_args!(\n                \"Failed to deserialize PaymentsMandateReference `{}`\",\n                err_msg\n            ))\n        })?;\n\n    let payouts_data = value\n        .clone()\n        .map(|mandate_details| {\n            serde_json::from_value::<Option<CommonMandateReference>>(mandate_details).map(\n                |optional_common_mandate_details| {\n                    optional_common_mandate_details\n                        .and_then(|common_mandate_details| common_mandate_details.payouts)\n                },\n            )\n        })\n        .transpose()\n        .map_err(|err| {\n            let err_msg = format!(\"{err:?}\");\n            de::Error::custom(format_args!(\n                \"Failed to deserialize CommonMandateReference `{}`\",\n                err_msg\n            ))\n        })?\n        .flatten();\n\n    Ok(Some(CommonMandateReference {\n        payments: payments_data,\n        payouts: payouts_data,\n    }))\n}",
+      "diff_span": {
+        "before": "        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize PaymentsMandateReference\"))?;\n\n    let payouts_data = value\n        .clone()\n        .map(|mandate_details| {\n            serde_json::from_value::<Option<CommonMandateReference>>(mandate_details).map(\n                |optional_common_mandate_details| {\n                    optional_common_mandate_details\n                        .and_then(|common_mandate_details| common_mandate_details.payouts)\n                },\n            )\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize CommonMandateReference\"))?\n        .flatten();\n",
+        "after": "        })\n        .transpose()\n        .map_err(|err| {\n            let err_msg = format!(\"{err:?}\");\n            de::Error::custom(format_args!(\n                \"Failed to deserialize PaymentsMandateReference `{}`\",\n                err_msg\n            ))\n        })?;\n\n    let payouts_data = value\n        .clone()\n        .map(|mandate_details| {\n            serde_json::from_value::<Option<CommonMandateReference>>(mandate_details).map(\n                |optional_common_mandate_details| {\n                    optional_common_mandate_details\n                        .and_then(|common_mandate_details| common_mandate_details.payouts)\n                },\n            )\n        })\n        .transpose()\n        .map_err(|err| {\n            let err_msg = format!(\"{err:?}\");\n            de::Error::custom(format_args!(\n                \"Failed to deserialize CommonMandateReference `{}`\",\n                err_msg\n            ))\n        })?\n        .flatten();\n"
+      },
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de"
+    },
+    {
+      "id": "crates/hyperswitch_domain_models/src/mandates.rs::struct::PaymentsMandateReference",
+      "file": "crates/hyperswitch_domain_models/src/mandates.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PaymentsMandateReference(\n    pub HashMap<common_utils::id_type::MerchantConnectorAccountId, PaymentsMandateReferenceRecord>,\n);",
+      "diff_span": null,
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de"
+    },
+    {
+      "id": "crates/hyperswitch_domain_models/src/mandates.rs::struct::CommonMandateReference",
+      "file": "crates/hyperswitch_domain_models/src/mandates.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct CommonMandateReference {\n    pub payments: Option<PaymentsMandateReference>,\n    pub payouts: Option<PayoutsMandateReference>,\n}",
+      "diff_span": null,
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de"
+    },
+    {
+      "id": "crates/hyperswitch_domain_models/src/mandates.rs::struct::PayoutsMandateReferenceRecord",
+      "file": "crates/hyperswitch_domain_models/src/mandates.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PayoutsMandateReferenceRecord {\n    pub transfer_method_id: Option<String>,\n}",
+      "diff_span": null,
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de"
+    },
+    {
+      "id": "crates/hyperswitch_domain_models/src/mandates.rs::struct::PayoutsMandateReference",
+      "file": "crates/hyperswitch_domain_models/src/mandates.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PayoutsMandateReference(\n    pub HashMap<common_utils::id_type::MerchantConnectorAccountId, PayoutsMandateReferenceRecord>,\n);",
+      "diff_span": null,
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de"
+    },
+    {
+      "id": "crates/hyperswitch_domain_models/src/mandates.rs::struct::PaymentsMandateReferenceRecord",
+      "file": "crates/hyperswitch_domain_models/src/mandates.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PaymentsMandateReferenceRecord {\n    pub connector_mandate_id: String,\n    pub payment_method_type: Option<common_enums::PaymentMethodType>,\n    pub original_payment_authorized_amount: Option<i64>,\n    pub original_payment_authorized_currency: Option<Currency>,\n    pub mandate_metadata: Option<pii::SecretSerdeValue>,\n    pub connector_mandate_status: Option<common_enums::ConnectorMandateStatus>,\n    pub connector_mandate_request_reference_id: Option<String>,\n}",
+      "diff_span": null,
+      "commit_sha": "3cd9d76b6896bef96373169009468c171f88a9de"
+    }
+  ]
+}

diffs/pr_6687/42f45b0/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "42f45b084ca1fcdb95d669ff449fb4bd8182f3ce",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/router/src/core/payouts.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payouts.rs::function::payout_create_db_entries",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn payout_create_db_entries(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    req: &payouts::PayoutCreateRequest,\n    payout_id: &String,\n    profile_id: &common_utils::id_type::ProfileId,\n    stored_payout_method_data: Option<&payouts::PayoutMethodData>,\n    locale: &str,\n    customer: Option<&domain::Customer>,\n    payment_method: Option<PaymentMethod>,\n) -> RouterResult<PayoutData> {\n    let db = &*state.store;\n    let merchant_id = merchant_account.get_id();\n    let customer_id = customer.map(|cust| cust.customer_id.clone());\n\n    // Validate whether profile_id passed in request is valid and is linked to the merchant\n    let business_profile =\n        validate_and_get_business_profile(state, key_store, profile_id, merchant_id).await?;\n\n    let payout_link = match req.payout_link {\n        Some(true) => Some(\n            create_payout_link(\n                state,\n                &business_profile,\n                &customer_id\n                    .clone()\n                    .get_required_value(\"customer.id when payout_link is true\")?,\n                merchant_id,\n                req,\n                payout_id,\n                locale,\n            )\n            .await?,\n        ),\n        _ => None,\n    };\n\n    // We have to do this because the function that is being used to create / get address is from payments\n    // which expects a payment_id\n    let payout_id_as_payment_id_type =\n        common_utils::id_type::PaymentId::try_from(std::borrow::Cow::Owned(payout_id.to_string()))\n            .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                message: \"payout_id contains invalid data\".to_string(),\n            })\n            .attach_printable(\"Error converting payout_id to PaymentId type\")?;\n\n    // Get or create address\n    let billing_address = payment_helpers::create_or_find_address_for_payment_by_request(\n        state,\n        req.billing.as_ref(),\n        None,\n        merchant_id,\n        customer_id.as_ref(),\n        key_store,\n        &payout_id_as_payment_id_type,\n        merchant_account.storage_scheme,\n    )\n    .await?;\n    let address_id = billing_address.to_owned().map(|address| address.address_id);\n\n    // Make payouts entry\n    let currency = req.currency.to_owned().get_required_value(\"currency\")?;\n\n    let (payout_method_id, payout_type) = match stored_payout_method_data {\n        Some(payout_method_data) => (\n            req.payout_token.to_owned(),\n            Some(api_enums::PayoutType::foreign_from(payout_method_data)),\n        ),\n        None => (\n            payment_method\n                .as_ref()\n                .map(|pm| pm.payment_method_id.clone()),\n            req.payout_type.to_owned(),\n        ),\n    };\n\n    let client_secret = utils::generate_id(\n        consts::ID_LENGTH,\n        format!(\"payout_{payout_id}_secret\").as_str(),\n    );\n    let amount = MinorUnit::from(req.amount.unwrap_or(api::Amount::Zero));\n    let status = if req.payout_method_data.is_some()\n        || req.payout_token.is_some()\n        || stored_payout_method_data.is_some()\n    {\n        match req.confirm {\n            Some(true) => storage_enums::PayoutStatus::RequiresCreation,\n            _ => storage_enums::PayoutStatus::RequiresConfirmation,\n        }\n    } else {\n        storage_enums::PayoutStatus::RequiresPayoutMethodData\n    };\n\n    let payouts_req = storage::PayoutsNew {\n        payout_id: payout_id.to_string(),\n        merchant_id: merchant_id.to_owned(),\n        customer_id: customer_id.to_owned(),\n        address_id: address_id.to_owned(),\n        payout_type,\n        amount,\n        destination_currency: currency,\n        source_currency: currency,\n        description: req.description.to_owned(),\n        recurring: req.recurring.unwrap_or(false),\n        auto_fulfill: req.auto_fulfill.unwrap_or(false),\n        return_url: req.return_url.to_owned(),\n        entity_type: req.entity_type.unwrap_or_default(),\n        payout_method_id,\n        profile_id: profile_id.to_owned(),\n        attempt_count: 1,\n        metadata: req.metadata.clone(),\n        confirm: req.confirm,\n        payout_link_id: payout_link\n            .clone()\n            .map(|link_data| link_data.link_id.clone()),\n        client_secret: Some(client_secret),\n        priority: req.priority,\n        status,\n        created_at: common_utils::date_time::now(),\n        last_modified_at: common_utils::date_time::now(),\n    };\n    let payouts = db\n        .insert_payout(payouts_req, merchant_account.storage_scheme)\n        .await\n        .to_duplicate_response(errors::ApiErrorResponse::DuplicatePayout {\n            payout_id: payout_id.to_owned(),\n        })\n        .attach_printable(\"Error inserting payouts in db\")?;\n    // Make payout_attempt entry\n    let payout_attempt_id = utils::get_payout_attempt_id(payout_id, 1);\n\n    let additional_pm_data_value = req\n        .payout_method_data\n        .clone()\n        .or(stored_payout_method_data.cloned())\n        .async_and_then(|payout_method_data| async move {\n            helpers::get_additional_payout_data(&payout_method_data, &*state.store, profile_id)\n                .await\n        })\n        .await;\n\n    let payout_attempt_req = storage::PayoutAttemptNew {\n        payout_attempt_id: payout_attempt_id.to_string(),\n        payout_id: payout_id.to_owned(),\n        additional_payout_method_data: additional_pm_data_value,\n        merchant_id: merchant_id.to_owned(),\n        status,\n        business_country: req.business_country.to_owned(),\n        business_label: req.business_label.to_owned(),\n        payout_token: req.payout_token.to_owned(),\n        profile_id: profile_id.to_owned(),\n        customer_id,\n        address_id,\n        connector: None,\n        connector_payout_id: None,\n        is_eligible: None,\n        error_message: None,\n        error_code: None,\n        created_at: common_utils::date_time::now(),\n        last_modified_at: common_utils::date_time::now(),\n        merchant_connector_id: None,\n        routing_info: None,\n        unified_code: None,\n        unified_message: None,\n    };\n    let payout_attempt = db\n        .insert_payout_attempt(\n            payout_attempt_req,\n            &payouts,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_duplicate_response(errors::ApiErrorResponse::DuplicatePayout {\n            payout_id: payout_id.to_owned(),\n        })\n        .attach_printable(\"Error inserting payout_attempt in db\")?;\n\n    // Make PayoutData\n    Ok(PayoutData {\n        billing_address,\n        business_profile,\n        customer_details: customer.map(ToOwned::to_owned),\n        merchant_connector_account: None,\n        payouts,\n        payout_attempt,\n        payout_method_data: req\n            .payout_method_data\n            .as_ref()\n            .cloned()\n            .or(stored_payout_method_data.cloned()),\n        should_terminate: false,\n        profile_id: profile_id.to_owned(),\n        payout_link,\n        current_locale: locale.to_string(),\n        payment_method,\n    })\n}",
+      "after_code": "pub async fn payout_create_db_entries(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    req: &payouts::PayoutCreateRequest,\n    payout_id: &String,\n    profile_id: &common_utils::id_type::ProfileId,\n    stored_payout_method_data: Option<&payouts::PayoutMethodData>,\n    locale: &str,\n    customer: Option<&domain::Customer>,\n    payment_method: Option<PaymentMethod>,\n) -> RouterResult<PayoutData> {\n    let db = &*state.store;\n    let merchant_id = merchant_account.get_id();\n    let customer_id = customer.map(|cust| cust.customer_id.clone());\n\n    // Validate whether profile_id passed in request is valid and is linked to the merchant\n    let business_profile =\n        validate_and_get_business_profile(state, key_store, profile_id, merchant_id).await?;\n\n    let payout_link = match req.payout_link {\n        Some(true) => Some(\n            create_payout_link(\n                state,\n                &business_profile,\n                &customer_id\n                    .clone()\n                    .get_required_value(\"customer.id when payout_link is true\")?,\n                merchant_id,\n                req,\n                payout_id,\n                locale,\n            )\n            .await?,\n        ),\n        _ => None,\n    };\n\n    // We have to do this because the function that is being used to create / get address is from payments\n    // which expects a payment_id\n    let payout_id_as_payment_id_type =\n        common_utils::id_type::PaymentId::try_from(std::borrow::Cow::Owned(payout_id.to_string()))\n            .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                message: \"payout_id contains invalid data\".to_string(),\n            })\n            .attach_printable(\"Error converting payout_id to PaymentId type\")?;\n\n    // Get or create address\n    let billing_address = payment_helpers::create_or_find_address_for_payment_by_request(\n        state,\n        req.billing.as_ref(),\n        None,\n        merchant_id,\n        customer_id.as_ref(),\n        key_store,\n        &payout_id_as_payment_id_type,\n        merchant_account.storage_scheme,\n    )\n    .await?;\n    let address_id = billing_address.to_owned().map(|address| address.address_id);\n\n    // Make payouts entry\n    let currency = req.currency.to_owned().get_required_value(\"currency\")?;\n\n    let (payout_method_id, payout_type) = match stored_payout_method_data {\n        Some(payout_method_data) => (\n            payment_method\n                .as_ref()\n                .map(|pm| pm.payment_method_id.clone()),\n            Some(api_enums::PayoutType::foreign_from(payout_method_data)),\n        ),\n        None => (\n            payment_method\n                .as_ref()\n                .map(|pm| pm.payment_method_id.clone()),\n            req.payout_type.to_owned(),\n        ),\n    };\n\n    let client_secret = utils::generate_id(\n        consts::ID_LENGTH,\n        format!(\"payout_{payout_id}_secret\").as_str(),\n    );\n    let amount = MinorUnit::from(req.amount.unwrap_or(api::Amount::Zero));\n    let status = if req.payout_method_data.is_some()\n        || req.payout_token.is_some()\n        || stored_payout_method_data.is_some()\n    {\n        match req.confirm {\n            Some(true) => storage_enums::PayoutStatus::RequiresCreation,\n            _ => storage_enums::PayoutStatus::RequiresConfirmation,\n        }\n    } else {\n        storage_enums::PayoutStatus::RequiresPayoutMethodData\n    };\n\n    let payouts_req = storage::PayoutsNew {\n        payout_id: payout_id.to_string(),\n        merchant_id: merchant_id.to_owned(),\n        customer_id: customer_id.to_owned(),\n        address_id: address_id.to_owned(),\n        payout_type,\n        amount,\n        destination_currency: currency,\n        source_currency: currency,\n        description: req.description.to_owned(),\n        recurring: req.recurring.unwrap_or(false),\n        auto_fulfill: req.auto_fulfill.unwrap_or(false),\n        return_url: req.return_url.to_owned(),\n        entity_type: req.entity_type.unwrap_or_default(),\n        payout_method_id,\n        profile_id: profile_id.to_owned(),\n        attempt_count: 1,\n        metadata: req.metadata.clone(),\n        confirm: req.confirm,\n        payout_link_id: payout_link\n            .clone()\n            .map(|link_data| link_data.link_id.clone()),\n        client_secret: Some(client_secret),\n        priority: req.priority,\n        status,\n        created_at: common_utils::date_time::now(),\n        last_modified_at: common_utils::date_time::now(),\n    };\n    let payouts = db\n        .insert_payout(payouts_req, merchant_account.storage_scheme)\n        .await\n        .to_duplicate_response(errors::ApiErrorResponse::DuplicatePayout {\n            payout_id: payout_id.to_owned(),\n        })\n        .attach_printable(\"Error inserting payouts in db\")?;\n    // Make payout_attempt entry\n    let payout_attempt_id = utils::get_payout_attempt_id(payout_id, 1);\n\n    let additional_pm_data_value = req\n        .payout_method_data\n        .clone()\n        .or(stored_payout_method_data.cloned())\n        .async_and_then(|payout_method_data| async move {\n            helpers::get_additional_payout_data(&payout_method_data, &*state.store, profile_id)\n                .await\n        })\n        .await;\n\n    let payout_attempt_req = storage::PayoutAttemptNew {\n        payout_attempt_id: payout_attempt_id.to_string(),\n        payout_id: payout_id.to_owned(),\n        additional_payout_method_data: additional_pm_data_value,\n        merchant_id: merchant_id.to_owned(),\n        status,\n        business_country: req.business_country.to_owned(),\n        business_label: req.business_label.to_owned(),\n        payout_token: req.payout_token.to_owned(),\n        profile_id: profile_id.to_owned(),\n        customer_id,\n        address_id,\n        connector: None,\n        connector_payout_id: None,\n        is_eligible: None,\n        error_message: None,\n        error_code: None,\n        created_at: common_utils::date_time::now(),\n        last_modified_at: common_utils::date_time::now(),\n        merchant_connector_id: None,\n        routing_info: None,\n        unified_code: None,\n        unified_message: None,\n    };\n    let payout_attempt = db\n        .insert_payout_attempt(\n            payout_attempt_req,\n            &payouts,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_duplicate_response(errors::ApiErrorResponse::DuplicatePayout {\n            payout_id: payout_id.to_owned(),\n        })\n        .attach_printable(\"Error inserting payout_attempt in db\")?;\n\n    // Make PayoutData\n    Ok(PayoutData {\n        billing_address,\n        business_profile,\n        customer_details: customer.map(ToOwned::to_owned),\n        merchant_connector_account: None,\n        payouts,\n        payout_attempt,\n        payout_method_data: req\n            .payout_method_data\n            .as_ref()\n            .cloned()\n            .or(stored_payout_method_data.cloned()),\n        should_terminate: false,\n        profile_id: profile_id.to_owned(),\n        payout_link,\n        current_locale: locale.to_string(),\n        payment_method,\n    })\n}",
+      "diff_span": {
+        "before": "    let (payout_method_id, payout_type) = match stored_payout_method_data {\n        Some(payout_method_data) => (\n            req.payout_token.to_owned(),\n            Some(api_enums::PayoutType::foreign_from(payout_method_data)),\n        ),",
+        "after": "    let (payout_method_id, payout_type) = match stored_payout_method_data {\n        Some(payout_method_data) => (\n            payment_method\n                .as_ref()\n                .map(|pm| pm.payment_method_id.clone()),\n            Some(api_enums::PayoutType::foreign_from(payout_method_data)),\n        ),"
+      },
+      "commit_sha": "42f45b084ca1fcdb95d669ff449fb4bd8182f3ce"
+    }
+  ]
+}

diffs/pr_6687/4ab0b34/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "4ab0b344429642ad195226fc2904565bc98d9ae9",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/hyperswitch_domain_models/src/merchant_connector_account.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6687/625a49c/diff.json

@@ -0,0 +1,51 @@
+{
+  "commit_sha": "625a49c7d87d962afd33298be5ed6a9e8b822910",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/diesel_models/src/payment_method.rs",
+    "crates/router/src/core/payouts/helpers.rs",
+    "crates/router/src/core/utils.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payouts/helpers.rs::function::should_create_connector_transfer_method",
+      "file": "crates/router/src/core/payouts/helpers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn should_create_connector_transfer_method(\n    payout_data: &PayoutData,\n    connector_data: &api::ConnectorData,\n) -> RouterResult<Option<String>> {\n    let connector_mandate_id = if let Some(pm) = &payout_data.payment_method {\n        #[cfg(all(\n            any(feature = \"v1\", feature = \"v2\"),\n            not(feature = \"payment_methods_v2\")\n        ))]\n        let connector_mandate_details = pm\n            .connector_mandate_details\n            .clone()\n            .map(|details| {\n                details.parse_value::<diesel_models::CommonMandateReference>(\n                    \"connector_common_mandate_details\",\n                )\n            })\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to deserialize connector mandate details\")?;\n        #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n        let connector_mandate_details = pm.connector_mandate_details.clone();\n        if let Some(merchant_connector_id) = connector_data.merchant_connector_id.as_ref() {\n            connector_mandate_details\n                .clone()\n                .and_then(|common_mandate_reference| {\n                    common_mandate_reference\n                        .payouts\n                        .clone()\n                        .and_then(|payouts_mandate_reference| {\n                            payouts_mandate_reference.get(merchant_connector_id).map(\n                                |payouts_mandate_reference_record| {\n                                    payouts_mandate_reference_record.transfer_method_id.clone()\n                                },\n                            )\n                        })\n                        .flatten()\n                })\n        } else {\n            None\n        }\n    } else {\n        None\n    };\n\n    Ok(connector_mandate_id)\n}",
+      "after_code": "pub fn should_create_connector_transfer_method(\n    payout_data: &PayoutData,\n    connector_data: &api::ConnectorData,\n) -> RouterResult<Option<String>> {\n    let connector_transfer_method_id = if let Some(pm) = &payout_data.payment_method {\n        #[cfg(all(\n            any(feature = \"v1\", feature = \"v2\"),\n            not(feature = \"payment_methods_v2\")\n        ))]\n        let common_mandate_reference = storage::PaymentMethod::get_common_mandate_reference(\n            pm.connector_mandate_details.clone(),\n        )\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"unable to deserialize connector mandate details\")?;\n\n        if let Some(merchant_connector_id) = connector_data.merchant_connector_id.as_ref() {\n            common_mandate_reference\n                .payouts\n                .and_then(|payouts_mandate_reference| {\n                    payouts_mandate_reference.get(merchant_connector_id).map(\n                        |payouts_mandate_reference_record| {\n                            payouts_mandate_reference_record.transfer_method_id.clone()\n                        },\n                    )\n                })\n                .flatten()\n        } else {\n            None\n        }\n    } else {\n        None\n    };\n    Ok(connector_transfer_method_id)\n}",
+      "diff_span": {
+        "before": "    connector_data: &api::ConnectorData,\n) -> RouterResult<Option<String>> {\n    let connector_mandate_id = if let Some(pm) = &payout_data.payment_method {\n        #[cfg(all(\n            any(feature = \"v1\", feature = \"v2\"),\n            not(feature = \"payment_methods_v2\")\n        ))]\n        let connector_mandate_details = pm\n            .connector_mandate_details\n            .clone()\n            .map(|details| {\n                details.parse_value::<diesel_models::CommonMandateReference>(\n                    \"connector_common_mandate_details\",\n                )\n            })\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to deserialize connector mandate details\")?;\n        #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n        let connector_mandate_details = pm.connector_mandate_details.clone();\n        if let Some(merchant_connector_id) = connector_data.merchant_connector_id.as_ref() {\n            connector_mandate_details\n                .clone()\n                .and_then(|common_mandate_reference| {\n                    common_mandate_reference\n                        .payouts\n                        .clone()\n                        .and_then(|payouts_mandate_reference| {\n                            payouts_mandate_reference.get(merchant_connector_id).map(\n                                |payouts_mandate_reference_record| {\n                                    payouts_mandate_reference_record.transfer_method_id.clone()\n                                },\n                            )\n                        })\n                        .flatten()\n                })\n        } else {\n            None\n        }\n    } else {\n        None\n    };\n\n    Ok(connector_mandate_id)\n}",
+        "after": "    connector_data: &api::ConnectorData,\n) -> RouterResult<Option<String>> {\n    let connector_transfer_method_id = if let Some(pm) = &payout_data.payment_method {\n        #[cfg(all(\n            any(feature = \"v1\", feature = \"v2\"),\n            not(feature = \"payment_methods_v2\")\n        ))]\n        let common_mandate_reference = storage::PaymentMethod::get_common_mandate_reference(\n            pm.connector_mandate_details.clone(),\n        )\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"unable to deserialize connector mandate details\")?;\n\n        if let Some(merchant_connector_id) = connector_data.merchant_connector_id.as_ref() {\n            common_mandate_reference\n                .payouts\n                .and_then(|payouts_mandate_reference| {\n                    payouts_mandate_reference.get(merchant_connector_id).map(\n                        |payouts_mandate_reference_record| {\n                            payouts_mandate_reference_record.transfer_method_id.clone()\n                        },\n                    )\n                })\n                .flatten()\n        } else {\n            None\n        }\n    } else {\n        None\n    };\n    Ok(connector_transfer_method_id)\n}"
+      },
+      "commit_sha": "625a49c7d87d962afd33298be5ed6a9e8b822910"
+    },
+    {
+      "id": "crates/router/src/core/utils.rs::function::construct_payout_router_data",
+      "file": "crates/router/src/core/utils.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn construct_payout_router_data<'a, F>(\n    state: &SessionState,\n    connector_data: &api::ConnectorData,\n    merchant_account: &domain::MerchantAccount,\n    payout_data: &mut PayoutData,\n) -> RouterResult<types::PayoutsRouterData<F>> {\n    let merchant_connector_account = payout_data\n        .merchant_connector_account\n        .clone()\n        .get_required_value(\"merchant_connector_account\")?;\n    let connector_name = connector_data.connector_name;\n    let connector_auth_type: types::ConnectorAuthType = merchant_connector_account\n        .get_connector_account_details()\n        .parse_value(\"ConnectorAuthType\")\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let billing = payout_data.billing_address.to_owned();\n\n    let billing_address = billing.map(|a| {\n        let phone_details = api_models::payments::PhoneDetails {\n            number: a.phone_number.clone().map(Encryptable::into_inner),\n            country_code: a.country_code.to_owned(),\n        };\n        let address_details = api_models::payments::AddressDetails {\n            city: a.city.to_owned(),\n            country: a.country.to_owned(),\n            line1: a.line1.clone().map(Encryptable::into_inner),\n            line2: a.line2.clone().map(Encryptable::into_inner),\n            line3: a.line3.clone().map(Encryptable::into_inner),\n            zip: a.zip.clone().map(Encryptable::into_inner),\n            first_name: a.first_name.clone().map(Encryptable::into_inner),\n            last_name: a.last_name.clone().map(Encryptable::into_inner),\n            state: a.state.map(Encryptable::into_inner),\n        };\n\n        api_models::payments::Address {\n            phone: Some(phone_details),\n            address: Some(address_details),\n            email: a.email.to_owned().map(Email::from),\n        }\n    });\n\n    let address = PaymentAddress::new(None, billing_address.map(From::from), None, None);\n\n    let test_mode: Option<bool> = merchant_connector_account.is_test_mode_on();\n    let payouts = &payout_data.payouts;\n    let payout_attempt = &payout_data.payout_attempt;\n    let customer_details = &payout_data.customer_details;\n    let connector_label = format!(\n        \"{}_{}\",\n        payout_data.profile_id.get_string_repr(),\n        connector_name\n    );\n    let connector_customer_id = customer_details\n        .as_ref()\n        .and_then(|c| c.connector_customer.as_ref())\n        .and_then(|connector_customer_value| {\n            connector_customer_value\n                .clone()\n                .expose()\n                .get(connector_label)\n                .cloned()\n        })\n        .and_then(|id| serde_json::from_value::<String>(id).ok());\n\n    let vendor_details: Option<PayoutVendorAccountDetails> =\n        match api_models::enums::PayoutConnectors::try_from(connector_name.to_owned()).map_err(\n            |err| report!(errors::ApiErrorResponse::InternalServerError).attach_printable(err),\n        )? {\n            api_models::enums::PayoutConnectors::Stripe => {\n                payout_data.payouts.metadata.to_owned().and_then(|meta| {\n                    let val = meta\n                        .peek()\n                        .to_owned()\n                        .parse_value(\"PayoutVendorAccountDetails\")\n                        .ok();\n                    val\n                })\n            }\n            _ => None,\n        };\n\n    let connector_mandate_id =\n        payout_helpers::should_create_connector_transfer_method(&*payout_data, connector_data)?;\n\n    let router_data = types::RouterData {\n        flow: PhantomData,\n        merchant_id: merchant_account.get_id().to_owned(),\n        customer_id: customer_details.to_owned().map(|c| c.customer_id),\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_customer: connector_customer_id,\n        connector: connector_name.to_string(),\n        payment_id: common_utils::id_type::PaymentId::get_irrelevant_id(\"payout\")\n            .get_string_repr()\n            .to_owned(),\n        attempt_id: \"\".to_string(),\n        status: enums::AttemptStatus::Failure,\n        payment_method: enums::PaymentMethod::default(),\n        connector_auth_type,\n        description: None,\n        address,\n        auth_type: enums::AuthenticationType::default(),\n        connector_meta_data: merchant_connector_account.get_metadata(),\n        connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),\n        amount_captured: None,\n        minor_amount_captured: None,\n        payment_method_status: None,\n        request: types::PayoutsData {\n            payout_id: payouts.payout_id.to_owned(),\n            amount: payouts.amount.get_amount_as_i64(),\n            minor_amount: payouts.amount,\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            destination_currency: payouts.destination_currency,\n            source_currency: payouts.source_currency,\n            entity_type: payouts.entity_type.to_owned(),\n            payout_type: payouts.payout_type,\n            vendor_details,\n            priority: payouts.priority,\n            customer_details: customer_details\n                .to_owned()\n                .map(|c| payments::CustomerDetails {\n                    customer_id: Some(c.customer_id),\n                    name: c.name.map(Encryptable::into_inner),\n                    email: c.email.map(Email::from),\n                    phone: c.phone.map(Encryptable::into_inner),\n                    phone_country_code: c.phone_country_code,\n                }),\n            connector_transfer_method_id: connector_mandate_id,\n        },\n        response: Ok(types::PayoutsResponseData::default()),\n        access_token: None,\n        session_token: None,\n        reference_id: None,\n        payment_method_token: None,\n        recurring_mandate_payment_data: None,\n        preprocessing_id: None,\n        connector_request_reference_id: payout_attempt.payout_attempt_id.clone(),\n        payout_method_data: payout_data.payout_method_data.to_owned(),\n        quote_id: None,\n        test_mode,\n        payment_method_balance: None,\n        connector_api_version: None,\n        connector_http_status_code: None,\n        external_latency: None,\n        apple_pay_flow: None,\n        frm_metadata: None,\n        refund_id: None,\n        dispute_id: None,\n        connector_response: None,\n        integrity_check: Ok(()),\n        additional_merchant_data: None,\n        header_payload: None,\n        connector_mandate_request_reference_id: None,\n        authentication_id: None,\n        psd2_sca_exemption_type: None,\n    };\n\n    Ok(router_data)\n}",
+      "after_code": "pub async fn construct_payout_router_data<'a, F>(\n    state: &SessionState,\n    connector_data: &api::ConnectorData,\n    merchant_account: &domain::MerchantAccount,\n    payout_data: &mut PayoutData,\n) -> RouterResult<types::PayoutsRouterData<F>> {\n    let merchant_connector_account = payout_data\n        .merchant_connector_account\n        .clone()\n        .get_required_value(\"merchant_connector_account\")?;\n    let connector_name = connector_data.connector_name;\n    let connector_auth_type: types::ConnectorAuthType = merchant_connector_account\n        .get_connector_account_details()\n        .parse_value(\"ConnectorAuthType\")\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let billing = payout_data.billing_address.to_owned();\n\n    let billing_address = billing.map(|a| {\n        let phone_details = api_models::payments::PhoneDetails {\n            number: a.phone_number.clone().map(Encryptable::into_inner),\n            country_code: a.country_code.to_owned(),\n        };\n        let address_details = api_models::payments::AddressDetails {\n            city: a.city.to_owned(),\n            country: a.country.to_owned(),\n            line1: a.line1.clone().map(Encryptable::into_inner),\n            line2: a.line2.clone().map(Encryptable::into_inner),\n            line3: a.line3.clone().map(Encryptable::into_inner),\n            zip: a.zip.clone().map(Encryptable::into_inner),\n            first_name: a.first_name.clone().map(Encryptable::into_inner),\n            last_name: a.last_name.clone().map(Encryptable::into_inner),\n            state: a.state.map(Encryptable::into_inner),\n        };\n\n        api_models::payments::Address {\n            phone: Some(phone_details),\n            address: Some(address_details),\n            email: a.email.to_owned().map(Email::from),\n        }\n    });\n\n    let address = PaymentAddress::new(None, billing_address.map(From::from), None, None);\n\n    let test_mode: Option<bool> = merchant_connector_account.is_test_mode_on();\n    let payouts = &payout_data.payouts;\n    let payout_attempt = &payout_data.payout_attempt;\n    let customer_details = &payout_data.customer_details;\n    let connector_label = format!(\n        \"{}_{}\",\n        payout_data.profile_id.get_string_repr(),\n        connector_name\n    );\n    let connector_customer_id = customer_details\n        .as_ref()\n        .and_then(|c| c.connector_customer.as_ref())\n        .and_then(|connector_customer_value| {\n            connector_customer_value\n                .clone()\n                .expose()\n                .get(connector_label)\n                .cloned()\n        })\n        .and_then(|id| serde_json::from_value::<String>(id).ok());\n\n    let vendor_details: Option<PayoutVendorAccountDetails> =\n        match api_models::enums::PayoutConnectors::try_from(connector_name.to_owned()).map_err(\n            |err| report!(errors::ApiErrorResponse::InternalServerError).attach_printable(err),\n        )? {\n            api_models::enums::PayoutConnectors::Stripe => {\n                payout_data.payouts.metadata.to_owned().and_then(|meta| {\n                    let val = meta\n                        .peek()\n                        .to_owned()\n                        .parse_value(\"PayoutVendorAccountDetails\")\n                        .ok();\n                    val\n                })\n            }\n            _ => None,\n        };\n\n    let connector_transfer_method_id =\n        payout_helpers::should_create_connector_transfer_method(&*payout_data, connector_data)?;\n\n    let router_data = types::RouterData {\n        flow: PhantomData,\n        merchant_id: merchant_account.get_id().to_owned(),\n        customer_id: customer_details.to_owned().map(|c| c.customer_id),\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_customer: connector_customer_id,\n        connector: connector_name.to_string(),\n        payment_id: common_utils::id_type::PaymentId::get_irrelevant_id(\"payout\")\n            .get_string_repr()\n            .to_owned(),\n        attempt_id: \"\".to_string(),\n        status: enums::AttemptStatus::Failure,\n        payment_method: enums::PaymentMethod::default(),\n        connector_auth_type,\n        description: None,\n        address,\n        auth_type: enums::AuthenticationType::default(),\n        connector_meta_data: merchant_connector_account.get_metadata(),\n        connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),\n        amount_captured: None,\n        minor_amount_captured: None,\n        payment_method_status: None,\n        request: types::PayoutsData {\n            payout_id: payouts.payout_id.to_owned(),\n            amount: payouts.amount.get_amount_as_i64(),\n            minor_amount: payouts.amount,\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            destination_currency: payouts.destination_currency,\n            source_currency: payouts.source_currency,\n            entity_type: payouts.entity_type.to_owned(),\n            payout_type: payouts.payout_type,\n            vendor_details,\n            priority: payouts.priority,\n            customer_details: customer_details\n                .to_owned()\n                .map(|c| payments::CustomerDetails {\n                    customer_id: Some(c.customer_id),\n                    name: c.name.map(Encryptable::into_inner),\n                    email: c.email.map(Email::from),\n                    phone: c.phone.map(Encryptable::into_inner),\n                    phone_country_code: c.phone_country_code,\n                }),\n            connector_transfer_method_id: connector_transfer_method_id,\n        },\n        response: Ok(types::PayoutsResponseData::default()),\n        access_token: None,\n        session_token: None,\n        reference_id: None,\n        payment_method_token: None,\n        recurring_mandate_payment_data: None,\n        preprocessing_id: None,\n        connector_request_reference_id: payout_attempt.payout_attempt_id.clone(),\n        payout_method_data: payout_data.payout_method_data.to_owned(),\n        quote_id: None,\n        test_mode,\n        payment_method_balance: None,\n        connector_api_version: None,\n        connector_http_status_code: None,\n        external_latency: None,\n        apple_pay_flow: None,\n        frm_metadata: None,\n        refund_id: None,\n        dispute_id: None,\n        connector_response: None,\n        integrity_check: Ok(()),\n        additional_merchant_data: None,\n        header_payload: None,\n        connector_mandate_request_reference_id: None,\n        authentication_id: None,\n        psd2_sca_exemption_type: None,\n    };\n\n    Ok(router_data)\n}",
+      "diff_span": {
+        "before": "        };\n\n    let connector_mandate_id =\n        payout_helpers::should_create_connector_transfer_method(&*payout_data, connector_data)?;\n\n    let router_data = types::RouterData {\n        flow: PhantomData,\n        merchant_id: merchant_account.get_id().to_owned(),\n        customer_id: customer_details.to_owned().map(|c| c.customer_id),\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_customer: connector_customer_id,\n        connector: connector_name.to_string(),\n        payment_id: common_utils::id_type::PaymentId::get_irrelevant_id(\"payout\")\n            .get_string_repr()\n            .to_owned(),\n        attempt_id: \"\".to_string(),\n        status: enums::AttemptStatus::Failure,\n        payment_method: enums::PaymentMethod::default(),\n        connector_auth_type,\n        description: None,\n        address,\n        auth_type: enums::AuthenticationType::default(),\n        connector_meta_data: merchant_connector_account.get_metadata(),\n        connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),\n        amount_captured: None,\n        minor_amount_captured: None,\n        payment_method_status: None,\n        request: types::PayoutsData {\n            payout_id: payouts.payout_id.to_owned(),\n            amount: payouts.amount.get_amount_as_i64(),\n            minor_amount: payouts.amount,\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            destination_currency: payouts.destination_currency,\n            source_currency: payouts.source_currency,\n            entity_type: payouts.entity_type.to_owned(),\n            payout_type: payouts.payout_type,\n            vendor_details,\n            priority: payouts.priority,\n            customer_details: customer_details\n                .to_owned()\n                .map(|c| payments::CustomerDetails {\n                    customer_id: Some(c.customer_id),\n                    name: c.name.map(Encryptable::into_inner),\n                    email: c.email.map(Email::from),\n                    phone: c.phone.map(Encryptable::into_inner),\n                    phone_country_code: c.phone_country_code,\n                }),\n            connector_transfer_method_id: connector_mandate_id,\n        },\n        response: Ok(types::PayoutsResponseData::default()),",
+        "after": "        };\n\n    let connector_transfer_method_id =\n        payout_helpers::should_create_connector_transfer_method(&*payout_data, connector_data)?;\n\n    let router_data = types::RouterData {\n        flow: PhantomData,\n        merchant_id: merchant_account.get_id().to_owned(),\n        customer_id: customer_details.to_owned().map(|c| c.customer_id),\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_customer: connector_customer_id,\n        connector: connector_name.to_string(),\n        payment_id: common_utils::id_type::PaymentId::get_irrelevant_id(\"payout\")\n            .get_string_repr()\n            .to_owned(),\n        attempt_id: \"\".to_string(),\n        status: enums::AttemptStatus::Failure,\n        payment_method: enums::PaymentMethod::default(),\n        connector_auth_type,\n        description: None,\n        address,\n        auth_type: enums::AuthenticationType::default(),\n        connector_meta_data: merchant_connector_account.get_metadata(),\n        connector_wallets_details: merchant_connector_account.get_connector_wallets_details(),\n        amount_captured: None,\n        minor_amount_captured: None,\n        payment_method_status: None,\n        request: types::PayoutsData {\n            payout_id: payouts.payout_id.to_owned(),\n            amount: payouts.amount.get_amount_as_i64(),\n            minor_amount: payouts.amount,\n            connector_payout_id: payout_attempt.connector_payout_id.clone(),\n            destination_currency: payouts.destination_currency,\n            source_currency: payouts.source_currency,\n            entity_type: payouts.entity_type.to_owned(),\n            payout_type: payouts.payout_type,\n            vendor_details,\n            priority: payouts.priority,\n            customer_details: customer_details\n                .to_owned()\n                .map(|c| payments::CustomerDetails {\n                    customer_id: Some(c.customer_id),\n                    name: c.name.map(Encryptable::into_inner),\n                    email: c.email.map(Email::from),\n                    phone: c.phone.map(Encryptable::into_inner),\n                    phone_country_code: c.phone_country_code,\n                }),\n            connector_transfer_method_id: connector_transfer_method_id,\n        },\n        response: Ok(types::PayoutsResponseData::default()),"
+      },
+      "commit_sha": "625a49c7d87d962afd33298be5ed6a9e8b822910"
+    },
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::PaymentMethod::function::get_common_mandate_reference",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn get_common_mandate_reference(\n        connector_mandate_details: Option<serde_json::Value>,\n    ) -> Result<CommonMandateReference, ParsingError> {\n        if let Some(value) = connector_mandate_details {\n            match serde_json::from_value::<CommonMandateReference>(value.clone()) {\n                Ok(common_mandate_reference) => Ok(common_mandate_reference),\n                Err(_) => match serde_json::from_value::<PaymentsMandateReference>(value.clone()) {\n                    Ok(payment_mandate_reference) => Ok(CommonMandateReference {\n                        payments: Some(payment_mandate_reference),\n                        payouts: None,\n                    }),\n                    Err(_) => Err(ParsingError::StructParseFailure(\n                        \"Faild to deserialize PaymentMethod\",\n                    ))?,\n                },\n            }\n        } else {\n            Err(ParsingError::StructParseFailure(\n                \"Faild to deserialize PaymentMethod\",\n            ))?\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "625a49c7d87d962afd33298be5ed6a9e8b822910"
+    }
+  ]
+}

diffs/pr_6687/652722d/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "652722d91d14b22a9326a0f3b7e690e5e137276c",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/router/src/core/payments/tokenization.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments/tokenization.rs::function::update_connector_mandate_details",
+      "file": "crates/router/src/core/payments/tokenization.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn update_connector_mandate_details(\n    mandate_details: Option<diesel_models::CommonMandateReference>,\n    payment_method_type: Option<storage_enums::PaymentMethodType>,\n    authorized_amount: Option<i64>,\n    authorized_currency: Option<storage_enums::Currency>,\n    merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,\n    connector_mandate_id: Option<String>,\n    mandate_metadata: Option<Secret<serde_json::Value>>,\n    connector_mandate_request_reference_id: Option<String>,\n) -> RouterResult<Option<serde_json::Value>> {\n    let mandate_reference = match mandate_details {\n        Some(mut common_mandate_reference) => {\n            if let Some((mca_id, connector_mandate_id)) =\n                merchant_connector_id.clone().zip(connector_mandate_id)\n            {\n                let updated_record = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: connector_mandate_id.clone(),\n                    payment_method_type,\n                    original_payment_authorized_amount: authorized_amount,\n                    original_payment_authorized_currency: authorized_currency,\n                    mandate_metadata: mandate_metadata.clone(),\n                    connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                    connector_mandate_request_reference_id: connector_mandate_request_reference_id\n                        .clone(),\n                };\n\n                if let Some(payments_mandate_reference) = common_mandate_reference.payments.as_mut()\n                {\n                    payments_mandate_reference\n                        .entry(mca_id)\n                        .and_modify(|pm| *pm = updated_record)\n                        .or_insert(diesel_models::PaymentsMandateReferenceRecord {\n                            connector_mandate_id,\n                            payment_method_type,\n                            original_payment_authorized_amount: authorized_amount,\n                            original_payment_authorized_currency: authorized_currency,\n                            mandate_metadata: mandate_metadata.clone(),\n                            connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                            connector_mandate_request_reference_id,\n                        });\n                }\n                Some(common_mandate_reference)\n            } else {\n                None\n            }\n        }\n        None => add_connector_mandate_details_in_payment_method(\n            payment_method_type,\n            authorized_amount,\n            authorized_currency,\n            merchant_connector_id,\n            connector_mandate_id,\n            mandate_metadata,\n            connector_mandate_request_reference_id,\n        ),\n    };\n    let connector_mandate_details = mandate_reference\n        .map(|mand| mand.encode_to_value())\n        .transpose()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n\n    Ok(connector_mandate_details)\n}",
+      "after_code": "pub fn update_connector_mandate_details(\n    mandate_details: Option<diesel_models::CommonMandateReference>,\n    payment_method_type: Option<storage_enums::PaymentMethodType>,\n    authorized_amount: Option<i64>,\n    authorized_currency: Option<storage_enums::Currency>,\n    merchant_connector_id: Option<id_type::MerchantConnectorAccountId>,\n    connector_mandate_id: Option<String>,\n    mandate_metadata: Option<Secret<serde_json::Value>>,\n    connector_mandate_request_reference_id: Option<String>,\n) -> RouterResult<Option<serde_json::Value>> {\n    let mandate_reference = match mandate_details\n        .as_ref()\n        .and_then(|common_mandate| common_mandate.payments.clone())\n    {\n        Some(mut payments_mandate_reference) => {\n            router_env::logger::info!(\"here : {:?}\", payments_mandate_reference.clone());\n            if let Some((mca_id, connector_mandate_id)) =\n                merchant_connector_id.clone().zip(connector_mandate_id)\n            {\n                let updated_record = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: connector_mandate_id.clone(),\n                    payment_method_type,\n                    original_payment_authorized_amount: authorized_amount,\n                    original_payment_authorized_currency: authorized_currency,\n                    mandate_metadata: mandate_metadata.clone(),\n                    connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                    connector_mandate_request_reference_id: connector_mandate_request_reference_id\n                        .clone(),\n                };\n\n                payments_mandate_reference\n                    .entry(mca_id)\n                    .and_modify(|pm| *pm = updated_record)\n                    .or_insert(diesel_models::PaymentsMandateReferenceRecord {\n                        connector_mandate_id,\n                        payment_method_type,\n                        original_payment_authorized_amount: authorized_amount,\n                        original_payment_authorized_currency: authorized_currency,\n                        mandate_metadata: mandate_metadata.clone(),\n                        connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                        connector_mandate_request_reference_id,\n                    });\n\n                let payout_data = mandate_details.and_then(|common_mandate| common_mandate.payouts);\n\n                Some(diesel_models::CommonMandateReference {\n                    payments: Some(payments_mandate_reference),\n                    payouts: payout_data,\n                })\n            } else {\n                None\n            }\n        }\n        None => add_connector_mandate_details_in_payment_method(\n            payment_method_type,\n            authorized_amount,\n            authorized_currency,\n            merchant_connector_id,\n            connector_mandate_id,\n            mandate_metadata,\n            connector_mandate_request_reference_id,\n        ),\n    };\n    let connector_mandate_details = mandate_reference\n        .map(|mand| mand.encode_to_value())\n        .transpose()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n    Ok(connector_mandate_details)\n}",
+      "diff_span": {
+        "before": "    connector_mandate_request_reference_id: Option<String>,\n) -> RouterResult<Option<serde_json::Value>> {\n    let mandate_reference = match mandate_details {\n        Some(mut common_mandate_reference) => {\n            if let Some((mca_id, connector_mandate_id)) =\n                merchant_connector_id.clone().zip(connector_mandate_id)\n            {\n                let updated_record = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: connector_mandate_id.clone(),\n                    payment_method_type,\n                    original_payment_authorized_amount: authorized_amount,\n                    original_payment_authorized_currency: authorized_currency,\n                    mandate_metadata: mandate_metadata.clone(),\n                    connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                    connector_mandate_request_reference_id: connector_mandate_request_reference_id\n                        .clone(),\n                };\n\n                if let Some(payments_mandate_reference) = common_mandate_reference.payments.as_mut()\n                {\n                    payments_mandate_reference\n                        .entry(mca_id)\n                        .and_modify(|pm| *pm = updated_record)\n                        .or_insert(diesel_models::PaymentsMandateReferenceRecord {\n                            connector_mandate_id,\n                            payment_method_type,\n                            original_payment_authorized_amount: authorized_amount,\n                            original_payment_authorized_currency: authorized_currency,\n                            mandate_metadata: mandate_metadata.clone(),\n                            connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                            connector_mandate_request_reference_id,\n                        });\n                }\n                Some(common_mandate_reference)\n            } else {\n                None\n            }\n        }\n        None => add_connector_mandate_details_in_payment_method(\n            payment_method_type,\n            authorized_amount,\n            authorized_currency,\n            merchant_connector_id,\n            connector_mandate_id,\n            mandate_metadata,\n            connector_mandate_request_reference_id,\n        ),\n    };\n    let connector_mandate_details = mandate_reference\n        .map(|mand| mand.encode_to_value())\n        .transpose()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n\n    Ok(connector_mandate_details)\n}",
+        "after": "    connector_mandate_request_reference_id: Option<String>,\n) -> RouterResult<Option<serde_json::Value>> {\n    let mandate_reference = match mandate_details\n        .as_ref()\n        .and_then(|common_mandate| common_mandate.payments.clone())\n    {\n        Some(mut payments_mandate_reference) => {\n            router_env::logger::info!(\"here : {:?}\", payments_mandate_reference.clone());\n            if let Some((mca_id, connector_mandate_id)) =\n                merchant_connector_id.clone().zip(connector_mandate_id)\n            {\n                let updated_record = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: connector_mandate_id.clone(),\n                    payment_method_type,\n                    original_payment_authorized_amount: authorized_amount,\n                    original_payment_authorized_currency: authorized_currency,\n                    mandate_metadata: mandate_metadata.clone(),\n                    connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                    connector_mandate_request_reference_id: connector_mandate_request_reference_id\n                        .clone(),\n                };\n\n                payments_mandate_reference\n                    .entry(mca_id)\n                    .and_modify(|pm| *pm = updated_record)\n                    .or_insert(diesel_models::PaymentsMandateReferenceRecord {\n                        connector_mandate_id,\n                        payment_method_type,\n                        original_payment_authorized_amount: authorized_amount,\n                        original_payment_authorized_currency: authorized_currency,\n                        mandate_metadata: mandate_metadata.clone(),\n                        connector_mandate_status: Some(ConnectorMandateStatus::Active),\n                        connector_mandate_request_reference_id,\n                    });\n\n                let payout_data = mandate_details.and_then(|common_mandate| common_mandate.payouts);\n\n                Some(diesel_models::CommonMandateReference {\n                    payments: Some(payments_mandate_reference),\n                    payouts: payout_data,\n                })\n            } else {\n                None"
+      },
+      "commit_sha": "652722d91d14b22a9326a0f3b7e690e5e137276c"
+    }
+  ]
+}

diffs/pr_6687/71cbdff/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "71cbdfff3d4e9f8587130751ca00b0fdadc1626c",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/diesel_models/src/payment_method.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::CommonMandateReference::function::from_sql",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        let mut payments_data = None;\n        let mut payouts_data = None;\n\n        if let Some(obj) = value.clone().as_object_mut() {\n            obj.remove(\"payouts\");\n\n            if let Ok(payment_mandate_record) =\n                serde_json::from_value::<PaymentsMandateReference>(serde_json::json!(obj))\n            {\n                payments_data = Some(payment_mandate_record);\n            }\n        }\n\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<CommonMandateReference>(value.clone())\n        {\n            payouts_data = payment_mandate_record.payouts\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(\n                report!(ParsingError::StructParseFailure(\"CommonMandateReference\"))\n                    .attach_printable(\n                    \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n                ),\n            )?\n        } else {\n            Ok(CommonMandateReference {\n                payments: payments_data,\n                payouts: payouts_data,\n            })\n        }\n    }",
+      "after_code": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        let mut payments_data = None;\n        let mut payouts_data = None;\n\n        if let Some(obj) = value.clone().as_object_mut() {\n            obj.remove(\"payouts\");\n\n            if let Ok(payment_mandate_record) =\n                serde_json::from_value::<PaymentsMandateReference>(serde_json::json!(obj))\n            {\n                payments_data = Some(payment_mandate_record);\n            }\n        }\n\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<Self>(value.clone())\n        {\n            payouts_data = payment_mandate_record.payouts\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(\n                report!(ParsingError::StructParseFailure(\"CommonMandateReference\"))\n                    .attach_printable(\n                    \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n                ),\n            )?\n        } else {\n            Ok(Self {\n                payments: payments_data,\n                payouts: payouts_data,\n            })\n        }\n    }",
+      "diff_span": {
+        "before": "\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<CommonMandateReference>(value.clone())\n        {\n            payouts_data = payment_mandate_record.payouts\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(\n                report!(ParsingError::StructParseFailure(\"CommonMandateReference\"))\n                    .attach_printable(\n                    \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n                ),\n            )?\n        } else {\n            Ok(CommonMandateReference {\n                payments: payments_data,\n                payouts: payouts_data,",
+        "after": "\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<Self>(value.clone())\n        {\n            payouts_data = payment_mandate_record.payouts\n        }\n\n        if payments_data.is_none() && payouts_data.is_none() {\n            Err(\n                report!(ParsingError::StructParseFailure(\"CommonMandateReference\"))\n                    .attach_printable(\n                    \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n                ),\n            )?\n        } else {\n            Ok(Self {\n                payments: payments_data,\n                payouts: payouts_data,"
+      },
+      "commit_sha": "71cbdfff3d4e9f8587130751ca00b0fdadc1626c"
+    }
+  ]
+}

diffs/pr_6687/8357acc/diff.json

@@ -0,0 +1,47 @@
+{
+  "commit_sha": "8357acc15444cf6926c15dbc34ff3f7c7373f1bd",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/api_models/src/payment_methods.rs",
+    "crates/diesel_models/src/payment_method.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::CommonMandateReference::function::from_sql",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        // Deserialize into a generic serde_json::Value first\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        // Try to directly deserialize into CommonMandateReference\n        if let Ok(common_reference) = serde_json::from_value::<Self>(value.clone()) {\n            return Ok(common_reference);\n        }\n\n        // If that fails, try deserializing into PaymentsMandateReference\n        if let Ok(payment_reference) = serde_json::from_value::<PaymentsMandateReference>(value) {\n            // Convert PaymentsMandateReference to CommonMandateReference\n            return Ok(Self::from(payment_reference));\n        }\n\n        // If neither succeeds, return an error\n        Err(\n            report!(ParsingError::StructParseFailure(\"CommonMandateReference\")).attach_printable(\n                \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n            ),\n        )?\n    }",
+      "after_code": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        if let Ok(payment_reference) =\n            serde_json::from_value::<PaymentsMandateReference>(value.clone())\n        {\n            return Ok(Self::from(payment_reference));\n        }\n\n        if let Ok(common_reference) = serde_json::from_value::<Self>(value) {\n            return Ok(common_reference);\n        }\n        Err(\n            report!(ParsingError::StructParseFailure(\"CommonMandateReference\")).attach_printable(\n                \"Failed to parse JSON into CommonMandateReference or PaymentsMandateReference\",\n            ),\n        )?\n    }",
+      "diff_span": {
+        "before": "fn from_sql(bytes: DB::RawValue<'_>) -> diesel::deserialize::Result<Self> {\n        // Deserialize into a generic serde_json::Value first\n        let value = <serde_json::Value as diesel::deserialize::FromSql<\n            diesel::sql_types::Jsonb,\n            DB,\n        >>::from_sql(bytes)?;\n\n        // Try to directly deserialize into CommonMandateReference\n        if let Ok(common_reference) = serde_json::from_value::<Self>(value.clone()) {\n            return Ok(common_reference);\n        }\n\n        // If that fails, try deserializing into PaymentsMandateReference\n        if let Ok(payment_reference) = serde_json::from_value::<PaymentsMandateReference>(value) {\n            // Convert PaymentsMandateReference to CommonMandateReference\n            return Ok(Self::from(payment_reference));\n        }\n\n        // If neither succeeds, return an error\n        Err(\n            report!(ParsingError::StructParseFailure(\"CommonMandateReference\")).attach_printable(",
+        "after": "        >>::from_sql(bytes)?;\n\n        if let Ok(payment_reference) =\n            serde_json::from_value::<PaymentsMandateReference>(value.clone())\n        {\n            return Ok(Self::from(payment_reference));\n        }\n\n        if let Ok(common_reference) = serde_json::from_value::<Self>(value) {\n            return Ok(common_reference);\n        }\n        Err(\n            report!(ParsingError::StructParseFailure(\"CommonMandateReference\")).attach_printable("
+      },
+      "commit_sha": "8357acc15444cf6926c15dbc34ff3f7c7373f1bd",
+      "before_imports": [
+        "use error_stack::report;",
+        "use serde::{Deserialize, Serialize};"
+      ],
+      "after_imports": [
+        "use error_stack::report;"
+      ]
+    },
+    {
+      "id": "crates/api_models/src/payment_methods.rs::function::deserialize_connector_mandate_details",
+      "file": "crates/api_models/src/payment_methods.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn deserialize_connector_mandate_details<'de, D>(\n    deserializer: D,\n) -> Result<Option<CommonMandateReference>, D::Error>\nwhere\n    D: serde::Deserializer<'de>,\n{\n    let value: Option<serde_json::Value> = Option::<serde_json::Value>::deserialize(deserializer)?;\n    if let Some(connector_mandate_value) = value {\n        if let Ok(common_mandate) =\n            serde_json::from_value::<CommonMandateReference>(connector_mandate_value.clone())\n        {\n            Ok(Some(common_mandate))\n        } else if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(connector_mandate_value)\n        {\n            Ok(Some(CommonMandateReference {\n                payments: Some(payment_mandate_record),\n                payouts: None,\n            }))\n        } else {\n            Err(de::Error::custom(\n                \"Failed to deserialize connector_mandate_details\",\n            ))\n        }\n    } else {\n        Ok(None)\n    }\n}",
+      "after_code": "fn deserialize_connector_mandate_details<'de, D>(\n    deserializer: D,\n) -> Result<Option<CommonMandateReference>, D::Error>\nwhere\n    D: serde::Deserializer<'de>,\n{\n    let value: Option<serde_json::Value> = Option::<serde_json::Value>::deserialize(deserializer)?;\n    if let Some(connector_mandate_value) = value {\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(connector_mandate_value.clone())\n        {\n            Ok(Some(CommonMandateReference {\n                payments: Some(payment_mandate_record),\n                payouts: None,\n            }))\n        } else if let Ok(common_mandate) =\n            serde_json::from_value::<CommonMandateReference>(connector_mandate_value)\n        {\n            Ok(Some(common_mandate))\n        } else {\n            Err(de::Error::custom(\n                \"Failed to deserialize connector_mandate_details\",\n            ))\n        }\n    } else {\n        Ok(None)\n    }\n}",
+      "diff_span": {
+        "before": "    let value: Option<serde_json::Value> = Option::<serde_json::Value>::deserialize(deserializer)?;\n    if let Some(connector_mandate_value) = value {\n        if let Ok(common_mandate) =\n            serde_json::from_value::<CommonMandateReference>(connector_mandate_value.clone())\n        {\n            Ok(Some(common_mandate))\n        } else if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(connector_mandate_value)\n        {\n            Ok(Some(CommonMandateReference {",
+        "after": "    let value: Option<serde_json::Value> = Option::<serde_json::Value>::deserialize(deserializer)?;\n    if let Some(connector_mandate_value) = value {\n        if let Ok(payment_mandate_record) =\n            serde_json::from_value::<PaymentsMandateReference>(connector_mandate_value.clone())\n        {\n            Ok(Some(CommonMandateReference {\n                payments: Some(payment_mandate_record),\n                payouts: None,\n            }))\n        } else if let Ok(common_mandate) =\n            serde_json::from_value::<CommonMandateReference>(connector_mandate_value)\n        {\n            Ok(Some(common_mandate))\n        } else {\n            Err(de::Error::custom("
+      },
+      "commit_sha": "8357acc15444cf6926c15dbc34ff3f7c7373f1bd"
+    }
+  ]
+}

diffs/pr_6687/8717d29/diff.json

@@ -0,0 +1,104 @@
+{
+  "commit_sha": "8717d297200bb8ac8027519fe166a3916abadabb",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/api_models/src/payment_methods.rs",
+    "crates/diesel_models/src/payment_method.rs",
+    "crates/router/src/core/payment_methods/cards.rs",
+    "crates/router/src/core/payouts.rs",
+    "crates/router/src/core/payouts/helpers.rs",
+    "crates/router/src/core/webhooks/incoming.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payment_methods/cards.rs::function::update_payment_method_connector_mandate_details",
+      "file": "crates/router/src/core/payment_methods/cards.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn update_payment_method_connector_mandate_details(\n    state: &routes::SessionState,\n    key_store: &domain::MerchantKeyStore,\n    db: &dyn db::StorageInterface,\n    pm: domain::PaymentMethod,\n    connector_mandate_details: Option<diesel_models::CommonMandateReference>,\n    storage_scheme: MerchantStorageScheme,\n) -> errors::CustomResult<(), errors::VaultError> {\n    let connector_mandate_details_value = connector_mandate_details\n        .map(|common_mandate| {\n            serde_json::to_value(common_mandate.payments.as_ref())\n                .and_then(|mut payments| {\n                    serde_json::to_value(common_mandate.payouts.as_ref()).map(|payouts| {\n                        if let Some(payments_object) = payments.as_object_mut() {\n                            if !payouts.is_null() {\n                                payments_object.insert(\"payouts\".to_string(), payouts);\n                            }\n                        }\n                        payments\n                    })\n                })\n                .map_err(|_| errors::VaultError::UpdateInPaymentMethodDataTableFailed)\n        })\n        .transpose()?;\n\n    let pm_update = payment_method::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n        connector_mandate_details: connector_mandate_details_value,\n    };\n\n    db.update_payment_method(&(state.into()), key_store, pm, pm_update, storage_scheme)\n        .await\n        .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n    Ok(())\n}",
+      "after_code": "pub async fn update_payment_method_connector_mandate_details(\n    state: &routes::SessionState,\n    key_store: &domain::MerchantKeyStore,\n    db: &dyn db::StorageInterface,\n    pm: domain::PaymentMethod,\n    connector_mandate_details: Option<diesel_models::CommonMandateReference>,\n    storage_scheme: MerchantStorageScheme,\n) -> errors::CustomResult<(), errors::VaultError> {\n    let connector_mandate_details_value = connector_mandate_details\n        .map(|common_mandate| {\n            serde_json::to_value(common_mandate.payments.as_ref())\n                .and_then(|mut payments| {\n                    if payments.is_null() {\n                        payments = serde_json::json!({});\n                    }\n                    serde_json::to_value(common_mandate.payouts.as_ref()).map(|payouts| {\n                        if let Some(payments_object) = payments.as_object_mut() {\n                            if !payouts.is_null() {\n                                payments_object.insert(\"payouts\".to_string(), payouts);\n                            }\n                        }\n                        payments\n                    })\n                })\n                .map_err(|_| errors::VaultError::UpdateInPaymentMethodDataTableFailed)\n        })\n        .transpose()?;\n\n    let pm_update = payment_method::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n        connector_mandate_details: connector_mandate_details_value,\n    };\n\n    db.update_payment_method(&(state.into()), key_store, pm, pm_update, storage_scheme)\n        .await\n        .change_context(errors::VaultError::UpdateInPaymentMethodDataTableFailed)?;\n    Ok(())\n}",
+      "diff_span": {
+        "before": "",
+        "after": "            serde_json::to_value(common_mandate.payments.as_ref())\n                .and_then(|mut payments| {\n                    if payments.is_null() {\n                        payments = serde_json::json!({});\n                    }\n                    serde_json::to_value(common_mandate.payouts.as_ref()).map(|payouts| {\n                        if let Some(payments_object) = payments.as_object_mut() {"
+      },
+      "commit_sha": "8717d297200bb8ac8027519fe166a3916abadabb"
+    },
+    {
+      "id": "crates/router/src/core/payouts.rs::function::create_recipient_disburse_account",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn create_recipient_disburse_account(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n    key_store: &domain::MerchantKeyStore,\n) -> RouterResult<()> {\n    // 1. Form Router data\n    let router_data = core_utils::construct_payout_router_data(\n        state,\n        connector_data,\n        merchant_account,\n        payout_data,\n    )\n    .await?;\n\n    // 2. Fetch connector integration details\n    let connector_integration: services::BoxedPayoutConnectorIntegrationInterface<\n        api::PoRecipientAccount,\n        types::PayoutsData,\n        types::PayoutsResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    // 3. Call connector service\n    let router_data_resp = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &router_data,\n        payments::CallConnectorAction::Trigger,\n        None,\n    )\n    .await\n    .to_payout_failed_response()?;\n\n    // 4. Process data returned by the connector\n    let db = &*state.store;\n    match router_data_resp.response {\n        Ok(payout_response_data) => {\n            let payout_attempt = &payout_data.payout_attempt;\n            let status = payout_response_data\n                .status\n                .unwrap_or(payout_attempt.status.to_owned());\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_response_data.connector_payout_id.clone(),\n                status,\n                error_code: None,\n                error_message: None,\n                is_eligible: payout_response_data.payout_eligible,\n                unified_code: None,\n                unified_message: None,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n\n            if let (\n                true,\n                Some(ref payout_method_data),\n                Some(connector_payout_id),\n                Some(customer_details),\n                Some(merchant_connector_id),\n            ) = (\n                payout_data.payouts.recurring,\n                payout_data.payout_method_data.clone(),\n                payout_response_data.connector_payout_id.clone(),\n                payout_data.customer_details.clone(),\n                connector_data.merchant_connector_id.clone(),\n            ) {\n                let connector_mandate_details = HashMap::from([(\n                    merchant_connector_id.clone(),\n                    PayoutsMandateReferenceRecord {\n                        transfer_method_id: Some(connector_payout_id),\n                    },\n                )]);\n\n                let common_connector_mandate = CommonMandateReference {\n                    payments: None,\n                    payouts: Some(PayoutsMandateReference(connector_mandate_details)),\n                };\n\n                let connector_mandate_details_value =\n                    serde_json::to_value(common_connector_mandate.clone()).ok();\n\n                if let Some(pm_method) = payout_data.payment_method.clone() {\n                    let pm_update =\n                        diesel_models::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n                            #[cfg(all(\n                                any(feature = \"v1\", feature = \"v2\"),\n                                not(feature = \"payment_methods_v2\")\n                            ))]\n                            connector_mandate_details: connector_mandate_details_value,\n\n                            #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n                            connector_mandate_details: Some(common_connector_mandate),\n                        };\n\n                    payout_data.payment_method = Some(\n                        db.update_payment_method(\n                            &(state.into()),\n                            key_store,\n                            pm_method,\n                            pm_update,\n                            merchant_account.storage_scheme,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n                        .attach_printable(\"Unable to find payment method\")?,\n                    );\n                } else {\n                    #[cfg(all(any(feature = \"v1\", feature = \"v2\"), not(feature = \"customer_v2\")))]\n                    let customer_id = Some(customer_details.customer_id);\n\n                    #[cfg(all(feature = \"v2\", feature = \"customer_v2\"))]\n                    let customer_id = customer_details.merchant_reference_id;\n\n                    if let Some(customer_id) = customer_id {\n                        helpers::save_payout_data_to_locker(\n                            state,\n                            payout_data,\n                            &customer_id,\n                            payout_method_data,\n                            connector_mandate_details_value,\n                            merchant_account,\n                            key_store,\n                        )\n                        .await\n                        .attach_printable(\"Failed to save payout data to locker\")?;\n                    }\n                };\n            }\n        }\n        Err(err) => {\n            let (error_code, error_message) = (Some(err.code), Some(err.message));\n            let (unified_code, unified_message) = helpers::get_gsm_record(\n                state,\n                error_code.clone(),\n                error_message.clone(),\n                payout_data.payout_attempt.connector.clone(),\n                consts::PAYOUT_FLOW_STR,\n            )\n            .await\n            .map_or((None, None), |gsm| (gsm.unified_code, gsm.unified_message));\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_data.payout_attempt.connector_payout_id.to_owned(),\n                status: storage_enums::PayoutStatus::Failed,\n                error_code,\n                error_message,\n                is_eligible: None,\n                unified_code: unified_code\n                    .map(UnifiedCode::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_code\",\n                    })?,\n                unified_message: unified_message\n                    .map(UnifiedMessage::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_message\",\n                    })?,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    &payout_data.payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n        }\n    };\n\n    Ok(())\n}",
+      "after_code": "pub async fn create_recipient_disburse_account(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n    key_store: &domain::MerchantKeyStore,\n) -> RouterResult<()> {\n    // 1. Form Router data\n    let router_data = core_utils::construct_payout_router_data(\n        state,\n        connector_data,\n        merchant_account,\n        payout_data,\n    )\n    .await?;\n\n    // 2. Fetch connector integration details\n    let connector_integration: services::BoxedPayoutConnectorIntegrationInterface<\n        api::PoRecipientAccount,\n        types::PayoutsData,\n        types::PayoutsResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    // 3. Call connector service\n    let router_data_resp = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &router_data,\n        payments::CallConnectorAction::Trigger,\n        None,\n    )\n    .await\n    .to_payout_failed_response()?;\n\n    // 4. Process data returned by the connector\n    let db = &*state.store;\n    match router_data_resp.response {\n        Ok(payout_response_data) => {\n            let payout_attempt = &payout_data.payout_attempt;\n            let status = payout_response_data\n                .status\n                .unwrap_or(payout_attempt.status.to_owned());\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_response_data.connector_payout_id.clone(),\n                status,\n                error_code: None,\n                error_message: None,\n                is_eligible: payout_response_data.payout_eligible,\n                unified_code: None,\n                unified_message: None,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n\n            if let (\n                true,\n                Some(ref payout_method_data),\n                Some(connector_payout_id),\n                Some(customer_details),\n                Some(merchant_connector_id),\n            ) = (\n                payout_data.payouts.recurring,\n                payout_data.payout_method_data.clone(),\n                payout_response_data.connector_payout_id.clone(),\n                payout_data.customer_details.clone(),\n                connector_data.merchant_connector_id.clone(),\n            ) {\n                let connector_mandate_details = HashMap::from([(\n                    merchant_connector_id.clone(),\n                    PayoutsMandateReferenceRecord {\n                        transfer_method_id: Some(connector_payout_id),\n                    },\n                )]);\n\n                let common_connector_mandate = CommonMandateReference {\n                    payments: None,\n                    payouts: Some(PayoutsMandateReference(connector_mandate_details)),\n                };\n\n                let connector_mandate_details_value =\n                    serde_json::to_value(common_connector_mandate.payments.as_ref())\n                        .and_then(|mut payments| {\n                            if payments.is_null() {\n                                payments = serde_json::json!({});\n                            }\n                            serde_json::to_value(common_connector_mandate.payouts.as_ref()).map(\n                                |payouts| {\n                                    if let Some(payments_object) = payments.as_object_mut() {\n                                        if !payouts.is_null() {\n                                            payments_object.insert(\"payouts\".to_string(), payouts);\n                                        }\n                                    }\n                                    payments\n                                },\n                            )\n                        })\n                        .map_err(|_| errors::ApiErrorResponse::MandateUpdateFailed)?;\n\n                if let Some(pm_method) = payout_data.payment_method.clone() {\n                    let pm_update =\n                        diesel_models::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n                            #[cfg(all(\n                                any(feature = \"v1\", feature = \"v2\"),\n                                not(feature = \"payment_methods_v2\")\n                            ))]\n                            connector_mandate_details: Some(connector_mandate_details_value),\n\n                            #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n                            connector_mandate_details: Some(common_connector_mandate),\n                        };\n\n                    payout_data.payment_method = Some(\n                        db.update_payment_method(\n                            &(state.into()),\n                            key_store,\n                            pm_method,\n                            pm_update,\n                            merchant_account.storage_scheme,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n                        .attach_printable(\"Unable to find payment method\")?,\n                    );\n                } else {\n                    #[cfg(all(any(feature = \"v1\", feature = \"v2\"), not(feature = \"customer_v2\")))]\n                    let customer_id = Some(customer_details.customer_id);\n\n                    #[cfg(all(feature = \"v2\", feature = \"customer_v2\"))]\n                    let customer_id = customer_details.merchant_reference_id;\n\n                    if let Some(customer_id) = customer_id {\n                        helpers::save_payout_data_to_locker(\n                            state,\n                            payout_data,\n                            &customer_id,\n                            payout_method_data,\n                            Some(connector_mandate_details_value),\n                            merchant_account,\n                            key_store,\n                        )\n                        .await\n                        .attach_printable(\"Failed to save payout data to locker\")?;\n                    }\n                };\n            }\n        }\n        Err(err) => {\n            let (error_code, error_message) = (Some(err.code), Some(err.message));\n            let (unified_code, unified_message) = helpers::get_gsm_record(\n                state,\n                error_code.clone(),\n                error_message.clone(),\n                payout_data.payout_attempt.connector.clone(),\n                consts::PAYOUT_FLOW_STR,\n            )\n            .await\n            .map_or((None, None), |gsm| (gsm.unified_code, gsm.unified_message));\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_data.payout_attempt.connector_payout_id.to_owned(),\n                status: storage_enums::PayoutStatus::Failed,\n                error_code,\n                error_message,\n                is_eligible: None,\n                unified_code: unified_code\n                    .map(UnifiedCode::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_code\",\n                    })?,\n                unified_message: unified_message\n                    .map(UnifiedMessage::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_message\",\n                    })?,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    &payout_data.payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n        }\n    };\n\n    Ok(())\n}",
+      "diff_span": {
+        "before": "\n                let connector_mandate_details_value =\n                    serde_json::to_value(common_connector_mandate.clone()).ok();\n\n                if let Some(pm_method) = payout_data.payment_method.clone() {\n                    let pm_update =\n                        diesel_models::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n                            #[cfg(all(\n                                any(feature = \"v1\", feature = \"v2\"),\n                                not(feature = \"payment_methods_v2\")\n                            ))]\n                            connector_mandate_details: connector_mandate_details_value,\n\n                            #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n                            connector_mandate_details: Some(common_connector_mandate),\n                        };\n\n                    payout_data.payment_method = Some(\n                        db.update_payment_method(\n                            &(state.into()),\n                            key_store,\n                            pm_method,\n                            pm_update,\n                            merchant_account.storage_scheme,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n                        .attach_printable(\"Unable to find payment method\")?,\n                    );\n                } else {\n                    #[cfg(all(any(feature = \"v1\", feature = \"v2\"), not(feature = \"customer_v2\")))]\n                    let customer_id = Some(customer_details.customer_id);\n\n                    #[cfg(all(feature = \"v2\", feature = \"customer_v2\"))]\n                    let customer_id = customer_details.merchant_reference_id;\n\n                    if let Some(customer_id) = customer_id {\n                        helpers::save_payout_data_to_locker(\n                            state,\n                            payout_data,\n                            &customer_id,\n                            payout_method_data,\n                            connector_mandate_details_value,\n                            merchant_account,\n                            key_store,",
+        "after": "\n                let connector_mandate_details_value =\n                    serde_json::to_value(common_connector_mandate.payments.as_ref())\n                        .and_then(|mut payments| {\n                            if payments.is_null() {\n                                payments = serde_json::json!({});\n                            }\n                            serde_json::to_value(common_connector_mandate.payouts.as_ref()).map(\n                                |payouts| {\n                                    if let Some(payments_object) = payments.as_object_mut() {\n                                        if !payouts.is_null() {\n                                            payments_object.insert(\"payouts\".to_string(), payouts);\n                                        }\n                                    }\n                                    payments\n                                },\n                            )\n                        })\n                        .map_err(|_| errors::ApiErrorResponse::MandateUpdateFailed)?;\n\n                if let Some(pm_method) = payout_data.payment_method.clone() {\n                    let pm_update =\n                        diesel_models::PaymentMethodUpdate::ConnectorMandateDetailsUpdate {\n                            #[cfg(all(\n                                any(feature = \"v1\", feature = \"v2\"),\n                                not(feature = \"payment_methods_v2\")\n                            ))]\n                            connector_mandate_details: Some(connector_mandate_details_value),\n\n                            #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n                            connector_mandate_details: Some(common_connector_mandate),\n                        };\n\n                    payout_data.payment_method = Some(\n                        db.update_payment_method(\n                            &(state.into()),\n                            key_store,\n                            pm_method,\n                            pm_update,\n                            merchant_account.storage_scheme,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n                        .attach_printable(\"Unable to find payment method\")?,\n                    );\n                } else {\n                    #[cfg(all(any(feature = \"v1\", feature = \"v2\"), not(feature = \"customer_v2\")))]\n                    let customer_id = Some(customer_details.customer_id);\n\n                    #[cfg(all(feature = \"v2\", feature = \"customer_v2\"))]\n                    let customer_id = customer_details.merchant_reference_id;\n\n                    if let Some(customer_id) = customer_id {\n                        helpers::save_payout_data_to_locker(\n                            state,\n                            payout_data,\n                            &customer_id,\n                            payout_method_data,\n                            Some(connector_mandate_details_value),\n                            merchant_account,\n                            key_store,"
+      },
+      "commit_sha": "8717d297200bb8ac8027519fe166a3916abadabb"
+    },
+    {
+      "id": "crates/router/src/core/payouts/helpers.rs::function::should_create_connector_transfer_method",
+      "file": "crates/router/src/core/payouts/helpers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn should_create_connector_transfer_method(\n    payout_data: &PayoutData,\n    connector_data: &api::ConnectorData,\n) -> RouterResult<Option<String>> {\n    let connector_transfer_method_id = if let Some(pm) = &payout_data.payment_method {\n        #[cfg(all(\n            any(feature = \"v1\", feature = \"v2\"),\n            not(feature = \"payment_methods_v2\")\n        ))]\n        let common_mandate_reference = pm\n            .get_common_mandate_reference()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to deserialize connector mandate details\")?;\n\n        #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n        let common_mandate_reference = pm.connector_mandate_details.clone().unwrap_or_default();\n\n        if let Some(merchant_connector_id) = connector_data.merchant_connector_id.as_ref() {\n            common_mandate_reference\n                .payouts\n                .and_then(|payouts_mandate_reference| {\n                    payouts_mandate_reference.get(merchant_connector_id).map(\n                        |payouts_mandate_reference_record| {\n                            payouts_mandate_reference_record.transfer_method_id.clone()\n                        },\n                    )\n                })\n                .flatten()\n        } else {\n            None\n        }\n    } else {\n        None\n    };\n    Ok(connector_transfer_method_id)\n}",
+      "after_code": "pub fn should_create_connector_transfer_method(\n    payout_data: &PayoutData,\n    connector_data: &api::ConnectorData,\n) -> RouterResult<Option<String>> {\n    let connector_transfer_method_id = payout_data.payment_method.as_ref().and_then(|pm| {\n        #[cfg(all(\n            any(feature = \"v1\", feature = \"v2\"),\n            not(feature = \"payment_methods_v2\")\n        ))]\n        let common_mandate_reference = pm\n            .get_common_mandate_reference()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to deserialize connector mandate details\")\n            .ok()?;\n\n        #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n        let common_mandate_reference = pm.connector_mandate_details.clone().unwrap_or_default();\n\n        connector_data\n            .merchant_connector_id\n            .as_ref()\n            .and_then(|merchant_connector_id| {\n                common_mandate_reference\n                    .payouts\n                    .and_then(|payouts_mandate_reference| {\n                        payouts_mandate_reference\n                            .get(merchant_connector_id)\n                            .and_then(|payouts_mandate_reference_record| {\n                                payouts_mandate_reference_record.transfer_method_id.clone()\n                            })\n                    })\n            })\n    });\n\n    Ok(connector_transfer_method_id)\n}",
+      "diff_span": {
+        "before": "    connector_data: &api::ConnectorData,\n) -> RouterResult<Option<String>> {\n    let connector_transfer_method_id = if let Some(pm) = &payout_data.payment_method {\n        #[cfg(all(\n            any(feature = \"v1\", feature = \"v2\"),\n            not(feature = \"payment_methods_v2\")\n        ))]\n        let common_mandate_reference = pm\n            .get_common_mandate_reference()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to deserialize connector mandate details\")?;\n\n        #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n        let common_mandate_reference = pm.connector_mandate_details.clone().unwrap_or_default();\n\n        if let Some(merchant_connector_id) = connector_data.merchant_connector_id.as_ref() {\n            common_mandate_reference\n                .payouts\n                .and_then(|payouts_mandate_reference| {\n                    payouts_mandate_reference.get(merchant_connector_id).map(\n                        |payouts_mandate_reference_record| {\n                            payouts_mandate_reference_record.transfer_method_id.clone()\n                        },\n                    )\n                })\n                .flatten()\n        } else {\n            None\n        }\n    } else {\n        None\n    };\n    Ok(connector_transfer_method_id)\n}",
+        "after": "    connector_data: &api::ConnectorData,\n) -> RouterResult<Option<String>> {\n    let connector_transfer_method_id = payout_data.payment_method.as_ref().and_then(|pm| {\n        #[cfg(all(\n            any(feature = \"v1\", feature = \"v2\"),\n            not(feature = \"payment_methods_v2\")\n        ))]\n        let common_mandate_reference = pm\n            .get_common_mandate_reference()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"unable to deserialize connector mandate details\")\n            .ok()?;\n\n        #[cfg(all(feature = \"v2\", feature = \"payment_methods_v2\"))]\n        let common_mandate_reference = pm.connector_mandate_details.clone().unwrap_or_default();\n\n        connector_data\n            .merchant_connector_id\n            .as_ref()\n            .and_then(|merchant_connector_id| {\n                common_mandate_reference\n                    .payouts\n                    .and_then(|payouts_mandate_reference| {\n                        payouts_mandate_reference\n                            .get(merchant_connector_id)\n                            .and_then(|payouts_mandate_reference_record| {\n                                payouts_mandate_reference_record.transfer_method_id.clone()\n                            })\n                    })\n            })\n    });\n\n    Ok(connector_transfer_method_id)\n}"
+      },
+      "commit_sha": "8717d297200bb8ac8027519fe166a3916abadabb"
+    },
+    {
+      "id": "crates/diesel_models/src/payment_method.rs::CommonMandateReference::function::to_sql",
+      "file": "crates/diesel_models/src/payment_method.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn to_sql<'b>(\n        &'b self,\n        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,\n    ) -> diesel::serialize::Result {\n        let mut payments = serde_json::to_value(self.payments.as_ref())?;\n\n        self.payouts\n            .as_ref()\n            .map(serde_json::to_value)\n            .transpose()?\n            .map(|payout_val| {\n                if !payout_val.is_null() {\n                    payments\n                        .as_object_mut()\n                        .map(|payment_val| payment_val.insert(\"payouts\".to_string(), payout_val))\n                } else {\n                    None\n                }\n            });\n\n        <serde_json::Value as diesel::serialize::ToSql<\n            diesel::sql_types::Jsonb,\n            diesel::pg::Pg,\n        >>::to_sql(&payments, &mut out.reborrow())\n    }",
+      "after_code": "fn to_sql<'b>(\n        &'b self,\n        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,\n    ) -> diesel::serialize::Result {\n        let payments = serde_json::to_value(self.payments.as_ref()).and_then(|mut payments| {\n            if payments.is_null() {\n                payments = serde_json::json!({});\n            }\n            serde_json::to_value(self.payouts.as_ref()).map(|payouts| {\n                if let Some(payments_object) = payments.as_object_mut() {\n                    if !payouts.is_null() {\n                        payments_object.insert(\"payouts\".to_string(), payouts);\n                    }\n                }\n                payments\n            })\n        })?;\n\n        <serde_json::Value as diesel::serialize::ToSql<\n            diesel::sql_types::Jsonb,\n            diesel::pg::Pg,\n        >>::to_sql(&payments, &mut out.reborrow())\n    }",
+      "diff_span": {
+        "before": "        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,\n    ) -> diesel::serialize::Result {\n        let mut payments = serde_json::to_value(self.payments.as_ref())?;\n\n        self.payouts\n            .as_ref()\n            .map(serde_json::to_value)\n            .transpose()?\n            .map(|payout_val| {\n                if !payout_val.is_null() {\n                    payments\n                        .as_object_mut()\n                        .map(|payment_val| payment_val.insert(\"payouts\".to_string(), payout_val))\n                } else {\n                    None\n                }\n            });\n\n        <serde_json::Value as diesel::serialize::ToSql<",
+        "after": "        out: &mut diesel::serialize::Output<'b, '_, diesel::pg::Pg>,\n    ) -> diesel::serialize::Result {\n        let payments = serde_json::to_value(self.payments.as_ref()).and_then(|mut payments| {\n            if payments.is_null() {\n                payments = serde_json::json!({});\n            }\n            serde_json::to_value(self.payouts.as_ref()).map(|payouts| {\n                if let Some(payments_object) = payments.as_object_mut() {\n                    if !payouts.is_null() {\n                        payments_object.insert(\"payouts\".to_string(), payouts);\n                    }\n                }\n                payments\n            })\n        })?;\n\n        <serde_json::Value as diesel::serialize::ToSql<"
+      },
+      "commit_sha": "8717d297200bb8ac8027519fe166a3916abadabb"
+    },
+    {
+      "id": "crates/router/src/core/webhooks/incoming.rs::function::update_connector_mandate_details",
+      "file": "crates/router/src/core/webhooks/incoming.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn update_connector_mandate_details(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    object_ref_id: api::ObjectReferenceId,\n    connector: &ConnectorEnum,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n) -> CustomResult<(), errors::ApiErrorResponse> {\n    let webhook_connector_mandate_details = connector\n        .get_mandate_details(request_details)\n        .switch()\n        .attach_printable(\"Could not find connector mandate details in incoming webhook body\")?;\n\n    let webhook_connector_network_transaction_id = connector\n        .get_network_txn_id(request_details)\n        .switch()\n        .attach_printable(\n            \"Could not find connector network transaction id in incoming webhook body\",\n        )?;\n\n    // Either one OR both of the fields are present\n    if webhook_connector_mandate_details.is_some()\n        || webhook_connector_network_transaction_id.is_some()\n    {\n        let payment_attempt =\n            get_payment_attempt_from_object_reference_id(state, object_ref_id, merchant_account)\n                .await?;\n        if let Some(ref payment_method_id) = payment_attempt.payment_method_id {\n            let key_manager_state = &state.into();\n            let payment_method_info = state\n                .store\n                .find_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_id,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;\n\n            // Update connector's mandate details\n            let updated_connector_mandate_details =\n                if let Some(webhook_mandate_details) = webhook_connector_mandate_details {\n                    let mandate_details = payment_method_info\n                        .get_common_mandate_reference()\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed to deserialize to Payment Mandate Reference\")?;\n\n                    let merchant_connector_account_id = payment_attempt\n                        .merchant_connector_id\n                        .clone()\n                        .get_required_value(\"merchant_connector_id\")?;\n\n                    if mandate_details.payments.as_ref().map_or(true, |payments| {\n                        !payments.0.contains_key(&merchant_connector_account_id)\n                    }) {\n                        // Update the payment attempt to maintain consistency across tables.\n                        let (mandate_metadata, connector_mandate_request_reference_id) =\n                            payment_attempt\n                                .connector_mandate_detail\n                                .as_ref()\n                                .map(|details| {\n                                    (\n                                        details.mandate_metadata.clone(),\n                                        details.connector_mandate_request_reference_id.clone(),\n                                    )\n                                })\n                                .unwrap_or((None, None));\n\n                        let connector_mandate_reference_id = ConnectorMandateReferenceId {\n                            connector_mandate_id: Some(\n                                webhook_mandate_details\n                                    .connector_mandate_id\n                                    .peek()\n                                    .to_string(),\n                            ),\n                            payment_method_id: Some(payment_method_id.to_string()),\n                            mandate_metadata,\n                            connector_mandate_request_reference_id,\n                        };\n\n                        let attempt_update =\n                            storage::PaymentAttemptUpdate::ConnectorMandateDetailUpdate {\n                                connector_mandate_detail: Some(connector_mandate_reference_id),\n                                updated_by: merchant_account.storage_scheme.to_string(),\n                            };\n\n                        state\n                            .store\n                            .update_payment_attempt_with_attempt_id(\n                                payment_attempt.clone(),\n                                attempt_update,\n                                merchant_account.storage_scheme,\n                            )\n                            .await\n                            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n                        insert_mandate_details(\n                            &payment_attempt,\n                            &webhook_mandate_details,\n                            Some(mandate_details),\n                        )?\n                    } else {\n                        logger::info!(\n                        \"Skipping connector mandate details update since they are already present.\"\n                    );\n                        None\n                    }\n                } else {\n                    None\n                };\n\n            let connector_mandate_details_value = updated_connector_mandate_details\n                .map(|common_mandate| {\n                    serde_json::to_value(common_mandate.payments.as_ref())\n                        .and_then(|mut payments| {\n                            serde_json::to_value(common_mandate.payouts.as_ref()).map(|payouts| {\n                                if let Some(payments_object) = payments.as_object_mut() {\n                                    if !payouts.is_null() {\n                                        payments_object.insert(\"payouts\".to_string(), payouts);\n                                    }\n                                }\n                                payments\n                            })\n                        })\n                        .map_err(|_| errors::ApiErrorResponse::MandateUpdateFailed)\n                })\n                .transpose()?;\n\n            let pm_update = diesel_models::PaymentMethodUpdate::ConnectorNetworkTransactionIdAndMandateDetailsUpdate {\n                connector_mandate_details: connector_mandate_details_value.map(masking::Secret::new),\n                network_transaction_id: webhook_connector_network_transaction_id\n                    .map(|webhook_network_transaction_id| webhook_network_transaction_id.get_id().clone()),\n            };\n\n            state\n                .store\n                .update_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_info,\n                    pm_update,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to update payment method in db\")?;\n        }\n    }\n    Ok(())\n}",
+      "after_code": "async fn update_connector_mandate_details(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    object_ref_id: api::ObjectReferenceId,\n    connector: &ConnectorEnum,\n    request_details: &IncomingWebhookRequestDetails<'_>,\n) -> CustomResult<(), errors::ApiErrorResponse> {\n    let webhook_connector_mandate_details = connector\n        .get_mandate_details(request_details)\n        .switch()\n        .attach_printable(\"Could not find connector mandate details in incoming webhook body\")?;\n\n    let webhook_connector_network_transaction_id = connector\n        .get_network_txn_id(request_details)\n        .switch()\n        .attach_printable(\n            \"Could not find connector network transaction id in incoming webhook body\",\n        )?;\n\n    // Either one OR both of the fields are present\n    if webhook_connector_mandate_details.is_some()\n        || webhook_connector_network_transaction_id.is_some()\n    {\n        let payment_attempt =\n            get_payment_attempt_from_object_reference_id(state, object_ref_id, merchant_account)\n                .await?;\n        if let Some(ref payment_method_id) = payment_attempt.payment_method_id {\n            let key_manager_state = &state.into();\n            let payment_method_info = state\n                .store\n                .find_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_id,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentMethodNotFound)?;\n\n            // Update connector's mandate details\n            let updated_connector_mandate_details =\n                if let Some(webhook_mandate_details) = webhook_connector_mandate_details {\n                    let mandate_details = payment_method_info\n                        .get_common_mandate_reference()\n                        .change_context(errors::ApiErrorResponse::InternalServerError)\n                        .attach_printable(\"Failed to deserialize to Payment Mandate Reference\")?;\n\n                    let merchant_connector_account_id = payment_attempt\n                        .merchant_connector_id\n                        .clone()\n                        .get_required_value(\"merchant_connector_id\")?;\n\n                    if mandate_details.payments.as_ref().map_or(true, |payments| {\n                        !payments.0.contains_key(&merchant_connector_account_id)\n                    }) {\n                        // Update the payment attempt to maintain consistency across tables.\n                        let (mandate_metadata, connector_mandate_request_reference_id) =\n                            payment_attempt\n                                .connector_mandate_detail\n                                .as_ref()\n                                .map(|details| {\n                                    (\n                                        details.mandate_metadata.clone(),\n                                        details.connector_mandate_request_reference_id.clone(),\n                                    )\n                                })\n                                .unwrap_or((None, None));\n\n                        let connector_mandate_reference_id = ConnectorMandateReferenceId {\n                            connector_mandate_id: Some(\n                                webhook_mandate_details\n                                    .connector_mandate_id\n                                    .peek()\n                                    .to_string(),\n                            ),\n                            payment_method_id: Some(payment_method_id.to_string()),\n                            mandate_metadata,\n                            connector_mandate_request_reference_id,\n                        };\n\n                        let attempt_update =\n                            storage::PaymentAttemptUpdate::ConnectorMandateDetailUpdate {\n                                connector_mandate_detail: Some(connector_mandate_reference_id),\n                                updated_by: merchant_account.storage_scheme.to_string(),\n                            };\n\n                        state\n                            .store\n                            .update_payment_attempt_with_attempt_id(\n                                payment_attempt.clone(),\n                                attempt_update,\n                                merchant_account.storage_scheme,\n                            )\n                            .await\n                            .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n                        insert_mandate_details(\n                            &payment_attempt,\n                            &webhook_mandate_details,\n                            Some(mandate_details),\n                        )?\n                    } else {\n                        logger::info!(\n                        \"Skipping connector mandate details update since they are already present.\"\n                    );\n                        None\n                    }\n                } else {\n                    None\n                };\n\n            let connector_mandate_details_value = updated_connector_mandate_details\n                .map(|common_mandate| {\n                    serde_json::to_value(common_mandate.payments.as_ref())\n                        .and_then(|mut payments| {\n                            if payments.is_null() {\n                                payments = serde_json::json!({});\n                            }\n                            serde_json::to_value(common_mandate.payouts.as_ref()).map(|payouts| {\n                                if let Some(payments_object) = payments.as_object_mut() {\n                                    if !payouts.is_null() {\n                                        payments_object.insert(\"payouts\".to_string(), payouts);\n                                    }\n                                }\n                                payments\n                            })\n                        })\n                        .map_err(|_| errors::ApiErrorResponse::MandateUpdateFailed)\n                })\n                .transpose()?;\n\n            let pm_update = diesel_models::PaymentMethodUpdate::ConnectorNetworkTransactionIdAndMandateDetailsUpdate {\n                connector_mandate_details: connector_mandate_details_value.map(masking::Secret::new),\n                network_transaction_id: webhook_connector_network_transaction_id\n                    .map(|webhook_network_transaction_id| webhook_network_transaction_id.get_id().clone()),\n            };\n\n            state\n                .store\n                .update_payment_method(\n                    key_manager_state,\n                    key_store,\n                    payment_method_info,\n                    pm_update,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to update payment method in db\")?;\n        }\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "",
+        "after": "                    serde_json::to_value(common_mandate.payments.as_ref())\n                        .and_then(|mut payments| {\n                            if payments.is_null() {\n                                payments = serde_json::json!({});\n                            }\n                            serde_json::to_value(common_mandate.payouts.as_ref()).map(|payouts| {\n                                if let Some(payments_object) = payments.as_object_mut() {"
+      },
+      "commit_sha": "8717d297200bb8ac8027519fe166a3916abadabb"
+    },
+    {
+      "id": "crates/api_models/src/payment_methods.rs::function::deserialize_connector_mandate_details",
+      "file": "crates/api_models/src/payment_methods.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn deserialize_connector_mandate_details<'de, D>(\n    deserializer: D,\n) -> Result<Option<CommonMandateReference>, D::Error>\nwhere\n    D: serde::Deserializer<'de>,\n{\n    let value: Option<serde_json::Value> =\n        <Option<serde_json::Value> as de::Deserialize>::deserialize(deserializer)?;\n\n    let payments_data = value\n        .clone()\n        .map(|mut mandate_details| {\n            mandate_details\n                .as_object_mut()\n                .map(|obj| obj.remove(\"payouts\"));\n\n            serde_json::from_value::<PaymentsMandateReference>(mandate_details)\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize paymentsMandateReference\"))?;\n\n    let payouts_data = value\n        .clone()\n        .map(|mandate_details| {\n            serde_json::from_value::<Option<CommonMandateReference>>(mandate_details).map(\n                |optional_common_mandate_details| {\n                    optional_common_mandate_details\n                        .and_then(|common_mandate_details| common_mandate_details.payouts)\n                },\n            )\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize paymentsMandateReference\"))?\n        .flatten();\n\n    Ok(Some(CommonMandateReference {\n        payments: payments_data,\n        payouts: payouts_data,\n    }))\n}",
+      "after_code": "fn deserialize_connector_mandate_details<'de, D>(\n    deserializer: D,\n) -> Result<Option<CommonMandateReference>, D::Error>\nwhere\n    D: serde::Deserializer<'de>,\n{\n    let value: Option<serde_json::Value> =\n        <Option<serde_json::Value> as de::Deserialize>::deserialize(deserializer)?;\n\n    let payments_data = value\n        .clone()\n        .map(|mut mandate_details| {\n            mandate_details\n                .as_object_mut()\n                .map(|obj| obj.remove(\"payouts\"));\n\n            serde_json::from_value::<PaymentsMandateReference>(mandate_details)\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize PaymentsMandateReference\"))?;\n\n    let payouts_data = value\n        .clone()\n        .map(|mandate_details| {\n            serde_json::from_value::<Option<CommonMandateReference>>(mandate_details).map(\n                |optional_common_mandate_details| {\n                    optional_common_mandate_details\n                        .and_then(|common_mandate_details| common_mandate_details.payouts)\n                },\n            )\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize CommonMandateReference\"))?\n        .flatten();\n\n    Ok(Some(CommonMandateReference {\n        payments: payments_data,\n        payouts: payouts_data,\n    }))\n}",
+      "diff_span": {
+        "before": "        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize paymentsMandateReference\"))?;\n\n    let payouts_data = value\n        .clone()\n        .map(|mandate_details| {\n            serde_json::from_value::<Option<CommonMandateReference>>(mandate_details).map(\n                |optional_common_mandate_details| {\n                    optional_common_mandate_details\n                        .and_then(|common_mandate_details| common_mandate_details.payouts)\n                },\n            )\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize paymentsMandateReference\"))?\n        .flatten();\n",
+        "after": "        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize PaymentsMandateReference\"))?;\n\n    let payouts_data = value\n        .clone()\n        .map(|mandate_details| {\n            serde_json::from_value::<Option<CommonMandateReference>>(mandate_details).map(\n                |optional_common_mandate_details| {\n                    optional_common_mandate_details\n                        .and_then(|common_mandate_details| common_mandate_details.payouts)\n                },\n            )\n        })\n        .transpose()\n        .map_err(|_| de::Error::custom(\"Failed to deserialize CommonMandateReference\"))?\n        .flatten();\n"
+      },
+      "commit_sha": "8717d297200bb8ac8027519fe166a3916abadabb"
+    }
+  ]
+}

diffs/pr_6687/9ec8a16/diff.json

@@ -0,0 +1,99 @@
+{
+  "commit_sha": "9ec8a16d9c1e2079fed4afcb84ad6af9544ab8a3",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/router/src/core/payouts.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payouts.rs::function::response_handler",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn response_handler(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    payout_data: &PayoutData,\n) -> RouterResponse<payouts::PayoutCreateResponse> {\n    let payout_attempt = payout_data.payout_attempt.to_owned();\n    let payouts = payout_data.payouts.to_owned();\n\n    let payment_method_id: Option<String> = payout_data\n        .payment_method\n        .as_ref() // Safely access the `payment_method` as a reference\n        .and_then(|pm| Some(pm.payment_method_id.clone()));\n\n    let payout_link = payout_data.payout_link.to_owned();\n    let billing_address = payout_data.billing_address.to_owned();\n    let customer_details = payout_data.customer_details.to_owned();\n    let customer_id = payouts.customer_id;\n    let billing = billing_address\n        .as_ref()\n        .map(hyperswitch_domain_models::address::Address::from)\n        .map(From::from);\n\n    let translated_unified_message = helpers::get_translated_unified_code_and_message(\n        state,\n        payout_attempt.unified_code.as_ref(),\n        payout_attempt.unified_message.as_ref(),\n        &payout_data.current_locale,\n    )\n    .await?;\n\n    let additional_payout_method_data = payout_attempt.additional_payout_method_data.clone();\n\n    let payout_method_data =\n        additional_payout_method_data.map(payouts::PayoutMethodDataResponse::from);\n\n    let response = api::PayoutCreateResponse {\n        payout_id: payouts.payout_id.to_owned(),\n        merchant_id: merchant_account.get_id().to_owned(),\n        amount: payouts.amount,\n        currency: payouts.destination_currency.to_owned(),\n        connector: payout_attempt.connector,\n        payout_type: payouts.payout_type.to_owned(),\n        payout_method_data,\n        billing,\n        auto_fulfill: payouts.auto_fulfill,\n        customer_id,\n        email: customer_details.as_ref().and_then(|c| c.email.clone()),\n        name: customer_details.as_ref().and_then(|c| c.name.clone()),\n        phone: customer_details.as_ref().and_then(|c| c.phone.clone()),\n        phone_country_code: customer_details\n            .as_ref()\n            .and_then(|c| c.phone_country_code.clone()),\n        customer: customer_details\n            .as_ref()\n            .map(payment_api_types::CustomerDetailsResponse::foreign_from),\n        client_secret: payouts.client_secret.to_owned(),\n        return_url: payouts.return_url.to_owned(),\n        business_country: payout_attempt.business_country,\n        business_label: payout_attempt.business_label,\n        description: payouts.description.to_owned(),\n        entity_type: payouts.entity_type.to_owned(),\n        recurring: payouts.recurring,\n        metadata: payouts.metadata,\n        merchant_connector_id: payout_attempt.merchant_connector_id.to_owned(),\n        status: payout_attempt.status.to_owned(),\n        error_message: payout_attempt.error_message.to_owned(),\n        error_code: payout_attempt.error_code,\n        profile_id: payout_attempt.profile_id,\n        created: Some(payouts.created_at),\n        connector_transaction_id: payout_attempt.connector_payout_id,\n        priority: payouts.priority,\n        attempts: None,\n        unified_code: payout_attempt.unified_code,\n        unified_message: translated_unified_message,\n        payout_link: payout_link\n            .map(|payout_link| {\n                url::Url::parse(payout_link.url.peek()).map(|link| PayoutLinkResponse {\n                    payout_link_id: payout_link.link_id,\n                    link: link.into(),\n                })\n            })\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to parse payout link's URL\")?,\n        payment_method_id: payment_method_id,\n    };\n    Ok(services::ApplicationResponse::Json(response))\n}",
+      "after_code": "pub async fn response_handler(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    payout_data: &PayoutData,\n) -> RouterResponse<payouts::PayoutCreateResponse> {\n    let payout_attempt = payout_data.payout_attempt.to_owned();\n    let payouts = payout_data.payouts.to_owned();\n\n    let payment_method_id: Option<String> = payout_data\n        .payment_method\n        .as_ref() // Safely access the `payment_method` as a reference\n        .map(|pm| pm.payment_method_id.clone());\n\n    let payout_link = payout_data.payout_link.to_owned();\n    let billing_address = payout_data.billing_address.to_owned();\n    let customer_details = payout_data.customer_details.to_owned();\n    let customer_id = payouts.customer_id;\n    let billing = billing_address\n        .as_ref()\n        .map(hyperswitch_domain_models::address::Address::from)\n        .map(From::from);\n\n    let translated_unified_message = helpers::get_translated_unified_code_and_message(\n        state,\n        payout_attempt.unified_code.as_ref(),\n        payout_attempt.unified_message.as_ref(),\n        &payout_data.current_locale,\n    )\n    .await?;\n\n    let additional_payout_method_data = payout_attempt.additional_payout_method_data.clone();\n\n    let payout_method_data =\n        additional_payout_method_data.map(payouts::PayoutMethodDataResponse::from);\n\n    let response = api::PayoutCreateResponse {\n        payout_id: payouts.payout_id.to_owned(),\n        merchant_id: merchant_account.get_id().to_owned(),\n        amount: payouts.amount,\n        currency: payouts.destination_currency.to_owned(),\n        connector: payout_attempt.connector,\n        payout_type: payouts.payout_type.to_owned(),\n        payout_method_data,\n        billing,\n        auto_fulfill: payouts.auto_fulfill,\n        customer_id,\n        email: customer_details.as_ref().and_then(|c| c.email.clone()),\n        name: customer_details.as_ref().and_then(|c| c.name.clone()),\n        phone: customer_details.as_ref().and_then(|c| c.phone.clone()),\n        phone_country_code: customer_details\n            .as_ref()\n            .and_then(|c| c.phone_country_code.clone()),\n        customer: customer_details\n            .as_ref()\n            .map(payment_api_types::CustomerDetailsResponse::foreign_from),\n        client_secret: payouts.client_secret.to_owned(),\n        return_url: payouts.return_url.to_owned(),\n        business_country: payout_attempt.business_country,\n        business_label: payout_attempt.business_label,\n        description: payouts.description.to_owned(),\n        entity_type: payouts.entity_type.to_owned(),\n        recurring: payouts.recurring,\n        metadata: payouts.metadata,\n        merchant_connector_id: payout_attempt.merchant_connector_id.to_owned(),\n        status: payout_attempt.status.to_owned(),\n        error_message: payout_attempt.error_message.to_owned(),\n        error_code: payout_attempt.error_code,\n        profile_id: payout_attempt.profile_id,\n        created: Some(payouts.created_at),\n        connector_transaction_id: payout_attempt.connector_payout_id,\n        priority: payouts.priority,\n        attempts: None,\n        unified_code: payout_attempt.unified_code,\n        unified_message: translated_unified_message,\n        payout_link: payout_link\n            .map(|payout_link| {\n                url::Url::parse(payout_link.url.peek()).map(|link| PayoutLinkResponse {\n                    payout_link_id: payout_link.link_id,\n                    link: link.into(),\n                })\n            })\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to parse payout link's URL\")?,\n        payment_method_id,\n    };\n    Ok(services::ApplicationResponse::Json(response))\n}",
+      "diff_span": {
+        "before": "        .payment_method\n        .as_ref() // Safely access the `payment_method` as a reference\n        .and_then(|pm| Some(pm.payment_method_id.clone()));\n\n    let payout_link = payout_data.payout_link.to_owned();\n    let billing_address = payout_data.billing_address.to_owned();\n    let customer_details = payout_data.customer_details.to_owned();\n    let customer_id = payouts.customer_id;\n    let billing = billing_address\n        .as_ref()\n        .map(hyperswitch_domain_models::address::Address::from)\n        .map(From::from);\n\n    let translated_unified_message = helpers::get_translated_unified_code_and_message(\n        state,\n        payout_attempt.unified_code.as_ref(),\n        payout_attempt.unified_message.as_ref(),\n        &payout_data.current_locale,\n    )\n    .await?;\n\n    let additional_payout_method_data = payout_attempt.additional_payout_method_data.clone();\n\n    let payout_method_data =\n        additional_payout_method_data.map(payouts::PayoutMethodDataResponse::from);\n\n    let response = api::PayoutCreateResponse {\n        payout_id: payouts.payout_id.to_owned(),\n        merchant_id: merchant_account.get_id().to_owned(),\n        amount: payouts.amount,\n        currency: payouts.destination_currency.to_owned(),\n        connector: payout_attempt.connector,\n        payout_type: payouts.payout_type.to_owned(),\n        payout_method_data,\n        billing,\n        auto_fulfill: payouts.auto_fulfill,\n        customer_id,\n        email: customer_details.as_ref().and_then(|c| c.email.clone()),\n        name: customer_details.as_ref().and_then(|c| c.name.clone()),\n        phone: customer_details.as_ref().and_then(|c| c.phone.clone()),\n        phone_country_code: customer_details\n            .as_ref()\n            .and_then(|c| c.phone_country_code.clone()),\n        customer: customer_details\n            .as_ref()\n            .map(payment_api_types::CustomerDetailsResponse::foreign_from),\n        client_secret: payouts.client_secret.to_owned(),\n        return_url: payouts.return_url.to_owned(),\n        business_country: payout_attempt.business_country,\n        business_label: payout_attempt.business_label,\n        description: payouts.description.to_owned(),\n        entity_type: payouts.entity_type.to_owned(),\n        recurring: payouts.recurring,\n        metadata: payouts.metadata,\n        merchant_connector_id: payout_attempt.merchant_connector_id.to_owned(),\n        status: payout_attempt.status.to_owned(),\n        error_message: payout_attempt.error_message.to_owned(),\n        error_code: payout_attempt.error_code,\n        profile_id: payout_attempt.profile_id,\n        created: Some(payouts.created_at),\n        connector_transaction_id: payout_attempt.connector_payout_id,\n        priority: payouts.priority,\n        attempts: None,\n        unified_code: payout_attempt.unified_code,\n        unified_message: translated_unified_message,\n        payout_link: payout_link\n            .map(|payout_link| {\n                url::Url::parse(payout_link.url.peek()).map(|link| PayoutLinkResponse {\n                    payout_link_id: payout_link.link_id,\n                    link: link.into(),\n                })\n            })\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to parse payout link's URL\")?,\n        payment_method_id: payment_method_id,\n    };\n    Ok(services::ApplicationResponse::Json(response))",
+        "after": "        .payment_method\n        .as_ref() // Safely access the `payment_method` as a reference\n        .map(|pm| pm.payment_method_id.clone());\n\n    let payout_link = payout_data.payout_link.to_owned();\n    let billing_address = payout_data.billing_address.to_owned();\n    let customer_details = payout_data.customer_details.to_owned();\n    let customer_id = payouts.customer_id;\n    let billing = billing_address\n        .as_ref()\n        .map(hyperswitch_domain_models::address::Address::from)\n        .map(From::from);\n\n    let translated_unified_message = helpers::get_translated_unified_code_and_message(\n        state,\n        payout_attempt.unified_code.as_ref(),\n        payout_attempt.unified_message.as_ref(),\n        &payout_data.current_locale,\n    )\n    .await?;\n\n    let additional_payout_method_data = payout_attempt.additional_payout_method_data.clone();\n\n    let payout_method_data =\n        additional_payout_method_data.map(payouts::PayoutMethodDataResponse::from);\n\n    let response = api::PayoutCreateResponse {\n        payout_id: payouts.payout_id.to_owned(),\n        merchant_id: merchant_account.get_id().to_owned(),\n        amount: payouts.amount,\n        currency: payouts.destination_currency.to_owned(),\n        connector: payout_attempt.connector,\n        payout_type: payouts.payout_type.to_owned(),\n        payout_method_data,\n        billing,\n        auto_fulfill: payouts.auto_fulfill,\n        customer_id,\n        email: customer_details.as_ref().and_then(|c| c.email.clone()),\n        name: customer_details.as_ref().and_then(|c| c.name.clone()),\n        phone: customer_details.as_ref().and_then(|c| c.phone.clone()),\n        phone_country_code: customer_details\n            .as_ref()\n            .and_then(|c| c.phone_country_code.clone()),\n        customer: customer_details\n            .as_ref()\n            .map(payment_api_types::CustomerDetailsResponse::foreign_from),\n        client_secret: payouts.client_secret.to_owned(),\n        return_url: payouts.return_url.to_owned(),\n        business_country: payout_attempt.business_country,\n        business_label: payout_attempt.business_label,\n        description: payouts.description.to_owned(),\n        entity_type: payouts.entity_type.to_owned(),\n        recurring: payouts.recurring,\n        metadata: payouts.metadata,\n        merchant_connector_id: payout_attempt.merchant_connector_id.to_owned(),\n        status: payout_attempt.status.to_owned(),\n        error_message: payout_attempt.error_message.to_owned(),\n        error_code: payout_attempt.error_code,\n        profile_id: payout_attempt.profile_id,\n        created: Some(payouts.created_at),\n        connector_transaction_id: payout_attempt.connector_payout_id,\n        priority: payouts.priority,\n        attempts: None,\n        unified_code: payout_attempt.unified_code,\n        unified_message: translated_unified_message,\n        payout_link: payout_link\n            .map(|payout_link| {\n                url::Url::parse(payout_link.url.peek()).map(|link| PayoutLinkResponse {\n                    payout_link_id: payout_link.link_id,\n                    link: link.into(),\n                })\n            })\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to parse payout link's URL\")?,\n        payment_method_id,\n    };\n    Ok(services::ApplicationResponse::Json(response))"
+      },
+      "commit_sha": "9ec8a16d9c1e2079fed4afcb84ad6af9544ab8a3"
+    },
+    {
+      "id": "crates/router/src/core/payouts.rs::function::payouts_create_core",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn payouts_create_core(\n    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    key_store: domain::MerchantKeyStore,\n    req: payouts::PayoutCreateRequest,\n) -> RouterResponse<payouts::PayoutCreateResponse> {\n    // Validate create request\n    let (payout_id, payout_method_data, profile_id, customer, payment_method) =\n        validator::validate_create_request(&state, &merchant_account, &req, &key_store).await?;\n\n    // Create DB entries\n    let mut payout_data = payout_create_db_entries(\n        &state,\n        &merchant_account,\n        &key_store,\n        &req,\n        &payout_id,\n        &profile_id,\n        payout_method_data.as_ref(),\n        &state.locale,\n        customer.as_ref(),\n        payment_method.clone(),\n    )\n    .await?;\n    /*\n\n\n\n\n\n\n\n\n    */\n\n    let payout_attempt = payout_data.payout_attempt.to_owned();\n    let payout_type = payout_data.payouts.payout_type.to_owned();\n\n    // Persist payout method data in temp locker\n    if req.payout_method_data.is_some() {\n        let customer_id = payout_data\n            .payouts\n            .customer_id\n            .clone()\n            .get_required_value(\"customer_id when payout_method_data is provided\")?;\n        payout_data.payout_method_data = helpers::make_payout_method_data(\n            &state,\n            req.payout_method_data.as_ref(),\n            payout_attempt.payout_token.as_deref(),\n            &customer_id,\n            &payout_attempt.merchant_id,\n            payout_type,\n            &key_store,\n            Some(&mut payout_data),\n            merchant_account.storage_scheme,\n        )\n        .await?;\n    }\n\n    if let Some(true) = payout_data.payouts.confirm {\n        payouts_core(\n            &state,\n            &merchant_account,\n            &key_store,\n            &mut payout_data,\n            req.routing.clone(),\n            req.connector.clone(),\n        )\n        .await?\n    };\n\n    response_handler(&state, &merchant_account, &payout_data).await\n}",
+      "after_code": "pub async fn payouts_create_core(\n    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    key_store: domain::MerchantKeyStore,\n    req: payouts::PayoutCreateRequest,\n) -> RouterResponse<payouts::PayoutCreateResponse> {\n    // Validate create request\n    let (payout_id, payout_method_data, profile_id, customer, payment_method) =\n        validator::validate_create_request(&state, &merchant_account, &req, &key_store).await?;\n\n    // Create DB entries\n    let mut payout_data = payout_create_db_entries(\n        &state,\n        &merchant_account,\n        &key_store,\n        &req,\n        &payout_id,\n        &profile_id,\n        payout_method_data.as_ref(),\n        &state.locale,\n        customer.as_ref(),\n        payment_method.clone(),\n    )\n    .await?;\n    /*\n\n\n    dummy commit\n\n\n\n\n\n    */\n\n    let payout_attempt = payout_data.payout_attempt.to_owned();\n    let payout_type = payout_data.payouts.payout_type.to_owned();\n\n    // Persist payout method data in temp locker\n    if req.payout_method_data.is_some() {\n        let customer_id = payout_data\n            .payouts\n            .customer_id\n            .clone()\n            .get_required_value(\"customer_id when payout_method_data is provided\")?;\n        payout_data.payout_method_data = helpers::make_payout_method_data(\n            &state,\n            req.payout_method_data.as_ref(),\n            payout_attempt.payout_token.as_deref(),\n            &customer_id,\n            &payout_attempt.merchant_id,\n            payout_type,\n            &key_store,\n            Some(&mut payout_data),\n            merchant_account.storage_scheme,\n        )\n        .await?;\n    }\n\n    if let Some(true) = payout_data.payouts.confirm {\n        payouts_core(\n            &state,\n            &merchant_account,\n            &key_store,\n            &mut payout_data,\n            req.routing.clone(),\n            req.connector.clone(),\n        )\n        .await?\n    };\n\n    response_handler(&state, &merchant_account, &payout_data).await\n}",
+      "diff_span": {
+        "before": "\n\n\n\n",
+        "after": "\n\n    dummy commit\n\n"
+      },
+      "commit_sha": "9ec8a16d9c1e2079fed4afcb84ad6af9544ab8a3"
+    },
+    {
+      "id": "crates/router/src/core/payouts.rs::function::create_recipient_disburse_account",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn create_recipient_disburse_account(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n    key_store: &domain::MerchantKeyStore,\n) -> RouterResult<()> {\n    // 1. Form Router data\n    let router_data = core_utils::construct_payout_router_data(\n        state,\n        connector_data,\n        merchant_account,\n        payout_data,\n    )\n    .await?;\n\n    // 2. Fetch connector integration details\n    let connector_integration: services::BoxedPayoutConnectorIntegrationInterface<\n        api::PoRecipientAccount,\n        types::PayoutsData,\n        types::PayoutsResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    // 3. Call connector service\n    let router_data_resp = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &router_data,\n        payments::CallConnectorAction::Trigger,\n        None,\n    )\n    .await\n    .to_payout_failed_response()?;\n\n    // 4. Process data returned by the connector\n    let db = &*state.store;\n    match router_data_resp.response {\n        Ok(payout_response_data) => {\n            let payout_attempt = &payout_data.payout_attempt;\n            let status = payout_response_data\n                .status\n                .unwrap_or(payout_attempt.status.to_owned());\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_response_data.connector_payout_id.clone(),\n                status,\n                error_code: None,\n                error_message: None,\n                is_eligible: payout_response_data.payout_eligible,\n                unified_code: None,\n                unified_message: None,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n\n            if let (\n                true,\n                Some(ref payout_method_data),\n                Some(connector_payout_id),\n                Some(customer_details),\n                Some(merchant_connector_id),\n            ) = (\n                payout_data.payouts.recurring,\n                payout_data.payout_method_data.clone(),\n                payout_response_data.connector_payout_id.clone(),\n                payout_data.customer_details.clone(),\n                connector_data.merchant_connector_id.clone(),\n            ) {\n                let connector_mandate_details = HashMap::from([(\n                    merchant_connector_id, // which connector was called  [MCA]\n                    PaymentsMandateReferenceRecord {\n                        connector_mandate_id: connector_payout_id, // what does the connector return\n                        payment_method_type: Some(api_enums::PaymentMethodType::foreign_from(\n                            payout_method_data,\n                        )),\n                        original_payment_authorized_amount: Some(\n                            payout_data.payouts.amount.get_amount_as_i64(),\n                        ),\n                        original_payment_authorized_currency: Some(\n                            payout_data.payouts.destination_currency,\n                        ),\n                    },\n                )]);\n\n                let connector_mandate_details_value =\n                    serde_json::to_value(connector_mandate_details).ok();\n\n                /**************** above this is correct **********************\n                need to fetch connector_mandate_details using payment_method_id\n                */\n                let pm_id = payout_data.payouts.payout_method_id.clone();\n\n                if let Some(payout_method_id) = pm_id {\n                    let payment_method = db\n                        .find_payment_method(\n                            &(state.into()),\n                            key_store,\n                            &payout_method_id, // need to get from api request\n                            merchant_account.storage_scheme,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n                        .attach_printable(\"Unable to find payment method\")?;\n\n                    payout_data.payment_method = Some(payment_method.clone());\n                    payout_data.payouts.payout_method_id =\n                        Some(payment_method.payment_method_id.clone());\n\n                    // router_env::logger::info!(\"XXXXXXXXXXXXXXXXX\");\n                    // router_env::logger::info!(\"{:?}\", payment_method.payment_method_id.clone());\n                    // router_env::logger::info!(\"XXXXXXXXXXXXXXXXX\");\n                    // router_env::logger::info!(\"{:?}\", payment_method.clone());\n                    // router_env::logger::info!(\"XXXXXXXXXXXXXXXXX\");\n                } else {\n                    // router_env::logger::info!(\"9999999999999999\");\n                    helpers::save_payout_data_to_locker(\n                        state,\n                        payout_data,\n                        &customer_details.customer_id,\n                        &payout_method_data,\n                        connector_mandate_details_value,\n                        merchant_account,\n                        key_store,\n                    )\n                    .await\n                    .attach_printable(\"Failed to save payout data to locker\")?;\n                };\n            }\n        }\n        Err(err) => {\n            let (error_code, error_message) = (Some(err.code), Some(err.message));\n            let (unified_code, unified_message) = helpers::get_gsm_record(\n                state,\n                error_code.clone(),\n                error_message.clone(),\n                payout_data.payout_attempt.connector.clone(),\n                consts::PAYOUT_FLOW_STR,\n            )\n            .await\n            .map_or((None, None), |gsm| (gsm.unified_code, gsm.unified_message));\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_data.payout_attempt.connector_payout_id.to_owned(),\n                status: storage_enums::PayoutStatus::Failed,\n                error_code,\n                error_message,\n                is_eligible: None,\n                unified_code: unified_code\n                    .map(UnifiedCode::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_code\",\n                    })?,\n                unified_message: unified_message\n                    .map(UnifiedMessage::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_message\",\n                    })?,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    &payout_data.payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n        }\n    };\n\n    Ok(())\n}",
+      "after_code": "pub async fn create_recipient_disburse_account(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n    key_store: &domain::MerchantKeyStore,\n) -> RouterResult<()> {\n    // 1. Form Router data\n    let router_data = core_utils::construct_payout_router_data(\n        state,\n        connector_data,\n        merchant_account,\n        payout_data,\n    )\n    .await?;\n\n    // 2. Fetch connector integration details\n    let connector_integration: services::BoxedPayoutConnectorIntegrationInterface<\n        api::PoRecipientAccount,\n        types::PayoutsData,\n        types::PayoutsResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    // 3. Call connector service\n    let router_data_resp = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &router_data,\n        payments::CallConnectorAction::Trigger,\n        None,\n    )\n    .await\n    .to_payout_failed_response()?;\n\n    // 4. Process data returned by the connector\n    let db = &*state.store;\n    match router_data_resp.response {\n        Ok(payout_response_data) => {\n            let payout_attempt = &payout_data.payout_attempt;\n            let status = payout_response_data\n                .status\n                .unwrap_or(payout_attempt.status.to_owned());\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_response_data.connector_payout_id.clone(),\n                status,\n                error_code: None,\n                error_message: None,\n                is_eligible: payout_response_data.payout_eligible,\n                unified_code: None,\n                unified_message: None,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n\n            if let (\n                true,\n                Some(ref payout_method_data),\n                Some(connector_payout_id),\n                Some(customer_details),\n                Some(merchant_connector_id),\n            ) = (\n                payout_data.payouts.recurring,\n                payout_data.payout_method_data.clone(),\n                payout_response_data.connector_payout_id.clone(),\n                payout_data.customer_details.clone(),\n                connector_data.merchant_connector_id.clone(),\n            ) {\n                let connector_mandate_details = HashMap::from([(\n                    merchant_connector_id, // which connector was called  [MCA]\n                    PaymentsMandateReferenceRecord {\n                        connector_mandate_id: connector_payout_id, // what does the connector return\n                        payment_method_type: Some(api_enums::PaymentMethodType::foreign_from(\n                            payout_method_data,\n                        )),\n                        original_payment_authorized_amount: Some(\n                            payout_data.payouts.amount.get_amount_as_i64(),\n                        ),\n                        original_payment_authorized_currency: Some(\n                            payout_data.payouts.destination_currency,\n                        ),\n                    },\n                )]);\n\n                let connector_mandate_details_value =\n                    serde_json::to_value(connector_mandate_details).ok();\n\n                /**************** above this is correct **********************\n                need to fetch connector_mandate_details using payment_method_id\n                */\n                let pm_id = payout_data.payouts.payout_method_id.clone();\n\n                if let Some(payout_method_id) = pm_id {\n                    let payment_method = db\n                        .find_payment_method(\n                            &(state.into()),\n                            key_store,\n                            &payout_method_id, // need to get from api request\n                            merchant_account.storage_scheme,\n                        )\n                        .await\n                        .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n                        .attach_printable(\"Unable to find payment method\")?;\n\n                    payout_data.payment_method = Some(payment_method.clone());\n                    payout_data.payouts.payout_method_id =\n                        Some(payment_method.payment_method_id.clone());\n\n                    // router_env::logger::info!(\"XXXXXXXXXXXXXXXXX\");\n                    // router_env::logger::info!(\"{:?}\", payment_method.payment_method_id.clone());\n                    // router_env::logger::info!(\"XXXXXXXXXXXXXXXXX\");\n                    // router_env::logger::info!(\"{:?}\", payment_method.clone());\n                    // router_env::logger::info!(\"XXXXXXXXXXXXXXXXX\");\n                } else {\n                    // router_env::logger::info!(\"9999999999999999\");\n                    helpers::save_payout_data_to_locker(\n                        state,\n                        payout_data,\n                        &customer_details.customer_id,\n                        payout_method_data,\n                        connector_mandate_details_value,\n                        merchant_account,\n                        key_store,\n                    )\n                    .await\n                    .attach_printable(\"Failed to save payout data to locker\")?;\n                };\n            }\n        }\n        Err(err) => {\n            let (error_code, error_message) = (Some(err.code), Some(err.message));\n            let (unified_code, unified_message) = helpers::get_gsm_record(\n                state,\n                error_code.clone(),\n                error_message.clone(),\n                payout_data.payout_attempt.connector.clone(),\n                consts::PAYOUT_FLOW_STR,\n            )\n            .await\n            .map_or((None, None), |gsm| (gsm.unified_code, gsm.unified_message));\n            let updated_payout_attempt = storage::PayoutAttemptUpdate::StatusUpdate {\n                connector_payout_id: payout_data.payout_attempt.connector_payout_id.to_owned(),\n                status: storage_enums::PayoutStatus::Failed,\n                error_code,\n                error_message,\n                is_eligible: None,\n                unified_code: unified_code\n                    .map(UnifiedCode::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_code\",\n                    })?,\n                unified_message: unified_message\n                    .map(UnifiedMessage::try_from)\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"unified_message\",\n                    })?,\n            };\n            payout_data.payout_attempt = db\n                .update_payout_attempt(\n                    &payout_data.payout_attempt,\n                    updated_payout_attempt,\n                    &payout_data.payouts,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error updating payout_attempt in db\")?;\n        }\n    };\n\n    Ok(())\n}",
+      "diff_span": {
+        "before": "                        payout_data,\n                        &customer_details.customer_id,\n                        &payout_method_data,\n                        connector_mandate_details_value,\n                        merchant_account,",
+        "after": "                        payout_data,\n                        &customer_details.customer_id,\n                        payout_method_data,\n                        connector_mandate_details_value,\n                        merchant_account,"
+      },
+      "commit_sha": "9ec8a16d9c1e2079fed4afcb84ad6af9544ab8a3"
+    },
+    {
+      "id": "crates/router/src/core/payouts.rs::function::complete_create_recipient_disburse_account",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn complete_create_recipient_disburse_account(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n    key_store: &domain::MerchantKeyStore,\n) -> RouterResult<()> {\n    if !payout_data.should_terminate\n        && matches!(\n            payout_data.payout_attempt.status,\n            storage_enums::PayoutStatus::RequiresVendorAccountCreation\n                | storage_enums::PayoutStatus::RequiresCreation\n        )\n        && connector_data\n            .connector_name\n            .supports_vendor_disburse_account_create_for_payout()\n        && connector_mandate_id_is_none(payout_data, connector_data)?\n    {\n        create_recipient_disburse_account(\n            state,\n            merchant_account,\n            connector_data,\n            payout_data,\n            key_store,\n        )\n        .await\n        .attach_printable(\"Creation of customer failed\")?;\n    }\n    Ok(())\n}",
+      "after_code": "pub async fn complete_create_recipient_disburse_account(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n    key_store: &domain::MerchantKeyStore,\n) -> RouterResult<()> {\n    if !payout_data.should_terminate\n        && matches!(\n            payout_data.payout_attempt.status,\n            storage_enums::PayoutStatus::RequiresVendorAccountCreation\n                | storage_enums::PayoutStatus::RequiresCreation\n        )\n        && connector_data\n            .connector_name\n            .supports_vendor_disburse_account_create_for_payout()\n        && connector_mandate_id_is_none(payout_data, connector_data)?\n    {\n        Box::pin(create_recipient_disburse_account(\n            state,\n            merchant_account,\n            connector_data,\n            payout_data,\n            key_store,\n        ))\n        .await\n        .attach_printable(\"Creation of customer failed\")?;\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "        && connector_mandate_id_is_none(payout_data, connector_data)?\n    {\n        create_recipient_disburse_account(\n            state,\n            merchant_account,\n            connector_data,\n            payout_data,\n            key_store,\n        )\n        .await\n        .attach_printable(\"Creation of customer failed\")?;",
+        "after": "        && connector_mandate_id_is_none(payout_data, connector_data)?\n    {\n        Box::pin(create_recipient_disburse_account(\n            state,\n            merchant_account,\n            connector_data,\n            payout_data,\n            key_store,\n        ))\n        .await\n        .attach_printable(\"Creation of customer failed\")?;"
+      },
+      "commit_sha": "9ec8a16d9c1e2079fed4afcb84ad6af9544ab8a3"
+    },
+    {
+      "id": "crates/router/src/core/payouts.rs::function::make_payout_data",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn make_payout_data(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    auth_profile_id: Option<common_utils::id_type::ProfileId>,\n    key_store: &domain::MerchantKeyStore,\n    req: &payouts::PayoutRequest,\n    locale: &str,\n) -> RouterResult<PayoutData> {\n    let db = &*state.store;\n    let merchant_id = merchant_account.get_id();\n    let payout_id = match req {\n        payouts::PayoutRequest::PayoutActionRequest(r) => r.payout_id.clone(),\n        payouts::PayoutRequest::PayoutCreateRequest(r) => r.payout_id.clone().unwrap_or_default(),\n        payouts::PayoutRequest::PayoutRetrieveRequest(r) => r.payout_id.clone(),\n    };\n\n    let payouts = db\n        .find_payout_by_merchant_id_payout_id(\n            merchant_id,\n            &payout_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::PayoutNotFound)?;\n    core_utils::validate_profile_id_from_auth_layer(auth_profile_id, &payouts)?;\n\n    let payout_attempt_id = utils::get_payout_attempt_id(payout_id, payouts.attempt_count);\n\n    let mut payout_attempt = db\n        .find_payout_attempt_by_merchant_id_payout_attempt_id(\n            merchant_id,\n            &payout_attempt_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::PayoutNotFound)?;\n\n    let customer_id = payouts.customer_id.as_ref();\n\n    // We have to do this because the function that is being used to create / get address is from payments\n    // which expects a payment_id\n    let payout_id_as_payment_id_type = common_utils::id_type::PaymentId::try_from(\n        std::borrow::Cow::Owned(payouts.payout_id.clone()),\n    )\n    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n        message: \"payout_id contains invalid data\".to_string(),\n    })\n    .attach_printable(\"Error converting payout_id to PaymentId type\")?;\n\n    let billing_address = payment_helpers::create_or_find_address_for_payment_by_request(\n        state,\n        None,\n        payouts.address_id.as_deref(),\n        merchant_id,\n        customer_id,\n        key_store,\n        &payout_id_as_payment_id_type,\n        merchant_account.storage_scheme,\n    )\n    .await?;\n\n    let payout_id = &payouts.payout_id;\n\n    let customer_details = customer_id\n        .async_map(|customer_id| async move {\n            db.find_customer_optional_by_customer_id_merchant_id(\n                &state.into(),\n                customer_id,\n                merchant_id,\n                key_store,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .map_err(|err| err.change_context(errors::ApiErrorResponse::InternalServerError))\n            .attach_printable_lazy(|| {\n                format!(\n                    \"Failed while fetching optional customer [id - {:?}] for payout [id - {}]\",\n                    customer_id, payout_id\n                )\n            })\n        })\n        .await\n        .transpose()?\n        .and_then(|c| c);\n    let profile_id = payout_attempt.profile_id.clone();\n\n    // Validate whether profile_id passed in request is valid and is linked to the merchant\n    let business_profile =\n        validate_and_get_business_profile(state, key_store, &profile_id, merchant_id).await?;\n    let payout_method_data_req = match req {\n        payouts::PayoutRequest::PayoutCreateRequest(r) => r.payout_method_data.to_owned(),\n        payouts::PayoutRequest::PayoutActionRequest(_) => {\n            match payout_attempt.payout_token.to_owned() {\n                Some(payout_token) => {\n                    let customer_id = customer_details\n                        .as_ref()\n                        .map(|cd| cd.customer_id.to_owned())\n                        .get_required_value(\"customer_id when payout_token is sent\")?;\n                    helpers::make_payout_method_data(\n                        state,\n                        None,\n                        Some(&payout_token),\n                        &customer_id,\n                        merchant_account.get_id(),\n                        payouts.payout_type,\n                        key_store,\n                        None,\n                        merchant_account.storage_scheme,\n                    )\n                    .await?\n                }\n                None => None,\n            }\n        }\n        payouts::PayoutRequest::PayoutRetrieveRequest(_) => None,\n    };\n\n    if let Some(payout_method_data) = payout_method_data_req.clone() {\n        let additional_payout_method_data =\n            helpers::get_additional_payout_data(&payout_method_data, &*state.store, &profile_id)\n                .await;\n\n        let update_additional_payout_method_data =\n            storage::PayoutAttemptUpdate::AdditionalPayoutMethodDataUpdate {\n                additional_payout_method_data,\n            };\n\n        payout_attempt = db\n            .update_payout_attempt(\n                &payout_attempt,\n                update_additional_payout_method_data,\n                &payouts,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Error updating additional payout method data in payout_attempt\")?;\n    };\n\n    let merchant_connector_account =\n        if payout_attempt.connector.is_some() && payout_attempt.merchant_connector_id.is_some() {\n            let connector_name = payout_attempt\n                .connector\n                .clone()\n                .get_required_value(\"connector_name\")?;\n            Some(\n                payment_helpers::get_merchant_connector_account(\n                    state,\n                    merchant_account.get_id(),\n                    None,\n                    key_store,\n                    &profile_id,\n                    connector_name.as_str(),\n                    payout_attempt.merchant_connector_id.as_ref(),\n                )\n                .await?,\n            )\n        } else {\n            None\n        };\n\n    let payout_link = payouts\n        .payout_link_id\n        .clone()\n        .async_map(|link_id| async move {\n            db.find_payout_link_by_link_id(&link_id)\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error fetching payout links from db\")\n        })\n        .await\n        .transpose()?;\n\n    let payout_method_id = payouts.payout_method_id.clone();\n    let mut payment_method: Option<PaymentMethod> = None;\n\n    if let Some(pm_id) = payout_method_id {\n        payment_method = Some(\n            db.find_payment_method(\n                &(state.into()),\n                &key_store,\n                &pm_id, // need to get from api request\n                merchant_account.storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n            .attach_printable(\"Unable to find payment method\")?,\n        );\n    }\n\n    Ok(PayoutData {\n        billing_address,\n        business_profile,\n        customer_details,\n        payouts,\n        payout_attempt,\n        payout_method_data: payout_method_data_req.to_owned(),\n        merchant_connector_account,\n        should_terminate: false,\n        profile_id,\n        payout_link,\n        current_locale: locale.to_string(),\n        payment_method,\n    })\n}",
+      "after_code": "pub async fn make_payout_data(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    auth_profile_id: Option<common_utils::id_type::ProfileId>,\n    key_store: &domain::MerchantKeyStore,\n    req: &payouts::PayoutRequest,\n    locale: &str,\n) -> RouterResult<PayoutData> {\n    let db = &*state.store;\n    let merchant_id = merchant_account.get_id();\n    let payout_id = match req {\n        payouts::PayoutRequest::PayoutActionRequest(r) => r.payout_id.clone(),\n        payouts::PayoutRequest::PayoutCreateRequest(r) => r.payout_id.clone().unwrap_or_default(),\n        payouts::PayoutRequest::PayoutRetrieveRequest(r) => r.payout_id.clone(),\n    };\n\n    let payouts = db\n        .find_payout_by_merchant_id_payout_id(\n            merchant_id,\n            &payout_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::PayoutNotFound)?;\n    core_utils::validate_profile_id_from_auth_layer(auth_profile_id, &payouts)?;\n\n    let payout_attempt_id = utils::get_payout_attempt_id(payout_id, payouts.attempt_count);\n\n    let mut payout_attempt = db\n        .find_payout_attempt_by_merchant_id_payout_attempt_id(\n            merchant_id,\n            &payout_attempt_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::PayoutNotFound)?;\n\n    let customer_id = payouts.customer_id.as_ref();\n\n    // We have to do this because the function that is being used to create / get address is from payments\n    // which expects a payment_id\n    let payout_id_as_payment_id_type = common_utils::id_type::PaymentId::try_from(\n        std::borrow::Cow::Owned(payouts.payout_id.clone()),\n    )\n    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n        message: \"payout_id contains invalid data\".to_string(),\n    })\n    .attach_printable(\"Error converting payout_id to PaymentId type\")?;\n\n    let billing_address = payment_helpers::create_or_find_address_for_payment_by_request(\n        state,\n        None,\n        payouts.address_id.as_deref(),\n        merchant_id,\n        customer_id,\n        key_store,\n        &payout_id_as_payment_id_type,\n        merchant_account.storage_scheme,\n    )\n    .await?;\n\n    let payout_id = &payouts.payout_id;\n\n    let customer_details = customer_id\n        .async_map(|customer_id| async move {\n            db.find_customer_optional_by_customer_id_merchant_id(\n                &state.into(),\n                customer_id,\n                merchant_id,\n                key_store,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .map_err(|err| err.change_context(errors::ApiErrorResponse::InternalServerError))\n            .attach_printable_lazy(|| {\n                format!(\n                    \"Failed while fetching optional customer [id - {:?}] for payout [id - {}]\",\n                    customer_id, payout_id\n                )\n            })\n        })\n        .await\n        .transpose()?\n        .and_then(|c| c);\n    let profile_id = payout_attempt.profile_id.clone();\n\n    // Validate whether profile_id passed in request is valid and is linked to the merchant\n    let business_profile =\n        validate_and_get_business_profile(state, key_store, &profile_id, merchant_id).await?;\n    let payout_method_data_req = match req {\n        payouts::PayoutRequest::PayoutCreateRequest(r) => r.payout_method_data.to_owned(),\n        payouts::PayoutRequest::PayoutActionRequest(_) => {\n            match payout_attempt.payout_token.to_owned() {\n                Some(payout_token) => {\n                    let customer_id = customer_details\n                        .as_ref()\n                        .map(|cd| cd.customer_id.to_owned())\n                        .get_required_value(\"customer_id when payout_token is sent\")?;\n                    helpers::make_payout_method_data(\n                        state,\n                        None,\n                        Some(&payout_token),\n                        &customer_id,\n                        merchant_account.get_id(),\n                        payouts.payout_type,\n                        key_store,\n                        None,\n                        merchant_account.storage_scheme,\n                    )\n                    .await?\n                }\n                None => None,\n            }\n        }\n        payouts::PayoutRequest::PayoutRetrieveRequest(_) => None,\n    };\n\n    if let Some(payout_method_data) = payout_method_data_req.clone() {\n        let additional_payout_method_data =\n            helpers::get_additional_payout_data(&payout_method_data, &*state.store, &profile_id)\n                .await;\n\n        let update_additional_payout_method_data =\n            storage::PayoutAttemptUpdate::AdditionalPayoutMethodDataUpdate {\n                additional_payout_method_data,\n            };\n\n        payout_attempt = db\n            .update_payout_attempt(\n                &payout_attempt,\n                update_additional_payout_method_data,\n                &payouts,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Error updating additional payout method data in payout_attempt\")?;\n    };\n\n    let merchant_connector_account =\n        if payout_attempt.connector.is_some() && payout_attempt.merchant_connector_id.is_some() {\n            let connector_name = payout_attempt\n                .connector\n                .clone()\n                .get_required_value(\"connector_name\")?;\n            Some(\n                payment_helpers::get_merchant_connector_account(\n                    state,\n                    merchant_account.get_id(),\n                    None,\n                    key_store,\n                    &profile_id,\n                    connector_name.as_str(),\n                    payout_attempt.merchant_connector_id.as_ref(),\n                )\n                .await?,\n            )\n        } else {\n            None\n        };\n\n    let payout_link = payouts\n        .payout_link_id\n        .clone()\n        .async_map(|link_id| async move {\n            db.find_payout_link_by_link_id(&link_id)\n                .await\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Error fetching payout links from db\")\n        })\n        .await\n        .transpose()?;\n\n    let payout_method_id = payouts.payout_method_id.clone();\n    let mut payment_method: Option<PaymentMethod> = None;\n\n    if let Some(pm_id) = payout_method_id {\n        payment_method = Some(\n            db.find_payment_method(\n                &(state.into()),\n                key_store,\n                &pm_id, // need to get from api request\n                merchant_account.storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::PaymentMethodNotFound)\n            .attach_printable(\"Unable to find payment method\")?,\n        );\n    }\n\n    Ok(PayoutData {\n        billing_address,\n        business_profile,\n        customer_details,\n        payouts,\n        payout_attempt,\n        payout_method_data: payout_method_data_req.to_owned(),\n        merchant_connector_account,\n        should_terminate: false,\n        profile_id,\n        payout_link,\n        current_locale: locale.to_string(),\n        payment_method,\n    })\n}",
+      "diff_span": {
+        "before": "            db.find_payment_method(\n                &(state.into()),\n                &key_store,\n                &pm_id, // need to get from api request\n                merchant_account.storage_scheme,",
+        "after": "            db.find_payment_method(\n                &(state.into()),\n                key_store,\n                &pm_id, // need to get from api request\n                merchant_account.storage_scheme,"
+      },
+      "commit_sha": "9ec8a16d9c1e2079fed4afcb84ad6af9544ab8a3"
+    },
+    {
+      "id": "crates/router/src/core/payouts.rs::function::call_connector_payout",
+      "file": "crates/router/src/core/payouts.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn call_connector_payout(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n) -> RouterResult<()> {\n    let payout_attempt = &payout_data.payout_attempt.to_owned();\n    let payouts = &payout_data.payouts.to_owned();\n\n    // fetch merchant connector account if not present\n    if payout_data.merchant_connector_account.is_none()\n        || payout_data.payout_attempt.merchant_connector_id.is_none()\n    {\n        let merchant_connector_account = get_mca_from_profile_id(\n            state,\n            merchant_account,\n            &payout_data.profile_id,\n            &connector_data.connector_name.to_string(),\n            payout_attempt\n                .merchant_connector_id\n                .clone()\n                .or(connector_data.merchant_connector_id.clone())\n                .as_ref(),\n            key_store,\n        )\n        .await?;\n        payout_data.payout_attempt.merchant_connector_id = merchant_connector_account.get_mca_id();\n        payout_data.merchant_connector_account = Some(merchant_connector_account);\n    }\n\n    // update connector_name\n    if payout_data.payout_attempt.connector.is_none()\n        || payout_data.payout_attempt.connector != Some(connector_data.connector_name.to_string())\n    {\n        payout_data.payout_attempt.connector = Some(connector_data.connector_name.to_string());\n        let updated_payout_attempt = storage::PayoutAttemptUpdate::UpdateRouting {\n            connector: connector_data.connector_name.to_string(),\n            routing_info: payout_data.payout_attempt.routing_info.clone(),\n            merchant_connector_id: payout_data.payout_attempt.merchant_connector_id.clone(),\n        };\n        let db = &*state.store;\n        payout_data.payout_attempt = db\n            .update_payout_attempt(\n                &payout_data.payout_attempt,\n                updated_payout_attempt,\n                payouts,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Error updating routing info in payout_attempt\")?;\n    };\n\n    // Fetch / store payout_method_data\n    if payout_data.payout_method_data.is_none() || payout_attempt.payout_token.is_none() {\n        let customer_id = payouts\n            .customer_id\n            .clone()\n            .get_required_value(\"customer_id\")?;\n        payout_data.payout_method_data = Some(\n            helpers::make_payout_method_data(\n                state,\n                payout_data.payout_method_data.to_owned().as_ref(),\n                payout_attempt.payout_token.as_deref(),\n                &customer_id,\n                &payout_attempt.merchant_id,\n                payouts.payout_type,\n                key_store,\n                Some(payout_data),\n                merchant_account.storage_scheme,\n            )\n            .await?\n            .get_required_value(\"payout_method_data\")?,\n        );\n    }\n    // Eligibility flow\n    complete_payout_eligibility(state, merchant_account, connector_data, payout_data).await?;\n    // Create customer flow\n    complete_create_recipient(\n        state,\n        merchant_account,\n        key_store,\n        connector_data,\n        payout_data,\n    )\n    .await?;\n    // Create customer's disbursement account flow\n    complete_create_recipient_disburse_account(\n        state,\n        merchant_account,\n        connector_data,\n        payout_data,\n        key_store,\n    )\n    .await?;\n    // Payout creation flow\n    Box::pin(complete_create_payout(\n        state,\n        merchant_account,\n        connector_data,\n        payout_data,\n    ))\n    .await?;\n\n    // Auto fulfillment flow\n    let status = payout_data.payout_attempt.status;\n    if payouts.auto_fulfill && status == storage_enums::PayoutStatus::RequiresFulfillment {\n        Box::pin(fulfill_payout(\n            state,\n            merchant_account,\n            key_store,\n            connector_data,\n            payout_data,\n        ))\n        .await\n        .attach_printable(\"Payout fulfillment failed for given Payout request\")?;\n    }\n\n    Ok(())\n}",
+      "after_code": "pub async fn call_connector_payout(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    connector_data: &api::ConnectorData,\n    payout_data: &mut PayoutData,\n) -> RouterResult<()> {\n    let payout_attempt = &payout_data.payout_attempt.to_owned();\n    let payouts = &payout_data.payouts.to_owned();\n\n    // fetch merchant connector account if not present\n    if payout_data.merchant_connector_account.is_none()\n        || payout_data.payout_attempt.merchant_connector_id.is_none()\n    {\n        let merchant_connector_account = get_mca_from_profile_id(\n            state,\n            merchant_account,\n            &payout_data.profile_id,\n            &connector_data.connector_name.to_string(),\n            payout_attempt\n                .merchant_connector_id\n                .clone()\n                .or(connector_data.merchant_connector_id.clone())\n                .as_ref(),\n            key_store,\n        )\n        .await?;\n        payout_data.payout_attempt.merchant_connector_id = merchant_connector_account.get_mca_id();\n        payout_data.merchant_connector_account = Some(merchant_connector_account);\n    }\n\n    // update connector_name\n    if payout_data.payout_attempt.connector.is_none()\n        || payout_data.payout_attempt.connector != Some(connector_data.connector_name.to_string())\n    {\n        payout_data.payout_attempt.connector = Some(connector_data.connector_name.to_string());\n        let updated_payout_attempt = storage::PayoutAttemptUpdate::UpdateRouting {\n            connector: connector_data.connector_name.to_string(),\n            routing_info: payout_data.payout_attempt.routing_info.clone(),\n            merchant_connector_id: payout_data.payout_attempt.merchant_connector_id.clone(),\n        };\n        let db = &*state.store;\n        payout_data.payout_attempt = db\n            .update_payout_attempt(\n                &payout_data.payout_attempt,\n                updated_payout_attempt,\n                payouts,\n                merchant_account.storage_scheme,\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Error updating routing info in payout_attempt\")?;\n    };\n\n    // Fetch / store payout_method_data\n    if payout_data.payout_method_data.is_none() || payout_attempt.payout_token.is_none() {\n        let customer_id = payouts\n            .customer_id\n            .clone()\n            .get_required_value(\"customer_id\")?;\n        payout_data.payout_method_data = Some(\n            helpers::make_payout_method_data(\n                state,\n                payout_data.payout_method_data.to_owned().as_ref(),\n                payout_attempt.payout_token.as_deref(),\n                &customer_id,\n                &payout_attempt.merchant_id,\n                payouts.payout_type,\n                key_store,\n                Some(payout_data),\n                merchant_account.storage_scheme,\n            )\n            .await?\n            .get_required_value(\"payout_method_data\")?,\n        );\n    }\n    // Eligibility flow\n    complete_payout_eligibility(state, merchant_account, connector_data, payout_data).await?;\n    // Create customer flow\n    complete_create_recipient(\n        state,\n        merchant_account,\n        key_store,\n        connector_data,\n        payout_data,\n    )\n    .await?;\n    // Create customer's disbursement account flow\n    Box::pin(complete_create_recipient_disburse_account(\n        state,\n        merchant_account,\n        connector_data,\n        payout_data,\n        key_store,\n    ))\n    .await?;\n    // Payout creation flow\n    Box::pin(complete_create_payout(\n        state,\n        merchant_account,\n        connector_data,\n        payout_data,\n    ))\n    .await?;\n\n    // Auto fulfillment flow\n    let status = payout_data.payout_attempt.status;\n    if payouts.auto_fulfill && status == storage_enums::PayoutStatus::RequiresFulfillment {\n        Box::pin(fulfill_payout(\n            state,\n            merchant_account,\n            key_store,\n            connector_data,\n            payout_data,\n        ))\n        .await\n        .attach_printable(\"Payout fulfillment failed for given Payout request\")?;\n    }\n\n    Ok(())\n}",
+      "diff_span": {
+        "before": "    .await?;\n    // Create customer's disbursement account flow\n    complete_create_recipient_disburse_account(\n        state,\n        merchant_account,\n        connector_data,\n        payout_data,\n        key_store,\n    )\n    .await?;\n    // Payout creation flow",
+        "after": "    .await?;\n    // Create customer's disbursement account flow\n    Box::pin(complete_create_recipient_disburse_account(\n        state,\n        merchant_account,\n        connector_data,\n        payout_data,\n        key_store,\n    ))\n    .await?;\n    // Payout creation flow"
+      },
+      "commit_sha": "9ec8a16d9c1e2079fed4afcb84ad6af9544ab8a3"
+    }
+  ]
+}

diffs/pr_6687/af509f3/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "af509f3222c4a4977c763b03ebdb0373ceba52f9",
+  "pr_number": 6687,
+  "rust_files": [
+    "crates/router/src/core/payments/tokenization.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payments/tokenization.rs::function::update_connector_mandate_details_status",
+      "file": "crates/router/src/core/payments/tokenization.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn update_connector_mandate_details_status(\n    merchant_connector_id: id_type::MerchantConnectorAccountId,\n    mut payment_mandate_reference: diesel_models::PaymentsMandateReference,\n    status: ConnectorMandateStatus,\n) -> RouterResult<Option<serde_json::Value>> {\n    let mandate_reference = {\n        payment_mandate_reference\n            .entry(merchant_connector_id)\n            .and_modify(|pm| {\n                let update_rec = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: pm.connector_mandate_id.clone(),\n                    payment_method_type: pm.payment_method_type,\n                    original_payment_authorized_amount: pm.original_payment_authorized_amount,\n                    original_payment_authorized_currency: pm.original_payment_authorized_currency,\n                    mandate_metadata: pm.mandate_metadata.clone(),\n                    connector_mandate_status: Some(status),\n                    connector_mandate_request_reference_id: pm\n                        .connector_mandate_request_reference_id\n                        .clone(),\n                };\n                *pm = update_rec\n            });\n        Some(payment_mandate_reference)\n    };\n    let connector_mandate_details = mandate_reference\n        .map(|mandate| mandate.encode_to_value())\n        .transpose()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n\n    Ok(connector_mandate_details)\n}",
+      "after_code": "pub fn update_connector_mandate_details_status(\n    merchant_connector_id: id_type::MerchantConnectorAccountId,\n    mut payment_mandate_reference: diesel_models::PaymentsMandateReference,\n    status: ConnectorMandateStatus,\n) -> RouterResult<Option<diesel_models::CommonMandateReference>> {\n    let mandate_reference = {\n        payment_mandate_reference\n            .entry(merchant_connector_id)\n            .and_modify(|pm| {\n                let update_rec = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: pm.connector_mandate_id.clone(),\n                    payment_method_type: pm.payment_method_type,\n                    original_payment_authorized_amount: pm.original_payment_authorized_amount,\n                    original_payment_authorized_currency: pm.original_payment_authorized_currency,\n                    mandate_metadata: pm.mandate_metadata.clone(),\n                    connector_mandate_status: Some(status),\n                    connector_mandate_request_reference_id: pm\n                        .connector_mandate_request_reference_id\n                        .clone(),\n                };\n                *pm = update_rec\n            });\n        Some(payment_mandate_reference)\n    };\n\n    Ok(Some(diesel_models::CommonMandateReference {\n        payments: mandate_reference,\n        payouts: None,\n    }))\n}",
+      "diff_span": {
+        "before": "    mut payment_mandate_reference: diesel_models::PaymentsMandateReference,\n    status: ConnectorMandateStatus,\n) -> RouterResult<Option<serde_json::Value>> {\n    let mandate_reference = {\n        payment_mandate_reference\n            .entry(merchant_connector_id)\n            .and_modify(|pm| {\n                let update_rec = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: pm.connector_mandate_id.clone(),\n                    payment_method_type: pm.payment_method_type,\n                    original_payment_authorized_amount: pm.original_payment_authorized_amount,\n                    original_payment_authorized_currency: pm.original_payment_authorized_currency,\n                    mandate_metadata: pm.mandate_metadata.clone(),\n                    connector_mandate_status: Some(status),\n                    connector_mandate_request_reference_id: pm\n                        .connector_mandate_request_reference_id\n                        .clone(),\n                };\n                *pm = update_rec\n            });\n        Some(payment_mandate_reference)\n    };\n    let connector_mandate_details = mandate_reference\n        .map(|mandate| mandate.encode_to_value())\n        .transpose()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Unable to serialize customer acceptance to value\")?;\n\n    Ok(connector_mandate_details)\n}",
+        "after": "    mut payment_mandate_reference: diesel_models::PaymentsMandateReference,\n    status: ConnectorMandateStatus,\n) -> RouterResult<Option<diesel_models::CommonMandateReference>> {\n    let mandate_reference = {\n        payment_mandate_reference\n            .entry(merchant_connector_id)\n            .and_modify(|pm| {\n                let update_rec = diesel_models::PaymentsMandateReferenceRecord {\n                    connector_mandate_id: pm.connector_mandate_id.clone(),\n                    payment_method_type: pm.payment_method_type,\n                    original_payment_authorized_amount: pm.original_payment_authorized_amount,\n                    original_payment_authorized_currency: pm.original_payment_authorized_currency,\n                    mandate_metadata: pm.mandate_metadata.clone(),\n                    connector_mandate_status: Some(status),\n                    connector_mandate_request_reference_id: pm\n                        .connector_mandate_request_reference_id\n                        .clone(),\n                };\n                *pm = update_rec\n            });\n        Some(payment_mandate_reference)\n    };\n\n    Ok(Some(diesel_models::CommonMandateReference {\n        payments: mandate_reference,\n        payouts: None,\n    }))\n}"
+      },
+      "commit_sha": "af509f3222c4a4977c763b03ebdb0373ceba52f9"
+    }
+  ]
+}