Add files using upload-large-folder tool

diffs/pr_10002/1871e0a/diff.json

@@ -0,0 +1,55 @@
+{
+  "commit_sha": "1871e0a201f5e2997b11e17eac242752082a55e7",
+  "pr_number": 10002,
+  "rust_files": [
+    "crates/router/src/routes/admin.rs",
+    "crates/router/src/routes/profiles.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/routes/admin.rs::function::connector_update",
+      "file": "crates/router/src/routes/admin.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn connector_update(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantConnectorAccountId>,\n    json_payload: web::Json<api_models::admin::MerchantConnectorUpdate>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsUpdate;\n    let id = path.into_inner();\n    let payload = json_payload.into_inner();\n    let merchant_id = payload.merchant_id.clone();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, _, req, _| update_connector(state, merchant_id, None, &id, req),\n        auth::auth_type(\n            &auth::V2AdminApiAuth,\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id: merchant_id.clone(),\n                required_permission: Permission::MerchantConnectorWrite,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn connector_update(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantConnectorAccountId>,\n    json_payload: web::Json<api_models::admin::MerchantConnectorUpdate>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsUpdate;\n    let id = path.into_inner();\n    let payload = json_payload.into_inner();\n    let merchant_id = payload.merchant_id.clone();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, _, req, _| update_connector(state, merchant_id.clone(), None, &id, req),\n        auth::auth_type(\n            &auth::V2AdminApiAuth,\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id: merchant_id.clone(),\n                required_permission: Permission::MerchantConnectorWrite,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": "        &req,\n        payload,\n        |state, _, req, _| update_connector(state, merchant_id, None, &id, req),\n        auth::auth_type(\n            &auth::V2AdminApiAuth,",
+        "after": "        &req,\n        payload,\n        |state, _, req, _| update_connector(state, merchant_id.clone(), None, &id, req),\n        auth::auth_type(\n            &auth::V2AdminApiAuth,"
+      },
+      "commit_sha": "1871e0a201f5e2997b11e17eac242752082a55e7"
+    },
+    {
+      "id": "crates/router/src/routes/profiles.rs::function::profile_update",
+      "file": "crates/router/src/routes/profiles.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn profile_update(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::ProfileId>,\n    json_payload: web::Json<api_models::admin::ProfileUpdate>,\n) -> HttpResponse {\n    let flow = Flow::ProfileUpdate;\n    let profile_id = path.into_inner();\n    let payload = json_payload.into_inner();\n    if let Err(api_error) = payload\n        .webhook_details\n        .as_ref()\n        .map(|details| {\n            details\n                .validate()\n                .map_err(|message| errors::ApiErrorResponse::InvalidRequestData { message })\n        })\n        .transpose()\n    {\n        return api::log_and_return_error_response(api_error.into());\n    }\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, auth::AuthenticationDataWithoutProfile { key_store, .. }, req, _| {\n            update_profile(state, &profile_id, key_store, req)\n        },\n        auth::auth_type(\n            &auth::AdminApiAuthWithMerchantIdFromHeader,\n            &auth::JWTAuthMerchantFromHeader {\n                required_permission: permissions::Permission::MerchantAccountWrite,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn profile_update(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::ProfileId>,\n    json_payload: web::Json<api_models::admin::ProfileUpdate>,\n) -> HttpResponse {\n    let flow = Flow::ProfileUpdate;\n    let profile_id = path.into_inner();\n    let payload = json_payload.into_inner();\n    if let Err(api_error) = payload\n        .webhook_details\n        .as_ref()\n        .map(|details| {\n            details\n                .validate()\n                .map_err(|message| errors::ApiErrorResponse::InvalidRequestData { message })\n        })\n        .transpose()\n    {\n        return api::log_and_return_error_response(api_error.into());\n    }\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state,\n         auth::AuthenticationDataWithoutProfile {\n             merchant_account,\n             key_store,\n         },\n         req,\n         _| {\n            update_profile(\n                state,\n                &profile_id,\n                merchant_account.get_id().clone(),\n                key_store,\n                req,\n            )\n        },\n        auth::auth_type(\n            &auth::AdminApiAuthWithMerchantIdFromHeader,\n            &auth::JWTAuthMerchantFromHeader {\n                required_permission: permissions::Permission::MerchantAccountWrite,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": "        &req,\n        payload,\n        |state, auth::AuthenticationDataWithoutProfile { key_store, .. }, req, _| {\n            update_profile(state, &profile_id, key_store, req)\n        },\n        auth::auth_type(",
+        "after": "        &req,\n        payload,\n        |state,\n         auth::AuthenticationDataWithoutProfile {\n             merchant_account,\n             key_store,\n         },\n         req,\n         _| {\n            update_profile(\n                state,\n                &profile_id,\n                merchant_account.get_id().clone(),\n                key_store,\n                req,\n            )\n        },\n        auth::auth_type("
+      },
+      "commit_sha": "1871e0a201f5e2997b11e17eac242752082a55e7"
+    },
+    {
+      "id": "crates/router/src/routes/profiles.rs::function::profile_retrieve",
+      "file": "crates/router/src/routes/profiles.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn profile_retrieve(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::ProfileId>,\n) -> HttpResponse {\n    let flow = Flow::ProfileRetrieve;\n    let profile_id = path.into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        profile_id,\n        |state, auth::AuthenticationDataWithoutProfile { key_store, .. }, profile_id, _| {\n            retrieve_profile(state, profile_id, key_store)\n        },\n        auth::auth_type(\n            &auth::AdminApiAuthWithMerchantIdFromHeader,\n            &auth::JWTAuthMerchantFromHeader {\n                required_permission: permissions::Permission::MerchantAccountRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn profile_retrieve(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::ProfileId>,\n) -> HttpResponse {\n    let flow = Flow::ProfileRetrieve;\n    let profile_id = path.into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        profile_id,\n        |state,\n         auth::AuthenticationDataWithoutProfile {\n             merchant_account,\n             key_store,\n         },\n         profile_id,\n         _| {\n            retrieve_profile(\n                state,\n                profile_id,\n                merchant_account.get_id().clone(),\n                key_store,\n            )\n        },\n        auth::auth_type(\n            &auth::AdminApiAuthWithMerchantIdFromHeader,\n            &auth::JWTAuthMerchantFromHeader {\n                required_permission: permissions::Permission::MerchantAccountRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": "        &req,\n        profile_id,\n        |state, auth::AuthenticationDataWithoutProfile { key_store, .. }, profile_id, _| {\n            retrieve_profile(state, profile_id, key_store)\n        },\n        auth::auth_type(",
+        "after": "        &req,\n        profile_id,\n        |state,\n         auth::AuthenticationDataWithoutProfile {\n             merchant_account,\n             key_store,\n         },\n         profile_id,\n         _| {\n            retrieve_profile(\n                state,\n                profile_id,\n                merchant_account.get_id().clone(),\n                key_store,\n            )\n        },\n        auth::auth_type("
+      },
+      "commit_sha": "1871e0a201f5e2997b11e17eac242752082a55e7"
+    }
+  ]
+}

diffs/pr_10002/8adc253/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "8adc253b894686df983ce7d7a160a56c38b91f18",
+  "pr_number": 10002,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10002/901eca8/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "901eca86020ef8d0a27afd778578ce770a0429bc",
+  "pr_number": 10002,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_10002/c274258/diff.json

@@ -0,0 +1,147 @@
+{
+  "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce",
+  "pr_number": 10002,
+  "rust_files": [
+    "crates/router/src/core/admin.rs",
+    "crates/router/src/core/connector_onboarding/paypal.rs",
+    "crates/router/src/routes/admin.rs",
+    "crates/router/src/routes/profiles.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/admin.rs::function::update_profile",
+      "file": "crates/router/src/core/admin.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn update_profile(\n    state: SessionState,\n    profile_id: &id_type::ProfileId,\n    key_store: domain::MerchantKeyStore,\n    request: api::ProfileUpdate,\n) -> RouterResponse<api::ProfileResponse> {\n    let db = state.store.as_ref();\n    let key_manager_state = &(&state).into();\n\n    let business_profile = db\n        .find_business_profile_by_profile_id(key_manager_state, &key_store, profile_id)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {\n            id: profile_id.get_string_repr().to_owned(),\n        })?;\n\n    let profile_update = request\n        .get_update_profile_object(&state, &key_store, &business_profile)\n        .await?;\n\n    let updated_business_profile = db\n        .update_profile_by_profile_id(\n            key_manager_state,\n            &key_store,\n            business_profile,\n            profile_update,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {\n            id: profile_id.get_string_repr().to_owned(),\n        })?;\n\n    Ok(service_api::ApplicationResponse::Json(\n        api_models::admin::ProfileResponse::foreign_try_from(updated_business_profile)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to parse business profile details\")?,\n    ))\n}",
+      "after_code": "pub async fn update_profile(\n    state: SessionState,\n    profile_id: &id_type::ProfileId,\n    merchant_id: id_type::MerchantId,\n    key_store: domain::MerchantKeyStore,\n    request: api::ProfileUpdate,\n) -> RouterResponse<api::ProfileResponse> {\n    let db = state.store.as_ref();\n    let key_manager_state = &(&state).into();\n\n    let business_profile = db\n        .find_business_profile_by_merchant_id_profile_id(\n            key_manager_state,\n            &key_store,\n            &merchant_id,\n            profile_id,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {\n            id: profile_id.get_string_repr().to_owned(),\n        })?;\n\n    let profile_update = request\n        .get_update_profile_object(&state, &key_store, &business_profile)\n        .await?;\n\n    let updated_business_profile = db\n        .update_profile_by_profile_id(\n            key_manager_state,\n            &key_store,\n            business_profile,\n            profile_update,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {\n            id: profile_id.get_string_repr().to_owned(),\n        })?;\n\n    Ok(service_api::ApplicationResponse::Json(\n        api_models::admin::ProfileResponse::foreign_try_from(updated_business_profile)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to parse business profile details\")?,\n    ))\n}",
+      "diff_span": {
+        "before": "\n    let business_profile = db\n        .find_business_profile_by_profile_id(key_manager_state, &key_store, profile_id)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {",
+        "after": "    state: SessionState,\n    profile_id: &id_type::ProfileId,\n    merchant_id: id_type::MerchantId,\n    key_store: domain::MerchantKeyStore,\n    request: api::ProfileUpdate,\n) -> RouterResponse<api::ProfileResponse> {\n    let db = state.store.as_ref();\n    let key_manager_state = &(&state).into();\n\n    let business_profile = db\n        .find_business_profile_by_merchant_id_profile_id(\n            key_manager_state,\n            &key_store,\n            &merchant_id,\n            profile_id,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    },
+    {
+      "id": "crates/router/src/routes/admin.rs::function::connector_update",
+      "file": "crates/router/src/routes/admin.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn connector_update(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantConnectorAccountId>,\n    json_payload: web::Json<api_models::admin::MerchantConnectorUpdate>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsUpdate;\n    let id = path.into_inner();\n    let payload = json_payload.into_inner();\n    let merchant_id = payload.merchant_id.clone();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, _, req, _| update_connector(state, &merchant_id, None, &id, req),\n        auth::auth_type(\n            &auth::V2AdminApiAuth,\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id: merchant_id.clone(),\n                required_permission: Permission::MerchantConnectorWrite,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn connector_update(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantConnectorAccountId>,\n    json_payload: web::Json<api_models::admin::MerchantConnectorUpdate>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsUpdate;\n    let id = path.into_inner();\n    let payload = json_payload.into_inner();\n    let merchant_id = payload.merchant_id.clone();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        payload,\n        |state, _, req, _| update_connector(state, merchant_id, None, &id, req),\n        auth::auth_type(\n            &auth::V2AdminApiAuth,\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id: merchant_id.clone(),\n                required_permission: Permission::MerchantConnectorWrite,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": "        &req,\n        payload,\n        |state, _, req, _| update_connector(state, &merchant_id, None, &id, req),\n        auth::auth_type(\n            &auth::V2AdminApiAuth,",
+        "after": "        &req,\n        payload,\n        |state, _, req, _| update_connector(state, merchant_id, None, &id, req),\n        auth::auth_type(\n            &auth::V2AdminApiAuth,"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    },
+    {
+      "id": "crates/router/src/routes/profiles.rs::function::profiles_list_at_profile_level",
+      "file": "crates/router/src/routes/profiles.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn profiles_list_at_profile_level(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantId>,\n) -> HttpResponse {\n    let flow = Flow::ProfileList;\n    let merchant_id = path.into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        merchant_id.clone(),\n        |state, auth, merchant_id, _| {\n            list_profile(\n                state,\n                merchant_id,\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone())),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,\n                required_permission: permissions::Permission::ProfileAccountRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn profiles_list_at_profile_level(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantId>,\n) -> HttpResponse {\n    let flow = Flow::ProfileList;\n    let merchant_id = path.into_inner();\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        merchant_id.clone(),\n        |state, auth, _, _| {\n            list_profile(\n                state,\n                auth.merchant_account.get_id().clone(),\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone()),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,\n                required_permission: permissions::Permission::ProfileAccountRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": "        &req,\n        merchant_id.clone(),\n        |state, auth, merchant_id, _| {\n            list_profile(\n                state,\n                merchant_id,\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone())),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,",
+        "after": "        &req,\n        merchant_id.clone(),\n        |state, auth, _, _| {\n            list_profile(\n                state,\n                auth.merchant_account.get_id().clone(),\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone()),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    },
+    {
+      "id": "crates/router/src/core/admin.rs::function::retrieve_profile",
+      "file": "crates/router/src/core/admin.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn retrieve_profile(\n    state: SessionState,\n    profile_id: id_type::ProfileId,\n    key_store: domain::MerchantKeyStore,\n) -> RouterResponse<api_models::admin::ProfileResponse> {\n    let db = state.store.as_ref();\n\n    let business_profile = db\n        .find_business_profile_by_profile_id(&(&state).into(), &key_store, &profile_id)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {\n            id: profile_id.get_string_repr().to_owned(),\n        })?;\n\n    Ok(service_api::ApplicationResponse::Json(\n        api_models::admin::ProfileResponse::foreign_try_from(business_profile)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to parse business profile details\")?,\n    ))\n}",
+      "after_code": "pub async fn retrieve_profile(\n    state: SessionState,\n    profile_id: id_type::ProfileId,\n    merchant_id: id_type::MerchantId,\n    key_store: domain::MerchantKeyStore,\n) -> RouterResponse<api_models::admin::ProfileResponse> {\n    let db = state.store.as_ref();\n\n    let business_profile = db\n        .find_business_profile_by_merchant_id_profile_id(\n            &(&state).into(),\n            &key_store,\n            &merchant_id,\n            &profile_id,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {\n            id: profile_id.get_string_repr().to_owned(),\n        })?;\n\n    Ok(service_api::ApplicationResponse::Json(\n        api_models::admin::ProfileResponse::foreign_try_from(business_profile)\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to parse business profile details\")?,\n    ))\n}",
+      "diff_span": {
+        "before": "\n    let business_profile = db\n        .find_business_profile_by_profile_id(&(&state).into(), &key_store, &profile_id)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {",
+        "after": "    state: SessionState,\n    profile_id: id_type::ProfileId,\n    merchant_id: id_type::MerchantId,\n    key_store: domain::MerchantKeyStore,\n) -> RouterResponse<api_models::admin::ProfileResponse> {\n    let db = state.store.as_ref();\n\n    let business_profile = db\n        .find_business_profile_by_merchant_id_profile_id(\n            &(&state).into(),\n            &key_store,\n            &merchant_id,\n            &profile_id,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::ProfileNotFound {"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    },
+    {
+      "id": "crates/router/src/routes/admin.rs::function::connector_list",
+      "file": "crates/router/src/routes/admin.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn connector_list(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantId>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsList;\n    let merchant_id = path.into_inner();\n\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        merchant_id.to_owned(),\n        |state, _auth, merchant_id, _| list_payment_connectors(state, merchant_id, None),\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone())),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,\n                required_permission: Permission::MerchantConnectorRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "after_code": "pub async fn connector_list(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantId>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsList;\n    let merchant_id = path.into_inner();\n\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        merchant_id.to_owned(),\n        |state, auth, _, _| {\n            list_payment_connectors(state, auth.merchant_account.get_id().clone(), None)\n        },\n        auth::auth_type(\n            &auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone()),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,\n                required_permission: Permission::MerchantConnectorRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "diff_span": {
+        "before": "        &req,\n        merchant_id.to_owned(),\n        |state, _auth, merchant_id, _| list_payment_connectors(state, merchant_id, None),\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone())),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,",
+        "after": "        &req,\n        merchant_id.to_owned(),\n        |state, auth, _, _| {\n            list_payment_connectors(state, auth.merchant_account.get_id().clone(), None)\n        },\n        auth::auth_type(\n            &auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone()),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    },
+    {
+      "id": "crates/router/src/routes/profiles.rs::function::payment_connector_list_profile",
+      "file": "crates/router/src/routes/profiles.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn payment_connector_list_profile(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantId>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsList;\n    let merchant_id = path.into_inner();\n\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        merchant_id.to_owned(),\n        |state, auth, merchant_id, _| {\n            list_payment_connectors(\n                state,\n                merchant_id,\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone())),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,\n                required_permission: permissions::Permission::ProfileConnectorRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "after_code": "pub async fn payment_connector_list_profile(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantId>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsList;\n    let merchant_id = path.into_inner();\n\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        merchant_id.to_owned(),\n        |state, auth, _, _| {\n            list_payment_connectors(\n                state,\n                auth.merchant_account.get_id().clone(),\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone()),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,\n                required_permission: permissions::Permission::ProfileConnectorRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "diff_span": {
+        "before": "        &req,\n        merchant_id.to_owned(),\n        |state, auth, merchant_id, _| {\n            list_payment_connectors(\n                state,\n                merchant_id,\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone())),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,",
+        "after": "        &req,\n        merchant_id.to_owned(),\n        |state, auth, _, _| {\n            list_payment_connectors(\n                state,\n                auth.merchant_account.get_id().clone(),\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone()),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    },
+    {
+      "id": "crates/router/src/routes/admin.rs::function::connector_list_profile",
+      "file": "crates/router/src/routes/admin.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn connector_list_profile(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantId>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsList;\n    let merchant_id = path.into_inner();\n\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        merchant_id.to_owned(),\n        |state, auth, merchant_id, _| {\n            list_payment_connectors(\n                state,\n                merchant_id,\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone())),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,\n                required_permission: Permission::ProfileConnectorRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "after_code": "pub async fn connector_list_profile(\n    state: web::Data<AppState>,\n    req: HttpRequest,\n    path: web::Path<common_utils::id_type::MerchantId>,\n) -> HttpResponse {\n    let flow = Flow::MerchantConnectorsList;\n    let merchant_id = path.into_inner();\n\n    api::server_wrap(\n        flow,\n        state,\n        &req,\n        merchant_id.to_owned(),\n        |state, auth, _, _| {\n            list_payment_connectors(\n                state,\n                auth.merchant_account.get_id().clone(),\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone()),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,\n                required_permission: Permission::ProfileConnectorRead,\n            },\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    )\n    .await\n}",
+      "diff_span": {
+        "before": "        &req,\n        merchant_id.to_owned(),\n        |state, auth, merchant_id, _| {\n            list_payment_connectors(\n                state,\n                merchant_id,\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::HeaderAuth(auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone())),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,",
+        "after": "        &req,\n        merchant_id.to_owned(),\n        |state, auth, _, _| {\n            list_payment_connectors(\n                state,\n                auth.merchant_account.get_id().clone(),\n                auth.profile_id.map(|profile_id| vec![profile_id]),\n            )\n        },\n        auth::auth_type(\n            &auth::ApiKeyAuthWithMerchantIdFromRoute(merchant_id.clone()),\n            &auth::JWTAuthMerchantFromRoute {\n                merchant_id,"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    },
+    {
+      "id": "crates/router/src/core/admin.rs::function::update_connector",
+      "file": "crates/router/src/core/admin.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn update_connector(\n    state: SessionState,\n    merchant_id: &id_type::MerchantId,\n    profile_id: Option<id_type::ProfileId>,\n    merchant_connector_id: &id_type::MerchantConnectorAccountId,\n    req: api_models::admin::MerchantConnectorUpdate,\n) -> RouterResponse<api_models::admin::MerchantConnectorResponse> {\n    let db = state.store.as_ref();\n    let key_manager_state = &(&state).into();\n    let key_store = db\n        .get_merchant_key_store_by_merchant_id(\n            key_manager_state,\n            merchant_id,\n            &db.get_master_key().to_vec().into(),\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let merchant_account = db\n        .find_merchant_account_by_merchant_id(key_manager_state, merchant_id, &key_store)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let mca = req\n        .clone()\n        .get_merchant_connector_account_from_id(\n            db,\n            merchant_id,\n            merchant_connector_id,\n            &key_store,\n            key_manager_state,\n        )\n        .await?;\n    core_utils::validate_profile_id_from_auth_layer(profile_id, &mca)?;\n\n    let merchant_context = domain::MerchantContext::NormalMerchant(Box::new(domain::Context(\n        merchant_account.clone(),\n        key_store.clone(),\n    )));\n    let payment_connector = req\n        .clone()\n        .create_domain_model_from_request(&state, &mca, key_manager_state, &merchant_context)\n        .await?;\n\n    // Profile id should always be present\n    let profile_id = mca.profile_id.clone();\n\n    let request_connector_label = req.connector_label;\n\n    let updated_mca = db\n        .update_merchant_connector_account(\n            key_manager_state,\n            mca.clone(),\n            payment_connector.into(),\n            &key_store,\n        )\n        .await\n        .change_context(\n            errors::ApiErrorResponse::DuplicateMerchantConnectorAccount {\n                profile_id: profile_id.get_string_repr().to_owned(),\n                connector_label: request_connector_label.unwrap_or_default(),\n            },\n        )\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating MerchantConnectorAccount: id: {merchant_connector_id:?}\",\n\n            )\n        })?;\n\n    // redact cgraph cache on connector updation\n    redact_cgraph_cache(&state, merchant_id, &profile_id).await?;\n\n    // redact routing cache on connector updation\n    #[cfg(feature = \"v1\")]\n    let merchant_config = MerchantDefaultConfigUpdate {\n        routable_connector: &Some(\n            common_enums::RoutableConnectors::from_str(&mca.connector_name).map_err(|_| {\n                errors::ApiErrorResponse::InvalidDataValue {\n                    field_name: \"connector_name\",\n                }\n            })?,\n        ),\n        merchant_connector_id: &mca.get_id(),\n        store: db,\n        merchant_id,\n        profile_id: &mca.profile_id,\n        transaction_type: &mca.connector_type.into(),\n    };\n\n    #[cfg(feature = \"v1\")]\n    if req.disabled.unwrap_or(false) {\n        merchant_config\n            .retrieve_and_delete_from_default_fallback_routing_algorithm_if_routable_connector_exists()\n            .await?;\n    } else {\n        merchant_config\n            .retrieve_and_update_default_fallback_routing_algorithm_if_routable_connector_exists()\n            .await?;\n    }\n\n    let response = updated_mca.foreign_try_into()?;\n\n    Ok(service_api::ApplicationResponse::Json(response))\n}",
+      "after_code": "pub async fn update_connector(\n    state: SessionState,\n    merchant_id: id_type::MerchantId,\n    profile_id: Option<id_type::ProfileId>,\n    merchant_connector_id: &id_type::MerchantConnectorAccountId,\n    req: api_models::admin::MerchantConnectorUpdate,\n) -> RouterResponse<api_models::admin::MerchantConnectorResponse> {\n    let db = state.store.as_ref();\n    let key_manager_state = &(&state).into();\n    let key_store = db\n        .get_merchant_key_store_by_merchant_id(\n            key_manager_state,\n            &merchant_id,\n            &db.get_master_key().to_vec().into(),\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let merchant_account = db\n        .find_merchant_account_by_merchant_id(key_manager_state, &merchant_id, &key_store)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let mca = req\n        .clone()\n        .get_merchant_connector_account_from_id(\n            db,\n            &merchant_id,\n            merchant_connector_id,\n            &key_store,\n            key_manager_state,\n        )\n        .await?;\n    core_utils::validate_profile_id_from_auth_layer(profile_id, &mca)?;\n\n    let merchant_context = domain::MerchantContext::NormalMerchant(Box::new(domain::Context(\n        merchant_account.clone(),\n        key_store.clone(),\n    )));\n    let payment_connector = req\n        .clone()\n        .create_domain_model_from_request(&state, &mca, key_manager_state, &merchant_context)\n        .await?;\n\n    // Profile id should always be present\n    let profile_id = mca.profile_id.clone();\n\n    let request_connector_label = req.connector_label;\n\n    let updated_mca = db\n        .update_merchant_connector_account(\n            key_manager_state,\n            mca.clone(),\n            payment_connector.into(),\n            &key_store,\n        )\n        .await\n        .change_context(\n            errors::ApiErrorResponse::DuplicateMerchantConnectorAccount {\n                profile_id: profile_id.get_string_repr().to_owned(),\n                connector_label: request_connector_label.unwrap_or_default(),\n            },\n        )\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating MerchantConnectorAccount: id: {merchant_connector_id:?}\",\n\n            )\n        })?;\n\n    // redact cgraph cache on connector updation\n    redact_cgraph_cache(&state, &merchant_id, &profile_id).await?;\n\n    // redact routing cache on connector updation\n    #[cfg(feature = \"v1\")]\n    let merchant_config = MerchantDefaultConfigUpdate {\n        routable_connector: &Some(\n            common_enums::RoutableConnectors::from_str(&mca.connector_name).map_err(|_| {\n                errors::ApiErrorResponse::InvalidDataValue {\n                    field_name: \"connector_name\",\n                }\n            })?,\n        ),\n        merchant_connector_id: &mca.get_id(),\n        store: db,\n        merchant_id: &merchant_id,\n        profile_id: &mca.profile_id,\n        transaction_type: &mca.connector_type.into(),\n    };\n\n    #[cfg(feature = \"v1\")]\n    if req.disabled.unwrap_or(false) {\n        merchant_config\n            .retrieve_and_delete_from_default_fallback_routing_algorithm_if_routable_connector_exists()\n            .await?;\n    } else {\n        merchant_config\n            .retrieve_and_update_default_fallback_routing_algorithm_if_routable_connector_exists()\n            .await?;\n    }\n\n    let response = updated_mca.foreign_try_into()?;\n\n    Ok(service_api::ApplicationResponse::Json(response))\n}",
+      "diff_span": {
+        "before": "pub async fn update_connector(\n    state: SessionState,\n    merchant_id: &id_type::MerchantId,\n    profile_id: Option<id_type::ProfileId>,\n    merchant_connector_id: &id_type::MerchantConnectorAccountId,\n    req: api_models::admin::MerchantConnectorUpdate,\n) -> RouterResponse<api_models::admin::MerchantConnectorResponse> {\n    let db = state.store.as_ref();\n    let key_manager_state = &(&state).into();\n    let key_store = db\n        .get_merchant_key_store_by_merchant_id(\n            key_manager_state,\n            merchant_id,\n            &db.get_master_key().to_vec().into(),\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let merchant_account = db\n        .find_merchant_account_by_merchant_id(key_manager_state, merchant_id, &key_store)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let mca = req\n        .clone()\n        .get_merchant_connector_account_from_id(\n            db,\n            merchant_id,\n            merchant_connector_id,\n            &key_store,\n            key_manager_state,\n        )\n        .await?;\n    core_utils::validate_profile_id_from_auth_layer(profile_id, &mca)?;\n\n    let merchant_context = domain::MerchantContext::NormalMerchant(Box::new(domain::Context(\n        merchant_account.clone(),\n        key_store.clone(),\n    )));\n    let payment_connector = req\n        .clone()\n        .create_domain_model_from_request(&state, &mca, key_manager_state, &merchant_context)\n        .await?;\n\n    // Profile id should always be present\n    let profile_id = mca.profile_id.clone();\n\n    let request_connector_label = req.connector_label;\n\n    let updated_mca = db\n        .update_merchant_connector_account(\n            key_manager_state,\n            mca.clone(),\n            payment_connector.into(),\n            &key_store,\n        )\n        .await\n        .change_context(\n            errors::ApiErrorResponse::DuplicateMerchantConnectorAccount {\n                profile_id: profile_id.get_string_repr().to_owned(),\n                connector_label: request_connector_label.unwrap_or_default(),\n            },\n        )\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating MerchantConnectorAccount: id: {merchant_connector_id:?}\",\n\n            )\n        })?;\n\n    // redact cgraph cache on connector updation\n    redact_cgraph_cache(&state, merchant_id, &profile_id).await?;\n\n    // redact routing cache on connector updation\n    #[cfg(feature = \"v1\")]\n    let merchant_config = MerchantDefaultConfigUpdate {\n        routable_connector: &Some(\n            common_enums::RoutableConnectors::from_str(&mca.connector_name).map_err(|_| {\n                errors::ApiErrorResponse::InvalidDataValue {\n                    field_name: \"connector_name\",\n                }\n            })?,\n        ),\n        merchant_connector_id: &mca.get_id(),\n        store: db,\n        merchant_id,\n        profile_id: &mca.profile_id,\n        transaction_type: &mca.connector_type.into(),",
+        "after": "pub async fn update_connector(\n    state: SessionState,\n    merchant_id: id_type::MerchantId,\n    profile_id: Option<id_type::ProfileId>,\n    merchant_connector_id: &id_type::MerchantConnectorAccountId,\n    req: api_models::admin::MerchantConnectorUpdate,\n) -> RouterResponse<api_models::admin::MerchantConnectorResponse> {\n    let db = state.store.as_ref();\n    let key_manager_state = &(&state).into();\n    let key_store = db\n        .get_merchant_key_store_by_merchant_id(\n            key_manager_state,\n            &merchant_id,\n            &db.get_master_key().to_vec().into(),\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let merchant_account = db\n        .find_merchant_account_by_merchant_id(key_manager_state, &merchant_id, &key_store)\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let mca = req\n        .clone()\n        .get_merchant_connector_account_from_id(\n            db,\n            &merchant_id,\n            merchant_connector_id,\n            &key_store,\n            key_manager_state,\n        )\n        .await?;\n    core_utils::validate_profile_id_from_auth_layer(profile_id, &mca)?;\n\n    let merchant_context = domain::MerchantContext::NormalMerchant(Box::new(domain::Context(\n        merchant_account.clone(),\n        key_store.clone(),\n    )));\n    let payment_connector = req\n        .clone()\n        .create_domain_model_from_request(&state, &mca, key_manager_state, &merchant_context)\n        .await?;\n\n    // Profile id should always be present\n    let profile_id = mca.profile_id.clone();\n\n    let request_connector_label = req.connector_label;\n\n    let updated_mca = db\n        .update_merchant_connector_account(\n            key_manager_state,\n            mca.clone(),\n            payment_connector.into(),\n            &key_store,\n        )\n        .await\n        .change_context(\n            errors::ApiErrorResponse::DuplicateMerchantConnectorAccount {\n                profile_id: profile_id.get_string_repr().to_owned(),\n                connector_label: request_connector_label.unwrap_or_default(),\n            },\n        )\n        .attach_printable_lazy(|| {\n            format!(\n                \"Failed while updating MerchantConnectorAccount: id: {merchant_connector_id:?}\",\n\n            )\n        })?;\n\n    // redact cgraph cache on connector updation\n    redact_cgraph_cache(&state, &merchant_id, &profile_id).await?;\n\n    // redact routing cache on connector updation\n    #[cfg(feature = \"v1\")]\n    let merchant_config = MerchantDefaultConfigUpdate {\n        routable_connector: &Some(\n            common_enums::RoutableConnectors::from_str(&mca.connector_name).map_err(|_| {\n                errors::ApiErrorResponse::InvalidDataValue {\n                    field_name: \"connector_name\",\n                }\n            })?,\n        ),\n        merchant_connector_id: &mca.get_id(),\n        store: db,\n        merchant_id: &merchant_id,\n        profile_id: &mca.profile_id,\n        transaction_type: &mca.connector_type.into(),"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    },
+    {
+      "id": "crates/router/src/core/connector_onboarding/paypal.rs::function::update_mca",
+      "file": "crates/router/src/core/connector_onboarding/paypal.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn update_mca(\n    state: &SessionState,\n    merchant_id: common_utils::id_type::MerchantId,\n    connector_id: common_utils::id_type::MerchantConnectorAccountId,\n    auth_details: oss_types::ConnectorAuthType,\n) -> RouterResult<oss_api_types::MerchantConnectorResponse> {\n    let connector_auth_json = auth_details\n        .encode_to_value()\n        .change_context(ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Error while deserializing connector_account_details\")?;\n    #[cfg(feature = \"v1\")]\n    let request = MerchantConnectorUpdate {\n        connector_type: common_enums::ConnectorType::PaymentProcessor,\n        connector_account_details: Some(Secret::new(connector_auth_json)),\n        disabled: Some(false),\n        status: Some(common_enums::ConnectorStatus::Active),\n        connector_label: None,\n        payment_methods_enabled: None,\n        metadata: None,\n        frm_configs: None,\n        connector_webhook_details: None,\n        pm_auth_config: None,\n        test_mode: None,\n        additional_merchant_data: None,\n        connector_wallets_details: None,\n    };\n    #[cfg(feature = \"v2\")]\n    let request = MerchantConnectorUpdate {\n        connector_type: common_enums::ConnectorType::PaymentProcessor,\n        connector_account_details: Some(Secret::new(connector_auth_json)),\n        disabled: Some(false),\n        status: Some(common_enums::ConnectorStatus::Active),\n        connector_label: None,\n        payment_methods_enabled: None,\n        metadata: None,\n        frm_configs: None,\n        connector_webhook_details: None,\n        pm_auth_config: None,\n        merchant_id: merchant_id.clone(),\n        additional_merchant_data: None,\n        connector_wallets_details: None,\n        feature_metadata: None,\n    };\n    let mca_response =\n        admin::update_connector(state.clone(), &merchant_id, None, &connector_id, request).await?;\n\n    match mca_response {\n        ApplicationResponse::Json(mca_data) => Ok(mca_data),\n        _ => Err(ApiErrorResponse::InternalServerError.into()),\n    }\n}",
+      "after_code": "pub async fn update_mca(\n    state: &SessionState,\n    merchant_id: common_utils::id_type::MerchantId,\n    connector_id: common_utils::id_type::MerchantConnectorAccountId,\n    auth_details: oss_types::ConnectorAuthType,\n) -> RouterResult<oss_api_types::MerchantConnectorResponse> {\n    let connector_auth_json = auth_details\n        .encode_to_value()\n        .change_context(ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Error while deserializing connector_account_details\")?;\n    #[cfg(feature = \"v1\")]\n    let request = MerchantConnectorUpdate {\n        connector_type: common_enums::ConnectorType::PaymentProcessor,\n        connector_account_details: Some(Secret::new(connector_auth_json)),\n        disabled: Some(false),\n        status: Some(common_enums::ConnectorStatus::Active),\n        connector_label: None,\n        payment_methods_enabled: None,\n        metadata: None,\n        frm_configs: None,\n        connector_webhook_details: None,\n        pm_auth_config: None,\n        test_mode: None,\n        additional_merchant_data: None,\n        connector_wallets_details: None,\n    };\n    #[cfg(feature = \"v2\")]\n    let request = MerchantConnectorUpdate {\n        connector_type: common_enums::ConnectorType::PaymentProcessor,\n        connector_account_details: Some(Secret::new(connector_auth_json)),\n        disabled: Some(false),\n        status: Some(common_enums::ConnectorStatus::Active),\n        connector_label: None,\n        payment_methods_enabled: None,\n        metadata: None,\n        frm_configs: None,\n        connector_webhook_details: None,\n        pm_auth_config: None,\n        merchant_id: merchant_id.clone(),\n        additional_merchant_data: None,\n        connector_wallets_details: None,\n        feature_metadata: None,\n    };\n    let mca_response =\n        admin::update_connector(state.clone(), merchant_id, None, &connector_id, request).await?;\n\n    match mca_response {\n        ApplicationResponse::Json(mca_data) => Ok(mca_data),\n        _ => Err(ApiErrorResponse::InternalServerError.into()),\n    }\n}",
+      "diff_span": {
+        "before": "    };\n    let mca_response =\n        admin::update_connector(state.clone(), &merchant_id, None, &connector_id, request).await?;\n\n    match mca_response {",
+        "after": "    };\n    let mca_response =\n        admin::update_connector(state.clone(), merchant_id, None, &connector_id, request).await?;\n\n    match mca_response {"
+      },
+      "commit_sha": "c27425869cb155e3f2502baaa3da34cbfa859bce"
+    }
+  ]
+}

diffs/pr_10071/1bb2d15/diff.json

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

diffs/pr_10071/d540635/diff.json

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

diffs/pr_10071/df6d9cd/diff.json

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

diffs/pr_10138/544521b/diff.json

@@ -0,0 +1,115 @@
+{
+  "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b",
+  "pr_number": 10138,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/payjustnow.rs",
+    "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::impl::PayjustnowRefundRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F> TryFrom<&RefundsRouterData<F>> for PayjustnowRefundRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.request.refund_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),\n            refund_amount_cents: item.request.minor_refund_amount,\n            refund_description: item\n                .request\n                .reason\n                .clone()\n                .unwrap_or(NO_REFUND_REASON.to_string()),\n        })\n    }\n}",
+      "after_code": "impl<F> TryFrom<&RefundsRouterData<F>> for PayjustnowRefundRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.connector_request_reference_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),\n            refund_amount_cents: item.request.minor_refund_amount,\n            refund_description: item\n                .request\n                .reason\n                .clone()\n                .unwrap_or(NO_REFUND_REASON.to_string()),\n        })\n    }\n}",
+      "diff_span": {
+        "before": "    fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.request.refund_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),",
+        "after": "    fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.connector_request_reference_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),"
+      },
+      "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::PayjustnowRefundRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.request.refund_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),\n            refund_amount_cents: item.request.minor_refund_amount,\n            refund_description: item\n                .request\n                .reason\n                .clone()\n                .unwrap_or(NO_REFUND_REASON.to_string()),\n        })\n    }",
+      "after_code": "fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.connector_request_reference_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),\n            refund_amount_cents: item.request.minor_refund_amount,\n            refund_description: item\n                .request\n                .reason\n                .clone()\n                .unwrap_or(NO_REFUND_REASON.to_string()),\n        })\n    }",
+      "diff_span": {
+        "before": "fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.request.refund_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),",
+        "after": "fn try_from(item: &RefundsRouterData<F>) -> Result<Self, Self::Error> {\n        Ok(Self {\n            request_id: Some(item.connector_request_reference_id.clone()),\n            checkout_token: item.request.connector_transaction_id.clone(),\n            merchant_refund_reference: item.request.refund_id.clone(),"
+      },
+      "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs::Payjustnow::function::build_error_response",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn build_error_response(\n        &self,\n        res: Response,\n        event_builder: Option<&mut ConnectorEvent>,\n    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {\n        let response: payjustnow::PayjustnowErrorResponse = res\n            .response\n            .parse_struct(\"PayjustnowErrorResponse\")\n            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;\n\n        event_builder.map(|i| i.set_response_body(&response));\n        router_env::logger::info!(connector_response=?response);\n\n        Ok(ErrorResponse {\n            status_code: res.status_code,\n            code: hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),\n            message: response.message,\n            reason: None,\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    }",
+      "after_code": "fn build_error_response(\n        &self,\n        res: Response,\n        event_builder: Option<&mut ConnectorEvent>,\n    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {\n        let response: payjustnow::PayjustnowErrorResponse = res\n            .response\n            .parse_struct(\"PayjustnowErrorResponse\")\n            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;\n\n        event_builder.map(|i| i.set_response_body(&response));\n        router_env::logger::info!(connector_response=?response);\n\n        let message = match response {\n            payjustnow::PayjustnowErrorResponse::Structured(error) => error.message,\n            payjustnow::PayjustnowErrorResponse::Message(message) => message,\n        };\n\n        Ok(ErrorResponse {\n            status_code: res.status_code,\n            code: hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),\n            message,\n            reason: None,\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    }",
+      "diff_span": {
+        "before": "            status_code: res.status_code,\n            code: hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),\n            message: response.message,\n            reason: None,\n            attempt_status: None,",
+        "after": "        router_env::logger::info!(connector_response=?response);\n\n        let message = match response {\n            payjustnow::PayjustnowErrorResponse::Structured(error) => error.message,\n            payjustnow::PayjustnowErrorResponse::Message(message) => message,\n        };\n\n        Ok(ErrorResponse {\n            status_code: res.status_code,\n            code: hyperswitch_interfaces::consts::NO_ERROR_CODE.to_string(),\n            message,\n            reason: None,\n            attempt_status: None,"
+      },
+      "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::impl::PayjustnowPaymentsRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&PayjustnowRouterData<&PaymentsAuthorizeRouterData>> for PayjustnowPaymentsRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: &PayjustnowRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let router_data = item.router_data;\n        let order_items = router_data\n            .request\n            .order_details\n            .as_ref()\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|order| {\n                        Ok(OrderItem {\n                            name: order.product_name.clone(),\n                            sku: order.product_id.clone().unwrap_or_default(),\n                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let router_return_url = item.router_data.request.get_router_return_url()?;\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url: router_return_url.clone(),\n            cancel_redirect_url: router_return_url,\n        };\n\n        Ok(Self {\n            payjustnow: payjustnow_request,\n            checkout_total_cents: item.amount,\n        })\n    }\n}",
+      "after_code": "impl TryFrom<&PayjustnowRouterData<&PaymentsAuthorizeRouterData>> for PayjustnowPaymentsRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: &PayjustnowRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let router_data = item.router_data;\n        let order_items = router_data\n            .request\n            .order_details\n            .as_ref()\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|order| {\n                        Ok(OrderItem {\n                            name: order.product_name.clone(),\n                            sku: order.product_id.clone().unwrap_or_default(),\n                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let router_return_url = item.router_data.request.get_router_return_url()?;\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.connector_request_reference_id.clone()),\n            merchant_order_reference: item\n                .router_data\n                .request\n                .merchant_order_reference_id\n                .clone()\n                .unwrap_or(item.router_data.payment_id.clone()),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url: router_return_url.clone(),\n            cancel_redirect_url: router_return_url,\n        };\n\n        Ok(Self {\n            payjustnow: payjustnow_request,\n            checkout_total_cents: item.amount,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,",
+        "after": "\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.connector_request_reference_id.clone()),\n            merchant_order_reference: item\n                .router_data\n                .request\n                .merchant_order_reference_id\n                .clone()\n                .unwrap_or(item.router_data.payment_id.clone()),\n            order_amount_cents: item.amount,\n            order_items,"
+      },
+      "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::PayjustnowPaymentsRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: &PayjustnowRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let router_data = item.router_data;\n        let order_items = router_data\n            .request\n            .order_details\n            .as_ref()\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|order| {\n                        Ok(OrderItem {\n                            name: order.product_name.clone(),\n                            sku: order.product_id.clone().unwrap_or_default(),\n                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let router_return_url = item.router_data.request.get_router_return_url()?;\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url: router_return_url.clone(),\n            cancel_redirect_url: router_return_url,\n        };\n\n        Ok(Self {\n            payjustnow: payjustnow_request,\n            checkout_total_cents: item.amount,\n        })\n    }",
+      "after_code": "fn try_from(\n        item: &PayjustnowRouterData<&PaymentsAuthorizeRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let router_data = item.router_data;\n        let order_items = router_data\n            .request\n            .order_details\n            .as_ref()\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|order| {\n                        Ok(OrderItem {\n                            name: order.product_name.clone(),\n                            sku: order.product_id.clone().unwrap_or_default(),\n                            quantity: u32::from(order.quantity),\n                            price_cents: order.amount,\n                        })\n                    })\n                    .collect::<Result<Vec<OrderItem>, errors::ConnectorError>>()\n            })\n            .transpose()?;\n\n        let customer = router_data\n            .get_optional_billing_email()\n            .or_else(|| item.router_data.request.email.clone())\n            .map(|email| Customer {\n                first_name: router_data.get_optional_billing_first_name(),\n                last_name: router_data.get_optional_billing_last_name(),\n                email,\n                phone_number: router_data.get_optional_billing_phone_number(),\n            });\n\n        let billing_address = Some(Address {\n            address_line1: router_data.get_optional_billing_line1(),\n            address_line2: router_data.get_optional_billing_line2(),\n            city: router_data.get_optional_billing_city(),\n            province: router_data.get_optional_billing_state(),\n            postal_code: item.router_data.get_optional_billing_zip(),\n        });\n\n        let shipping_address = Some(Address {\n            address_line1: item.router_data.get_optional_shipping_line1(),\n            address_line2: item.router_data.get_optional_shipping_line2(),\n            city: item.router_data.get_optional_shipping_city(),\n            province: item.router_data.get_optional_shipping_state(),\n            postal_code: item.router_data.get_optional_shipping_zip(),\n        });\n\n        let router_return_url = item.router_data.request.get_router_return_url()?;\n\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.connector_request_reference_id.clone()),\n            merchant_order_reference: item\n                .router_data\n                .request\n                .merchant_order_reference_id\n                .clone()\n                .unwrap_or(item.router_data.payment_id.clone()),\n            order_amount_cents: item.amount,\n            order_items,\n            customer,\n            billing_address,\n            shipping_address,\n            confirm_redirect_url: router_return_url.clone(),\n            cancel_redirect_url: router_return_url,\n        };\n\n        Ok(Self {\n            payjustnow: payjustnow_request,\n            checkout_total_cents: item.amount,\n        })\n    }",
+      "diff_span": {
+        "before": "\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.payment_id.clone()),\n            merchant_order_reference: router_data.connector_request_reference_id.clone(),\n            order_amount_cents: item.amount,\n            order_items,",
+        "after": "\n        let payjustnow_request = PayjustnowRequest {\n            request_id: Some(item.router_data.connector_request_reference_id.clone()),\n            merchant_order_reference: item\n                .router_data\n                .request\n                .merchant_order_reference_id\n                .clone()\n                .unwrap_or(item.router_data.payment_id.clone()),\n            order_amount_cents: item.amount,\n            order_items,"
+      },
+      "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::struct::PayjustnowError",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PayjustnowError {\n    pub message: String,\n}",
+      "diff_span": null,
+      "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::enum::PayjustnowErrorResponse",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "enum_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub enum PayjustnowErrorResponse {\n    Structured(PayjustnowError),\n    Message(String),\n}",
+      "diff_span": null,
+      "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs::struct::PayjustnowErrorResponse",
+      "file": "crates/hyperswitch_connectors/src/connectors/payjustnow/transformers.rs",
+      "kind": "struct_item",
+      "status": "removed",
+      "before_code": "pub struct PayjustnowErrorResponse {\n    pub code: String,\n    pub message: String,\n    pub reason: Option<String>,\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "544521b80b1a37e6a07db68212c60d814daffa4b"
+    }
+  ]
+}

diffs/pr_10162/0b3886d/diff.json

@@ -0,0 +1,159 @@
+{
+  "commit_sha": "0b3886d8f2a6c57d5a67dc59f4e05d9c7e180801",
+  "pr_number": 10162,
+  "rust_files": [
+    "crates/api_models/src/ephemeral_key.rs",
+    "crates/api_models/src/tokenization.rs",
+    "crates/common_enums/src/enums/accounts.rs",
+    "crates/common_enums/src/enums/payments.rs",
+    "crates/common_utils/src/crypto.rs",
+    "crates/common_utils/src/payout_method_utils.rs",
+    "crates/connector_configs/src/connector.rs",
+    "crates/diesel_models/src/authentication.rs",
+    "crates/diesel_models/src/query/utils.rs",
+    "crates/diesel_models/src/tokenization.rs",
+    "crates/external_services/src/crm.rs",
+    "crates/external_services/src/grpc_client.rs",
+    "crates/external_services/src/grpc_client/dynamic_routing.rs",
+    "crates/hyperswitch_connectors/src/connectors/amazonpay.rs",
+    "crates/hyperswitch_connectors/src/connectors/authipay/transformers.rs",
+    "crates/hyperswitch_connectors/src/connectors/nmi.rs",
+    "crates/hyperswitch_connectors/src/connectors/payjustnow.rs",
+    "crates/hyperswitch_connectors/src/connectors/riskified/transformers/auth.rs",
+    "crates/hyperswitch_connectors/src/connectors/signifyd/transformers/auth.rs",
+    "crates/hyperswitch_connectors/src/connectors/stripe/transformers/connect.rs",
+    "crates/hyperswitch_connectors/src/connectors/trustpayments/transformers.rs",
+    "crates/hyperswitch_domain_models/src/connector_endpoints.rs",
+    "crates/hyperswitch_domain_models/src/router_request_types/fraud_check.rs",
+    "crates/hyperswitch_domain_models/src/routing.rs",
+    "crates/hyperswitch_domain_models/src/tokenization.rs",
+    "crates/hyperswitch_domain_models/src/vault.rs",
+    "crates/openapi/src/routes/subscriptions.rs",
+    "crates/router/src/consts/user.rs",
+    "crates/router/src/core/payments.rs",
+    "crates/router/src/core/payments/access_token.rs",
+    "crates/router/src/core/payments/operations/payment_cancel.rs",
+    "crates/router/src/core/payments/operations/payment_cancel_post_capture.rs",
+    "crates/router/src/core/payments/operations/payment_cancel_v2.rs",
+    "crates/router/src/core/payments/operations/payment_reject.rs",
+    "crates/router/src/core/payments/operations/payment_response.rs",
+    "crates/router/src/core/payments/operations/payments_extend_authorization.rs",
+    "crates/router/src/core/payouts.rs",
+    "crates/router/src/core/pm_auth.rs",
+    "crates/router/src/core/tokenization.rs",
+    "crates/router/src/core/webhooks/outgoing_v2.rs",
+    "crates/router/src/db/relay.rs",
+    "crates/router/src/routes/refunds.rs",
+    "crates/router/src/routes/tokenization.rs",
+    "crates/router/src/services/kafka/payment_intent.rs",
+    "crates/router/src/types/api/poll.rs",
+    "crates/router/tests/connectors/authipay.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/tests/connectors/authipay.rs::function::should_make_payment",
+      "file": "crates/router/tests/connectors/authipay.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn should_make_payment() {\n    let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n}",
+      "after_code": "async fn should_make_payment() {\n    let authorize_response = CONNECTOR\n        .make_payment(payment_method_details(), get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n}",
+      "diff_span": {
+        "before": "async fn should_make_payment() {\n    let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n}",
+        "after": "async fn should_make_payment() {\n    let authorize_response = CONNECTOR\n        .make_payment(payment_method_details(), get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n}"
+      },
+      "commit_sha": "0b3886d8f2a6c57d5a67dc59f4e05d9c7e180801"
+    },
+    {
+      "id": "crates/router/tests/connectors/authipay.rs::function::should_refund_manually_captured_payment",
+      "file": "crates/router/tests/connectors/authipay.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn should_refund_manually_captured_payment() {\n    let response = CONNECTOR\n        .capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(\n        response.response.unwrap().refund_status,\n        enums::RefundStatus::Success,\n    );\n}",
+      "after_code": "async fn should_refund_manually_captured_payment() {\n    let response = CONNECTOR\n        .capture_payment_and_refund(\n            payment_method_details(),\n            None,\n            None,\n            get_default_payment_info(),\n        )\n        .await\n        .unwrap();\n    assert_eq!(\n        response.response.unwrap().refund_status,\n        enums::RefundStatus::Success,\n    );\n}",
+      "diff_span": {
+        "before": "async fn should_refund_manually_captured_payment() {\n    let response = CONNECTOR\n        .capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())\n        .await\n        .unwrap();",
+        "after": "async fn should_refund_manually_captured_payment() {\n    let response = CONNECTOR\n        .capture_payment_and_refund(\n            payment_method_details(),\n            None,\n            None,\n            get_default_payment_info(),\n        )\n        .await\n        .unwrap();"
+      },
+      "commit_sha": "0b3886d8f2a6c57d5a67dc59f4e05d9c7e180801"
+    },
+    {
+      "id": "crates/router/tests/connectors/authipay.rs::function::should_fail_void_payment_for_auto_capture",
+      "file": "crates/router/tests/connectors/authipay.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn should_fail_void_payment_for_auto_capture() {\n    let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n    let txn_id = utils::get_connector_transaction_id(authorize_response.response);\n    assert_ne!(txn_id, None, \"Empty connector transaction id\");\n    let void_response = CONNECTOR\n        .void_payment(txn_id.unwrap(), None, get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(\n        void_response.response.unwrap_err().message,\n        \"You cannot cancel this PaymentIntent because it has a status of succeeded.\"\n    );\n}",
+      "after_code": "async fn should_fail_void_payment_for_auto_capture() {\n    let authorize_response = CONNECTOR\n        .make_payment(payment_method_details(), get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n    let txn_id = utils::get_connector_transaction_id(authorize_response.response);\n    assert_ne!(txn_id, None, \"Empty connector transaction id\");\n    let void_response = CONNECTOR\n        .void_payment(txn_id.unwrap(), None, get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(\n        void_response.response.unwrap_err().message,\n        \"You cannot cancel this PaymentIntent because it has a status of succeeded.\"\n    );\n}",
+      "diff_span": {
+        "before": "async fn should_fail_void_payment_for_auto_capture() {\n    let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n    let txn_id = utils::get_connector_transaction_id(authorize_response.response);",
+        "after": "async fn should_fail_void_payment_for_auto_capture() {\n    let authorize_response = CONNECTOR\n        .make_payment(payment_method_details(), get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n    let txn_id = utils::get_connector_transaction_id(authorize_response.response);"
+      },
+      "commit_sha": "0b3886d8f2a6c57d5a67dc59f4e05d9c7e180801"
+    },
+    {
+      "id": "crates/router/tests/connectors/authipay.rs::impl::AuthipayTest",
+      "file": "crates/router/tests/connectors/authipay.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl utils::Connector for AuthipayTest {\n    fn get_data(&self) -> api::ConnectorData {\n        use router::connector::Authipay;\n        api::ConnectorData {\n            connector: Box::new(Authipay::new()),\n            connector_name: types::Connector::Authipay,\n            get_token: types::api::GetToken::Connector,\n            merchant_connector_id: None,\n        }\n    }\n\n    fn get_auth_token(&self) -> types::ConnectorAuthType {\n        utils::to_connector_auth_type(\n            connector_auth::ConnectorAuthentication::new()\n                .authipay\n                .expect(\"Missing connector authentication configuration\").into(),\n        )\n    }\n\n    fn get_name(&self) -> String {\n        \"authipay\".to_string()\n    }\n}",
+      "after_code": "impl utils::Connector for AuthipayTest {\n    fn get_data(&self) -> api::ConnectorData {\n        use router::connector::Authipay;\n        api::ConnectorData {\n            connector: Box::new(Authipay::new()),\n            connector_name: types::Connector::Authipay,\n            get_token: types::api::GetToken::Connector,\n            merchant_connector_id: None,\n        }\n    }\n\n    fn get_auth_token(&self) -> types::ConnectorAuthType {\n        utils::to_connector_auth_type(\n            connector_auth::ConnectorAuthentication::new()\n                .authipay\n                .expect(\"Missing connector authentication configuration\")\n                .into(),\n        )\n    }\n\n    fn get_name(&self) -> String {\n        \"authipay\".to_string()\n    }\n}",
+      "diff_span": {
+        "before": "            connector_auth::ConnectorAuthentication::new()\n                .authipay\n                .expect(\"Missing connector authentication configuration\").into(),\n        )\n    }",
+        "after": "            connector_auth::ConnectorAuthentication::new()\n                .authipay\n                .expect(\"Missing connector authentication configuration\")\n                .into(),\n        )\n    }"
+      },
+      "commit_sha": "0b3886d8f2a6c57d5a67dc59f4e05d9c7e180801"
+    },
+    {
+      "id": "crates/router/tests/connectors/authipay.rs::function::should_sync_manually_captured_refund",
+      "file": "crates/router/tests/connectors/authipay.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn should_sync_manually_captured_refund() {\n    let refund_response = CONNECTOR\n        .capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())\n        .await\n        .unwrap();\n    let response = CONNECTOR\n        .rsync_retry_till_status_matches(\n            enums::RefundStatus::Success,\n            refund_response.response.unwrap().connector_refund_id,\n            None,\n            get_default_payment_info(),\n        )\n        .await\n        .unwrap();\n    assert_eq!(\n        response.response.unwrap().refund_status,\n        enums::RefundStatus::Success,\n    );\n}",
+      "after_code": "async fn should_sync_manually_captured_refund() {\n    let refund_response = CONNECTOR\n        .capture_payment_and_refund(\n            payment_method_details(),\n            None,\n            None,\n            get_default_payment_info(),\n        )\n        .await\n        .unwrap();\n    let response = CONNECTOR\n        .rsync_retry_till_status_matches(\n            enums::RefundStatus::Success,\n            refund_response.response.unwrap().connector_refund_id,\n            None,\n            get_default_payment_info(),\n        )\n        .await\n        .unwrap();\n    assert_eq!(\n        response.response.unwrap().refund_status,\n        enums::RefundStatus::Success,\n    );\n}",
+      "diff_span": {
+        "before": "async fn should_sync_manually_captured_refund() {\n    let refund_response = CONNECTOR\n        .capture_payment_and_refund(payment_method_details(), None, None, get_default_payment_info())\n        .await\n        .unwrap();",
+        "after": "async fn should_sync_manually_captured_refund() {\n    let refund_response = CONNECTOR\n        .capture_payment_and_refund(\n            payment_method_details(),\n            None,\n            None,\n            get_default_payment_info(),\n        )\n        .await\n        .unwrap();"
+      },
+      "commit_sha": "0b3886d8f2a6c57d5a67dc59f4e05d9c7e180801"
+    },
+    {
+      "id": "crates/router/tests/connectors/authipay.rs::AuthipayTest::function::get_auth_token",
+      "file": "crates/router/tests/connectors/authipay.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn get_auth_token(&self) -> types::ConnectorAuthType {\n        utils::to_connector_auth_type(\n            connector_auth::ConnectorAuthentication::new()\n                .authipay\n                .expect(\"Missing connector authentication configuration\").into(),\n        )\n    }",
+      "after_code": "fn get_auth_token(&self) -> types::ConnectorAuthType {\n        utils::to_connector_auth_type(\n            connector_auth::ConnectorAuthentication::new()\n                .authipay\n                .expect(\"Missing connector authentication configuration\")\n                .into(),\n        )\n    }",
+      "diff_span": {
+        "before": "            connector_auth::ConnectorAuthentication::new()\n                .authipay\n                .expect(\"Missing connector authentication configuration\").into(),\n        )\n    }",
+        "after": "            connector_auth::ConnectorAuthentication::new()\n                .authipay\n                .expect(\"Missing connector authentication configuration\")\n                .into(),\n        )\n    }"
+      },
+      "commit_sha": "0b3886d8f2a6c57d5a67dc59f4e05d9c7e180801"
+    },
+    {
+      "id": "crates/router/tests/connectors/authipay.rs::function::should_sync_auto_captured_payment",
+      "file": "crates/router/tests/connectors/authipay.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "async fn should_sync_auto_captured_payment() {\n    let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n    let txn_id = utils::get_connector_transaction_id(authorize_response.response);\n    assert_ne!(txn_id, None, \"Empty connector transaction id\");\n    let response = CONNECTOR\n        .psync_retry_till_status_matches(\n            enums::AttemptStatus::Charged,\n            Some(types::PaymentsSyncData {\n                connector_transaction_id: types::ResponseId::ConnectorTransactionId(\n                    txn_id.unwrap(),\n                ),\n                capture_method: Some(enums::CaptureMethod::Automatic),\n                ..Default::default()\n            }),\n            get_default_payment_info(),\n        )\n        .await\n        .unwrap();\n    assert_eq!(response.status, enums::AttemptStatus::Charged,);\n}",
+      "after_code": "async fn should_sync_auto_captured_payment() {\n    let authorize_response = CONNECTOR\n        .make_payment(payment_method_details(), get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n    let txn_id = utils::get_connector_transaction_id(authorize_response.response);\n    assert_ne!(txn_id, None, \"Empty connector transaction id\");\n    let response = CONNECTOR\n        .psync_retry_till_status_matches(\n            enums::AttemptStatus::Charged,\n            Some(types::PaymentsSyncData {\n                connector_transaction_id: types::ResponseId::ConnectorTransactionId(\n                    txn_id.unwrap(),\n                ),\n                capture_method: Some(enums::CaptureMethod::Automatic),\n                ..Default::default()\n            }),\n            get_default_payment_info(),\n        )\n        .await\n        .unwrap();\n    assert_eq!(response.status, enums::AttemptStatus::Charged,);\n}",
+      "diff_span": {
+        "before": "async fn should_sync_auto_captured_payment() {\n    let authorize_response = CONNECTOR.make_payment(payment_method_details(), get_default_payment_info()).await.unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n    let txn_id = utils::get_connector_transaction_id(authorize_response.response);",
+        "after": "async fn should_sync_auto_captured_payment() {\n    let authorize_response = CONNECTOR\n        .make_payment(payment_method_details(), get_default_payment_info())\n        .await\n        .unwrap();\n    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);\n    let txn_id = utils::get_connector_transaction_id(authorize_response.response);"
+      },
+      "commit_sha": "0b3886d8f2a6c57d5a67dc59f4e05d9c7e180801"
+    }
+  ]
+}

diffs/pr_10162/38e59dd/diff.json

@@ -0,0 +1,86 @@
+{
+  "commit_sha": "38e59dd13fd37cbd08dc67894e5d24709ea0e082",
+  "pr_number": 10162,
+  "rust_files": [
+    "crates/external_services/build.rs",
+    "crates/masking/tests/basic.rs",
+    "crates/router_env/tests/logger.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/external_services/build.rs::function::main",
+      "file": "crates/external_services/build.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn main() -> Result<(), Box<dyn std::error::Error>> {\n    // Compilation for revenue recovery protos\n    #[cfg(feature = \"revenue_recovery\")]\n    {\n        let proto_base_path = router_env::workspace_path().join(\"proto\");\n        let out_dir = std::path::PathBuf::from(std::env::var(\"OUT_DIR\")?);\n        let recovery_proto_files = [proto_base_path.join(\"recovery_decider.proto\")];\n        tonic_build::configure()\n            .out_dir(&out_dir)\n            .compile_well_known_types(true)\n            .extern_path(\".google.protobuf.Timestamp\", \"::prost_types::Timestamp\")\n            .compile_protos(&recovery_proto_files, &[&proto_base_path])\n            .expect(\"Failed to compile revenue-recovery proto files\");\n    }\n\n    // Compilation for dynamic_routing protos\n    #[cfg(feature = \"dynamic_routing\")]\n    {\n        // Get the directory of the current crate\n        let proto_path = router_env::workspace_path().join(\"proto\");\n        let success_rate_proto_file = proto_path.join(\"success_rate.proto\");\n        let contract_routing_proto_file = proto_path.join(\"contract_routing.proto\");\n        let elimination_proto_file = proto_path.join(\"elimination_rate.proto\");\n        let health_check_proto_file = proto_path.join(\"health_check.proto\");\n        let out_dir = std::path::PathBuf::from(std::env::var(\"OUT_DIR\")?);\n\n        // Compile the .proto file\n        tonic_build::configure()\n            .out_dir(out_dir)\n            .compile_protos(\n                &[\n                    success_rate_proto_file,\n                    health_check_proto_file,\n                    elimination_proto_file,\n                    contract_routing_proto_file,\n                ],\n                &[proto_path],\n            )\n            .expect(\"Failed to compile proto files\");\n    }\n    Ok(())\n}",
+      "after_code": "fn main() -> Result<(), Box<dyn std::error::Error>> {\n    // Compilation for revenue recovery protos\n    #[cfg(feature = \"revenue_recovery\")]\n    {\n        let proto_base_path = router_env::workspace_path().join(\"proto\");\n        let out_dir = std::path::PathBuf::from(std::env::var(\"OUT_DIR\")?);\n        let recovery_proto_files = [proto_base_path.join(\"recovery_decider.proto\")];\n\n        #[allow(clippy::expect_used, clippy::unwrap_in_result)]\n        tonic_build::configure()\n            .out_dir(&out_dir)\n            .compile_well_known_types(true)\n            .extern_path(\".google.protobuf.Timestamp\", \"::prost_types::Timestamp\")\n            .compile_protos(&recovery_proto_files, &[&proto_base_path])\n            .expect(\"Failed to compile revenue-recovery proto files\");\n    }\n\n    // Compilation for dynamic_routing protos\n    #[cfg(feature = \"dynamic_routing\")]\n    {\n        // Get the directory of the current crate\n        let proto_path = router_env::workspace_path().join(\"proto\");\n        let success_rate_proto_file = proto_path.join(\"success_rate.proto\");\n        let contract_routing_proto_file = proto_path.join(\"contract_routing.proto\");\n        let elimination_proto_file = proto_path.join(\"elimination_rate.proto\");\n        let health_check_proto_file = proto_path.join(\"health_check.proto\");\n        let out_dir = std::path::PathBuf::from(std::env::var(\"OUT_DIR\")?);\n\n        // Compile the .proto file\n        #[allow(clippy::expect_used, clippy::unwrap_in_result)]\n        tonic_build::configure()\n            .out_dir(out_dir)\n            .compile_protos(\n                &[\n                    success_rate_proto_file,\n                    health_check_proto_file,\n                    elimination_proto_file,\n                    contract_routing_proto_file,\n                ],\n                &[proto_path],\n            )\n            .expect(\"Failed to compile proto files\");\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "",
+        "after": "        let out_dir = std::path::PathBuf::from(std::env::var(\"OUT_DIR\")?);\n        let recovery_proto_files = [proto_base_path.join(\"recovery_decider.proto\")];\n\n        #[allow(clippy::expect_used, clippy::unwrap_in_result)]\n        tonic_build::configure()\n            .out_dir(&out_dir)\n            .compile_well_known_types(true)\n            .extern_path(\".google.protobuf.Timestamp\", \"::prost_types::Timestamp\")\n            .compile_protos(&recovery_proto_files, &[&proto_base_path])\n            .expect(\"Failed to compile revenue-recovery proto files\");\n    }\n\n    // Compilation for dynamic_routing protos\n    #[cfg(feature = \"dynamic_routing\")]\n    {\n        // Get the directory of the current crate\n        let proto_path = router_env::workspace_path().join(\"proto\");\n        let success_rate_proto_file = proto_path.join(\"success_rate.proto\");\n        let contract_routing_proto_file = proto_path.join(\"contract_routing.proto\");\n        let elimination_proto_file = proto_path.join(\"elimination_rate.proto\");\n        let health_check_proto_file = proto_path.join(\"health_check.proto\");\n        let out_dir = std::path::PathBuf::from(std::env::var(\"OUT_DIR\")?);\n\n        // Compile the .proto file\n        #[allow(clippy::expect_used, clippy::unwrap_in_result)]\n        tonic_build::configure()\n            .out_dir(out_dir)"
+      },
+      "commit_sha": "38e59dd13fd37cbd08dc67894e5d24709ea0e082"
+    },
+    {
+      "id": "crates/masking/tests/basic.rs::function::without_serialize",
+      "file": "crates/masking/tests/basic.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn without_serialize() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct AccountNumber(String);\n\n    #[cfg(feature = \"alloc\")]\n    impl ZeroizableSecret for AccountNumber {\n        fn zeroize(&mut self) {\n            self.0.zeroize();\n        }\n    }\n\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        #[cfg_attr(feature = \"serde\", serde(skip))]\n        secret_number: Secret<AccountNumber>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<AccountNumber>::new(AccountNumber(\"abc\".to_string()));\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp = r#\"Composite { secret_number: *** basic::without_serialize::AccountNumber ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(feature = \"serde\")]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n\n    Ok(())\n}",
+      "after_code": "fn without_serialize() {\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct AccountNumber(String);\n\n    #[cfg(feature = \"alloc\")]\n    impl ZeroizableSecret for AccountNumber {\n        fn zeroize(&mut self) {\n            self.0.zeroize();\n        }\n    }\n\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        #[cfg_attr(feature = \"serde\", serde(skip))]\n        secret_number: Secret<AccountNumber>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<AccountNumber>::new(AccountNumber(\"abc\".to_string()));\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp = r#\"Composite { secret_number: *** basic::without_serialize::AccountNumber ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(feature = \"serde\")]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n}",
+      "diff_span": {
+        "before": "fn without_serialize() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct AccountNumber(String);\n\n    #[cfg(feature = \"alloc\")]\n    impl ZeroizableSecret for AccountNumber {\n        fn zeroize(&mut self) {\n            self.0.zeroize();\n        }\n    }\n\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        #[cfg_attr(feature = \"serde\", serde(skip))]\n        secret_number: Secret<AccountNumber>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<AccountNumber>::new(AccountNumber(\"abc\".to_string()));\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp = r#\"Composite { secret_number: *** basic::without_serialize::AccountNumber ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(feature = \"serde\")]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n\n    Ok(())\n}",
+        "after": "fn without_serialize() {\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]"
+      },
+      "commit_sha": "38e59dd13fd37cbd08dc67894e5d24709ea0e082"
+    },
+    {
+      "id": "crates/masking/tests/basic.rs::function::basic",
+      "file": "crates/masking/tests/basic.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn basic() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct AccountNumber(String);\n\n    #[cfg(feature = \"alloc\")]\n    impl ZeroizableSecret for AccountNumber {\n        fn zeroize(&mut self) {\n            self.0.zeroize();\n        }\n    }\n\n    #[cfg(feature = \"serde\")]\n    impl SerializableSecret for AccountNumber {}\n\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        secret_number: Secret<AccountNumber>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<AccountNumber>::new(AccountNumber(\"abc\".to_string()));\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // clone\n    #[allow(clippy::redundant_clone)] // We are asserting that the cloned value is equal\n    let composite2 = composite.clone();\n    assert_eq!(composite, composite2);\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp = r#\"Composite { secret_number: *** basic::basic::AccountNumber ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(feature = \"serde\")]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"secret_number\":\"abc\",\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n\n    Ok(())\n}",
+      "after_code": "fn basic() {\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct AccountNumber(String);\n\n    #[cfg(feature = \"alloc\")]\n    impl ZeroizableSecret for AccountNumber {\n        fn zeroize(&mut self) {\n            self.0.zeroize();\n        }\n    }\n\n    #[cfg(feature = \"serde\")]\n    impl SerializableSecret for AccountNumber {}\n\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        secret_number: Secret<AccountNumber>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<AccountNumber>::new(AccountNumber(\"abc\".to_string()));\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // clone\n    #[allow(clippy::redundant_clone)] // We are asserting that the cloned value is equal\n    let composite2 = composite.clone();\n    assert_eq!(composite, composite2);\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp = r#\"Composite { secret_number: *** basic::basic::AccountNumber ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(feature = \"serde\")]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"secret_number\":\"abc\",\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n}",
+      "diff_span": {
+        "before": "fn basic() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct AccountNumber(String);\n\n    #[cfg(feature = \"alloc\")]\n    impl ZeroizableSecret for AccountNumber {\n        fn zeroize(&mut self) {\n            self.0.zeroize();\n        }\n    }\n\n    #[cfg(feature = \"serde\")]\n    impl SerializableSecret for AccountNumber {}\n\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        secret_number: Secret<AccountNumber>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<AccountNumber>::new(AccountNumber(\"abc\".to_string()));\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // clone\n    #[allow(clippy::redundant_clone)] // We are asserting that the cloned value is equal\n    let composite2 = composite.clone();\n    assert_eq!(composite, composite2);\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp = r#\"Composite { secret_number: *** basic::basic::AccountNumber ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(feature = \"serde\")]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"secret_number\":\"abc\",\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n\n    Ok(())\n}",
+        "after": "fn basic() {\n    #[cfg_attr(feature = \"serde\", derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]"
+      },
+      "commit_sha": "38e59dd13fd37cbd08dc67894e5d24709ea0e082"
+    },
+    {
+      "id": "crates/router_env/tests/logger.rs::function::logger",
+      "file": "crates/router_env/tests/logger.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn logger() -> error_stack::Result<&'static TelemetryGuard, ConfigError> {\n    use std::sync::OnceLock;\n\n    static INSTANCE: OnceLock<TelemetryGuard> = OnceLock::new();\n    Ok(INSTANCE.get_or_init(|| {\n        let config = router_env::Config::new().unwrap();\n\n        router_env::setup(&config.log, \"router_env_test\", []).unwrap()\n    }))\n}",
+      "after_code": "fn logger() -> error_stack::Result<&'static TelemetryGuard, ConfigError> {\n    use std::sync::OnceLock;\n\n    static INSTANCE: OnceLock<TelemetryGuard> = OnceLock::new();\n\n    #[allow(clippy::unwrap_used)]\n    Ok(INSTANCE.get_or_init(|| {\n        let config = router_env::Config::new().unwrap();\n\n        router_env::setup(&config.log, \"router_env_test\", []).unwrap()\n    }))\n}",
+      "diff_span": {
+        "before": "",
+        "after": "\n    static INSTANCE: OnceLock<TelemetryGuard> = OnceLock::new();\n\n    #[allow(clippy::unwrap_used)]\n    Ok(INSTANCE.get_or_init(|| {\n        let config = router_env::Config::new().unwrap();"
+      },
+      "commit_sha": "38e59dd13fd37cbd08dc67894e5d24709ea0e082"
+    },
+    {
+      "id": "crates/masking/tests/basic.rs::function::for_string",
+      "file": "crates/masking/tests/basic.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn for_string() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {\n    #[cfg_attr(all(feature = \"alloc\", feature = \"serde\"), derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        secret_number: Secret<String>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<String>::new(\"abc\".to_string());\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // clone\n    #[allow(clippy::redundant_clone)] // We are asserting that the cloned value is equal\n    let composite2 = composite.clone();\n    assert_eq!(composite, composite2);\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp =\n        r#\"Composite { secret_number: *** alloc::string::String ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(all(feature = \"alloc\", feature = \"serde\"))]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"secret_number\":\"abc\",\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n\n    Ok(())\n}",
+      "after_code": "fn for_string() {\n    #[cfg_attr(all(feature = \"alloc\", feature = \"serde\"), derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        secret_number: Secret<String>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<String>::new(\"abc\".to_string());\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // clone\n    #[allow(clippy::redundant_clone)] // We are asserting that the cloned value is equal\n    let composite2 = composite.clone();\n    assert_eq!(composite, composite2);\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp =\n        r#\"Composite { secret_number: *** alloc::string::String ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(all(feature = \"alloc\", feature = \"serde\"))]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"secret_number\":\"abc\",\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n}",
+      "diff_span": {
+        "before": "fn for_string() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {\n    #[cfg_attr(all(feature = \"alloc\", feature = \"serde\"), derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]\n    pub struct Composite {\n        secret_number: Secret<String>,\n        not_secret: String,\n    }\n\n    // construct\n\n    let secret_number = Secret::<String>::new(\"abc\".to_string());\n    let not_secret = \"not secret\".to_string();\n    let composite = Composite {\n        secret_number,\n        not_secret,\n    };\n\n    // clone\n    #[allow(clippy::redundant_clone)] // We are asserting that the cloned value is equal\n    let composite2 = composite.clone();\n    assert_eq!(composite, composite2);\n\n    // format\n\n    let got = format!(\"{composite:?}\");\n    let exp =\n        r#\"Composite { secret_number: *** alloc::string::String ***, not_secret: \"not secret\" }\"#;\n    assert_eq!(got, exp);\n\n    // serialize\n\n    #[cfg(all(feature = \"alloc\", feature = \"serde\"))]\n    {\n        let got = serde_json::to_string(&composite).unwrap();\n        let exp = r#\"{\"secret_number\":\"abc\",\"not_secret\":\"not secret\"}\"#;\n        assert_eq!(got, exp);\n    }\n\n    // end\n\n    Ok(())\n}",
+        "after": "fn for_string() {\n    #[cfg_attr(all(feature = \"alloc\", feature = \"serde\"), derive(Serialize))]\n    #[derive(Clone, Debug, PartialEq, Eq)]"
+      },
+      "commit_sha": "38e59dd13fd37cbd08dc67894e5d24709ea0e082"
+    }
+  ]
+}

diffs/pr_10162/c3f9846/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "c3f9846134dc4a1d335984942a31ce3aeeec661d",
+  "pr_number": 10162,
+  "rust_files": [
+    "crates/cards/src/validate.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/cards/src/validate.rs::function::validate_card_number_chars",
+      "file": "crates/cards/src/validate.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn validate_card_number_chars(number: &str) -> Result<Vec<u8>, CardNumberValidationErr> {\n    let data = number.chars().try_fold(\n        Vec::with_capacity(MAX_CARD_NUMBER_LENGTH),\n        |mut data, character| {\n            data.push(\n                #[allow(clippy::expect_used)]\n                character\n                    .to_digit(10)\n                    .ok_or(CardNumberValidationErr(\n                        \"invalid character found in card number\",\n                    ))?\n                    .try_into()\n                    .expect(\"error while converting a single character to u8\"), // safety, a single character will never be greater `u8`\n            );\n            Ok::<Vec<u8>, CardNumberValidationErr>(data)\n        },\n    )?;\n\n    Ok(data)\n}",
+      "after_code": "pub fn validate_card_number_chars(number: &str) -> Result<Vec<u8>, CardNumberValidationErr> {\n    let data = number.chars().try_fold(\n        Vec::with_capacity(MAX_CARD_NUMBER_LENGTH),\n        |mut data, character| {\n            data.push(\n                #[allow(clippy::expect_used)]\n                character\n                    .to_digit(10)\n                    .ok_or(CardNumberValidationErr(\n                        \"invalid character found in card number\",\n                    ))?\n                    .try_into()\n                    .expect(\"error while converting a single decimal digit to u8\"), // safety, a single decimal digit will never be greater `u8`\n            );\n            Ok::<Vec<u8>, CardNumberValidationErr>(data)\n        },\n    )?;\n\n    Ok(data)\n}",
+      "diff_span": {
+        "before": "                    ))?\n                    .try_into()\n                    .expect(\"error while converting a single character to u8\"), // safety, a single character will never be greater `u8`\n            );\n            Ok::<Vec<u8>, CardNumberValidationErr>(data)",
+        "after": "                    ))?\n                    .try_into()\n                    .expect(\"error while converting a single decimal digit to u8\"), // safety, a single decimal digit will never be greater `u8`\n            );\n            Ok::<Vec<u8>, CardNumberValidationErr>(data)"
+      },
+      "commit_sha": "c3f9846134dc4a1d335984942a31ce3aeeec661d"
+    }
+  ]
+}

diffs/pr_10162/c98bc4c/diff.json

@@ -0,0 +1,40 @@
+{
+  "commit_sha": "c98bc4c64a085ac152b8aaa7d83f70d93819af83",
+  "pr_number": 10162,
+  "rust_files": [
+    "crates/scheduler/src/consumer.rs",
+    "crates/scheduler/src/producer.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/scheduler/src/producer.rs::function::start_producer",
+      "file": "crates/scheduler/src/producer.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn start_producer<T, U, F>(\n    state: &T,\n    scheduler_settings: Arc<SchedulerSettings>,\n    (tx, mut rx): (mpsc::Sender<()>, mpsc::Receiver<()>),\n    app_state_to_session_state: F,\n) -> CustomResult<(), errors::ProcessTrackerError>\nwhere\n    F: Fn(&T, &id_type::TenantId) -> CustomResult<U, errors::ProcessTrackerError>,\n    T: SchedulerAppState,\n    U: SchedulerSessionState,\n{\n    use std::time::Duration;\n\n    use rand::distributions::{Distribution, Uniform};\n\n    let mut rng = rand::thread_rng();\n\n    // TODO: this can be removed once rand-0.9 is released\n    // reference - https://github.com/rust-random/rand/issues/1326#issuecomment-1635331942\n    #[allow(unknown_lints)]\n    #[allow(clippy::unnecessary_fallible_conversions)]\n    let timeout = Uniform::try_from(0..=scheduler_settings.loop_interval)\n        .change_context(errors::ProcessTrackerError::ConfigurationError)?;\n\n    tokio::time::sleep(Duration::from_millis(timeout.sample(&mut rng))).await;\n\n    let mut interval =\n        tokio::time::interval(Duration::from_millis(scheduler_settings.loop_interval));\n\n    let mut shutdown_interval = tokio::time::interval(Duration::from_millis(\n        scheduler_settings.graceful_shutdown_interval,\n    ));\n\n    let signal = common_utils::signals::get_allowed_signals()\n        .map_err(|error| {\n            logger::error!(\"Signal Handler Error: {:?}\", error);\n            errors::ProcessTrackerError::ConfigurationError\n        })\n        .attach_printable(\"Failed while creating a signals handler\")?;\n    let handle = signal.handle();\n    let task_handle =\n        tokio::spawn(common_utils::signals::signal_handler(signal, tx).in_current_span());\n\n    loop {\n        match rx.try_recv() {\n            Err(mpsc::error::TryRecvError::Empty) => {\n                interval.tick().await;\n                let tenants = state.get_tenants();\n                for tenant in tenants {\n                    let session_state = app_state_to_session_state(state, &tenant)?;\n                    match run_producer_flow(&session_state, &scheduler_settings).await {\n                        Ok(_) => (),\n                        Err(error) => {\n                            // Intentionally not propagating error to caller.\n                            // Any errors that occur in the producer flow must be handled here only, as\n                            // this is the topmost level function which is concerned with the producer flow.\n                            error!(?error);\n                        }\n                    }\n                }\n            }\n            Ok(()) | Err(mpsc::error::TryRecvError::Disconnected) => {\n                logger::debug!(\"Awaiting shutdown!\");\n                rx.close();\n                shutdown_interval.tick().await;\n                logger::info!(\"Terminating producer\");\n                break;\n            }\n        }\n    }\n    handle.close();\n    task_handle\n        .await\n        .change_context(errors::ProcessTrackerError::UnexpectedFlow)?;\n\n    Ok(())\n}",
+      "after_code": "pub async fn start_producer<T, U, F>(\n    state: &T,\n    scheduler_settings: Arc<SchedulerSettings>,\n    (tx, mut rx): (mpsc::Sender<()>, mpsc::Receiver<()>),\n    app_state_to_session_state: F,\n) -> CustomResult<(), errors::ProcessTrackerError>\nwhere\n    F: Fn(&T, &id_type::TenantId) -> CustomResult<U, errors::ProcessTrackerError>,\n    T: SchedulerAppState,\n    U: SchedulerSessionState,\n{\n    use std::time::Duration;\n\n    use rand::distributions::{Distribution, Uniform};\n\n    let mut rng = rand::thread_rng();\n\n    // TODO: this can be removed once rand-0.9 is released\n    // reference - https://github.com/rust-random/rand/issues/1326#issuecomment-1635331942\n    #[allow(clippy::unnecessary_fallible_conversions)]\n    let timeout = Uniform::try_from(0..=scheduler_settings.loop_interval)\n        .change_context(errors::ProcessTrackerError::ConfigurationError)?;\n\n    tokio::time::sleep(Duration::from_millis(timeout.sample(&mut rng))).await;\n\n    let mut interval =\n        tokio::time::interval(Duration::from_millis(scheduler_settings.loop_interval));\n\n    let mut shutdown_interval = tokio::time::interval(Duration::from_millis(\n        scheduler_settings.graceful_shutdown_interval,\n    ));\n\n    let signal = common_utils::signals::get_allowed_signals()\n        .map_err(|error| {\n            logger::error!(\"Signal Handler Error: {:?}\", error);\n            errors::ProcessTrackerError::ConfigurationError\n        })\n        .attach_printable(\"Failed while creating a signals handler\")?;\n    let handle = signal.handle();\n    let task_handle =\n        tokio::spawn(common_utils::signals::signal_handler(signal, tx).in_current_span());\n\n    loop {\n        match rx.try_recv() {\n            Err(mpsc::error::TryRecvError::Empty) => {\n                interval.tick().await;\n                let tenants = state.get_tenants();\n                for tenant in tenants {\n                    let session_state = app_state_to_session_state(state, &tenant)?;\n                    match run_producer_flow(&session_state, &scheduler_settings).await {\n                        Ok(_) => (),\n                        Err(error) => {\n                            // Intentionally not propagating error to caller.\n                            // Any errors that occur in the producer flow must be handled here only, as\n                            // this is the topmost level function which is concerned with the producer flow.\n                            error!(?error);\n                        }\n                    }\n                }\n            }\n            Ok(()) | Err(mpsc::error::TryRecvError::Disconnected) => {\n                logger::debug!(\"Awaiting shutdown!\");\n                rx.close();\n                shutdown_interval.tick().await;\n                logger::info!(\"Terminating producer\");\n                break;\n            }\n        }\n    }\n    handle.close();\n    task_handle\n        .await\n        .change_context(errors::ProcessTrackerError::UnexpectedFlow)?;\n\n    Ok(())\n}",
+      "diff_span": {
+        "before": "    // TODO: this can be removed once rand-0.9 is released\n    // reference - https://github.com/rust-random/rand/issues/1326#issuecomment-1635331942\n    #[allow(unknown_lints)]\n    #[allow(clippy::unnecessary_fallible_conversions)]\n    let timeout = Uniform::try_from(0..=scheduler_settings.loop_interval)",
+        "after": ""
+      },
+      "commit_sha": "c98bc4c64a085ac152b8aaa7d83f70d93819af83"
+    },
+    {
+      "id": "crates/scheduler/src/consumer.rs::function::start_consumer",
+      "file": "crates/scheduler/src/consumer.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn start_consumer<T: SchedulerAppState + 'static, U: SchedulerSessionState + 'static, F>(\n    state: &T,\n    settings: sync::Arc<SchedulerSettings>,\n    workflow_selector: impl workflows::ProcessTrackerWorkflows<U> + 'static + Copy + std::fmt::Debug,\n    (tx, mut rx): (mpsc::Sender<()>, mpsc::Receiver<()>),\n    app_state_to_session_state: F,\n) -> CustomResult<(), errors::ProcessTrackerError>\nwhere\n    F: Fn(&T, &id_type::TenantId) -> CustomResult<U, errors::ProcessTrackerError>,\n{\n    use std::time::Duration;\n\n    use rand::distributions::{Distribution, Uniform};\n\n    let mut rng = rand::thread_rng();\n\n    // TODO: this can be removed once rand-0.9 is released\n    // reference - https://github.com/rust-random/rand/issues/1326#issuecomment-1635331942\n    #[allow(unknown_lints)]\n    #[allow(clippy::unnecessary_fallible_conversions)]\n    let timeout = Uniform::try_from(0..=settings.loop_interval)\n        .change_context(errors::ProcessTrackerError::ConfigurationError)?;\n\n    tokio::time::sleep(Duration::from_millis(timeout.sample(&mut rng))).await;\n\n    let mut interval = tokio::time::interval(Duration::from_millis(settings.loop_interval));\n\n    let mut shutdown_interval =\n        tokio::time::interval(Duration::from_millis(settings.graceful_shutdown_interval));\n\n    let consumer_operation_counter = sync::Arc::new(atomic::AtomicU64::new(0));\n    let signal = get_allowed_signals()\n        .map_err(|error| {\n            logger::error!(?error, \"Signal Handler Error\");\n            errors::ProcessTrackerError::ConfigurationError\n        })\n        .attach_printable(\"Failed while creating a signals handler\")?;\n    let handle = signal.handle();\n    let task_handle =\n        tokio::spawn(common_utils::signals::signal_handler(signal, tx).in_current_span());\n\n    'consumer: loop {\n        match rx.try_recv() {\n            Err(mpsc::error::TryRecvError::Empty) => {\n                interval.tick().await;\n\n                // A guard from env to disable the consumer\n                if settings.consumer.disabled {\n                    continue;\n                }\n                consumer_operation_counter.fetch_add(1, atomic::Ordering::SeqCst);\n                let start_time = std_time::Instant::now();\n                let tenants = state.get_tenants();\n                for tenant in tenants {\n                    let session_state = app_state_to_session_state(state, &tenant)?;\n                    pt_utils::consumer_operation_handler(\n                        session_state.clone(),\n                        settings.clone(),\n                        |error| {\n                            logger::error!(?error, \"Failed to perform consumer operation\");\n                        },\n                        workflow_selector,\n                    )\n                    .await;\n                }\n\n                let end_time = std_time::Instant::now();\n                let duration = end_time.saturating_duration_since(start_time).as_secs_f64();\n                logger::debug!(\"Time taken to execute consumer_operation: {}s\", duration);\n\n                let current_count =\n                    consumer_operation_counter.fetch_sub(1, atomic::Ordering::SeqCst);\n                logger::info!(\"Current tasks being executed: {}\", current_count);\n            }\n            Ok(()) | Err(mpsc::error::TryRecvError::Disconnected) => {\n                logger::debug!(\"Awaiting shutdown!\");\n                rx.close();\n                loop {\n                    shutdown_interval.tick().await;\n                    let active_tasks = consumer_operation_counter.load(atomic::Ordering::Acquire);\n                    logger::info!(\"Active tasks: {active_tasks}\");\n                    match active_tasks {\n                        0 => {\n                            logger::info!(\"Terminating consumer\");\n                            break 'consumer;\n                        }\n                        _ => continue,\n                    }\n                }\n            }\n        }\n    }\n    handle.close();\n    task_handle\n        .await\n        .change_context(errors::ProcessTrackerError::UnexpectedFlow)?;\n\n    Ok(())\n}",
+      "after_code": "pub async fn start_consumer<T: SchedulerAppState + 'static, U: SchedulerSessionState + 'static, F>(\n    state: &T,\n    settings: sync::Arc<SchedulerSettings>,\n    workflow_selector: impl workflows::ProcessTrackerWorkflows<U> + 'static + Copy + std::fmt::Debug,\n    (tx, mut rx): (mpsc::Sender<()>, mpsc::Receiver<()>),\n    app_state_to_session_state: F,\n) -> CustomResult<(), errors::ProcessTrackerError>\nwhere\n    F: Fn(&T, &id_type::TenantId) -> CustomResult<U, errors::ProcessTrackerError>,\n{\n    use std::time::Duration;\n\n    use rand::distributions::{Distribution, Uniform};\n\n    let mut rng = rand::thread_rng();\n\n    // TODO: this can be removed once rand-0.9 is released\n    // reference - https://github.com/rust-random/rand/issues/1326#issuecomment-1635331942\n    #[allow(clippy::unnecessary_fallible_conversions)]\n    let timeout = Uniform::try_from(0..=settings.loop_interval)\n        .change_context(errors::ProcessTrackerError::ConfigurationError)?;\n\n    tokio::time::sleep(Duration::from_millis(timeout.sample(&mut rng))).await;\n\n    let mut interval = tokio::time::interval(Duration::from_millis(settings.loop_interval));\n\n    let mut shutdown_interval =\n        tokio::time::interval(Duration::from_millis(settings.graceful_shutdown_interval));\n\n    let consumer_operation_counter = sync::Arc::new(atomic::AtomicU64::new(0));\n    let signal = get_allowed_signals()\n        .map_err(|error| {\n            logger::error!(?error, \"Signal Handler Error\");\n            errors::ProcessTrackerError::ConfigurationError\n        })\n        .attach_printable(\"Failed while creating a signals handler\")?;\n    let handle = signal.handle();\n    let task_handle =\n        tokio::spawn(common_utils::signals::signal_handler(signal, tx).in_current_span());\n\n    'consumer: loop {\n        match rx.try_recv() {\n            Err(mpsc::error::TryRecvError::Empty) => {\n                interval.tick().await;\n\n                // A guard from env to disable the consumer\n                if settings.consumer.disabled {\n                    continue;\n                }\n                consumer_operation_counter.fetch_add(1, atomic::Ordering::SeqCst);\n                let start_time = std_time::Instant::now();\n                let tenants = state.get_tenants();\n                for tenant in tenants {\n                    let session_state = app_state_to_session_state(state, &tenant)?;\n                    pt_utils::consumer_operation_handler(\n                        session_state.clone(),\n                        settings.clone(),\n                        |error| {\n                            logger::error!(?error, \"Failed to perform consumer operation\");\n                        },\n                        workflow_selector,\n                    )\n                    .await;\n                }\n\n                let end_time = std_time::Instant::now();\n                let duration = end_time.saturating_duration_since(start_time).as_secs_f64();\n                logger::debug!(\"Time taken to execute consumer_operation: {}s\", duration);\n\n                let current_count =\n                    consumer_operation_counter.fetch_sub(1, atomic::Ordering::SeqCst);\n                logger::info!(\"Current tasks being executed: {}\", current_count);\n            }\n            Ok(()) | Err(mpsc::error::TryRecvError::Disconnected) => {\n                logger::debug!(\"Awaiting shutdown!\");\n                rx.close();\n                loop {\n                    shutdown_interval.tick().await;\n                    let active_tasks = consumer_operation_counter.load(atomic::Ordering::Acquire);\n                    logger::info!(\"Active tasks: {active_tasks}\");\n                    match active_tasks {\n                        0 => {\n                            logger::info!(\"Terminating consumer\");\n                            break 'consumer;\n                        }\n                        _ => continue,\n                    }\n                }\n            }\n        }\n    }\n    handle.close();\n    task_handle\n        .await\n        .change_context(errors::ProcessTrackerError::UnexpectedFlow)?;\n\n    Ok(())\n}",
+      "diff_span": {
+        "before": "    // TODO: this can be removed once rand-0.9 is released\n    // reference - https://github.com/rust-random/rand/issues/1326#issuecomment-1635331942\n    #[allow(unknown_lints)]\n    #[allow(clippy::unnecessary_fallible_conversions)]\n    let timeout = Uniform::try_from(0..=settings.loop_interval)",
+        "after": ""
+      },
+      "commit_sha": "c98bc4c64a085ac152b8aaa7d83f70d93819af83"
+    }
+  ]
+}

diffs/pr_10163/cb4e03f/diff.json

@@ -0,0 +1,49 @@
+{
+  "commit_sha": "cb4e03f329425db7d0b904105209a6fe4cadc42f",
+  "pr_number": 10163,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs::AdyenPaymentRequest<'_>::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        value: (\n            &AdyenRouterData<&PaymentsAuthorizeRouterData>,\n            &NetworkTokenData,\n        ),\n    ) -> Result<Self, Self::Error> {\n        let (item, token_data) = value;\n        let amount = get_amount_data(item);\n        let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let shopper_interaction = AdyenShopperInteraction::from(item.router_data);\n        let shopper_reference = build_shopper_reference(item.router_data);\n        let (recurring_processing_model, store_payment_method, _) =\n            get_recurring_processing_model(item.router_data)?;\n        let browser_info = get_browser_info(item.router_data)?;\n        let billing_address =\n            get_address_info(item.router_data.get_optional_billing()).transpose()?;\n        let country_code = get_country_code(item.router_data.get_optional_billing());\n        let additional_data = get_additional_data(item.router_data);\n        let return_url = item.router_data.request.get_router_return_url()?;\n        let testing_data = item\n            .router_data\n            .request\n            .get_connector_testing_data()\n            .map(AdyenTestingData::try_from)\n            .transpose()?;\n        let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);\n        let card_holder_name =\n            test_holder_name.or(item.router_data.get_optional_billing_full_name());\n        let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(\n            AdyenPaymentMethod::try_from((token_data, card_holder_name))?,\n        ));\n\n        let shopper_email = item.router_data.request.email.clone();\n        let shopper_name = get_shopper_name(item.router_data.get_optional_billing());\n        let mpi_data = AdyenMpiData {\n            directory_response: \"Y\".to_string(),\n            authentication_response: \"Y\".to_string(),\n            cavv: None,\n            token_authentication_verification_value: Some(\n                token_data.get_cryptogram().clone().unwrap_or_default(),\n            ),\n            eci: Some(\"02\".to_string()),\n        };\n        let (store, splits) = match item.router_data.request.split_payments.as_ref() {\n            Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(\n                adyen_split_payment,\n            )) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),\n            _ => (None, None),\n        };\n        let device_fingerprint = item\n            .router_data\n            .request\n            .metadata\n            .clone()\n            .and_then(get_device_fingerprint);\n\n        let delivery_address =\n            get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);\n        let telephone_number = item.router_data.get_optional_billing_phone_number();\n\n        Ok(AdyenPaymentRequest {\n            amount,\n            merchant_account: auth_type.merchant_account,\n            payment_method,\n            reference: item.router_data.connector_request_reference_id.clone(),\n            return_url,\n            shopper_interaction,\n            recurring_processing_model,\n            browser_info,\n            additional_data,\n            telephone_number,\n            shopper_name,\n            shopper_email,\n            shopper_locale: item.router_data.request.locale.clone(),\n            social_security_number: None,\n            billing_address,\n            delivery_address,\n            country_code,\n            line_items: None,\n            shopper_reference,\n            store_payment_method,\n            channel: None,\n            shopper_statement: item.router_data.request.statement_descriptor.clone(),\n            shopper_ip: item.router_data.request.get_ip_address_as_optional(),\n            merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),\n            mpi_data: Some(mpi_data),\n            store,\n            splits,\n            device_fingerprint,\n            session_validity: None,\n            metadata: item.router_data.request.metadata.clone(),\n        })\n    }",
+      "after_code": "fn try_from(\n        value: (\n            &AdyenRouterData<&PaymentsAuthorizeRouterData>,\n            &NetworkTokenData,\n        ),\n    ) -> Result<Self, Self::Error> {\n        let (item, token_data) = value;\n        let amount = get_amount_data(item);\n        let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let shopper_interaction = AdyenShopperInteraction::from(item.router_data);\n        let (recurring_processing_model, store_payment_method, shopper_reference) =\n            get_recurring_processing_model(item.router_data)?;\n        let browser_info = get_browser_info(item.router_data)?;\n        let billing_address =\n            get_address_info(item.router_data.get_optional_billing()).transpose()?;\n        let country_code = get_country_code(item.router_data.get_optional_billing());\n        let additional_data = get_additional_data(item.router_data);\n        let return_url = item.router_data.request.get_router_return_url()?;\n        let testing_data = item\n            .router_data\n            .request\n            .get_connector_testing_data()\n            .map(AdyenTestingData::try_from)\n            .transpose()?;\n        let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);\n        let card_holder_name =\n            test_holder_name.or(item.router_data.get_optional_billing_full_name());\n        let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(\n            AdyenPaymentMethod::try_from((token_data, card_holder_name))?,\n        ));\n\n        let shopper_email = item.router_data.request.email.clone();\n        let shopper_name = get_shopper_name(item.router_data.get_optional_billing());\n        let mpi_data = AdyenMpiData {\n            directory_response: \"Y\".to_string(),\n            authentication_response: \"Y\".to_string(),\n            cavv: None,\n            token_authentication_verification_value: Some(\n                token_data.get_cryptogram().clone().unwrap_or_default(),\n            ),\n            eci: Some(\"02\".to_string()),\n        };\n        let (store, splits) = match item.router_data.request.split_payments.as_ref() {\n            Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(\n                adyen_split_payment,\n            )) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),\n            _ => (None, None),\n        };\n        let device_fingerprint = item\n            .router_data\n            .request\n            .metadata\n            .clone()\n            .and_then(get_device_fingerprint);\n\n        let delivery_address =\n            get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);\n        let telephone_number = item.router_data.get_optional_billing_phone_number();\n\n        Ok(AdyenPaymentRequest {\n            amount,\n            merchant_account: auth_type.merchant_account,\n            payment_method,\n            reference: item.router_data.connector_request_reference_id.clone(),\n            return_url,\n            shopper_interaction,\n            recurring_processing_model,\n            browser_info,\n            additional_data,\n            telephone_number,\n            shopper_name,\n            shopper_email,\n            shopper_locale: item.router_data.request.locale.clone(),\n            social_security_number: None,\n            billing_address,\n            delivery_address,\n            country_code,\n            line_items: None,\n            shopper_reference,\n            store_payment_method,\n            channel: None,\n            shopper_statement: item.router_data.request.statement_descriptor.clone(),\n            shopper_ip: item.router_data.request.get_ip_address_as_optional(),\n            merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),\n            mpi_data: Some(mpi_data),\n            store,\n            splits,\n            device_fingerprint,\n            session_validity: None,\n            metadata: item.router_data.request.metadata.clone(),\n        })\n    }",
+      "diff_span": {
+        "before": "        let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let shopper_interaction = AdyenShopperInteraction::from(item.router_data);\n        let shopper_reference = build_shopper_reference(item.router_data);\n        let (recurring_processing_model, store_payment_method, _) =\n            get_recurring_processing_model(item.router_data)?;\n        let browser_info = get_browser_info(item.router_data)?;",
+        "after": "        let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let shopper_interaction = AdyenShopperInteraction::from(item.router_data);\n        let (recurring_processing_model, store_payment_method, shopper_reference) =\n            get_recurring_processing_model(item.router_data)?;\n        let browser_info = get_browser_info(item.router_data)?;"
+      },
+      "commit_sha": "cb4e03f329425db7d0b904105209a6fe4cadc42f"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs::impl::AdyenPaymentRequest<'_>",
+      "file": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl\n    TryFrom<(\n        &AdyenRouterData<&PaymentsAuthorizeRouterData>,\n        &NetworkTokenData,\n    )> for AdyenPaymentRequest<'_>\n{\n    type Error = Error;\n    fn try_from(\n        value: (\n            &AdyenRouterData<&PaymentsAuthorizeRouterData>,\n            &NetworkTokenData,\n        ),\n    ) -> Result<Self, Self::Error> {\n        let (item, token_data) = value;\n        let amount = get_amount_data(item);\n        let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let shopper_interaction = AdyenShopperInteraction::from(item.router_data);\n        let shopper_reference = build_shopper_reference(item.router_data);\n        let (recurring_processing_model, store_payment_method, _) =\n            get_recurring_processing_model(item.router_data)?;\n        let browser_info = get_browser_info(item.router_data)?;\n        let billing_address =\n            get_address_info(item.router_data.get_optional_billing()).transpose()?;\n        let country_code = get_country_code(item.router_data.get_optional_billing());\n        let additional_data = get_additional_data(item.router_data);\n        let return_url = item.router_data.request.get_router_return_url()?;\n        let testing_data = item\n            .router_data\n            .request\n            .get_connector_testing_data()\n            .map(AdyenTestingData::try_from)\n            .transpose()?;\n        let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);\n        let card_holder_name =\n            test_holder_name.or(item.router_data.get_optional_billing_full_name());\n        let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(\n            AdyenPaymentMethod::try_from((token_data, card_holder_name))?,\n        ));\n\n        let shopper_email = item.router_data.request.email.clone();\n        let shopper_name = get_shopper_name(item.router_data.get_optional_billing());\n        let mpi_data = AdyenMpiData {\n            directory_response: \"Y\".to_string(),\n            authentication_response: \"Y\".to_string(),\n            cavv: None,\n            token_authentication_verification_value: Some(\n                token_data.get_cryptogram().clone().unwrap_or_default(),\n            ),\n            eci: Some(\"02\".to_string()),\n        };\n        let (store, splits) = match item.router_data.request.split_payments.as_ref() {\n            Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(\n                adyen_split_payment,\n            )) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),\n            _ => (None, None),\n        };\n        let device_fingerprint = item\n            .router_data\n            .request\n            .metadata\n            .clone()\n            .and_then(get_device_fingerprint);\n\n        let delivery_address =\n            get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);\n        let telephone_number = item.router_data.get_optional_billing_phone_number();\n\n        Ok(AdyenPaymentRequest {\n            amount,\n            merchant_account: auth_type.merchant_account,\n            payment_method,\n            reference: item.router_data.connector_request_reference_id.clone(),\n            return_url,\n            shopper_interaction,\n            recurring_processing_model,\n            browser_info,\n            additional_data,\n            telephone_number,\n            shopper_name,\n            shopper_email,\n            shopper_locale: item.router_data.request.locale.clone(),\n            social_security_number: None,\n            billing_address,\n            delivery_address,\n            country_code,\n            line_items: None,\n            shopper_reference,\n            store_payment_method,\n            channel: None,\n            shopper_statement: item.router_data.request.statement_descriptor.clone(),\n            shopper_ip: item.router_data.request.get_ip_address_as_optional(),\n            merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),\n            mpi_data: Some(mpi_data),\n            store,\n            splits,\n            device_fingerprint,\n            session_validity: None,\n            metadata: item.router_data.request.metadata.clone(),\n        })\n    }\n}",
+      "after_code": "impl\n    TryFrom<(\n        &AdyenRouterData<&PaymentsAuthorizeRouterData>,\n        &NetworkTokenData,\n    )> for AdyenPaymentRequest<'_>\n{\n    type Error = Error;\n    fn try_from(\n        value: (\n            &AdyenRouterData<&PaymentsAuthorizeRouterData>,\n            &NetworkTokenData,\n        ),\n    ) -> Result<Self, Self::Error> {\n        let (item, token_data) = value;\n        let amount = get_amount_data(item);\n        let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let shopper_interaction = AdyenShopperInteraction::from(item.router_data);\n        let (recurring_processing_model, store_payment_method, shopper_reference) =\n            get_recurring_processing_model(item.router_data)?;\n        let browser_info = get_browser_info(item.router_data)?;\n        let billing_address =\n            get_address_info(item.router_data.get_optional_billing()).transpose()?;\n        let country_code = get_country_code(item.router_data.get_optional_billing());\n        let additional_data = get_additional_data(item.router_data);\n        let return_url = item.router_data.request.get_router_return_url()?;\n        let testing_data = item\n            .router_data\n            .request\n            .get_connector_testing_data()\n            .map(AdyenTestingData::try_from)\n            .transpose()?;\n        let test_holder_name = testing_data.and_then(|test_data| test_data.holder_name);\n        let card_holder_name =\n            test_holder_name.or(item.router_data.get_optional_billing_full_name());\n        let payment_method = PaymentMethod::AdyenPaymentMethod(Box::new(\n            AdyenPaymentMethod::try_from((token_data, card_holder_name))?,\n        ));\n\n        let shopper_email = item.router_data.request.email.clone();\n        let shopper_name = get_shopper_name(item.router_data.get_optional_billing());\n        let mpi_data = AdyenMpiData {\n            directory_response: \"Y\".to_string(),\n            authentication_response: \"Y\".to_string(),\n            cavv: None,\n            token_authentication_verification_value: Some(\n                token_data.get_cryptogram().clone().unwrap_or_default(),\n            ),\n            eci: Some(\"02\".to_string()),\n        };\n        let (store, splits) = match item.router_data.request.split_payments.as_ref() {\n            Some(common_types::payments::SplitPaymentsRequest::AdyenSplitPayment(\n                adyen_split_payment,\n            )) => get_adyen_split_request(adyen_split_payment, item.router_data.request.currency),\n            _ => (None, None),\n        };\n        let device_fingerprint = item\n            .router_data\n            .request\n            .metadata\n            .clone()\n            .and_then(get_device_fingerprint);\n\n        let delivery_address =\n            get_address_info(item.router_data.get_optional_shipping()).and_then(Result::ok);\n        let telephone_number = item.router_data.get_optional_billing_phone_number();\n\n        Ok(AdyenPaymentRequest {\n            amount,\n            merchant_account: auth_type.merchant_account,\n            payment_method,\n            reference: item.router_data.connector_request_reference_id.clone(),\n            return_url,\n            shopper_interaction,\n            recurring_processing_model,\n            browser_info,\n            additional_data,\n            telephone_number,\n            shopper_name,\n            shopper_email,\n            shopper_locale: item.router_data.request.locale.clone(),\n            social_security_number: None,\n            billing_address,\n            delivery_address,\n            country_code,\n            line_items: None,\n            shopper_reference,\n            store_payment_method,\n            channel: None,\n            shopper_statement: item.router_data.request.statement_descriptor.clone(),\n            shopper_ip: item.router_data.request.get_ip_address_as_optional(),\n            merchant_order_reference: item.router_data.request.merchant_order_reference_id.clone(),\n            mpi_data: Some(mpi_data),\n            store,\n            splits,\n            device_fingerprint,\n            session_validity: None,\n            metadata: item.router_data.request.metadata.clone(),\n        })\n    }\n}",
+      "diff_span": {
+        "before": "        let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let shopper_interaction = AdyenShopperInteraction::from(item.router_data);\n        let shopper_reference = build_shopper_reference(item.router_data);\n        let (recurring_processing_model, store_payment_method, _) =\n            get_recurring_processing_model(item.router_data)?;\n        let browser_info = get_browser_info(item.router_data)?;",
+        "after": "        let auth_type = AdyenAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let shopper_interaction = AdyenShopperInteraction::from(item.router_data);\n        let (recurring_processing_model, store_payment_method, shopper_reference) =\n            get_recurring_processing_model(item.router_data)?;\n        let browser_info = get_browser_info(item.router_data)?;"
+      },
+      "commit_sha": "cb4e03f329425db7d0b904105209a6fe4cadc42f"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs::function::build_shopper_reference",
+      "file": "crates/hyperswitch_connectors/src/connectors/adyen/transformers.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn build_shopper_reference(item: &PaymentsAuthorizeRouterData) -> Option<String> {\n    match item.get_connector_customer_id() {\n        Ok(connector_customer_id) => Some(connector_customer_id),\n        Err(_) => match item.get_customer_id() {\n            Ok(customer_id) => Some(format!(\n                \"{}_{}\",\n                item.merchant_id.get_string_repr(),\n                customer_id.get_string_repr()\n            )),\n            Err(_) => None,\n        },\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "cb4e03f329425db7d0b904105209a6fe4cadc42f"
+    }
+  ]
+}

diffs/pr_10197/1022c03/diff.json

@@ -0,0 +1,39 @@
+{
+  "commit_sha": "1022c037e9060c5378b1ff9450e70864648d551d",
+  "pr_number": 10197,
+  "rust_files": [
+    "crates/api_models/src/payments.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/api_models/src/payments.rs::impl::PMBalanceCheckEligibilityResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl PMBalanceCheckEligibilityResponse {\n    pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            PMBalanceCheckEligibilityResponse::Success(resp) => resp.balance,\n            PMBalanceCheckEligibilityResponse::Failure(_) => MinorUnit::zero(),\n        }\n    }\n}",
+      "after_code": "impl PMBalanceCheckEligibilityResponse {\n    pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            Self::Success(resp) => resp.balance,\n            Self::Failure(_) => MinorUnit::zero(),\n        }\n    }\n}",
+      "diff_span": {
+        "before": "    pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            PMBalanceCheckEligibilityResponse::Success(resp) => resp.balance,\n            PMBalanceCheckEligibilityResponse::Failure(_) => MinorUnit::zero(),\n        }\n    }",
+        "after": "    pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            Self::Success(resp) => resp.balance,\n            Self::Failure(_) => MinorUnit::zero(),\n        }\n    }"
+      },
+      "commit_sha": "1022c037e9060c5378b1ff9450e70864648d551d"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::PMBalanceCheckEligibilityResponse::function::get_balance",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            PMBalanceCheckEligibilityResponse::Success(resp) => resp.balance,\n            PMBalanceCheckEligibilityResponse::Failure(_) => MinorUnit::zero(),\n        }\n    }",
+      "after_code": "pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            Self::Success(resp) => resp.balance,\n            Self::Failure(_) => MinorUnit::zero(),\n        }\n    }",
+      "diff_span": {
+        "before": "pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            PMBalanceCheckEligibilityResponse::Success(resp) => resp.balance,\n            PMBalanceCheckEligibilityResponse::Failure(_) => MinorUnit::zero(),\n        }\n    }",
+        "after": "pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            Self::Success(resp) => resp.balance,\n            Self::Failure(_) => MinorUnit::zero(),\n        }\n    }"
+      },
+      "commit_sha": "1022c037e9060c5378b1ff9450e70864648d551d"
+    }
+  ]
+}

diffs/pr_10197/234898a/diff.json

@@ -0,0 +1,251 @@
+{
+  "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597",
+  "pr_number": 10197,
+  "rust_files": [
+    "crates/api_models/src/events/payment.rs",
+    "crates/api_models/src/payments.rs",
+    "crates/openapi/src/openapi_v2.rs",
+    "crates/openapi/src/routes/payments.rs",
+    "crates/router/src/core/payment_method_balance.rs",
+    "crates/router/src/routes/app.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_check_and_apply_pm_data_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn payments_check_and_apply_pm_data_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<ApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let mut balance_values: Vec<api_models::payments::BalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                        PaymentMethodBalanceApi {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                                PaymentMethodBalanceApi {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::BalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        let balance_a = match &a.eligibility {\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        let balance_b = match &b.eligibility {\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        balance_a.cmp(&balance_b)\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                balance_api,\n            ) = &value.eligibility\n            {\n                Some(balance_api.applicable_amount)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = ApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,\n        currency: payment_intent.amount_details.currency,\n        requires_additional_pm_data: remaining_amount.is_greater_than(0),\n        surcharge_details: None, // TODO: Implement surcharge recalculation logic\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "after_code": "pub async fn payments_check_and_apply_pm_data_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<CheckAndApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let mut balance_values: Vec<api_models::payments::EligibilityBalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                        PMBalanceCheckSuccessResponse {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                                PMBalanceCheckSuccessResponse {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::EligibilityBalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        let balance_a = match &a.eligibility {\n            api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        let balance_b = match &b.eligibility {\n            api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        balance_a.cmp(&balance_b)\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n                &value.eligibility\n            {\n                Some(balance_api.applicable_amount)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = CheckAndApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,\n        currency: payment_intent.amount_details.currency,\n        requires_additional_pm_data: remaining_amount.is_greater_than(0),\n        surcharge_details: None, // TODO: Implement surcharge recalculation logic\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "diff_span": {
+        "before": "    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<ApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let mut balance_values: Vec<api_models::payments::BalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                        PaymentMethodBalanceApi {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                                PaymentMethodBalanceApi {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::BalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        let balance_a = match &a.eligibility {\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        let balance_b = match &b.eligibility {\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        balance_a.cmp(&balance_b)\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                balance_api,\n            ) = &value.eligibility\n            {\n                Some(balance_api.applicable_amount)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = ApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,",
+        "after": "    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<CheckAndApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let mut balance_values: Vec<api_models::payments::EligibilityBalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                        PMBalanceCheckSuccessResponse {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                                PMBalanceCheckSuccessResponse {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::EligibilityBalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        let balance_a = match &a.eligibility {\n            api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        let balance_b = match &b.eligibility {\n            api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        balance_a.cmp(&balance_b)\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n                &value.eligibility\n            {\n                Some(balance_api.applicable_amount)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = CheckAndApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,"
+      },
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::fetch_payment_methods_balances_from_redis_fallible",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn fetch_payment_methods_balances_from_redis_fallible(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<\n    HashMap<domain::PaymentMethodBalanceKey, Option<domain::PaymentMethodBalance>>,\n> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned();\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "after_code": "pub async fn fetch_payment_methods_balances_from_redis_fallible(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<\n    HashMap<domain::PaymentMethodBalanceKey, Option<domain::PaymentMethodBalance>>,\n> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned();\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::fetch_payment_methods_balances_from_redis",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn fetch_payment_methods_balances_from_redis(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<HashMap<domain::PaymentMethodBalanceKey, domain::PaymentMethodBalance>> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned().ok_or(\n                errors::ApiErrorResponse::GenericNotFoundError {\n                    message: \"Balance not found for one or more payment methods\".to_string(),\n                },\n            )?;\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "after_code": "pub async fn fetch_payment_methods_balances_from_redis(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<HashMap<domain::PaymentMethodBalanceKey, domain::PaymentMethodBalance>> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned().ok_or(\n                errors::ApiErrorResponse::GenericNotFoundError {\n                    message: \"Balance not found for one or more payment methods\".to_string(),\n                },\n            )?;\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_check_gift_card_balance_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn payments_check_gift_card_balance_core(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    profile: &domain::Profile,\n    _req_state: &ReqState,\n    payment_method_data: api_models::payments::BalanceCheckPaymentMethodData,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<(MinorUnit, common_enums::Currency)> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = (balance, currency);\n\n    Ok(resp)\n}",
+      "after_code": "pub async fn payments_check_gift_card_balance_core(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    profile: &domain::Profile,\n    _req_state: &ReqState,\n    payment_method_data: api_models::payments::BalanceCheckPaymentMethodData,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<(MinorUnit, common_enums::Currency)> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = (balance, currency);\n\n    Ok(resp)\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};",
+        "use common_enums::CallConnectorAction;"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};",
+        "use common_enums::CallConnectorAction;"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::persist_individual_pm_balance_details_in_redis",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn persist_individual_pm_balance_details_in_redis<'a>(\n    state: &SessionState,\n    business_profile: &domain::Profile,\n    pm_balance_data: &domain::PaymentMethodBalanceData<'_>,\n) -> errors::RouterResult<()> {\n    if !pm_balance_data.is_empty() {\n        let redis_conn = state\n            .store\n            .get_redis_conn()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get redis connection\")?;\n        let redis_key = pm_balance_data.get_pm_balance_redis_key();\n\n        let value_list = pm_balance_data\n            .get_individual_pm_balance_key_value_pairs()\n            .into_iter()\n            .map(|(key, value)| {\n                value\n                    .encode_to_string_of_json()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to encode to string of json\")\n                    .map(|encoded_value| (key, encoded_value))\n            })\n            .collect::<Result<Vec<_>, _>>()?;\n\n        let intent_fulfillment_time = business_profile\n            .get_order_fulfillment_time()\n            .unwrap_or(consts::DEFAULT_FULFILLMENT_TIME);\n\n        redis_conn\n            .set_hash_fields(\n                &redis_key.as_str().into(),\n                value_list,\n                Some(intent_fulfillment_time),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to write to redis\")?;\n\n        logger::debug!(\"Surcharge results stored in redis with key = {}\", redis_key);\n    }\n    Ok(())\n}",
+      "after_code": "pub async fn persist_individual_pm_balance_details_in_redis<'a>(\n    state: &SessionState,\n    business_profile: &domain::Profile,\n    pm_balance_data: &domain::PaymentMethodBalanceData<'_>,\n) -> errors::RouterResult<()> {\n    if !pm_balance_data.is_empty() {\n        let redis_conn = state\n            .store\n            .get_redis_conn()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get redis connection\")?;\n        let redis_key = pm_balance_data.get_pm_balance_redis_key();\n\n        let value_list = pm_balance_data\n            .get_individual_pm_balance_key_value_pairs()\n            .into_iter()\n            .map(|(key, value)| {\n                value\n                    .encode_to_string_of_json()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to encode to string of json\")\n                    .map(|encoded_value| (key, encoded_value))\n            })\n            .collect::<Result<Vec<_>, _>>()?;\n\n        let intent_fulfillment_time = business_profile\n            .get_order_fulfillment_time()\n            .unwrap_or(consts::DEFAULT_FULFILLMENT_TIME);\n\n        redis_conn\n            .set_hash_fields(\n                &redis_key.as_str().into(),\n                value_list,\n                Some(intent_fulfillment_time),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to write to redis\")?;\n\n        logger::debug!(\"Surcharge results stored in redis with key = {}\", redis_key);\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::EligibilityBalanceCheckResponseItem",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct EligibilityBalanceCheckResponseItem {\n    pub payment_method_data: BalanceCheckPaymentMethodData,\n    pub eligibility: PMBalanceCheckEligibilityResponse,\n}",
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::CheckAndApplyPaymentMethodDataResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct CheckAndApplyPaymentMethodDataResponse {\n    pub balances: Vec<EligibilityBalanceCheckResponseItem>,\n    /// The amount left after subtracting applied payment method balance from order amount\n    pub remaining_amount: MinorUnit,\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n    /// Whether the applied payment method balance is enough for the order amount or additional PM is required\n    pub requires_additional_pm_data: bool,\n    pub surcharge_details: Option<Vec<ApplyPaymentMethodDataSurchargeResponseItem>>,\n}",
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/events/payment.rs::payments::CheckAndApplyPaymentMethodDataResponse::function::get_api_event_type",
+      "file": "crates/api_models/src/events/payment.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn get_api_event_type(&self) -> Option<ApiEventsType> {\n        None\n    }",
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/events/payment.rs::impl::payments::CheckAndApplyPaymentMethodDataResponse",
+      "file": "crates/api_models/src/events/payment.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl ApiEventMetric for payments::CheckAndApplyPaymentMethodDataResponse {\n    fn get_api_event_type(&self) -> Option<ApiEventsType> {\n        None\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::enum::PMBalanceCheckEligibilityResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "enum_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub enum PMBalanceCheckEligibilityResponse {\n    Success(PMBalanceCheckSuccessResponse),\n    Failure(String),\n}",
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PMBalanceCheckSuccessResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PMBalanceCheckSuccessResponse {\n    pub balance: MinorUnit,\n    pub applicable_amount: MinorUnit,\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n}",
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/events/payment.rs::impl::payments::ApplyPaymentMethodDataResponse",
+      "file": "crates/api_models/src/events/payment.rs",
+      "kind": "impl_item",
+      "status": "removed",
+      "before_code": "impl ApiEventMetric for payments::ApplyPaymentMethodDataResponse {\n    fn get_api_event_type(&self) -> Option<ApiEventsType> {\n        None\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::enum::PaymentMethodBalanceCheckEligibility",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "enum_item",
+      "status": "removed",
+      "before_code": "pub enum PaymentMethodBalanceCheckEligibility {\n    Success(PaymentMethodBalanceApi),\n    Failure(String),\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::BalanceCheckResponseItem",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "removed",
+      "before_code": "pub struct BalanceCheckResponseItem {\n    pub payment_method_data: BalanceCheckPaymentMethodData,\n    pub eligibility: PaymentMethodBalanceCheckEligibility,\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PaymentMethodBalanceApi",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "removed",
+      "before_code": "pub struct PaymentMethodBalanceApi {\n    pub balance: MinorUnit,\n    pub applicable_amount: MinorUnit,\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::ApplyPaymentMethodDataResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "removed",
+      "before_code": "pub struct ApplyPaymentMethodDataResponse {\n    pub balances: Vec<BalanceCheckResponseItem>,\n    pub remaining_amount: MinorUnit,\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n    pub requires_additional_pm_data: bool,\n    pub surcharge_details: Option<Vec<ApplyPaymentMethodDataSurchargeResponseItem>>,\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    },
+    {
+      "id": "crates/api_models/src/events/payment.rs::payments::ApplyPaymentMethodDataResponse::function::get_api_event_type",
+      "file": "crates/api_models/src/events/payment.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_api_event_type(&self) -> Option<ApiEventsType> {\n        None\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "234898a5cf27247301ce272d5d071aef4fd90597"
+    }
+  ]
+}

diffs/pr_10197/9ec1575/diff.json

@@ -0,0 +1,200 @@
+{
+  "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6",
+  "pr_number": 10197,
+  "rust_files": [
+    "crates/api_models/src/payments.rs",
+    "crates/router/src/core/payment_method_balance.rs",
+    "crates/router/src/routes/app.rs",
+    "crates/router/src/routes/payments.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/routes/payments.rs::function::payment_check_gift_card_balance",
+      "file": "crates/router/src/routes/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn payment_check_gift_card_balance(\n    state: web::Data<app::AppState>,\n    req: actix_web::HttpRequest,\n    json_payload: web::Json<api_models::payments::PaymentMethodBalanceCheckRequest>,\n    path: web::Path<common_utils::id_type::GlobalPaymentId>,\n) -> impl Responder {\n    let flow = Flow::PaymentMethodBalanceCheck;\n\n    let global_payment_id = path.into_inner();\n    tracing::Span::current().record(\"payment_id\", global_payment_id.get_string_repr());\n\n    let internal_payload = internal_payload_types::PaymentsGenericRequestWithResourceId {\n        global_payment_id: global_payment_id.clone(),\n        payload: json_payload.into_inner(),\n    };\n\n    let header_payload = match HeaderPayload::foreign_try_from(req.headers()) {\n        Ok(headers) => headers,\n        Err(err) => {\n            return api::log_and_return_error_response(err);\n        }\n    };\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        internal_payload,\n        |state, auth: auth::AuthenticationData, req, req_state| async {\n            let payment_id = req.global_payment_id;\n            let request = req.payload;\n\n            let merchant_context = domain::MerchantContext::NormalMerchant(Box::new(\n                domain::Context(auth.merchant_account, auth.key_store),\n            ));\n            Box::pin(\n                payment_method_balance::payments_check_gift_card_balance_core(\n                    state,\n                    merchant_context,\n                    auth.profile,\n                    req_state,\n                    request,\n                    header_payload.clone(),\n                    payment_id,\n                ),\n            )\n            .await\n        },\n        auth::api_or_client_auth(\n            &auth::V2ApiKeyAuth {\n                is_connected_allowed: false,\n                is_platform_allowed: false,\n            },\n            &auth::V2ClientAuth(common_utils::types::authentication::ResourceId::Payment(\n                global_payment_id,\n            )),\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn payment_check_gift_card_balance(\n    state: web::Data<app::AppState>,\n    req: actix_web::HttpRequest,\n    json_payload: web::Json<api_models::payments::PaymentMethodBalanceCheckRequest>,\n    path: web::Path<common_utils::id_type::GlobalPaymentId>,\n) -> impl Responder {\n    let flow = Flow::PaymentMethodBalanceCheck;\n\n    let global_payment_id = path.into_inner();\n    tracing::Span::current().record(\"payment_id\", global_payment_id.get_string_repr());\n\n    let internal_payload = internal_payload_types::PaymentsGenericRequestWithResourceId {\n        global_payment_id: global_payment_id.clone(),\n        payload: json_payload.into_inner(),\n    };\n\n    let header_payload = match HeaderPayload::foreign_try_from(req.headers()) {\n        Ok(headers) => headers,\n        Err(err) => {\n            return api::log_and_return_error_response(err);\n        }\n    };\n\n    todo!()\n}",
+      "diff_span": {
+        "before": "    };\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        internal_payload,\n        |state, auth: auth::AuthenticationData, req, req_state| async {\n            let payment_id = req.global_payment_id;\n            let request = req.payload;\n\n            let merchant_context = domain::MerchantContext::NormalMerchant(Box::new(\n                domain::Context(auth.merchant_account, auth.key_store),\n            ));\n            Box::pin(\n                payment_method_balance::payments_check_gift_card_balance_core(\n                    state,\n                    merchant_context,\n                    auth.profile,\n                    req_state,\n                    request,\n                    header_payload.clone(),\n                    payment_id,\n                ),\n            )\n            .await\n        },\n        auth::api_or_client_auth(\n            &auth::V2ApiKeyAuth {\n                is_connected_allowed: false,\n                is_platform_allowed: false,\n            },\n            &auth::V2ClientAuth(common_utils::types::authentication::ResourceId::Payment(\n                global_payment_id,\n            )),\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+        "after": "    };\n\n    todo!()\n}"
+      },
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6",
+      "before_imports": [
+        "use hyperswitch_domain_models::payments::HeaderPayload;",
+        "use crate::core::payment_method_balance;",
+        "use router_env::{env, instrument, logger, tracing, types, Flow};",
+        "use crate::db::domain::merchant_context;",
+        "use actix_web::{web, Responder};"
+      ],
+      "after_imports": [
+        "use router_env::{env, instrument, logger, tracing, types, Flow};",
+        "use actix_web::{web, Responder};",
+        "use hyperswitch_domain_models::payments::HeaderPayload;"
+      ]
+    },
+    {
+      "id": "crates/router/src/routes/payments.rs::function::payments_apply_pm_data",
+      "file": "crates/router/src/routes/payments.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn payments_apply_pm_data(\n    state: web::Data<app::AppState>,\n    req: actix_web::HttpRequest,\n    json_payload: web::Json<api_models::payments::ApplyPaymentMethodDataRequest>,\n    path: web::Path<common_utils::id_type::GlobalPaymentId>,\n) -> impl Responder {\n    let flow = Flow::ApplyPaymentMethodData;\n\n    let global_payment_id = path.into_inner();\n    tracing::Span::current().record(\"payment_id\", global_payment_id.get_string_repr());\n\n    let internal_payload = internal_payload_types::PaymentsGenericRequestWithResourceId {\n        global_payment_id: global_payment_id.clone(),\n        payload: json_payload.into_inner(),\n    };\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        internal_payload,\n        |state, auth: auth::AuthenticationData, req, req_state| async {\n            let payment_id = req.global_payment_id;\n            let request = req.payload;\n\n            let merchant_context = domain::MerchantContext::NormalMerchant(Box::new(\n                domain::Context(auth.merchant_account, auth.key_store),\n            ));\n            Box::pin(payment_method_balance::payments_apply_pm_data_core(\n                state,\n                merchant_context,\n                req_state,\n                request,\n                payment_id,\n            ))\n            .await\n        },\n        auth::api_or_client_auth(\n            &auth::V2ApiKeyAuth {\n                is_connected_allowed: false,\n                is_platform_allowed: false,\n            },\n            &auth::V2ClientAuth(common_utils::types::authentication::ResourceId::Payment(\n                global_payment_id,\n            )),\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "after_code": "pub async fn payments_apply_pm_data(\n    state: web::Data<app::AppState>,\n    req: actix_web::HttpRequest,\n    json_payload: web::Json<api_models::payments::ApplyPaymentMethodDataRequest>,\n    path: web::Path<common_utils::id_type::GlobalPaymentId>,\n) -> impl Responder {\n    let flow = Flow::ApplyPaymentMethodData;\n\n    let global_payment_id = path.into_inner();\n    tracing::Span::current().record(\"payment_id\", global_payment_id.get_string_repr());\n\n    let internal_payload = internal_payload_types::PaymentsGenericRequestWithResourceId {\n        global_payment_id: global_payment_id.clone(),\n        payload: json_payload.into_inner(),\n    };\n\n    Box::pin(api::server_wrap(\n        flow,\n        state,\n        &req,\n        internal_payload,\n        |state, auth: auth::AuthenticationData, req, req_state| async {\n            let payment_id = req.global_payment_id;\n            let request = req.payload;\n\n            let merchant_context = domain::MerchantContext::NormalMerchant(Box::new(\n                domain::Context(auth.merchant_account, auth.key_store),\n            ));\n            Box::pin(\n                payment_method_balance::payments_check_and_apply_pm_data_core(\n                    state,\n                    merchant_context,\n                    auth.profile,\n                    req_state,\n                    request,\n                    payment_id,\n                ),\n            )\n            .await\n        },\n        auth::api_or_client_auth(\n            &auth::V2ApiKeyAuth {\n                is_connected_allowed: false,\n                is_platform_allowed: false,\n            },\n            &auth::V2ClientAuth(common_utils::types::authentication::ResourceId::Payment(\n                global_payment_id,\n            )),\n            req.headers(),\n        ),\n        api_locking::LockAction::NotApplicable,\n    ))\n    .await\n}",
+      "diff_span": {
+        "before": "                domain::Context(auth.merchant_account, auth.key_store),\n            ));\n            Box::pin(payment_method_balance::payments_apply_pm_data_core(\n                state,\n                merchant_context,\n                req_state,\n                request,\n                payment_id,\n            ))\n            .await\n        },",
+        "after": "                domain::Context(auth.merchant_account, auth.key_store),\n            ));\n            Box::pin(\n                payment_method_balance::payments_check_and_apply_pm_data_core(\n                    state,\n                    merchant_context,\n                    auth.profile,\n                    req_state,\n                    request,\n                    payment_id,\n                ),\n            )\n            .await\n        },"
+      },
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6"
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::fetch_payment_methods_balances_from_redis",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn fetch_payment_methods_balances_from_redis(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<HashMap<domain::PaymentMethodBalanceKey, domain::PaymentMethodBalance>> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned().ok_or(\n                errors::ApiErrorResponse::GenericNotFoundError {\n                    message: \"Balance not found for one or more payment methods\".to_string(),\n                },\n            )?;\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "after_code": "pub async fn fetch_payment_methods_balances_from_redis(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<HashMap<domain::PaymentMethodBalanceKey, domain::PaymentMethodBalance>> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned().ok_or(\n                errors::ApiErrorResponse::GenericNotFoundError {\n                    message: \"Balance not found for one or more payment methods\".to_string(),\n                },\n            )?;\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services,\n    services::logger,\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi, PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_check_gift_card_balance_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn payments_check_gift_card_balance_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: PaymentMethodBalanceCheckRequest,\n    _header_payload: HeaderPayload,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<PaymentMethodBalanceCheckResponse> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &(&state).into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        req.payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        &state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(&state, &profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = PaymentMethodBalanceCheckResponse {\n        payment_id: payment_intent.id.clone(),\n        balance,\n        currency,\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "after_code": "pub async fn payments_check_gift_card_balance_core(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    profile: &domain::Profile,\n    _req_state: &ReqState,\n    req: PaymentMethodBalanceCheckRequest,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<PaymentMethodBalanceCheckResponse> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        req.payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = PaymentMethodBalanceCheckResponse {\n        payment_id: payment_intent.id.clone(),\n        balance,\n        currency,\n    };\n\n    Ok(resp)\n}",
+      "diff_span": {
+        "before": "pub async fn payments_check_gift_card_balance_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: PaymentMethodBalanceCheckRequest,\n    _header_payload: HeaderPayload,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<PaymentMethodBalanceCheckResponse> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &(&state).into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        req.payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        &state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(&state, &profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = PaymentMethodBalanceCheckResponse {\n        payment_id: payment_intent.id.clone(),\n        balance,\n        currency,\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+        "after": "pub async fn payments_check_gift_card_balance_core(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    profile: &domain::Profile,\n    _req_state: &ReqState,\n    req: PaymentMethodBalanceCheckRequest,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<PaymentMethodBalanceCheckResponse> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        req.payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = PaymentMethodBalanceCheckResponse {\n        payment_id: payment_intent.id.clone(),\n        balance,\n        currency,\n    };\n\n    Ok(resp)\n}"
+      },
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services,\n    services::logger,\n    types::{api, domain},\n};",
+        "use common_enums::CallConnectorAction;"
+      ],
+      "after_imports": [
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};",
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi, PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use common_enums::CallConnectorAction;"
+      ]
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::ApplyPaymentMethodDataResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct ApplyPaymentMethodDataResponse {\n    pub remaining_amount: MinorUnit,\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n    pub requires_additional_pm_data: bool,\n    pub surcharge_details: Option<Vec<ApplyPaymentMethodDataSurchargeResponseItem>>,\n}",
+      "after_code": "pub struct ApplyPaymentMethodDataResponse {\n    pub balances: Vec<BalanceCheckResponseItem>,\n    pub remaining_amount: MinorUnit,\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n    pub requires_additional_pm_data: bool,\n    pub surcharge_details: Option<Vec<ApplyPaymentMethodDataSurchargeResponseItem>>,\n}",
+      "diff_span": {
+        "before": "",
+        "after": "pub struct ApplyPaymentMethodDataResponse {\n    pub balances: Vec<BalanceCheckResponseItem>,\n    pub remaining_amount: MinorUnit,\n    #[schema(value_type = Currency)]"
+      },
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6"
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::persist_individual_pm_balance_details_in_redis",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn persist_individual_pm_balance_details_in_redis<'a>(\n    state: &SessionState,\n    business_profile: &domain::Profile,\n    pm_balance_data: &domain::PaymentMethodBalanceData<'_>,\n) -> errors::RouterResult<()> {\n    if !pm_balance_data.is_empty() {\n        let redis_conn = state\n            .store\n            .get_redis_conn()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get redis connection\")?;\n        let redis_key = pm_balance_data.get_pm_balance_redis_key();\n\n        let value_list = pm_balance_data\n            .get_individual_pm_balance_key_value_pairs()\n            .into_iter()\n            .map(|(key, value)| {\n                value\n                    .encode_to_string_of_json()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to encode to string of json\")\n                    .map(|encoded_value| (key, encoded_value))\n            })\n            .collect::<Result<Vec<_>, _>>()?;\n\n        let intent_fulfillment_time = business_profile\n            .get_order_fulfillment_time()\n            .unwrap_or(consts::DEFAULT_FULFILLMENT_TIME);\n\n        redis_conn\n            .set_hash_fields(\n                &redis_key.as_str().into(),\n                value_list,\n                Some(intent_fulfillment_time),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to write to redis\")?;\n\n        logger::debug!(\"Surcharge results stored in redis with key = {}\", redis_key);\n    }\n    Ok(())\n}",
+      "after_code": "pub async fn persist_individual_pm_balance_details_in_redis<'a>(\n    state: &SessionState,\n    business_profile: &domain::Profile,\n    pm_balance_data: &domain::PaymentMethodBalanceData<'_>,\n) -> errors::RouterResult<()> {\n    if !pm_balance_data.is_empty() {\n        let redis_conn = state\n            .store\n            .get_redis_conn()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get redis connection\")?;\n        let redis_key = pm_balance_data.get_pm_balance_redis_key();\n\n        let value_list = pm_balance_data\n            .get_individual_pm_balance_key_value_pairs()\n            .into_iter()\n            .map(|(key, value)| {\n                value\n                    .encode_to_string_of_json()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to encode to string of json\")\n                    .map(|encoded_value| (key, encoded_value))\n            })\n            .collect::<Result<Vec<_>, _>>()?;\n\n        let intent_fulfillment_time = business_profile\n            .get_order_fulfillment_time()\n            .unwrap_or(consts::DEFAULT_FULFILLMENT_TIME);\n\n        redis_conn\n            .set_hash_fields(\n                &redis_key.as_str().into(),\n                value_list,\n                Some(intent_fulfillment_time),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to write to redis\")?;\n\n        logger::debug!(\"Surcharge results stored in redis with key = {}\", redis_key);\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services,\n    services::logger,\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi, PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::enum::PaymentMethodBalanceCheckEligibility",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "enum_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub enum PaymentMethodBalanceCheckEligibility {\n    Success(PaymentMethodBalanceApi),\n    Failure(String),\n}",
+      "diff_span": null,
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6"
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_check_and_apply_pm_data_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub async fn payments_check_and_apply_pm_data_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<ApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let balance_values: Vec<api_models::payments::BalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                        PaymentMethodBalanceApi {\n                            balance: balance.balance,\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        PaymentMethodBalanceCheckRequest {\n                            payment_method_data: pm.clone(),\n                        },\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok(balance) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                                PaymentMethodBalanceApi {\n                                    balance: balance.balance,\n                                    currency: balance.currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::BalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                balance_api,\n            ) = &value.eligibility\n            {\n                Some(balance_api.balance)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = ApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,\n        currency: payment_intent.amount_details.currency,\n        requires_additional_pm_data: remaining_amount.is_greater_than(0),\n        surcharge_details: None, // TODO: Implement surcharge recalculation logic\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "diff_span": null,
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::BalanceCheckResponseItem",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct BalanceCheckResponseItem {\n    pub payment_method_data: BalanceCheckPaymentMethodData,\n    pub eligibility: PaymentMethodBalanceCheckEligibility,\n}",
+      "diff_span": null,
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PaymentMethodBalanceApi",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PaymentMethodBalanceApi {\n    pub balance: MinorUnit,\n    pub currency: common_enums::Currency,\n}",
+      "diff_span": null,
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6"
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::fetch_payment_methods_balances_from_redis_fallible",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub async fn fetch_payment_methods_balances_from_redis_fallible(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<\n    HashMap<domain::PaymentMethodBalanceKey, Option<domain::PaymentMethodBalance>>,\n> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned();\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "diff_span": null,
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6"
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_apply_pm_data_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "pub async fn payments_apply_pm_data_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    _req_state: ReqState,\n    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<ApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let balances =\n        fetch_payment_methods_balances_from_redis(&state, &payment_intent.id, &req.payment_methods)\n            .await\n            .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let total_balance: MinorUnit = balances.values().map(|value| value.balance).sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = ApplyPaymentMethodDataResponse {\n        remaining_amount,\n        currency: payment_intent.amount_details.currency,\n        requires_additional_pm_data: remaining_amount.is_greater_than(0),\n        surcharge_details: None, // TODO: Implement surcharge recalculation logic\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "9ec1575300c0d3791ca4e00526dbff452e7d00f6"
+    }
+  ]
+}

diffs/pr_10197/d1426a6/diff.json

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

diffs/pr_10197/da4cfe5/diff.json

@@ -0,0 +1,173 @@
+{
+  "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5",
+  "pr_number": 10197,
+  "rust_files": [
+    "crates/api_models/src/payments.rs",
+    "crates/openapi/src/openapi_v2.rs",
+    "crates/router/src/core/payment_method_balance.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_check_and_apply_pm_data_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn payments_check_and_apply_pm_data_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<CheckAndApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let mut balance_values: Vec<api_models::payments::EligibilityBalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                        PMBalanceCheckSuccessResponse {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                                PMBalanceCheckSuccessResponse {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::EligibilityBalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        let balance_a = match &a.eligibility {\n            api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        let balance_b = match &b.eligibility {\n            api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        balance_a.cmp(&balance_b)\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n                &value.eligibility\n            {\n                Some(balance_api.applicable_amount)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = CheckAndApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,\n        currency: payment_intent.amount_details.currency,\n        requires_additional_pm_data: remaining_amount.is_greater_than(0),\n        surcharge_details: None, // TODO: Implement surcharge recalculation logic\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "after_code": "pub async fn payments_check_and_apply_pm_data_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<CheckAndApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let mut balance_values: Vec<api_models::payments::EligibilityBalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances\n                .get(&pm_balance_key)\n                .and_then(|inner| inner.as_ref())\n            {\n                Some(balance) => {\n                    api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                        PMBalanceCheckSuccessResponse {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                                PMBalanceCheckSuccessResponse {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(\n                                PMBalanceCheckFailureResponse {\n                                    error: err.to_string(),\n                                },\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::EligibilityBalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        a.eligibility\n            .get_balance()\n            .cmp(&b.eligibility.get_balance())\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_applicable_balance = running_total;\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount = (payment_intent.amount_details.order_amount - total_applicable_balance)\n        .max(MinorUnit::zero());\n\n    let resp = CheckAndApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,\n        currency: payment_intent.amount_details.currency,\n        requires_additional_pm_data: remaining_amount.is_greater_than(0),\n        surcharge_details: None, // TODO: Implement surcharge recalculation logic\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "diff_span": {
+        "before": "            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                        PMBalanceCheckSuccessResponse {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                                PMBalanceCheckSuccessResponse {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::EligibilityBalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        let balance_a = match &a.eligibility {\n            api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        let balance_b = match &b.eligibility {\n            api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        balance_a.cmp(&balance_b)\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n                &value.eligibility\n            {\n                Some(balance_api.applicable_amount)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = CheckAndApplyPaymentMethodDataResponse {",
+        "after": "            };\n\n            let eligibility = match payment_method_balances\n                .get(&pm_balance_key)\n                .and_then(|inner| inner.as_ref())\n            {\n                Some(balance) => {\n                    api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                        PMBalanceCheckSuccessResponse {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Success(\n                                PMBalanceCheckSuccessResponse {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PMBalanceCheckEligibilityResponse::Failure(\n                                PMBalanceCheckFailureResponse {\n                                    error: err.to_string(),\n                                },\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::EligibilityBalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        a.eligibility\n            .get_balance()\n            .cmp(&b.eligibility.get_balance())\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PMBalanceCheckEligibilityResponse::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_applicable_balance = running_total;\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount = (payment_intent.amount_details.order_amount - total_applicable_balance)\n        .max(MinorUnit::zero());\n\n    let resp = CheckAndApplyPaymentMethodDataResponse {"
+      },
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckFailureResponse, PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::fetch_payment_methods_balances_from_redis_fallible",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn fetch_payment_methods_balances_from_redis_fallible(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<\n    HashMap<domain::PaymentMethodBalanceKey, Option<domain::PaymentMethodBalance>>,\n> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned();\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "after_code": "pub async fn fetch_payment_methods_balances_from_redis_fallible(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<\n    HashMap<domain::PaymentMethodBalanceKey, Option<domain::PaymentMethodBalance>>,\n> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned();\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckFailureResponse, PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::enum::PMBalanceCheckEligibilityResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "enum_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub enum PMBalanceCheckEligibilityResponse {\n    Success(PMBalanceCheckSuccessResponse),\n    Failure(String),\n}",
+      "after_code": "pub enum PMBalanceCheckEligibilityResponse {\n    Success(PMBalanceCheckSuccessResponse),\n    Failure(PMBalanceCheckFailureResponse),\n}",
+      "diff_span": {
+        "before": "pub enum PMBalanceCheckEligibilityResponse {\n    Success(PMBalanceCheckSuccessResponse),\n    Failure(String),\n}",
+        "after": "pub enum PMBalanceCheckEligibilityResponse {\n    Success(PMBalanceCheckSuccessResponse),\n    Failure(PMBalanceCheckFailureResponse),\n}"
+      },
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5"
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::fetch_payment_methods_balances_from_redis",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn fetch_payment_methods_balances_from_redis(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<HashMap<domain::PaymentMethodBalanceKey, domain::PaymentMethodBalance>> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned().ok_or(\n                errors::ApiErrorResponse::GenericNotFoundError {\n                    message: \"Balance not found for one or more payment methods\".to_string(),\n                },\n            )?;\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "after_code": "pub async fn fetch_payment_methods_balances_from_redis(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<HashMap<domain::PaymentMethodBalanceKey, domain::PaymentMethodBalance>> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned().ok_or(\n                errors::ApiErrorResponse::GenericNotFoundError {\n                    message: \"Balance not found for one or more payment methods\".to_string(),\n                },\n            )?;\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckFailureResponse, PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_check_gift_card_balance_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn payments_check_gift_card_balance_core(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    profile: &domain::Profile,\n    _req_state: &ReqState,\n    payment_method_data: api_models::payments::BalanceCheckPaymentMethodData,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<(MinorUnit, common_enums::Currency)> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = (balance, currency);\n\n    Ok(resp)\n}",
+      "after_code": "pub async fn payments_check_gift_card_balance_core(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    profile: &domain::Profile,\n    _req_state: &ReqState,\n    payment_method_data: api_models::payments::BalanceCheckPaymentMethodData,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<(MinorUnit, common_enums::Currency)> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = (balance, currency);\n\n    Ok(resp)\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};",
+        "use common_enums::CallConnectorAction;"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckFailureResponse, PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};",
+        "use common_enums::CallConnectorAction;"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::persist_individual_pm_balance_details_in_redis",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn persist_individual_pm_balance_details_in_redis<'a>(\n    state: &SessionState,\n    business_profile: &domain::Profile,\n    pm_balance_data: &domain::PaymentMethodBalanceData<'_>,\n) -> errors::RouterResult<()> {\n    if !pm_balance_data.is_empty() {\n        let redis_conn = state\n            .store\n            .get_redis_conn()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get redis connection\")?;\n        let redis_key = pm_balance_data.get_pm_balance_redis_key();\n\n        let value_list = pm_balance_data\n            .get_individual_pm_balance_key_value_pairs()\n            .into_iter()\n            .map(|(key, value)| {\n                value\n                    .encode_to_string_of_json()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to encode to string of json\")\n                    .map(|encoded_value| (key, encoded_value))\n            })\n            .collect::<Result<Vec<_>, _>>()?;\n\n        let intent_fulfillment_time = business_profile\n            .get_order_fulfillment_time()\n            .unwrap_or(consts::DEFAULT_FULFILLMENT_TIME);\n\n        redis_conn\n            .set_hash_fields(\n                &redis_key.as_str().into(),\n                value_list,\n                Some(intent_fulfillment_time),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to write to redis\")?;\n\n        logger::debug!(\"Surcharge results stored in redis with key = {}\", redis_key);\n    }\n    Ok(())\n}",
+      "after_code": "pub async fn persist_individual_pm_balance_details_in_redis<'a>(\n    state: &SessionState,\n    business_profile: &domain::Profile,\n    pm_balance_data: &domain::PaymentMethodBalanceData<'_>,\n) -> errors::RouterResult<()> {\n    if !pm_balance_data.is_empty() {\n        let redis_conn = state\n            .store\n            .get_redis_conn()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get redis connection\")?;\n        let redis_key = pm_balance_data.get_pm_balance_redis_key();\n\n        let value_list = pm_balance_data\n            .get_individual_pm_balance_key_value_pairs()\n            .into_iter()\n            .map(|(key, value)| {\n                value\n                    .encode_to_string_of_json()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to encode to string of json\")\n                    .map(|encoded_value| (key, encoded_value))\n            })\n            .collect::<Result<Vec<_>, _>>()?;\n\n        let intent_fulfillment_time = business_profile\n            .get_order_fulfillment_time()\n            .unwrap_or(consts::DEFAULT_FULFILLMENT_TIME);\n\n        redis_conn\n            .set_hash_fields(\n                &redis_key.as_str().into(),\n                value_list,\n                Some(intent_fulfillment_time),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to write to redis\")?;\n\n        logger::debug!(\"Surcharge results stored in redis with key = {}\", redis_key);\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, CheckAndApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PMBalanceCheckFailureResponse, PMBalanceCheckSuccessResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PMBalanceCheckFailureResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct PMBalanceCheckFailureResponse {\n    pub error: String,\n}",
+      "diff_span": null,
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::impl::PMBalanceCheckEligibilityResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl PMBalanceCheckEligibilityResponse {\n    pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            PMBalanceCheckEligibilityResponse::Success(resp) => resp.balance,\n            PMBalanceCheckEligibilityResponse::Failure(_) => MinorUnit::zero(),\n        }\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::PMBalanceCheckEligibilityResponse::function::get_balance",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub fn get_balance(&self) -> MinorUnit {\n        match self {\n            PMBalanceCheckEligibilityResponse::Success(resp) => resp.balance,\n            PMBalanceCheckEligibilityResponse::Failure(_) => MinorUnit::zero(),\n        }\n    }",
+      "diff_span": null,
+      "commit_sha": "da4cfe5d71bf8a7bace807af35f9e531801b49e5"
+    }
+  ]
+}

diffs/pr_10197/e93005a/diff.json

@@ -0,0 +1,207 @@
+{
+  "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d",
+  "pr_number": 10197,
+  "rust_files": [
+    "crates/api_models/src/events/payment.rs",
+    "crates/api_models/src/payments.rs",
+    "crates/openapi/src/openapi_v2.rs",
+    "crates/openapi/src/routes/payments.rs",
+    "crates/router/src/core/payment_method_balance.rs",
+    "crates/router/src/routes/app.rs",
+    "crates/router/src/routes/payments.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_check_and_apply_pm_data_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn payments_check_and_apply_pm_data_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<ApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let balance_values: Vec<api_models::payments::BalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                        PaymentMethodBalanceApi {\n                            balance: balance.balance,\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        PaymentMethodBalanceCheckRequest {\n                            payment_method_data: pm.clone(),\n                        },\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok(balance) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                                PaymentMethodBalanceApi {\n                                    balance: balance.balance,\n                                    currency: balance.currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::BalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                balance_api,\n            ) = &value.eligibility\n            {\n                Some(balance_api.balance)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = ApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,\n        currency: payment_intent.amount_details.currency,\n        requires_additional_pm_data: remaining_amount.is_greater_than(0),\n        surcharge_details: None, // TODO: Implement surcharge recalculation logic\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "after_code": "pub async fn payments_check_and_apply_pm_data_core(\n    state: SessionState,\n    merchant_context: domain::MerchantContext,\n    profile: domain::Profile,\n    _req_state: ReqState,\n    req: ApplyPaymentMethodDataRequest,\n    payment_id: id_type::GlobalPaymentId,\n) -> RouterResponse<ApplyPaymentMethodDataResponse> {\n    let db = state.store.as_ref();\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    let payment_method_balances = fetch_payment_methods_balances_from_redis_fallible(\n        &state,\n        &payment_intent.id,\n        &req.payment_methods,\n    )\n    .await\n    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let mut balance_values: Vec<api_models::payments::BalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                        PaymentMethodBalanceApi {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                                PaymentMethodBalanceApi {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::BalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        let balance_a = match &a.eligibility {\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        let balance_b = match &b.eligibility {\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        balance_a.cmp(&balance_b)\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                balance_api,\n            ) = &value.eligibility\n            {\n                Some(balance_api.applicable_amount)\n            } else {\n                None\n            }\n        })\n        .sum();\n\n    // remaining_amount cannot be negative, hence using max with 0. This situation can arise when\n    // the gift card balance exceeds the order amount\n    let remaining_amount =\n        (payment_intent.amount_details.order_amount - total_balance).max(MinorUnit::zero());\n\n    let resp = ApplyPaymentMethodDataResponse {\n        balances: balance_values,\n        remaining_amount,\n        currency: payment_intent.amount_details.currency,\n        requires_additional_pm_data: remaining_amount.is_greater_than(0),\n        surcharge_details: None, // TODO: Implement surcharge recalculation logic\n    };\n\n    Ok(services::ApplicationResponse::Json(resp))\n}",
+      "diff_span": {
+        "before": "    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let balance_values: Vec<api_models::payments::BalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                        PaymentMethodBalanceApi {\n                            balance: balance.balance,\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        PaymentMethodBalanceCheckRequest {\n                            payment_method_data: pm.clone(),\n                        },\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok(balance) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                                PaymentMethodBalanceApi {\n                                    balance: balance.balance,\n                                    currency: balance.currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::BalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                balance_api,\n            ) = &value.eligibility\n            {\n                Some(balance_api.balance)\n            } else {\n                None",
+        "after": "    .attach_printable(\"Failed to retrieve payment method balances from redis\")?;\n\n    let mut balance_values: Vec<api_models::payments::BalanceCheckResponseItem> =\n        futures::future::join_all(req.payment_methods.into_iter().map(|pm| async {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n                pm.clone();\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n\n            let eligibility = match payment_method_balances.get(&pm_balance_key) {\n                Some(Some(balance)) => {\n                    api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                        PaymentMethodBalanceApi {\n                            balance: balance.balance,\n                            applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                            currency: balance.currency,\n                        },\n                    )\n                }\n                Some(None) | None => {\n                    match payments_check_gift_card_balance_core(\n                        &state,\n                        &merchant_context,\n                        &profile,\n                        &_req_state,\n                        pm.clone(),\n                        &payment_id,\n                    )\n                    .await\n                    {\n                        Ok((balance, currency)) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                                PaymentMethodBalanceApi {\n                                    balance,\n                                    applicable_amount: MinorUnit::zero(), // Will be calculated after sorting\n                                    currency,\n                                },\n                            )\n                        }\n                        Err(err) => {\n                            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(\n                                err.to_string(),\n                            )\n                        }\n                    }\n                }\n            };\n\n            Ok::<_, error_stack::Report<errors::ApiErrorResponse>>(\n                api_models::payments::BalanceCheckResponseItem {\n                    payment_method_data: pm,\n                    eligibility,\n                },\n            )\n        }))\n        .await\n        .into_iter()\n        .collect::<Result<Vec<_>, _>>()?;\n\n    // Sort balance_values by balance in ascending order (smallest first)\n    // This ensures smaller gift cards are fully utilized before larger ones\n    balance_values.sort_by(|a, b| {\n        let balance_a = match &a.eligibility {\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        let balance_b = match &b.eligibility {\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) => {\n                balance_api.balance\n            }\n            api_models::payments::PaymentMethodBalanceCheckEligibility::Failure(_) => {\n                MinorUnit::zero()\n            }\n        };\n        balance_a.cmp(&balance_b)\n    });\n\n    // Calculate applicable amounts with running total\n    let mut running_total = MinorUnit::zero();\n    let order_amount = payment_intent.amount_details.order_amount;\n    for balance_item in balance_values.iter_mut() {\n        if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(balance_api) =\n            &mut balance_item.eligibility\n        {\n            let remaining_amount = (order_amount - running_total).max(MinorUnit::zero());\n            balance_api.applicable_amount = std::cmp::min(balance_api.balance, remaining_amount);\n            running_total = running_total + balance_api.applicable_amount;\n        }\n    }\n\n    let total_balance: MinorUnit = balance_values\n        .iter()\n        .filter_map(|value| {\n            if let api_models::payments::PaymentMethodBalanceCheckEligibility::Success(\n                balance_api,\n            ) = &value.eligibility\n            {\n                Some(balance_api.applicable_amount)\n            } else {\n                None"
+      },
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi, PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PaymentMethodBalanceApi",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct PaymentMethodBalanceApi {\n    pub balance: MinorUnit,\n    pub currency: common_enums::Currency,\n}",
+      "after_code": "pub struct PaymentMethodBalanceApi {\n    pub balance: MinorUnit,\n    pub applicable_amount: MinorUnit,\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n}",
+      "diff_span": {
+        "before": "",
+        "after": "pub struct PaymentMethodBalanceApi {\n    pub balance: MinorUnit,\n    pub applicable_amount: MinorUnit,\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n}"
+      },
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d"
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::fetch_payment_methods_balances_from_redis_fallible",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn fetch_payment_methods_balances_from_redis_fallible(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<\n    HashMap<domain::PaymentMethodBalanceKey, Option<domain::PaymentMethodBalance>>,\n> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned();\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "after_code": "pub async fn fetch_payment_methods_balances_from_redis_fallible(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<\n    HashMap<domain::PaymentMethodBalanceKey, Option<domain::PaymentMethodBalance>>,\n> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned();\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi, PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::fetch_payment_methods_balances_from_redis",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn fetch_payment_methods_balances_from_redis(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<HashMap<domain::PaymentMethodBalanceKey, domain::PaymentMethodBalance>> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned().ok_or(\n                errors::ApiErrorResponse::GenericNotFoundError {\n                    message: \"Balance not found for one or more payment methods\".to_string(),\n                },\n            )?;\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "after_code": "pub async fn fetch_payment_methods_balances_from_redis(\n    state: &SessionState,\n    payment_intent_id: &id_type::GlobalPaymentId,\n    payment_methods: &[api_models::payments::BalanceCheckPaymentMethodData],\n) -> errors::RouterResult<HashMap<domain::PaymentMethodBalanceKey, domain::PaymentMethodBalance>> {\n    let redis_conn = state\n        .store\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to get redis connection\")?;\n\n    let balance_data = domain::PaymentMethodBalanceData::new(payment_intent_id);\n\n    let balance_values: HashMap<String, domain::PaymentMethodBalance> = redis_conn\n        .get_hash_fields::<Vec<(String, String)>>(&balance_data.get_pm_balance_redis_key().into())\n        .await\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed to read payment method balance data from redis\")?\n        .into_iter()\n        .map(|(key, value)| {\n            value\n                .parse_struct(\"PaymentMethodBalance\")\n                .change_context(errors::ApiErrorResponse::InternalServerError)\n                .attach_printable(\"Failed to parse PaymentMethodBalance\")\n                .map(|parsed| (key, parsed))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()?;\n\n    payment_methods\n        .iter()\n        .map(|pm| {\n            let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) = pm;\n            let pm_balance_key = domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key: domain::GiftCardData::from(gift_card_data.clone())\n                    .get_payment_method_key()\n                    .change_context(errors::ApiErrorResponse::InvalidRequestData {\n                        message: \"Unable to get unique key for payment method\".to_string(),\n                    })?\n                    .expose(),\n            };\n            let redis_key = pm_balance_key.get_redis_key();\n            let balance_value = balance_values.get(&redis_key).cloned().ok_or(\n                errors::ApiErrorResponse::GenericNotFoundError {\n                    message: \"Balance not found for one or more payment methods\".to_string(),\n                },\n            )?;\n            Ok((pm_balance_key, balance_value))\n        })\n        .collect::<errors::RouterResult<HashMap<_, _>>>()\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi, PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::payments_check_gift_card_balance_core",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub async fn payments_check_gift_card_balance_core(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    profile: &domain::Profile,\n    _req_state: &ReqState,\n    req: PaymentMethodBalanceCheckRequest,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<PaymentMethodBalanceCheckResponse> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        req.payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = PaymentMethodBalanceCheckResponse {\n        payment_id: payment_intent.id.clone(),\n        balance,\n        currency,\n    };\n\n    Ok(resp)\n}",
+      "after_code": "pub async fn payments_check_gift_card_balance_core(\n    state: &SessionState,\n    merchant_context: &domain::MerchantContext,\n    profile: &domain::Profile,\n    _req_state: &ReqState,\n    payment_method_data: api_models::payments::BalanceCheckPaymentMethodData,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<(MinorUnit, common_enums::Currency)> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = (balance, currency);\n\n    Ok(resp)\n}",
+      "diff_span": {
+        "before": "    profile: &domain::Profile,\n    _req_state: &ReqState,\n    req: PaymentMethodBalanceCheckRequest,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<PaymentMethodBalanceCheckResponse> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        req.payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = PaymentMethodBalanceCheckResponse {\n        payment_id: payment_intent.id.clone(),\n        balance,\n        currency,\n    };\n\n    Ok(resp)",
+        "after": "    profile: &domain::Profile,\n    _req_state: &ReqState,\n    payment_method_data: api_models::payments::BalanceCheckPaymentMethodData,\n    payment_id: &id_type::GlobalPaymentId,\n) -> errors::RouterResult<(MinorUnit, common_enums::Currency)> {\n    let db = state.store.as_ref();\n\n    let key_manager_state = &state.into();\n\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    let redis_conn = db\n        .get_redis_conn()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Could not get redis connection\")?;\n\n    let gift_card_connector_id: String = redis_conn\n        .get_key(&payment_id.get_gift_card_connector_key().as_str().into())\n        .await\n        .attach_printable(\"Failed to fetch gift card connector from redis\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\n\n    let gift_card_connector_id = id_type::MerchantConnectorAccountId::wrap(gift_card_connector_id)\n        .attach_printable(\"Failed to deserialize MCA\")\n        .change_context(errors::ApiErrorResponse::GenericNotFoundError {\n            message: \"No connector found with Gift Card Support\".to_string(),\n        })?;\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                Some(&gift_card_connector_id),\n            )\n            .await\n            .attach_printable(\n                \"failed to fetch merchant connector account for gift card balance check\",\n            )?,\n        ));\n\n    let connector_name = merchant_connector_account\n        .get_connector_name()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Connector name not present for gift card balance check\")?; // always get the connector name from this call\n\n    let connector_data = api::ConnectorData::get_connector_by_name(\n        &state.conf.connectors,\n        &connector_name.to_string(),\n        api::GetToken::Connector,\n        merchant_connector_account.get_mca_id(),\n    )\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed to get the connector data\")?;\n\n    let connector_auth_type = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)?;\n\n    let resource_common_data = GiftCardBalanceCheckFlowData;\n\n    let api_models::payments::BalanceCheckPaymentMethodData::GiftCard(gift_card_data) =\n        payment_method_data;\n\n    let router_data: RouterDataV2<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckFlowData,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = RouterDataV2 {\n        flow: PhantomData,\n        resource_common_data,\n        tenant_id: state.tenant.tenant_id.clone(),\n        connector_auth_type,\n        request: GiftCardBalanceCheckRequestData {\n            payment_method_data: domain::PaymentMethodData::GiftCard(Box::new(\n                gift_card_data.clone().into(),\n            )),\n            currency: Some(payment_intent.amount_details.currency),\n            minor_amount: Some(payment_intent.amount_details.order_amount),\n        },\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n    };\n\n    let old_router_data = GiftCardBalanceCheckFlowData::to_old_router_data(router_data)\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\n            \"Cannot construct router data for making the gift card balance check api call\",\n        )?;\n    let connector_integration: services::BoxedGiftCardBalanceCheckIntegrationInterface<\n        GiftCardBalanceCheck,\n        GiftCardBalanceCheckRequestData,\n        GiftCardBalanceCheckResponseData,\n    > = connector_data.connector.get_connector_integration();\n\n    let connector_response = services::execute_connector_processing_step(\n        state,\n        connector_integration,\n        &old_router_data,\n        CallConnectorAction::Trigger,\n        None,\n        None,\n    )\n    .await\n    .change_context(errors::ApiErrorResponse::InternalServerError)\n    .attach_printable(\"Failed while calling gift card balance check connector api\")?;\n\n    let gift_card_balance = connector_response\n        .response\n        .map_err(|_| errors::ApiErrorResponse::UnprocessableEntity {\n            message: \"Error while fetching gift card balance\".to_string(),\n        })\n        .attach_printable(\"Connector returned invalid response\")?;\n\n    let balance = gift_card_balance.balance;\n    let currency = gift_card_balance.currency;\n\n    let payment_method_key = domain::GiftCardData::from(gift_card_data.clone())\n        .get_payment_method_key()\n        .change_context(errors::ApiErrorResponse::InvalidRequestData {\n            message: \"Unable to get unique key for payment method\".to_string(),\n        })?\n        .expose();\n\n    let balance_data = domain::PaymentMethodBalanceData {\n        payment_intent_id: &payment_intent.id,\n        pm_balance_data: vec![(\n            domain::PaymentMethodBalanceKey {\n                payment_method_type: common_enums::PaymentMethod::GiftCard,\n                payment_method_subtype: gift_card_data.get_payment_method_type(),\n                payment_method_key,\n            },\n            domain::PaymentMethodBalance { balance, currency },\n        )]\n        .into_iter()\n        .collect(),\n    };\n\n    persist_individual_pm_balance_details_in_redis(state, profile, &balance_data)\n        .await\n        .attach_printable(\"Failed to persist gift card balance details in redis\")?;\n\n    let resp = (balance, currency);\n\n    Ok(resp)"
+      },
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d",
+      "before_imports": [
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};",
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi, PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use common_enums::CallConnectorAction;"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};",
+        "use common_enums::CallConnectorAction;"
+      ]
+    },
+    {
+      "id": "crates/router/src/core/payment_method_balance.rs::function::persist_individual_pm_balance_details_in_redis",
+      "file": "crates/router/src/core/payment_method_balance.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": false,
+      "imports_changed": true,
+      "before_code": "pub async fn persist_individual_pm_balance_details_in_redis<'a>(\n    state: &SessionState,\n    business_profile: &domain::Profile,\n    pm_balance_data: &domain::PaymentMethodBalanceData<'_>,\n) -> errors::RouterResult<()> {\n    if !pm_balance_data.is_empty() {\n        let redis_conn = state\n            .store\n            .get_redis_conn()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get redis connection\")?;\n        let redis_key = pm_balance_data.get_pm_balance_redis_key();\n\n        let value_list = pm_balance_data\n            .get_individual_pm_balance_key_value_pairs()\n            .into_iter()\n            .map(|(key, value)| {\n                value\n                    .encode_to_string_of_json()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to encode to string of json\")\n                    .map(|encoded_value| (key, encoded_value))\n            })\n            .collect::<Result<Vec<_>, _>>()?;\n\n        let intent_fulfillment_time = business_profile\n            .get_order_fulfillment_time()\n            .unwrap_or(consts::DEFAULT_FULFILLMENT_TIME);\n\n        redis_conn\n            .set_hash_fields(\n                &redis_key.as_str().into(),\n                value_list,\n                Some(intent_fulfillment_time),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to write to redis\")?;\n\n        logger::debug!(\"Surcharge results stored in redis with key = {}\", redis_key);\n    }\n    Ok(())\n}",
+      "after_code": "pub async fn persist_individual_pm_balance_details_in_redis<'a>(\n    state: &SessionState,\n    business_profile: &domain::Profile,\n    pm_balance_data: &domain::PaymentMethodBalanceData<'_>,\n) -> errors::RouterResult<()> {\n    if !pm_balance_data.is_empty() {\n        let redis_conn = state\n            .store\n            .get_redis_conn()\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to get redis connection\")?;\n        let redis_key = pm_balance_data.get_pm_balance_redis_key();\n\n        let value_list = pm_balance_data\n            .get_individual_pm_balance_key_value_pairs()\n            .into_iter()\n            .map(|(key, value)| {\n                value\n                    .encode_to_string_of_json()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to encode to string of json\")\n                    .map(|encoded_value| (key, encoded_value))\n            })\n            .collect::<Result<Vec<_>, _>>()?;\n\n        let intent_fulfillment_time = business_profile\n            .get_order_fulfillment_time()\n            .unwrap_or(consts::DEFAULT_FULFILLMENT_TIME);\n\n        redis_conn\n            .set_hash_fields(\n                &redis_key.as_str().into(),\n                value_list,\n                Some(intent_fulfillment_time),\n            )\n            .await\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable(\"Failed to write to redis\")?;\n\n        logger::debug!(\"Surcharge results stored in redis with key = {}\", redis_key);\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "",
+        "after": ""
+      },
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d",
+      "before_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi, PaymentMethodBalanceCheckRequest, PaymentMethodBalanceCheckResponse,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ],
+      "after_imports": [
+        "use api_models::payments::{\n    ApplyPaymentMethodDataRequest, ApplyPaymentMethodDataResponse, GetPaymentMethodType,\n    PaymentMethodBalanceApi,\n};",
+        "use crate::{\n    consts,\n    core::{\n        errors::{self, RouterResponse},\n        payments::helpers,\n    },\n    db::errors::StorageErrorExt,\n    routes::{app::ReqState, SessionState},\n    services::{self, logger},\n    types::{api, domain},\n};"
+      ]
+    },
+    {
+      "id": "crates/router/src/routes/payments.rs::function::payment_check_gift_card_balance",
+      "file": "crates/router/src/routes/payments.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "pub async fn payment_check_gift_card_balance(\n    state: web::Data<app::AppState>,\n    req: actix_web::HttpRequest,\n    json_payload: web::Json<api_models::payments::PaymentMethodBalanceCheckRequest>,\n    path: web::Path<common_utils::id_type::GlobalPaymentId>,\n) -> impl Responder {\n    let flow = Flow::PaymentMethodBalanceCheck;\n\n    let global_payment_id = path.into_inner();\n    tracing::Span::current().record(\"payment_id\", global_payment_id.get_string_repr());\n\n    let internal_payload = internal_payload_types::PaymentsGenericRequestWithResourceId {\n        global_payment_id: global_payment_id.clone(),\n        payload: json_payload.into_inner(),\n    };\n\n    let header_payload = match HeaderPayload::foreign_try_from(req.headers()) {\n        Ok(headers) => headers,\n        Err(err) => {\n            return api::log_and_return_error_response(err);\n        }\n    };\n\n    todo!()\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PaymentMethodBalanceCheckRequest",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "removed",
+      "before_code": "pub struct PaymentMethodBalanceCheckRequest {\n    /// The payment method data to be used for the balance check request. It can\n    /// only be a payment method that supports checking balance e.g. gift card\n    pub payment_method_data: BalanceCheckPaymentMethodData,\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d"
+    },
+    {
+      "id": "crates/api_models/src/events/payment.rs::payments::PaymentMethodBalanceCheckResponse::function::get_api_event_type",
+      "file": "crates/api_models/src/events/payment.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn get_api_event_type(&self) -> Option<ApiEventsType> {\n        None\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d"
+    },
+    {
+      "id": "crates/api_models/src/events/payment.rs::impl::payments::PaymentMethodBalanceCheckResponse",
+      "file": "crates/api_models/src/events/payment.rs",
+      "kind": "impl_item",
+      "status": "removed",
+      "before_code": "impl ApiEventMetric for payments::PaymentMethodBalanceCheckResponse {\n    fn get_api_event_type(&self) -> Option<ApiEventsType> {\n        None\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d"
+    },
+    {
+      "id": "crates/openapi/src/routes/payments.rs::function::payment_check_gift_card_balance",
+      "file": "crates/openapi/src/routes/payments.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "pub fn payment_check_gift_card_balance() {}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d"
+    },
+    {
+      "id": "crates/api_models/src/payments.rs::struct::PaymentMethodBalanceCheckResponse",
+      "file": "crates/api_models/src/payments.rs",
+      "kind": "struct_item",
+      "status": "removed",
+      "before_code": "pub struct PaymentMethodBalanceCheckResponse {\n    /// Global Payment Id for the payment\n    #[schema(value_type = String)]\n    pub payment_id: id_type::GlobalPaymentId,\n    /// The balance of the payment method\n    pub balance: MinorUnit,\n    /// The currency of the payment method\n    #[schema(value_type = Currency)]\n    pub currency: common_enums::Currency,\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "e93005ab880a5adfa72c56fc02b58afcaebf875d"
+    }
+  ]
+}

diffs/pr_10277/fa6a2d2/diff.json

@@ -0,0 +1,137 @@
+{
+  "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215",
+  "pr_number": 10277,
+  "rust_files": [
+    "crates/common_enums/src/connector_enums.rs",
+    "crates/hyperswitch_connectors/src/connectors/zift.rs",
+    "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+    "crates/router/src/core/payments/types.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift.rs::static::ZIFT_SUPPORTED_PAYMENT_METHODS",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift.rs",
+      "kind": "static_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "static ZIFT_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> = LazyLock::new(|| {\n    let supported_capture_methods = vec![\n        common_enums::CaptureMethod::Automatic,\n        common_enums::CaptureMethod::Manual,\n        common_enums::CaptureMethod::SequentialAutomatic,\n    ];\n\n    let supported_card_network = vec![\n        common_enums::CardNetwork::AmericanExpress,\n        common_enums::CardNetwork::DinersClub,\n        common_enums::CardNetwork::JCB,\n        common_enums::CardNetwork::Mastercard,\n        common_enums::CardNetwork::Visa,\n        common_enums::CardNetwork::Discover,\n    ];\n\n    let mut zift_supported_payment_methods = SupportedPaymentMethods::new();\n\n    zift_supported_payment_methods.add(\n        common_enums::PaymentMethod::Card,\n        common_enums::PaymentMethodType::Credit,\n        PaymentMethodDetails {\n            mandates: common_enums::FeatureStatus::Supported,\n            refunds: common_enums::FeatureStatus::Supported,\n            supported_capture_methods: supported_capture_methods.clone(),\n            specific_features: Some(\n                api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({\n                    api_models::feature_matrix::CardSpecificFeatures {\n                        three_ds: common_enums::FeatureStatus::NotSupported,\n                        no_three_ds: common_enums::FeatureStatus::Supported,\n                        supported_card_networks: supported_card_network.clone(),\n                    }\n                }),\n            ),\n        },\n    );\n\n    zift_supported_payment_methods.add(\n        common_enums::PaymentMethod::Card,\n        common_enums::PaymentMethodType::Debit,\n        PaymentMethodDetails {\n            mandates: common_enums::FeatureStatus::Supported,\n            refunds: common_enums::FeatureStatus::Supported,\n            supported_capture_methods: supported_capture_methods.clone(),\n            specific_features: Some(\n                api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({\n                    api_models::feature_matrix::CardSpecificFeatures {\n                        three_ds: common_enums::FeatureStatus::NotSupported,\n                        no_three_ds: common_enums::FeatureStatus::Supported,\n                        supported_card_networks: supported_card_network.clone(),\n                    }\n                }),\n            ),\n        },\n    );\n\n    zift_supported_payment_methods\n});",
+      "after_code": "static ZIFT_SUPPORTED_PAYMENT_METHODS: LazyLock<SupportedPaymentMethods> = LazyLock::new(|| {\n    let supported_capture_methods = vec![\n        common_enums::CaptureMethod::Automatic,\n        common_enums::CaptureMethod::Manual,\n        common_enums::CaptureMethod::SequentialAutomatic,\n    ];\n\n    let supported_card_network = vec![\n        common_enums::CardNetwork::AmericanExpress,\n        common_enums::CardNetwork::DinersClub,\n        common_enums::CardNetwork::JCB,\n        common_enums::CardNetwork::Mastercard,\n        common_enums::CardNetwork::Visa,\n        common_enums::CardNetwork::Discover,\n    ];\n\n    let mut zift_supported_payment_methods = SupportedPaymentMethods::new();\n\n    zift_supported_payment_methods.add(\n        common_enums::PaymentMethod::Card,\n        common_enums::PaymentMethodType::Credit,\n        PaymentMethodDetails {\n            mandates: common_enums::FeatureStatus::Supported,\n            refunds: common_enums::FeatureStatus::Supported,\n            supported_capture_methods: supported_capture_methods.clone(),\n            specific_features: Some(\n                api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({\n                    api_models::feature_matrix::CardSpecificFeatures {\n                        three_ds: common_enums::FeatureStatus::Supported,\n                        no_three_ds: common_enums::FeatureStatus::Supported,\n                        supported_card_networks: supported_card_network.clone(),\n                    }\n                }),\n            ),\n        },\n    );\n\n    zift_supported_payment_methods.add(\n        common_enums::PaymentMethod::Card,\n        common_enums::PaymentMethodType::Debit,\n        PaymentMethodDetails {\n            mandates: common_enums::FeatureStatus::Supported,\n            refunds: common_enums::FeatureStatus::Supported,\n            supported_capture_methods: supported_capture_methods.clone(),\n            specific_features: Some(\n                api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({\n                    api_models::feature_matrix::CardSpecificFeatures {\n                        three_ds: common_enums::FeatureStatus::NotSupported,\n                        no_three_ds: common_enums::FeatureStatus::Supported,\n                        supported_card_networks: supported_card_network.clone(),\n                    }\n                }),\n            ),\n        },\n    );\n\n    zift_supported_payment_methods\n});",
+      "diff_span": {
+        "before": "                api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({\n                    api_models::feature_matrix::CardSpecificFeatures {\n                        three_ds: common_enums::FeatureStatus::NotSupported,\n                        no_three_ds: common_enums::FeatureStatus::Supported,\n                        supported_card_networks: supported_card_network.clone(),",
+        "after": "                api_models::feature_matrix::PaymentMethodSpecificFeatures::Card({\n                    api_models::feature_matrix::CardSpecificFeatures {\n                        three_ds: common_enums::FeatureStatus::Supported,\n                        no_three_ds: common_enums::FeatureStatus::Supported,\n                        supported_card_networks: supported_card_network.clone(),"
+      },
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs::enum::ZiftPaymentsRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+      "kind": "enum_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub enum ZiftPaymentsRequest {\n    Card(ZiftCardPaymentRequest),\n    Mandate(ZiftMandatePaymentRequest),\n}",
+      "after_code": "pub enum ZiftPaymentsRequest {\n    Card(ZiftCardPaymentRequest),\n    Mandate(ZiftMandatePaymentRequest),\n    ExternalThreeDs(ZiftExternalThreeDsPaymentRequest),\n}",
+      "diff_span": {
+        "before": "",
+        "after": "    Card(ZiftCardPaymentRequest),\n    Mandate(ZiftMandatePaymentRequest),\n    ExternalThreeDs(ZiftExternalThreeDsPaymentRequest),\n}"
+      },
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs::ZiftPaymentsRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: &ZiftRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {\n        if item.router_data.is_three_ds() {\n            return Err(\n                errors::ConnectorError::NotImplemented(\"3DS Authentication\".to_string()).into(),\n            );\n        }\n        let auth = ZiftAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let request_type = if item.router_data.request.is_auto_capture()? {\n            RequestType::Sale\n        } else {\n            RequestType::Auth\n        };\n        match item.router_data.request.payment_method_data.clone() {\n            PaymentMethodData::Card(card) => {\n                let card_request = ZiftCardPaymentRequest {\n                    request_type,\n                    auth,\n                    account_number: card.card_number.clone(),\n                    account_accessory: card.get_expiry_date_as_mmyy()?,\n                    transaction_industry_type: TransactionIndustryType::CardPresent,\n                    holder_name: item.router_data.get_billing_full_name()?,\n                    amount: item.amount.to_owned(),\n                    account_type: AccountType::PaymentCard,\n                    holder_type: HolderType::Personal,\n                    csc: card.card_cvc,\n                    street: item.router_data.get_optional_billing_line1(),\n                    city: item.router_data.get_optional_billing_city(),\n                    state: item.router_data.get_optional_billing_state(),\n                    zip_code: item.router_data.get_optional_billing_zip(),\n                    country_code: item.router_data.get_optional_billing_country(),\n                    email: item.router_data.get_optional_billing_email(),\n                    phone: item.router_data.get_optional_billing_phone_number(),\n                };\n                Ok(Self::Card(card_request))\n            }\n            PaymentMethodData::MandatePayment => {\n                let additional_card_details = match item\n                    .router_data\n                    .request\n                    .additional_payment_method_data\n                    .clone()\n                    .ok_or(errors::ConnectorError::MissingRequiredField {\n                        field_name: \"additional_payment_method_data\",\n                    })? {\n                    AdditionalPaymentData::Card(card) => *card,\n                    _ => Err(errors::ConnectorError::NotSupported {\n                        message: \"Payment Method Not Supported\".to_string(),\n                        connector: \"DataTrans\",\n                    })?,\n                };\n                let mandate_request = ZiftMandatePaymentRequest {\n                    request_type,\n                    auth,\n                    account_type: AccountType::PaymentCard,\n                    token: Secret::new(item.router_data.request.connector_mandate_id().ok_or(\n                        errors::ConnectorError::MissingRequiredField {\n                            field_name: \"connector_mandate_id\",\n                        },\n                    )?),\n                    account_accessory: additional_card_details.get_expiry_date_as_mmyy()?,\n                    transaction_industry_type: TransactionIndustryType::CardNotPresent,\n                    holder_name: additional_card_details.get_card_holder_name()?,\n                    holder_type: HolderType::Personal,\n                    amount: item.amount.to_owned(),\n                    transaction_mode_type: TransactionModeType::CardNotPresent,\n                    transaction_category_type: TransactionCategoryType::Recurring,\n                    sequence_number: 2, // Its required for MIT\n                    street: item.router_data.get_optional_billing_line1(),\n                    city: item.router_data.get_optional_billing_city(),\n                    state: item.router_data.get_optional_billing_state(),\n                    zip_code: item.router_data.get_optional_billing_zip(),\n                    country_code: item.router_data.get_optional_billing_country(),\n                    email: item.router_data.get_optional_billing_email(),\n                    phone: item.router_data.get_optional_billing_phone_number(),\n                };\n                Ok(Self::Mandate(mandate_request))\n            }\n            _ => Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into()),\n        }\n    }",
+      "after_code": "fn try_from(item: &ZiftRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {\n        let auth = ZiftAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let request_type = if item.router_data.request.is_auto_capture()? {\n            RequestType::Sale\n        } else {\n            RequestType::Auth\n        };\n        match item.router_data.request.payment_method_data.clone() {\n            PaymentMethodData::Card(card) => {\n                // Check if this is an external 3DS payment - both is_three_ds() and authentication_data must be present\n                if item.router_data.is_three_ds()\n                    && item.router_data.request.authentication_data.is_some()\n                {\n                    // Handle external 3DS authentication\n                    let auth_data = item\n                        .router_data\n                        .request\n                        .authentication_data\n                        .as_ref()\n                        .ok_or(errors::ConnectorError::MissingRequiredField {\n                            field_name: \"authentication_data\",\n                        })?;\n\n                    let authentication_status = AuthenticationStatus::try_from(auth_data)?;\n\n                    let external_3ds_request = ZiftExternalThreeDsPaymentRequest {\n                        request_type,\n                        auth,\n                        account_number: card.card_number.clone(),\n                        account_accessory: card.get_expiry_date_as_mmyy()?,\n                        transaction_industry_type: TransactionIndustryType::CardNotPresent,\n                        holder_name: item.router_data.get_billing_full_name()?,\n                        amount: item.amount.to_owned(),\n                        account_type: AccountType::PaymentCard,\n                        holder_type: HolderType::Personal,\n                        authentication_status,\n                        authentication_code: auth_data.ds_trans_id.clone().map(Secret::new),\n                        authentication_verification_value: auth_data.cavv.clone(),\n                        authentication_version: auth_data\n                            .message_version\n                            .as_ref()\n                            .map(|v| Secret::new(v.to_string())),\n                        street: item.router_data.get_optional_billing_line1(),\n                        city: item.router_data.get_optional_billing_city(),\n                        state: item.router_data.get_optional_billing_state(),\n                        zip_code: item.router_data.get_optional_billing_zip(),\n                        country_code: item.router_data.get_optional_billing_country(),\n                        email: item.router_data.get_optional_billing_email(),\n                        phone: item.router_data.get_optional_billing_phone_number(),\n                    };\n                    Ok(Self::ExternalThreeDs(external_3ds_request))\n                } else {\n                    let card_request = ZiftCardPaymentRequest {\n                        request_type,\n                        auth,\n                        account_number: card.card_number.clone(),\n                        account_accessory: card.get_expiry_date_as_mmyy()?,\n                        transaction_industry_type: TransactionIndustryType::CardPresent,\n                        holder_name: item.router_data.get_billing_full_name()?,\n                        amount: item.amount.to_owned(),\n                        account_type: AccountType::PaymentCard,\n                        holder_type: HolderType::Personal,\n                        csc: card.card_cvc,\n                        street: item.router_data.get_optional_billing_line1(),\n                        city: item.router_data.get_optional_billing_city(),\n                        state: item.router_data.get_optional_billing_state(),\n                        zip_code: item.router_data.get_optional_billing_zip(),\n                        country_code: item.router_data.get_optional_billing_country(),\n                        email: item.router_data.get_optional_billing_email(),\n                        phone: item.router_data.get_optional_billing_phone_number(),\n                    };\n                    Ok(Self::Card(card_request))\n                }\n            }\n            PaymentMethodData::MandatePayment => {\n                let additional_card_details = match item\n                    .router_data\n                    .request\n                    .additional_payment_method_data\n                    .clone()\n                    .ok_or(errors::ConnectorError::MissingRequiredField {\n                        field_name: \"additional_payment_method_data\",\n                    })? {\n                    AdditionalPaymentData::Card(card) => *card,\n                    _ => Err(errors::ConnectorError::NotSupported {\n                        message: \"Payment Method Not Supported\".to_string(),\n                        connector: \"DataTrans\",\n                    })?,\n                };\n                let mandate_request = ZiftMandatePaymentRequest {\n                    request_type,\n                    auth,\n                    account_type: AccountType::PaymentCard,\n                    token: Secret::new(item.router_data.request.connector_mandate_id().ok_or(\n                        errors::ConnectorError::MissingRequiredField {\n                            field_name: \"connector_mandate_id\",\n                        },\n                    )?),\n                    account_accessory: additional_card_details.get_expiry_date_as_mmyy()?,\n                    transaction_industry_type: TransactionIndustryType::CardNotPresent,\n                    holder_name: additional_card_details.get_card_holder_name()?,\n                    holder_type: HolderType::Personal,\n                    amount: item.amount.to_owned(),\n                    transaction_mode_type: TransactionModeType::CardNotPresent,\n                    transaction_category_type: TransactionCategoryType::Recurring,\n                    sequence_number: 2, // Its required for MIT\n                    street: item.router_data.get_optional_billing_line1(),\n                    city: item.router_data.get_optional_billing_city(),\n                    state: item.router_data.get_optional_billing_state(),\n                    zip_code: item.router_data.get_optional_billing_zip(),\n                    country_code: item.router_data.get_optional_billing_country(),\n                    email: item.router_data.get_optional_billing_email(),\n                    phone: item.router_data.get_optional_billing_phone_number(),\n                };\n                Ok(Self::Mandate(mandate_request))\n            }\n            _ => Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into()),\n        }\n    }",
+      "diff_span": {
+        "before": "fn try_from(item: &ZiftRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {\n        if item.router_data.is_three_ds() {\n            return Err(\n                errors::ConnectorError::NotImplemented(\"3DS Authentication\".to_string()).into(),\n            );\n        }\n        let auth = ZiftAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let request_type = if item.router_data.request.is_auto_capture()? {\n            RequestType::Sale\n        } else {\n            RequestType::Auth\n        };\n        match item.router_data.request.payment_method_data.clone() {\n            PaymentMethodData::Card(card) => {\n                let card_request = ZiftCardPaymentRequest {\n                    request_type,\n                    auth,\n                    account_number: card.card_number.clone(),\n                    account_accessory: card.get_expiry_date_as_mmyy()?,\n                    transaction_industry_type: TransactionIndustryType::CardPresent,\n                    holder_name: item.router_data.get_billing_full_name()?,\n                    amount: item.amount.to_owned(),\n                    account_type: AccountType::PaymentCard,\n                    holder_type: HolderType::Personal,\n                    csc: card.card_cvc,\n                    street: item.router_data.get_optional_billing_line1(),\n                    city: item.router_data.get_optional_billing_city(),\n                    state: item.router_data.get_optional_billing_state(),\n                    zip_code: item.router_data.get_optional_billing_zip(),\n                    country_code: item.router_data.get_optional_billing_country(),\n                    email: item.router_data.get_optional_billing_email(),\n                    phone: item.router_data.get_optional_billing_phone_number(),\n                };\n                Ok(Self::Card(card_request))\n            }\n            PaymentMethodData::MandatePayment => {",
+        "after": "        match item.router_data.request.payment_method_data.clone() {\n            PaymentMethodData::Card(card) => {\n                // Check if this is an external 3DS payment - both is_three_ds() and authentication_data must be present\n                if item.router_data.is_three_ds()\n                    && item.router_data.request.authentication_data.is_some()\n                {\n                    // Handle external 3DS authentication\n                    let auth_data = item\n                        .router_data\n                        .request\n                        .authentication_data\n                        .as_ref()\n                        .ok_or(errors::ConnectorError::MissingRequiredField {\n                            field_name: \"authentication_data\",\n                        })?;\n\n                    let authentication_status = AuthenticationStatus::try_from(auth_data)?;\n\n                    let external_3ds_request = ZiftExternalThreeDsPaymentRequest {\n                        request_type,\n                        auth,\n                        account_number: card.card_number.clone(),\n                        account_accessory: card.get_expiry_date_as_mmyy()?,\n                        transaction_industry_type: TransactionIndustryType::CardNotPresent,\n                        holder_name: item.router_data.get_billing_full_name()?,\n                        amount: item.amount.to_owned(),\n                        account_type: AccountType::PaymentCard,\n                        holder_type: HolderType::Personal,\n                        authentication_status,\n                        authentication_code: auth_data.ds_trans_id.clone().map(Secret::new),\n                        authentication_verification_value: auth_data.cavv.clone(),\n                        authentication_version: auth_data\n                            .message_version\n                            .as_ref()\n                            .map(|v| Secret::new(v.to_string())),\n                        street: item.router_data.get_optional_billing_line1(),\n                        city: item.router_data.get_optional_billing_city(),\n                        state: item.router_data.get_optional_billing_state(),\n                        zip_code: item.router_data.get_optional_billing_zip(),\n                        country_code: item.router_data.get_optional_billing_country(),\n                        email: item.router_data.get_optional_billing_email(),\n                        phone: item.router_data.get_optional_billing_phone_number(),\n                    };\n                    Ok(Self::ExternalThreeDs(external_3ds_request))\n                } else {\n                    let card_request = ZiftCardPaymentRequest {\n                        request_type,\n                        auth,\n                        account_number: card.card_number.clone(),\n                        account_accessory: card.get_expiry_date_as_mmyy()?,\n                        transaction_industry_type: TransactionIndustryType::CardPresent,\n                        holder_name: item.router_data.get_billing_full_name()?,\n                        amount: item.amount.to_owned(),\n                        account_type: AccountType::PaymentCard,\n                        holder_type: HolderType::Personal,\n                        csc: card.card_cvc,\n                        street: item.router_data.get_optional_billing_line1(),\n                        city: item.router_data.get_optional_billing_city(),\n                        state: item.router_data.get_optional_billing_state(),\n                        zip_code: item.router_data.get_optional_billing_zip(),\n                        country_code: item.router_data.get_optional_billing_country(),\n                        email: item.router_data.get_optional_billing_email(),\n                        phone: item.router_data.get_optional_billing_phone_number(),\n                    };\n                    Ok(Self::Card(card_request))\n                }\n            }\n            PaymentMethodData::MandatePayment => {"
+      },
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs::impl::ZiftPaymentsRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&ZiftRouterData<&PaymentsAuthorizeRouterData>> for ZiftPaymentsRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &ZiftRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {\n        if item.router_data.is_three_ds() {\n            return Err(\n                errors::ConnectorError::NotImplemented(\"3DS Authentication\".to_string()).into(),\n            );\n        }\n        let auth = ZiftAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let request_type = if item.router_data.request.is_auto_capture()? {\n            RequestType::Sale\n        } else {\n            RequestType::Auth\n        };\n        match item.router_data.request.payment_method_data.clone() {\n            PaymentMethodData::Card(card) => {\n                let card_request = ZiftCardPaymentRequest {\n                    request_type,\n                    auth,\n                    account_number: card.card_number.clone(),\n                    account_accessory: card.get_expiry_date_as_mmyy()?,\n                    transaction_industry_type: TransactionIndustryType::CardPresent,\n                    holder_name: item.router_data.get_billing_full_name()?,\n                    amount: item.amount.to_owned(),\n                    account_type: AccountType::PaymentCard,\n                    holder_type: HolderType::Personal,\n                    csc: card.card_cvc,\n                    street: item.router_data.get_optional_billing_line1(),\n                    city: item.router_data.get_optional_billing_city(),\n                    state: item.router_data.get_optional_billing_state(),\n                    zip_code: item.router_data.get_optional_billing_zip(),\n                    country_code: item.router_data.get_optional_billing_country(),\n                    email: item.router_data.get_optional_billing_email(),\n                    phone: item.router_data.get_optional_billing_phone_number(),\n                };\n                Ok(Self::Card(card_request))\n            }\n            PaymentMethodData::MandatePayment => {\n                let additional_card_details = match item\n                    .router_data\n                    .request\n                    .additional_payment_method_data\n                    .clone()\n                    .ok_or(errors::ConnectorError::MissingRequiredField {\n                        field_name: \"additional_payment_method_data\",\n                    })? {\n                    AdditionalPaymentData::Card(card) => *card,\n                    _ => Err(errors::ConnectorError::NotSupported {\n                        message: \"Payment Method Not Supported\".to_string(),\n                        connector: \"DataTrans\",\n                    })?,\n                };\n                let mandate_request = ZiftMandatePaymentRequest {\n                    request_type,\n                    auth,\n                    account_type: AccountType::PaymentCard,\n                    token: Secret::new(item.router_data.request.connector_mandate_id().ok_or(\n                        errors::ConnectorError::MissingRequiredField {\n                            field_name: \"connector_mandate_id\",\n                        },\n                    )?),\n                    account_accessory: additional_card_details.get_expiry_date_as_mmyy()?,\n                    transaction_industry_type: TransactionIndustryType::CardNotPresent,\n                    holder_name: additional_card_details.get_card_holder_name()?,\n                    holder_type: HolderType::Personal,\n                    amount: item.amount.to_owned(),\n                    transaction_mode_type: TransactionModeType::CardNotPresent,\n                    transaction_category_type: TransactionCategoryType::Recurring,\n                    sequence_number: 2, // Its required for MIT\n                    street: item.router_data.get_optional_billing_line1(),\n                    city: item.router_data.get_optional_billing_city(),\n                    state: item.router_data.get_optional_billing_state(),\n                    zip_code: item.router_data.get_optional_billing_zip(),\n                    country_code: item.router_data.get_optional_billing_country(),\n                    email: item.router_data.get_optional_billing_email(),\n                    phone: item.router_data.get_optional_billing_phone_number(),\n                };\n                Ok(Self::Mandate(mandate_request))\n            }\n            _ => Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into()),\n        }\n    }\n}",
+      "after_code": "impl TryFrom<&ZiftRouterData<&PaymentsAuthorizeRouterData>> for ZiftPaymentsRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &ZiftRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {\n        let auth = ZiftAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let request_type = if item.router_data.request.is_auto_capture()? {\n            RequestType::Sale\n        } else {\n            RequestType::Auth\n        };\n        match item.router_data.request.payment_method_data.clone() {\n            PaymentMethodData::Card(card) => {\n                // Check if this is an external 3DS payment - both is_three_ds() and authentication_data must be present\n                if item.router_data.is_three_ds()\n                    && item.router_data.request.authentication_data.is_some()\n                {\n                    // Handle external 3DS authentication\n                    let auth_data = item\n                        .router_data\n                        .request\n                        .authentication_data\n                        .as_ref()\n                        .ok_or(errors::ConnectorError::MissingRequiredField {\n                            field_name: \"authentication_data\",\n                        })?;\n\n                    let authentication_status = AuthenticationStatus::try_from(auth_data)?;\n\n                    let external_3ds_request = ZiftExternalThreeDsPaymentRequest {\n                        request_type,\n                        auth,\n                        account_number: card.card_number.clone(),\n                        account_accessory: card.get_expiry_date_as_mmyy()?,\n                        transaction_industry_type: TransactionIndustryType::CardNotPresent,\n                        holder_name: item.router_data.get_billing_full_name()?,\n                        amount: item.amount.to_owned(),\n                        account_type: AccountType::PaymentCard,\n                        holder_type: HolderType::Personal,\n                        authentication_status,\n                        authentication_code: auth_data.ds_trans_id.clone().map(Secret::new),\n                        authentication_verification_value: auth_data.cavv.clone(),\n                        authentication_version: auth_data\n                            .message_version\n                            .as_ref()\n                            .map(|v| Secret::new(v.to_string())),\n                        street: item.router_data.get_optional_billing_line1(),\n                        city: item.router_data.get_optional_billing_city(),\n                        state: item.router_data.get_optional_billing_state(),\n                        zip_code: item.router_data.get_optional_billing_zip(),\n                        country_code: item.router_data.get_optional_billing_country(),\n                        email: item.router_data.get_optional_billing_email(),\n                        phone: item.router_data.get_optional_billing_phone_number(),\n                    };\n                    Ok(Self::ExternalThreeDs(external_3ds_request))\n                } else {\n                    let card_request = ZiftCardPaymentRequest {\n                        request_type,\n                        auth,\n                        account_number: card.card_number.clone(),\n                        account_accessory: card.get_expiry_date_as_mmyy()?,\n                        transaction_industry_type: TransactionIndustryType::CardPresent,\n                        holder_name: item.router_data.get_billing_full_name()?,\n                        amount: item.amount.to_owned(),\n                        account_type: AccountType::PaymentCard,\n                        holder_type: HolderType::Personal,\n                        csc: card.card_cvc,\n                        street: item.router_data.get_optional_billing_line1(),\n                        city: item.router_data.get_optional_billing_city(),\n                        state: item.router_data.get_optional_billing_state(),\n                        zip_code: item.router_data.get_optional_billing_zip(),\n                        country_code: item.router_data.get_optional_billing_country(),\n                        email: item.router_data.get_optional_billing_email(),\n                        phone: item.router_data.get_optional_billing_phone_number(),\n                    };\n                    Ok(Self::Card(card_request))\n                }\n            }\n            PaymentMethodData::MandatePayment => {\n                let additional_card_details = match item\n                    .router_data\n                    .request\n                    .additional_payment_method_data\n                    .clone()\n                    .ok_or(errors::ConnectorError::MissingRequiredField {\n                        field_name: \"additional_payment_method_data\",\n                    })? {\n                    AdditionalPaymentData::Card(card) => *card,\n                    _ => Err(errors::ConnectorError::NotSupported {\n                        message: \"Payment Method Not Supported\".to_string(),\n                        connector: \"DataTrans\",\n                    })?,\n                };\n                let mandate_request = ZiftMandatePaymentRequest {\n                    request_type,\n                    auth,\n                    account_type: AccountType::PaymentCard,\n                    token: Secret::new(item.router_data.request.connector_mandate_id().ok_or(\n                        errors::ConnectorError::MissingRequiredField {\n                            field_name: \"connector_mandate_id\",\n                        },\n                    )?),\n                    account_accessory: additional_card_details.get_expiry_date_as_mmyy()?,\n                    transaction_industry_type: TransactionIndustryType::CardNotPresent,\n                    holder_name: additional_card_details.get_card_holder_name()?,\n                    holder_type: HolderType::Personal,\n                    amount: item.amount.to_owned(),\n                    transaction_mode_type: TransactionModeType::CardNotPresent,\n                    transaction_category_type: TransactionCategoryType::Recurring,\n                    sequence_number: 2, // Its required for MIT\n                    street: item.router_data.get_optional_billing_line1(),\n                    city: item.router_data.get_optional_billing_city(),\n                    state: item.router_data.get_optional_billing_state(),\n                    zip_code: item.router_data.get_optional_billing_zip(),\n                    country_code: item.router_data.get_optional_billing_country(),\n                    email: item.router_data.get_optional_billing_email(),\n                    phone: item.router_data.get_optional_billing_phone_number(),\n                };\n                Ok(Self::Mandate(mandate_request))\n            }\n            _ => Err(errors::ConnectorError::NotImplemented(\"Payment method\".to_string()).into()),\n        }\n    }\n}",
+      "diff_span": {
+        "before": "    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &ZiftRouterData<&PaymentsAuthorizeRouterData>) -> Result<Self, Self::Error> {\n        if item.router_data.is_three_ds() {\n            return Err(\n                errors::ConnectorError::NotImplemented(\"3DS Authentication\".to_string()).into(),\n            );\n        }\n        let auth = ZiftAuthType::try_from(&item.router_data.connector_auth_type)?;\n        let request_type = if item.router_data.request.is_auto_capture()? {\n            RequestType::Sale\n        } else {\n            RequestType::Auth\n        };\n        match item.router_data.request.payment_method_data.clone() {\n            PaymentMethodData::Card(card) => {\n                let card_request = ZiftCardPaymentRequest {\n                    request_type,\n                    auth,\n                    account_number: card.card_number.clone(),\n                    account_accessory: card.get_expiry_date_as_mmyy()?,\n                    transaction_industry_type: TransactionIndustryType::CardPresent,\n                    holder_name: item.router_data.get_billing_full_name()?,\n                    amount: item.amount.to_owned(),\n                    account_type: AccountType::PaymentCard,\n                    holder_type: HolderType::Personal,\n                    csc: card.card_cvc,\n                    street: item.router_data.get_optional_billing_line1(),\n                    city: item.router_data.get_optional_billing_city(),\n                    state: item.router_data.get_optional_billing_state(),\n                    zip_code: item.router_data.get_optional_billing_zip(),\n                    country_code: item.router_data.get_optional_billing_country(),\n                    email: item.router_data.get_optional_billing_email(),\n                    phone: item.router_data.get_optional_billing_phone_number(),\n                };\n                Ok(Self::Card(card_request))\n            }\n            PaymentMethodData::MandatePayment => {",
+        "after": "        match item.router_data.request.payment_method_data.clone() {\n            PaymentMethodData::Card(card) => {\n                // Check if this is an external 3DS payment - both is_three_ds() and authentication_data must be present\n                if item.router_data.is_three_ds()\n                    && item.router_data.request.authentication_data.is_some()\n                {\n                    // Handle external 3DS authentication\n                    let auth_data = item\n                        .router_data\n                        .request\n                        .authentication_data\n                        .as_ref()\n                        .ok_or(errors::ConnectorError::MissingRequiredField {\n                            field_name: \"authentication_data\",\n                        })?;\n\n                    let authentication_status = AuthenticationStatus::try_from(auth_data)?;\n\n                    let external_3ds_request = ZiftExternalThreeDsPaymentRequest {\n                        request_type,\n                        auth,\n                        account_number: card.card_number.clone(),\n                        account_accessory: card.get_expiry_date_as_mmyy()?,\n                        transaction_industry_type: TransactionIndustryType::CardNotPresent,\n                        holder_name: item.router_data.get_billing_full_name()?,\n                        amount: item.amount.to_owned(),\n                        account_type: AccountType::PaymentCard,\n                        holder_type: HolderType::Personal,\n                        authentication_status,\n                        authentication_code: auth_data.ds_trans_id.clone().map(Secret::new),\n                        authentication_verification_value: auth_data.cavv.clone(),\n                        authentication_version: auth_data\n                            .message_version\n                            .as_ref()\n                            .map(|v| Secret::new(v.to_string())),\n                        street: item.router_data.get_optional_billing_line1(),\n                        city: item.router_data.get_optional_billing_city(),\n                        state: item.router_data.get_optional_billing_state(),\n                        zip_code: item.router_data.get_optional_billing_zip(),\n                        country_code: item.router_data.get_optional_billing_country(),\n                        email: item.router_data.get_optional_billing_email(),\n                        phone: item.router_data.get_optional_billing_phone_number(),\n                    };\n                    Ok(Self::ExternalThreeDs(external_3ds_request))\n                } else {\n                    let card_request = ZiftCardPaymentRequest {\n                        request_type,\n                        auth,\n                        account_number: card.card_number.clone(),\n                        account_accessory: card.get_expiry_date_as_mmyy()?,\n                        transaction_industry_type: TransactionIndustryType::CardPresent,\n                        holder_name: item.router_data.get_billing_full_name()?,\n                        amount: item.amount.to_owned(),\n                        account_type: AccountType::PaymentCard,\n                        holder_type: HolderType::Personal,\n                        csc: card.card_cvc,\n                        street: item.router_data.get_optional_billing_line1(),\n                        city: item.router_data.get_optional_billing_city(),\n                        state: item.router_data.get_optional_billing_state(),\n                        zip_code: item.router_data.get_optional_billing_zip(),\n                        country_code: item.router_data.get_optional_billing_country(),\n                        email: item.router_data.get_optional_billing_email(),\n                        phone: item.router_data.get_optional_billing_phone_number(),\n                    };\n                    Ok(Self::Card(card_request))\n                }\n            }\n            PaymentMethodData::MandatePayment => {"
+      },
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/common_enums/src/connector_enums.rs::Connector::function::is_separate_authentication_supported",
+      "file": "crates/common_enums/src/connector_enums.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn is_separate_authentication_supported(self) -> bool {\n        match self {\n            #[cfg(feature = \"dummy_connector\")]\n            Self::DummyBillingConnector => false,\n            #[cfg(feature = \"dummy_connector\")]\n            Self::DummyConnector1\n            | Self::DummyConnector2\n            | Self::DummyConnector3\n            | Self::DummyConnector4\n            | Self::DummyConnector5\n            | Self::DummyConnector6\n            | Self::DummyConnector7 => false,\n            Self::Aci\n            // Add Separate authentication support for connectors\n\t\t\t| Self::Authipay\n            | Self::Affirm\n            | Self::Adyenplatform\n            | Self::Airwallex\n            | Self::Amazonpay\n            | Self::Authorizedotnet\n            | Self::Bambora\n            | Self::Bamboraapac\n            | Self::Bankofamerica\n            | Self::Barclaycard\n            | Self::Billwerk\n            | Self::Bitpay\n            | Self::Bluesnap\n            | Self::Blackhawknetwork\n            | Self::Calida\n            | Self::Boku\n            | Self::Braintree\n            | Self::Breadpay\n            | Self::Cashtocode\n            | Self::Celero\n            | Self::Chargebee\n            | Self::Checkbook\n            | Self::Coinbase\n            | Self::Coingate\n            | Self::Cryptopay\n            | Self::Zift\n            | Self::Custombilling\n            | Self::Deutschebank\n            | Self::Digitalvirgo\n            | Self::Dlocal\n            | Self::Dwolla\n            | Self::Ebanx\n            | Self::Elavon\n            | Self::Facilitapay\n            | Self::Finix\n            | Self::Fiserv\n            | Self::Fiservemea\n            | Self::Fiuu\n            | Self::Flexiti\n            | Self::Forte\n            | Self::Getnet\n            | Self::Gigadat\n            | Self::Globalpay\n            | Self::Globepay\n            | Self::Gocardless\n            | Self::Gpayments\n            | Self::Hipay\n            | Self::Helcim\n            | Self::HyperswitchVault\n            | Self::Iatapay\n\t\t\t| Self::Inespay\n            | Self::Itaubank\n            | Self::Jpmorgan\n            | Self::Juspaythreedsserver\n            | Self::Klarna\n            | Self::Loonio\n            | Self::Mifinity\n            | Self::Mollie\n            | Self::Moneris\n            | Self::Multisafepay\n            | Self::Nexinets\n            | Self::Nexixpay\n            | Self::Nomupay\n            | Self::Nordea\n            | Self::Novalnet\n            | Self::Opennode\n            | Self::Paybox\n            | Self::Payload\n            | Self::Payme\n            | Self::Payone\n            | Self::Paypal\n            | Self::Paysafe\n            | Self::Paystack\n            | Self::Payu\n            | Self::Peachpayments\n            | Self::Placetopay\n            | Self::Powertranz\n            | Self::Prophetpay\n            | Self::Rapyd\n            | Self::Recurly\n            | Self::Redsys\n            | Self::Santander\n            | Self::Shift4\n            | Self::Silverflow\n            | Self::Square\n            | Self::Stax\n            | Self::Stripebilling\n            | Self::Taxjar\n            | Self::Tesouro\n            // | Self::Thunes\n            | Self::Trustpay\n            | Self::Trustpayments\n            // | Self::Tokenio\n            | Self::Tsys\n            // | Self::UnifiedAuthenticationService\n            | Self::Vgs\n            | Self::Volt\n            | Self::Wellsfargo\n            // | Self::Wellsfargopayout\n            | Self::Wise\n            | Self::Worldline\n            | Self::Worldpay\n            | Self::Worldpayvantiv\n            | Self::Worldpayxml\n            | Self::Xendit\n            | Self::Zen\n            | Self::Zsl\n            | Self::Signifyd\n            | Self::Plaid\n            | Self::Razorpay\n            | Self::Riskified\n            | Self::Threedsecureio\n            | Self::Netcetera\n            | Self::CtpMastercard\n            | Self::Cardinal\n            | Self::CtpVisa\n            | Self::Noon\n            | Self::Tokenex\n            | Self::Tokenio\n            | Self::Stripe\n            | Self::Datatrans\n            | Self::Paytm\n            | Self::Payjustnow\n            | Self::Phonepe => false,\n            Self::Checkout | Self::Nmi |Self::Cybersource | Self::Archipel | Self::Nuvei | Self::Adyen => true,\n        }\n    }",
+      "after_code": "pub fn is_separate_authentication_supported(self) -> bool {\n        match self {\n            #[cfg(feature = \"dummy_connector\")]\n            Self::DummyBillingConnector => false,\n            #[cfg(feature = \"dummy_connector\")]\n            Self::DummyConnector1\n            | Self::DummyConnector2\n            | Self::DummyConnector3\n            | Self::DummyConnector4\n            | Self::DummyConnector5\n            | Self::DummyConnector6\n            | Self::DummyConnector7 => false,\n            Self::Aci\n            // Add Separate authentication support for connectors\n\t\t\t| Self::Authipay\n            | Self::Affirm\n            | Self::Adyenplatform\n            | Self::Airwallex\n            | Self::Amazonpay\n            | Self::Authorizedotnet\n            | Self::Bambora\n            | Self::Bamboraapac\n            | Self::Bankofamerica\n            | Self::Barclaycard\n            | Self::Billwerk\n            | Self::Bitpay\n            | Self::Bluesnap\n            | Self::Blackhawknetwork\n            | Self::Calida\n            | Self::Boku\n            | Self::Braintree\n            | Self::Breadpay\n            | Self::Cashtocode\n            | Self::Celero\n            | Self::Chargebee\n            | Self::Checkbook\n            | Self::Coinbase\n            | Self::Coingate\n            | Self::Cryptopay\n            | Self::Custombilling\n            | Self::Deutschebank\n            | Self::Digitalvirgo\n            | Self::Dlocal\n            | Self::Dwolla\n            | Self::Ebanx\n            | Self::Elavon\n            | Self::Facilitapay\n            | Self::Finix\n            | Self::Fiserv\n            | Self::Fiservemea\n            | Self::Fiuu\n            | Self::Flexiti\n            | Self::Forte\n            | Self::Getnet\n            | Self::Gigadat\n            | Self::Globalpay\n            | Self::Globepay\n            | Self::Gocardless\n            | Self::Gpayments\n            | Self::Hipay\n            | Self::Helcim\n            | Self::HyperswitchVault\n            | Self::Iatapay\n\t\t\t| Self::Inespay\n            | Self::Itaubank\n            | Self::Jpmorgan\n            | Self::Juspaythreedsserver\n            | Self::Klarna\n            | Self::Loonio\n            | Self::Mifinity\n            | Self::Mollie\n            | Self::Moneris\n            | Self::Multisafepay\n            | Self::Nexinets\n            | Self::Nexixpay\n            | Self::Nomupay\n            | Self::Nordea\n            | Self::Novalnet\n            | Self::Opennode\n            | Self::Paybox\n            | Self::Payload\n            | Self::Payme\n            | Self::Payone\n            | Self::Paypal\n            | Self::Paysafe\n            | Self::Paystack\n            | Self::Payu\n            | Self::Peachpayments\n            | Self::Placetopay\n            | Self::Powertranz\n            | Self::Prophetpay\n            | Self::Rapyd\n            | Self::Recurly\n            | Self::Redsys\n            | Self::Santander\n            | Self::Shift4\n            | Self::Silverflow\n            | Self::Square\n            | Self::Stax\n            | Self::Stripebilling\n            | Self::Taxjar\n            | Self::Tesouro\n            // | Self::Thunes\n            | Self::Trustpay\n            | Self::Trustpayments\n            // | Self::Tokenio\n            | Self::Tsys\n            // | Self::UnifiedAuthenticationService\n            | Self::Vgs\n            | Self::Volt\n            | Self::Wellsfargo\n            // | Self::Wellsfargopayout\n            | Self::Wise\n            | Self::Worldline\n            | Self::Worldpay\n            | Self::Worldpayvantiv\n            | Self::Worldpayxml\n            | Self::Xendit\n            | Self::Zen\n            | Self::Zsl\n            | Self::Signifyd\n            | Self::Plaid\n            | Self::Razorpay\n            | Self::Riskified\n            | Self::Threedsecureio\n            | Self::Netcetera\n            | Self::CtpMastercard\n            | Self::Cardinal\n            | Self::CtpVisa\n            | Self::Noon\n            | Self::Tokenex\n            | Self::Tokenio\n            | Self::Stripe\n            | Self::Datatrans\n            | Self::Paytm\n            | Self::Payjustnow\n            | Self::Phonepe => false,\n            Self::Checkout |Self::Zift| Self::Nmi |Self::Cybersource | Self::Archipel | Self::Nuvei | Self::Adyen => true,\n        }\n    }",
+      "diff_span": {
+        "before": "            | Self::Coingate\n            | Self::Cryptopay\n            | Self::Zift\n            | Self::Custombilling\n            | Self::Deutschebank\n            | Self::Digitalvirgo\n            | Self::Dlocal\n            | Self::Dwolla\n            | Self::Ebanx\n            | Self::Elavon\n            | Self::Facilitapay\n            | Self::Finix\n            | Self::Fiserv\n            | Self::Fiservemea\n            | Self::Fiuu\n            | Self::Flexiti\n            | Self::Forte\n            | Self::Getnet\n            | Self::Gigadat\n            | Self::Globalpay\n            | Self::Globepay\n            | Self::Gocardless\n            | Self::Gpayments\n            | Self::Hipay\n            | Self::Helcim\n            | Self::HyperswitchVault\n            | Self::Iatapay\n\t\t\t| Self::Inespay\n            | Self::Itaubank\n            | Self::Jpmorgan\n            | Self::Juspaythreedsserver\n            | Self::Klarna\n            | Self::Loonio\n            | Self::Mifinity\n            | Self::Mollie\n            | Self::Moneris\n            | Self::Multisafepay\n            | Self::Nexinets\n            | Self::Nexixpay\n            | Self::Nomupay\n            | Self::Nordea\n            | Self::Novalnet\n            | Self::Opennode\n            | Self::Paybox\n            | Self::Payload\n            | Self::Payme\n            | Self::Payone\n            | Self::Paypal\n            | Self::Paysafe\n            | Self::Paystack\n            | Self::Payu\n            | Self::Peachpayments\n            | Self::Placetopay\n            | Self::Powertranz\n            | Self::Prophetpay\n            | Self::Rapyd\n            | Self::Recurly\n            | Self::Redsys\n            | Self::Santander\n            | Self::Shift4\n            | Self::Silverflow\n            | Self::Square\n            | Self::Stax\n            | Self::Stripebilling\n            | Self::Taxjar\n            | Self::Tesouro\n            // | Self::Thunes\n            | Self::Trustpay\n            | Self::Trustpayments\n            // | Self::Tokenio\n            | Self::Tsys\n            // | Self::UnifiedAuthenticationService\n            | Self::Vgs\n            | Self::Volt\n            | Self::Wellsfargo\n            // | Self::Wellsfargopayout\n            | Self::Wise\n            | Self::Worldline\n            | Self::Worldpay\n            | Self::Worldpayvantiv\n            | Self::Worldpayxml\n            | Self::Xendit\n            | Self::Zen\n            | Self::Zsl\n            | Self::Signifyd\n            | Self::Plaid\n            | Self::Razorpay\n            | Self::Riskified\n            | Self::Threedsecureio\n            | Self::Netcetera\n            | Self::CtpMastercard\n            | Self::Cardinal\n            | Self::CtpVisa\n            | Self::Noon\n            | Self::Tokenex\n            | Self::Tokenio\n            | Self::Stripe\n            | Self::Datatrans\n            | Self::Paytm\n            | Self::Payjustnow\n            | Self::Phonepe => false,\n            Self::Checkout | Self::Nmi |Self::Cybersource | Self::Archipel | Self::Nuvei | Self::Adyen => true,\n        }\n    }",
+        "after": "            | Self::Payjustnow\n            | Self::Phonepe => false,\n            Self::Checkout |Self::Zift| Self::Nmi |Self::Cybersource | Self::Archipel | Self::Nuvei | Self::Adyen => true,\n        }\n    }"
+      },
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs::struct::ZiftExternalThreeDsPaymentRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+      "kind": "struct_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub struct ZiftExternalThreeDsPaymentRequest {\n    request_type: RequestType,\n    #[serde(flatten)]\n    auth: ZiftAuthType,\n    account_type: AccountType,\n    account_number: cards::CardNumber,\n    account_accessory: Secret<String>,\n    transaction_industry_type: TransactionIndustryType,\n    holder_name: Secret<String>,\n    holder_type: HolderType,\n    amount: StringMinorUnit,\n    // 3DS authentication fields\n    authentication_status: AuthenticationStatus,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    authentication_code: Option<Secret<String>>,\n    authentication_verification_value: Secret<String>,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    authentication_version: Option<Secret<String>>,\n    // Billing address\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    street: Option<Secret<String>>,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    city: Option<String>,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    state: Option<Secret<String>>,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    zip_code: Option<Secret<String>>,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    country_code: Option<CountryAlpha2>,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    email: Option<pii::Email>,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    phone: Option<Secret<String>>,\n}",
+      "diff_span": null,
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs::impl::AuthenticationStatus",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+      "kind": "impl_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "impl TryFrom<&hyperswitch_domain_models::router_request_types::AuthenticationData>\n    for AuthenticationStatus\n{\n    type Error = error_stack::Report<errors::ConnectorError>;\n\n    fn try_from(\n        auth_data: &hyperswitch_domain_models::router_request_types::AuthenticationData,\n    ) -> Result<Self, Self::Error> {\n        // Map authentication status based on trans_status field\n        let authentication_status = match auth_data.transaction_status {\n            Some(common_enums::TransactionStatus::Success) => Self::Success,\n            Some(common_enums::TransactionStatus::NotVerified) => Self::Attempted,\n            Some(common_enums::TransactionStatus::VerificationNotPerformed)\n            | Some(common_enums::TransactionStatus::Rejected)\n            | Some(common_enums::TransactionStatus::InformationOnly)\n            | Some(common_enums::TransactionStatus::Failure)\n            | Some(common_enums::TransactionStatus::ChallengeRequired)\n            | Some(common_enums::TransactionStatus::ChallengeRequiredDecoupledAuthentication)\n            | None => Self::Unavailable,\n        };\n        Ok(authentication_status)\n    }\n}",
+      "diff_span": null,
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs::AuthenticationStatus::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+      "kind": "function_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "fn try_from(\n        auth_data: &hyperswitch_domain_models::router_request_types::AuthenticationData,\n    ) -> Result<Self, Self::Error> {\n        // Map authentication status based on trans_status field\n        let authentication_status = match auth_data.transaction_status {\n            Some(common_enums::TransactionStatus::Success) => Self::Success,\n            Some(common_enums::TransactionStatus::NotVerified) => Self::Attempted,\n            Some(common_enums::TransactionStatus::VerificationNotPerformed)\n            | Some(common_enums::TransactionStatus::Rejected)\n            | Some(common_enums::TransactionStatus::InformationOnly)\n            | Some(common_enums::TransactionStatus::Failure)\n            | Some(common_enums::TransactionStatus::ChallengeRequired)\n            | Some(common_enums::TransactionStatus::ChallengeRequiredDecoupledAuthentication)\n            | None => Self::Unavailable,\n        };\n        Ok(authentication_status)\n    }",
+      "diff_span": null,
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs::enum::AuthenticationStatus",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+      "kind": "enum_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "pub enum AuthenticationStatus {\n    #[serde(rename = \"Y\")]\n    Success,\n    #[serde(rename = \"A\")]\n    Attempted,\n    #[serde(rename = \"U\")]\n    Unavailable,\n}",
+      "diff_span": null,
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs::AuthenticationStatus::type::Error",
+      "file": "crates/hyperswitch_connectors/src/connectors/zift/transformers.rs",
+      "kind": "type_item",
+      "status": "added",
+      "before_code": null,
+      "after_code": "type Error = error_stack::Report<errors::ConnectorError>;",
+      "diff_span": null,
+      "commit_sha": "fa6a2d24b812ba46668b567761b81fa3638a3215"
+    }
+  ]
+}

diffs/pr_10436/2e7d22a/diff.json

@@ -0,0 +1,205 @@
+{
+  "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed",
+  "pr_number": 10436,
+  "rust_files": [
+    "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::NovalnetCaptureRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(\n        item: &NovalnetRouterData<&PaymentsCaptureRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let capture_type = CaptureType::Final;\n        let reference = item.router_data.connector_request_reference_id.clone();\n        let capture = Capture {\n            cap_type: capture_type,\n            reference,\n        };\n\n        let transaction = NovalnetTransaction {\n            tid: item.router_data.request.connector_transaction_id.clone(),\n            capture,\n            amount: Some(item.amount.to_owned()),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .router_data\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string()),\n            extra: None,\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }",
+      "after_code": "fn try_from(\n        item: &NovalnetRouterData<&PaymentsCaptureRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let capture_type = CaptureType::Final;\n        let reference = item.router_data.connector_request_reference_id.clone();\n        let capture = Capture {\n            cap_type: capture_type,\n            reference,\n        };\n\n        let transaction = NovalnetTransaction {\n            tid: item.router_data.request.connector_transaction_id.clone(),\n            capture,\n            amount: Some(item.amount.to_owned()),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .router_data\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string()),\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }",
+      "diff_span": {
+        "before": "                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string()),\n            extra: None,\n        };\n        Ok(Self {",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::impl::NovalnetCaptureRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&NovalnetRouterData<&PaymentsCaptureRouterData>> for NovalnetCaptureRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: &NovalnetRouterData<&PaymentsCaptureRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let capture_type = CaptureType::Final;\n        let reference = item.router_data.connector_request_reference_id.clone();\n        let capture = Capture {\n            cap_type: capture_type,\n            reference,\n        };\n\n        let transaction = NovalnetTransaction {\n            tid: item.router_data.request.connector_transaction_id.clone(),\n            capture,\n            amount: Some(item.amount.to_owned()),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .router_data\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string()),\n            extra: None,\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }\n}",
+      "after_code": "impl TryFrom<&NovalnetRouterData<&PaymentsCaptureRouterData>> for NovalnetCaptureRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(\n        item: &NovalnetRouterData<&PaymentsCaptureRouterData>,\n    ) -> Result<Self, Self::Error> {\n        let capture_type = CaptureType::Final;\n        let reference = item.router_data.connector_request_reference_id.clone();\n        let capture = Capture {\n            cap_type: capture_type,\n            reference,\n        };\n\n        let transaction = NovalnetTransaction {\n            tid: item.router_data.request.connector_transaction_id.clone(),\n            capture,\n            amount: Some(item.amount.to_owned()),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .router_data\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string()),\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string()),\n            extra: None,\n        };\n        Ok(Self {",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::NovalnetCancelRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {\n        let transaction = NovalnetCancelTransaction {\n            tid: item.request.connector_transaction_id.clone(),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }",
+      "after_code": "fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {\n        let transaction = NovalnetCancelTransaction {\n            tid: item.request.connector_transaction_id.clone(),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }",
+      "diff_span": {
+        "before": "                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::impl::NovalnetCancelRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&PaymentsCancelRouterData> for NovalnetCancelRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {\n        let transaction = NovalnetCancelTransaction {\n            tid: item.request.connector_transaction_id.clone(),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }\n}",
+      "after_code": "impl TryFrom<&PaymentsCancelRouterData> for NovalnetCancelRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &PaymentsCancelRouterData) -> Result<Self, Self::Error> {\n        let transaction = NovalnetCancelTransaction {\n            tid: item.request.connector_transaction_id.clone(),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::impl::NovalnetSyncRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&RefundSyncRouterData> for NovalnetSyncRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {\n        let transaction = NovalnetSyncTransaction {\n            tid: item.request.connector_transaction_id.clone(),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }\n}",
+      "after_code": "impl TryFrom<&RefundSyncRouterData> for NovalnetSyncRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {\n        let transaction = NovalnetSyncTransaction {\n            tid: item.request.connector_transaction_id.clone(),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::impl::NovalnetRefundRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F> TryFrom<&NovalnetRouterData<&RefundsRouterData<F>>> for NovalnetRefundRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &NovalnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {\n        let transaction = NovalnetRefundTransaction {\n            tid: item.router_data.request.connector_transaction_id.clone(),\n            amount: Some(item.amount.to_owned()),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .router_data\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }\n}",
+      "after_code": "impl<F> TryFrom<&NovalnetRouterData<&RefundsRouterData<F>>> for NovalnetRefundRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &NovalnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {\n        let transaction = NovalnetRefundTransaction {\n            tid: item.router_data.request.connector_transaction_id.clone(),\n            amount: Some(item.amount.to_owned()),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .router_data\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::struct::NovalnetCustom",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": true,
+      "before_code": "pub struct NovalnetCustom {\n    lang: String,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    #[serde(flatten)]\n    pub extra: Option<HashMap<String, String>>,\n}",
+      "after_code": "pub struct NovalnetCustom {\n    lang: String,\n}",
+      "diff_span": {
+        "before": "pub struct NovalnetCustom {\n    lang: String,\n    #[serde(skip_serializing_if = \"Option::is_none\")]\n    #[serde(flatten)]\n    pub extra: Option<HashMap<String, String>>,\n}",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed",
+      "before_imports": [
+        "use std::collections::HashMap;",
+        "use common_utils::{\n    consts,\n    ext_traits::OptionExt,\n    pii::Email,\n    request::Method,\n    types::{MinorUnit, StringMinorUnit},\n};",
+        "use crate::{\n    types::{\n        PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,\n        RefundsResponseRouterData, ResponseRouterData,\n    },\n    utils::{\n        self, AddressData, AddressDetailsData, ApplePay, PaymentsAuthorizeRequestData,\n        PaymentsCancelRequestData, PaymentsCaptureRequestData, PaymentsSetupMandateRequestData,\n        PaymentsSyncRequestData, RefundsRequestData, RouterData as _,\n    },\n};",
+        "use hyperswitch_domain_models::{\n    payment_method_data::{\n        BankDebitData, PaymentMethodData, WalletData as WalletDataPaymentMethod,\n    },\n    router_data::{ConnectorAuthType, ErrorResponse, RouterData},\n    router_flow_types::refunds::{Execute, RSync},\n    router_request_types::{PaymentsSyncData, ResponseId},\n    router_response_types::{\n        MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,\n    },\n    types::{\n        PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,\n        PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,\n    },\n};"
+      ],
+      "after_imports": [
+        "use crate::{\n    types::{\n        PaymentsCancelResponseRouterData, PaymentsCaptureResponseRouterData,\n        RefundsResponseRouterData, ResponseRouterData,\n    },\n    utils::{\n        self, AddressData, AddressDetailsData, ApplePay, PaymentsAuthorizeRequestData,\n        PaymentsCancelRequestData, PaymentsCaptureRequestData, PaymentsSetupMandateRequestData,\n        PaymentsSyncRequestData, RefundsRequestData, RouterData as _,\n    },\n};",
+        "use common_utils::{\n    consts,\n    ext_traits::OptionExt,\n    pii::Email,\n    request::Method,\n    types::{MinorUnit, StringMinorUnit},\n};",
+        "use hyperswitch_domain_models::{\n    payment_method_data::{\n        BankDebitData, PaymentMethodData, WalletData as WalletDataPaymentMethod,\n    },\n    router_data::{ConnectorAuthType, ErrorResponse, RouterData},\n    router_flow_types::refunds::{Execute, RSync},\n    router_request_types::{PaymentsSyncData, ResponseId},\n    router_response_types::{\n        MandateReference, PaymentsResponseData, RedirectForm, RefundsResponseData,\n    },\n    types::{\n        PaymentsAuthorizeRouterData, PaymentsCancelRouterData, PaymentsCaptureRouterData,\n        PaymentsSyncRouterData, RefundSyncRouterData, RefundsRouterData, SetupMandateRouterData,\n    },\n};"
+      ]
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::NovalnetSyncRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {\n        let transaction = NovalnetSyncTransaction {\n            tid: item.request.connector_transaction_id.clone(),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }",
+      "after_code": "fn try_from(item: &RefundSyncRouterData) -> Result<Self, Self::Error> {\n        let transaction = NovalnetSyncTransaction {\n            tid: item.request.connector_transaction_id.clone(),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }",
+      "diff_span": {
+        "before": "                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::NovalnetRefundRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(item: &NovalnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {\n        let transaction = NovalnetRefundTransaction {\n            tid: item.router_data.request.connector_transaction_id.clone(),\n            amount: Some(item.amount.to_owned()),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .router_data\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }",
+      "after_code": "fn try_from(item: &NovalnetRouterData<&RefundsRouterData<F>>) -> Result<Self, Self::Error> {\n        let transaction = NovalnetRefundTransaction {\n            tid: item.router_data.request.connector_transaction_id.clone(),\n            amount: Some(item.amount.to_owned()),\n        };\n\n        let custom = NovalnetCustom {\n            lang: item\n                .router_data\n                .request\n                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n        };\n        Ok(Self {\n            transaction,\n            custom,\n        })\n    }",
+      "diff_span": {
+        "before": "                .get_optional_language_from_browser_info()\n                .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string()),\n            extra: None,\n        };\n        Ok(Self {",
+        "after": ""
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::impl::NovalnetPaymentsRequest",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl TryFrom<&SetupMandateRouterData> for NovalnetPaymentsRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        let auth = NovalnetAuthType::try_from(&item.connector_auth_type)?;\n\n        let merchant = NovalnetPaymentsRequestMerchant {\n            signature: auth.product_activation_key,\n            tariff: auth.tariff_id,\n        };\n\n        let enforce_3d = match item.auth_type {\n            enums::AuthenticationType::ThreeDs => Some(1),\n            enums::AuthenticationType::NoThreeDs => None,\n        };\n        let test_mode = get_test_mode(item.test_mode);\n        let req_address = item.get_optional_billing();\n\n        let billing = NovalnetPaymentsRequestBilling {\n            house_no: item.get_optional_billing_line1(),\n            street: item.get_optional_billing_line2(),\n            city: item.get_optional_billing_city().map(Secret::new),\n            zip: item.get_optional_billing_zip(),\n            country_code: item.get_optional_billing_country(),\n        };\n\n        let email = item.get_billing_email().or(item.request.get_email())?;\n\n        let customer = NovalnetPaymentsRequestCustomer {\n            first_name: req_address.and_then(|addr| addr.get_optional_first_name()),\n            last_name: req_address.and_then(|addr| addr.get_optional_last_name()),\n            email,\n            mobile: item.get_optional_billing_phone_number(),\n            billing: Some(billing),\n            // no_nc is used to indicate if minimal customer data is passed or not\n            no_nc: MINIMAL_CUSTOMER_DATA_PASSED,\n            birth_date: Some(String::from(\"1992-06-10\")),\n        };\n\n        let lang = item\n            .request\n            .get_optional_language_from_browser_info()\n            .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());\n        let extra = metadata_to_novalnet_extra(item.request.metadata.clone().map(|m| m.expose()))?;\n        let custom = NovalnetCustom { lang, extra };\n        let hook_url = item.request.get_webhook_url()?;\n        let return_url = item.request.get_return_url()?;\n        let create_token = Some(CREATE_TOKEN_REQUIRED);\n\n        match item.request.payment_method_data {\n            PaymentMethodData::Card(ref req_card) => {\n                let novalnet_card = NovalNetPaymentData::Card(NovalnetCard {\n                    card_number: req_card.card_number.clone(),\n                    card_expiry_month: req_card.card_exp_month.clone(),\n                    card_expiry_year: req_card.card_exp_year.clone(),\n                    card_cvc: req_card.card_cvc.clone(),\n                    card_holder: item.get_billing_address()?.get_full_name()?,\n                });\n\n                let transaction = NovalnetPaymentsRequestTransaction {\n                    test_mode,\n                    payment_type: NovalNetPaymentTypes::CREDITCARD,\n                    amount: NovalNetAmount::Int(0),\n                    currency: item.request.currency,\n                    order_no: item.connector_request_reference_id.clone(),\n                    hook_url: Some(hook_url),\n                    return_url: Some(return_url.clone()),\n                    error_return_url: Some(return_url.clone()),\n                    payment_data: Some(novalnet_card),\n                    enforce_3d,\n                    create_token,\n                };\n\n                Ok(Self {\n                    merchant,\n                    transaction,\n                    customer,\n                    custom,\n                })\n            }\n\n            PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {\n                WalletDataPaymentMethod::GooglePay(ref req_wallet) => {\n                    let novalnet_google_pay: NovalNetPaymentData =\n                        NovalNetPaymentData::GooglePay(NovalnetGooglePay {\n                            wallet_data: Secret::new(\n                                req_wallet\n                                    .tokenization_data\n                                    .get_encrypted_google_pay_token()\n                                    .change_context(errors::ConnectorError::MissingRequiredField {\n                                        field_name: \"gpay wallet_token\",\n                                    })?\n                                    .clone(),\n                            ),\n                        });\n\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::GOOGLEPAY,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: None,\n                        error_return_url: None,\n                        payment_data: Some(novalnet_google_pay),\n                        enforce_3d,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::ApplePay(payment_method_data) => {\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::APPLEPAY,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: None,\n                        error_return_url: None,\n                        payment_data: Some(NovalNetPaymentData::ApplePay(NovalnetApplePay {\n                            wallet_data: payment_method_data.get_applepay_decoded_payment_data()?,\n                        })),\n                        enforce_3d: None,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::AliPayQr(_)\n                | WalletDataPaymentMethod::AliPayRedirect(_)\n                | WalletDataPaymentMethod::AliPayHkRedirect(_)\n                | WalletDataPaymentMethod::AmazonPay(_)\n                | WalletDataPaymentMethod::AmazonPayRedirect(_)\n                | WalletDataPaymentMethod::Paysera(_)\n                | WalletDataPaymentMethod::Skrill(_)\n                | WalletDataPaymentMethod::BluecodeRedirect {}\n                | WalletDataPaymentMethod::MomoRedirect(_)\n                | WalletDataPaymentMethod::KakaoPayRedirect(_)\n                | WalletDataPaymentMethod::GoPayRedirect(_)\n                | WalletDataPaymentMethod::GcashRedirect(_)\n                | WalletDataPaymentMethod::ApplePayRedirect(_)\n                | WalletDataPaymentMethod::ApplePayThirdPartySdk(_)\n                | WalletDataPaymentMethod::DanaRedirect {}\n                | WalletDataPaymentMethod::GooglePayRedirect(_)\n                | WalletDataPaymentMethod::GooglePayThirdPartySdk(_)\n                | WalletDataPaymentMethod::MbWayRedirect(_)\n                | WalletDataPaymentMethod::MobilePayRedirect(_)\n                | WalletDataPaymentMethod::RevolutPay(_) => {\n                    Err(errors::ConnectorError::NotImplemented(\n                        utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n                    ))?\n                }\n                WalletDataPaymentMethod::PaypalRedirect(_) => {\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::PAYPAL,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: Some(return_url.clone()),\n                        error_return_url: Some(return_url.clone()),\n                        payment_data: None,\n                        enforce_3d: None,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::PaypalSdk(_)\n                | WalletDataPaymentMethod::Paze(_)\n                | WalletDataPaymentMethod::SamsungPay(_)\n                | WalletDataPaymentMethod::TwintRedirect {}\n                | WalletDataPaymentMethod::VippsRedirect {}\n                | WalletDataPaymentMethod::TouchNGoRedirect(_)\n                | WalletDataPaymentMethod::WeChatPayRedirect(_)\n                | WalletDataPaymentMethod::CashappQr(_)\n                | WalletDataPaymentMethod::SwishQr(_)\n                | WalletDataPaymentMethod::WeChatPayQr(_)\n                | WalletDataPaymentMethod::Mifinity(_) => {\n                    Err(errors::ConnectorError::NotImplemented(\n                        utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n                    ))?\n                }\n            },\n            _ => Err(errors::ConnectorError::NotImplemented(\n                utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n            ))?,\n        }\n    }\n}",
+      "after_code": "impl TryFrom<&SetupMandateRouterData> for NovalnetPaymentsRequest {\n    type Error = error_stack::Report<errors::ConnectorError>;\n    fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        let auth = NovalnetAuthType::try_from(&item.connector_auth_type)?;\n\n        let merchant = NovalnetPaymentsRequestMerchant {\n            signature: auth.product_activation_key,\n            tariff: auth.tariff_id,\n        };\n\n        let enforce_3d = match item.auth_type {\n            enums::AuthenticationType::ThreeDs => Some(1),\n            enums::AuthenticationType::NoThreeDs => None,\n        };\n        let test_mode = get_test_mode(item.test_mode);\n        let req_address = item.get_optional_billing();\n\n        let billing = NovalnetPaymentsRequestBilling {\n            house_no: item.get_optional_billing_line1(),\n            street: item.get_optional_billing_line2(),\n            city: item.get_optional_billing_city().map(Secret::new),\n            zip: item.get_optional_billing_zip(),\n            country_code: item.get_optional_billing_country(),\n        };\n\n        let email = item.get_billing_email().or(item.request.get_email())?;\n\n        let customer = NovalnetPaymentsRequestCustomer {\n            first_name: req_address.and_then(|addr| addr.get_optional_first_name()),\n            last_name: req_address.and_then(|addr| addr.get_optional_last_name()),\n            email,\n            mobile: item.get_optional_billing_phone_number(),\n            billing: Some(billing),\n            // no_nc is used to indicate if minimal customer data is passed or not\n            no_nc: MINIMAL_CUSTOMER_DATA_PASSED,\n            birth_date: Some(String::from(\"1992-06-10\")),\n        };\n\n        let lang = item\n            .request\n            .get_optional_language_from_browser_info()\n            .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());\n\n        let custom = NovalnetCustom { lang };\n        let hook_url = item.request.get_webhook_url()?;\n        let return_url = item.request.get_return_url()?;\n        let create_token = Some(CREATE_TOKEN_REQUIRED);\n\n        match item.request.payment_method_data {\n            PaymentMethodData::Card(ref req_card) => {\n                let novalnet_card = NovalNetPaymentData::Card(NovalnetCard {\n                    card_number: req_card.card_number.clone(),\n                    card_expiry_month: req_card.card_exp_month.clone(),\n                    card_expiry_year: req_card.card_exp_year.clone(),\n                    card_cvc: req_card.card_cvc.clone(),\n                    card_holder: item.get_billing_address()?.get_full_name()?,\n                });\n\n                let transaction = NovalnetPaymentsRequestTransaction {\n                    test_mode,\n                    payment_type: NovalNetPaymentTypes::CREDITCARD,\n                    amount: NovalNetAmount::Int(0),\n                    currency: item.request.currency,\n                    order_no: item.connector_request_reference_id.clone(),\n                    hook_url: Some(hook_url),\n                    return_url: Some(return_url.clone()),\n                    error_return_url: Some(return_url.clone()),\n                    payment_data: Some(novalnet_card),\n                    enforce_3d,\n                    create_token,\n                };\n\n                Ok(Self {\n                    merchant,\n                    transaction,\n                    customer,\n                    custom,\n                })\n            }\n\n            PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {\n                WalletDataPaymentMethod::GooglePay(ref req_wallet) => {\n                    let novalnet_google_pay: NovalNetPaymentData =\n                        NovalNetPaymentData::GooglePay(NovalnetGooglePay {\n                            wallet_data: Secret::new(\n                                req_wallet\n                                    .tokenization_data\n                                    .get_encrypted_google_pay_token()\n                                    .change_context(errors::ConnectorError::MissingRequiredField {\n                                        field_name: \"gpay wallet_token\",\n                                    })?\n                                    .clone(),\n                            ),\n                        });\n\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::GOOGLEPAY,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: None,\n                        error_return_url: None,\n                        payment_data: Some(novalnet_google_pay),\n                        enforce_3d,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::ApplePay(payment_method_data) => {\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::APPLEPAY,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: None,\n                        error_return_url: None,\n                        payment_data: Some(NovalNetPaymentData::ApplePay(NovalnetApplePay {\n                            wallet_data: payment_method_data.get_applepay_decoded_payment_data()?,\n                        })),\n                        enforce_3d: None,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::AliPayQr(_)\n                | WalletDataPaymentMethod::AliPayRedirect(_)\n                | WalletDataPaymentMethod::AliPayHkRedirect(_)\n                | WalletDataPaymentMethod::AmazonPay(_)\n                | WalletDataPaymentMethod::AmazonPayRedirect(_)\n                | WalletDataPaymentMethod::Paysera(_)\n                | WalletDataPaymentMethod::Skrill(_)\n                | WalletDataPaymentMethod::BluecodeRedirect {}\n                | WalletDataPaymentMethod::MomoRedirect(_)\n                | WalletDataPaymentMethod::KakaoPayRedirect(_)\n                | WalletDataPaymentMethod::GoPayRedirect(_)\n                | WalletDataPaymentMethod::GcashRedirect(_)\n                | WalletDataPaymentMethod::ApplePayRedirect(_)\n                | WalletDataPaymentMethod::ApplePayThirdPartySdk(_)\n                | WalletDataPaymentMethod::DanaRedirect {}\n                | WalletDataPaymentMethod::GooglePayRedirect(_)\n                | WalletDataPaymentMethod::GooglePayThirdPartySdk(_)\n                | WalletDataPaymentMethod::MbWayRedirect(_)\n                | WalletDataPaymentMethod::MobilePayRedirect(_)\n                | WalletDataPaymentMethod::RevolutPay(_) => {\n                    Err(errors::ConnectorError::NotImplemented(\n                        utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n                    ))?\n                }\n                WalletDataPaymentMethod::PaypalRedirect(_) => {\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::PAYPAL,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: Some(return_url.clone()),\n                        error_return_url: Some(return_url.clone()),\n                        payment_data: None,\n                        enforce_3d: None,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::PaypalSdk(_)\n                | WalletDataPaymentMethod::Paze(_)\n                | WalletDataPaymentMethod::SamsungPay(_)\n                | WalletDataPaymentMethod::TwintRedirect {}\n                | WalletDataPaymentMethod::VippsRedirect {}\n                | WalletDataPaymentMethod::TouchNGoRedirect(_)\n                | WalletDataPaymentMethod::WeChatPayRedirect(_)\n                | WalletDataPaymentMethod::CashappQr(_)\n                | WalletDataPaymentMethod::SwishQr(_)\n                | WalletDataPaymentMethod::WeChatPayQr(_)\n                | WalletDataPaymentMethod::Mifinity(_) => {\n                    Err(errors::ConnectorError::NotImplemented(\n                        utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n                    ))?\n                }\n            },\n            _ => Err(errors::ConnectorError::NotImplemented(\n                utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n            ))?,\n        }\n    }\n}",
+      "diff_span": {
+        "before": "            .get_optional_language_from_browser_info()\n            .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());\n        let extra = metadata_to_novalnet_extra(item.request.metadata.clone().map(|m| m.expose()))?;\n        let custom = NovalnetCustom { lang, extra };\n        let hook_url = item.request.get_webhook_url()?;\n        let return_url = item.request.get_return_url()?;",
+        "after": "            .get_optional_language_from_browser_info()\n            .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());\n\n        let custom = NovalnetCustom { lang };\n        let hook_url = item.request.get_webhook_url()?;\n        let return_url = item.request.get_return_url()?;"
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::NovalnetPaymentsRequest::function::try_from",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/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 auth = NovalnetAuthType::try_from(&item.connector_auth_type)?;\n\n        let merchant = NovalnetPaymentsRequestMerchant {\n            signature: auth.product_activation_key,\n            tariff: auth.tariff_id,\n        };\n\n        let enforce_3d = match item.auth_type {\n            enums::AuthenticationType::ThreeDs => Some(1),\n            enums::AuthenticationType::NoThreeDs => None,\n        };\n        let test_mode = get_test_mode(item.test_mode);\n        let req_address = item.get_optional_billing();\n\n        let billing = NovalnetPaymentsRequestBilling {\n            house_no: item.get_optional_billing_line1(),\n            street: item.get_optional_billing_line2(),\n            city: item.get_optional_billing_city().map(Secret::new),\n            zip: item.get_optional_billing_zip(),\n            country_code: item.get_optional_billing_country(),\n        };\n\n        let email = item.get_billing_email().or(item.request.get_email())?;\n\n        let customer = NovalnetPaymentsRequestCustomer {\n            first_name: req_address.and_then(|addr| addr.get_optional_first_name()),\n            last_name: req_address.and_then(|addr| addr.get_optional_last_name()),\n            email,\n            mobile: item.get_optional_billing_phone_number(),\n            billing: Some(billing),\n            // no_nc is used to indicate if minimal customer data is passed or not\n            no_nc: MINIMAL_CUSTOMER_DATA_PASSED,\n            birth_date: Some(String::from(\"1992-06-10\")),\n        };\n\n        let lang = item\n            .request\n            .get_optional_language_from_browser_info()\n            .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());\n        let extra = metadata_to_novalnet_extra(item.request.metadata.clone().map(|m| m.expose()))?;\n        let custom = NovalnetCustom { lang, extra };\n        let hook_url = item.request.get_webhook_url()?;\n        let return_url = item.request.get_return_url()?;\n        let create_token = Some(CREATE_TOKEN_REQUIRED);\n\n        match item.request.payment_method_data {\n            PaymentMethodData::Card(ref req_card) => {\n                let novalnet_card = NovalNetPaymentData::Card(NovalnetCard {\n                    card_number: req_card.card_number.clone(),\n                    card_expiry_month: req_card.card_exp_month.clone(),\n                    card_expiry_year: req_card.card_exp_year.clone(),\n                    card_cvc: req_card.card_cvc.clone(),\n                    card_holder: item.get_billing_address()?.get_full_name()?,\n                });\n\n                let transaction = NovalnetPaymentsRequestTransaction {\n                    test_mode,\n                    payment_type: NovalNetPaymentTypes::CREDITCARD,\n                    amount: NovalNetAmount::Int(0),\n                    currency: item.request.currency,\n                    order_no: item.connector_request_reference_id.clone(),\n                    hook_url: Some(hook_url),\n                    return_url: Some(return_url.clone()),\n                    error_return_url: Some(return_url.clone()),\n                    payment_data: Some(novalnet_card),\n                    enforce_3d,\n                    create_token,\n                };\n\n                Ok(Self {\n                    merchant,\n                    transaction,\n                    customer,\n                    custom,\n                })\n            }\n\n            PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {\n                WalletDataPaymentMethod::GooglePay(ref req_wallet) => {\n                    let novalnet_google_pay: NovalNetPaymentData =\n                        NovalNetPaymentData::GooglePay(NovalnetGooglePay {\n                            wallet_data: Secret::new(\n                                req_wallet\n                                    .tokenization_data\n                                    .get_encrypted_google_pay_token()\n                                    .change_context(errors::ConnectorError::MissingRequiredField {\n                                        field_name: \"gpay wallet_token\",\n                                    })?\n                                    .clone(),\n                            ),\n                        });\n\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::GOOGLEPAY,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: None,\n                        error_return_url: None,\n                        payment_data: Some(novalnet_google_pay),\n                        enforce_3d,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::ApplePay(payment_method_data) => {\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::APPLEPAY,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: None,\n                        error_return_url: None,\n                        payment_data: Some(NovalNetPaymentData::ApplePay(NovalnetApplePay {\n                            wallet_data: payment_method_data.get_applepay_decoded_payment_data()?,\n                        })),\n                        enforce_3d: None,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::AliPayQr(_)\n                | WalletDataPaymentMethod::AliPayRedirect(_)\n                | WalletDataPaymentMethod::AliPayHkRedirect(_)\n                | WalletDataPaymentMethod::AmazonPay(_)\n                | WalletDataPaymentMethod::AmazonPayRedirect(_)\n                | WalletDataPaymentMethod::Paysera(_)\n                | WalletDataPaymentMethod::Skrill(_)\n                | WalletDataPaymentMethod::BluecodeRedirect {}\n                | WalletDataPaymentMethod::MomoRedirect(_)\n                | WalletDataPaymentMethod::KakaoPayRedirect(_)\n                | WalletDataPaymentMethod::GoPayRedirect(_)\n                | WalletDataPaymentMethod::GcashRedirect(_)\n                | WalletDataPaymentMethod::ApplePayRedirect(_)\n                | WalletDataPaymentMethod::ApplePayThirdPartySdk(_)\n                | WalletDataPaymentMethod::DanaRedirect {}\n                | WalletDataPaymentMethod::GooglePayRedirect(_)\n                | WalletDataPaymentMethod::GooglePayThirdPartySdk(_)\n                | WalletDataPaymentMethod::MbWayRedirect(_)\n                | WalletDataPaymentMethod::MobilePayRedirect(_)\n                | WalletDataPaymentMethod::RevolutPay(_) => {\n                    Err(errors::ConnectorError::NotImplemented(\n                        utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n                    ))?\n                }\n                WalletDataPaymentMethod::PaypalRedirect(_) => {\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::PAYPAL,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: Some(return_url.clone()),\n                        error_return_url: Some(return_url.clone()),\n                        payment_data: None,\n                        enforce_3d: None,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::PaypalSdk(_)\n                | WalletDataPaymentMethod::Paze(_)\n                | WalletDataPaymentMethod::SamsungPay(_)\n                | WalletDataPaymentMethod::TwintRedirect {}\n                | WalletDataPaymentMethod::VippsRedirect {}\n                | WalletDataPaymentMethod::TouchNGoRedirect(_)\n                | WalletDataPaymentMethod::WeChatPayRedirect(_)\n                | WalletDataPaymentMethod::CashappQr(_)\n                | WalletDataPaymentMethod::SwishQr(_)\n                | WalletDataPaymentMethod::WeChatPayQr(_)\n                | WalletDataPaymentMethod::Mifinity(_) => {\n                    Err(errors::ConnectorError::NotImplemented(\n                        utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n                    ))?\n                }\n            },\n            _ => Err(errors::ConnectorError::NotImplemented(\n                utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n            ))?,\n        }\n    }",
+      "after_code": "fn try_from(item: &SetupMandateRouterData) -> Result<Self, Self::Error> {\n        let auth = NovalnetAuthType::try_from(&item.connector_auth_type)?;\n\n        let merchant = NovalnetPaymentsRequestMerchant {\n            signature: auth.product_activation_key,\n            tariff: auth.tariff_id,\n        };\n\n        let enforce_3d = match item.auth_type {\n            enums::AuthenticationType::ThreeDs => Some(1),\n            enums::AuthenticationType::NoThreeDs => None,\n        };\n        let test_mode = get_test_mode(item.test_mode);\n        let req_address = item.get_optional_billing();\n\n        let billing = NovalnetPaymentsRequestBilling {\n            house_no: item.get_optional_billing_line1(),\n            street: item.get_optional_billing_line2(),\n            city: item.get_optional_billing_city().map(Secret::new),\n            zip: item.get_optional_billing_zip(),\n            country_code: item.get_optional_billing_country(),\n        };\n\n        let email = item.get_billing_email().or(item.request.get_email())?;\n\n        let customer = NovalnetPaymentsRequestCustomer {\n            first_name: req_address.and_then(|addr| addr.get_optional_first_name()),\n            last_name: req_address.and_then(|addr| addr.get_optional_last_name()),\n            email,\n            mobile: item.get_optional_billing_phone_number(),\n            billing: Some(billing),\n            // no_nc is used to indicate if minimal customer data is passed or not\n            no_nc: MINIMAL_CUSTOMER_DATA_PASSED,\n            birth_date: Some(String::from(\"1992-06-10\")),\n        };\n\n        let lang = item\n            .request\n            .get_optional_language_from_browser_info()\n            .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());\n\n        let custom = NovalnetCustom { lang };\n        let hook_url = item.request.get_webhook_url()?;\n        let return_url = item.request.get_return_url()?;\n        let create_token = Some(CREATE_TOKEN_REQUIRED);\n\n        match item.request.payment_method_data {\n            PaymentMethodData::Card(ref req_card) => {\n                let novalnet_card = NovalNetPaymentData::Card(NovalnetCard {\n                    card_number: req_card.card_number.clone(),\n                    card_expiry_month: req_card.card_exp_month.clone(),\n                    card_expiry_year: req_card.card_exp_year.clone(),\n                    card_cvc: req_card.card_cvc.clone(),\n                    card_holder: item.get_billing_address()?.get_full_name()?,\n                });\n\n                let transaction = NovalnetPaymentsRequestTransaction {\n                    test_mode,\n                    payment_type: NovalNetPaymentTypes::CREDITCARD,\n                    amount: NovalNetAmount::Int(0),\n                    currency: item.request.currency,\n                    order_no: item.connector_request_reference_id.clone(),\n                    hook_url: Some(hook_url),\n                    return_url: Some(return_url.clone()),\n                    error_return_url: Some(return_url.clone()),\n                    payment_data: Some(novalnet_card),\n                    enforce_3d,\n                    create_token,\n                };\n\n                Ok(Self {\n                    merchant,\n                    transaction,\n                    customer,\n                    custom,\n                })\n            }\n\n            PaymentMethodData::Wallet(ref wallet_data) => match wallet_data {\n                WalletDataPaymentMethod::GooglePay(ref req_wallet) => {\n                    let novalnet_google_pay: NovalNetPaymentData =\n                        NovalNetPaymentData::GooglePay(NovalnetGooglePay {\n                            wallet_data: Secret::new(\n                                req_wallet\n                                    .tokenization_data\n                                    .get_encrypted_google_pay_token()\n                                    .change_context(errors::ConnectorError::MissingRequiredField {\n                                        field_name: \"gpay wallet_token\",\n                                    })?\n                                    .clone(),\n                            ),\n                        });\n\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::GOOGLEPAY,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: None,\n                        error_return_url: None,\n                        payment_data: Some(novalnet_google_pay),\n                        enforce_3d,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::ApplePay(payment_method_data) => {\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::APPLEPAY,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: None,\n                        error_return_url: None,\n                        payment_data: Some(NovalNetPaymentData::ApplePay(NovalnetApplePay {\n                            wallet_data: payment_method_data.get_applepay_decoded_payment_data()?,\n                        })),\n                        enforce_3d: None,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::AliPayQr(_)\n                | WalletDataPaymentMethod::AliPayRedirect(_)\n                | WalletDataPaymentMethod::AliPayHkRedirect(_)\n                | WalletDataPaymentMethod::AmazonPay(_)\n                | WalletDataPaymentMethod::AmazonPayRedirect(_)\n                | WalletDataPaymentMethod::Paysera(_)\n                | WalletDataPaymentMethod::Skrill(_)\n                | WalletDataPaymentMethod::BluecodeRedirect {}\n                | WalletDataPaymentMethod::MomoRedirect(_)\n                | WalletDataPaymentMethod::KakaoPayRedirect(_)\n                | WalletDataPaymentMethod::GoPayRedirect(_)\n                | WalletDataPaymentMethod::GcashRedirect(_)\n                | WalletDataPaymentMethod::ApplePayRedirect(_)\n                | WalletDataPaymentMethod::ApplePayThirdPartySdk(_)\n                | WalletDataPaymentMethod::DanaRedirect {}\n                | WalletDataPaymentMethod::GooglePayRedirect(_)\n                | WalletDataPaymentMethod::GooglePayThirdPartySdk(_)\n                | WalletDataPaymentMethod::MbWayRedirect(_)\n                | WalletDataPaymentMethod::MobilePayRedirect(_)\n                | WalletDataPaymentMethod::RevolutPay(_) => {\n                    Err(errors::ConnectorError::NotImplemented(\n                        utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n                    ))?\n                }\n                WalletDataPaymentMethod::PaypalRedirect(_) => {\n                    let transaction = NovalnetPaymentsRequestTransaction {\n                        test_mode,\n                        payment_type: NovalNetPaymentTypes::PAYPAL,\n                        amount: NovalNetAmount::Int(0),\n                        currency: item.request.currency,\n                        order_no: item.connector_request_reference_id.clone(),\n                        hook_url: Some(hook_url),\n                        return_url: Some(return_url.clone()),\n                        error_return_url: Some(return_url.clone()),\n                        payment_data: None,\n                        enforce_3d: None,\n                        create_token,\n                    };\n\n                    Ok(Self {\n                        merchant,\n                        transaction,\n                        customer,\n                        custom,\n                    })\n                }\n                WalletDataPaymentMethod::PaypalSdk(_)\n                | WalletDataPaymentMethod::Paze(_)\n                | WalletDataPaymentMethod::SamsungPay(_)\n                | WalletDataPaymentMethod::TwintRedirect {}\n                | WalletDataPaymentMethod::VippsRedirect {}\n                | WalletDataPaymentMethod::TouchNGoRedirect(_)\n                | WalletDataPaymentMethod::WeChatPayRedirect(_)\n                | WalletDataPaymentMethod::CashappQr(_)\n                | WalletDataPaymentMethod::SwishQr(_)\n                | WalletDataPaymentMethod::WeChatPayQr(_)\n                | WalletDataPaymentMethod::Mifinity(_) => {\n                    Err(errors::ConnectorError::NotImplemented(\n                        utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n                    ))?\n                }\n            },\n            _ => Err(errors::ConnectorError::NotImplemented(\n                utils::get_unimplemented_payment_method_error_message(\"novalnet\"),\n            ))?,\n        }\n    }",
+      "diff_span": {
+        "before": "            .get_optional_language_from_browser_info()\n            .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());\n        let extra = metadata_to_novalnet_extra(item.request.metadata.clone().map(|m| m.expose()))?;\n        let custom = NovalnetCustom { lang, extra };\n        let hook_url = item.request.get_webhook_url()?;\n        let return_url = item.request.get_return_url()?;",
+        "after": "            .get_optional_language_from_browser_info()\n            .unwrap_or(consts::DEFAULT_LOCALE.to_string().to_string());\n\n        let custom = NovalnetCustom { lang };\n        let hook_url = item.request.get_webhook_url()?;\n        let return_url = item.request.get_return_url()?;"
+      },
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::function::metadata_to_novalnet_extra",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "pub fn metadata_to_novalnet_extra(\n    metadata: Option<serde_json::Value>,\n) -> Result<Option<HashMap<String, String>>, Error> {\n    let Some(serde_json::Value::Object(map)) = metadata else {\n        return Ok(None);\n    };\n\n    if map.is_empty() {\n        return Ok(None);\n    }\n\n    if map.len() > 7 {\n        return Err(errors::ConnectorError::InvalidDataFormat {\n            field_name: \"metadata (max 7 allowed for Novalnet\",\n        }\n        .into());\n    }\n\n    let mut extra = HashMap::new();\n\n    for (idx, (key, val)) in map.iter().enumerate() {\n        let slot = idx + 1;\n\n        extra.insert(format!(\"input{}\", slot), key.clone());\n\n        let val_str = match val {\n            serde_json::Value::String(s) => s.clone(),\n            _ => val.to_string(),\n        };\n\n        extra.insert(format!(\"inputval{}\", slot), val_str);\n    }\n\n    Ok(Some(extra))\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    },
+    {
+      "id": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs::type::Error",
+      "file": "crates/hyperswitch_connectors/src/connectors/novalnet/transformers.rs",
+      "kind": "type_item",
+      "status": "removed",
+      "before_code": "type Error = error_stack::Report<errors::ConnectorError>;",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "2e7d22a861020fd2f8135d9788e90f4f58e929ed"
+    }
+  ]
+}

diffs/pr_10631/7632690/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "7632690858d4493aeae773cd03c9d264f1618f64",
+  "pr_number": 10631,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6706/0013bf4/diff.json

@@ -0,0 +1,8 @@
+{
+  "commit_sha": "0013bf4027ebb1a2b93556190a36295e15dfe4ff",
+  "pr_number": 6706,
+  "rust_files": [
+    "crates/common_enums/src/enums.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6706/1036cfc/diff.json

@@ -0,0 +1,6 @@
+{
+  "commit_sha": "1036cfc14c1441470d150c308e9337cb51905971",
+  "pr_number": 6706,
+  "rust_files": [],
+  "diffs": []
+}

diffs/pr_6706/129fdf1/diff.json

@@ -0,0 +1,10 @@
+{
+  "commit_sha": "129fdf1fcb2020b6c1acf66f37286155165d9ad2",
+  "pr_number": 6706,
+  "rust_files": [
+    "crates/common_types/src/lib.rs",
+    "crates/common_types/src/payments.rs",
+    "crates/common_types/src/refunds.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6706/4e70d21/diff.json

@@ -0,0 +1,184 @@
+{
+  "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494",
+  "pr_number": 6706,
+  "rust_files": [
+    "crates/api_models/src/payments.rs",
+    "crates/common_enums/src/enums.rs",
+    "crates/common_utils/src/types.rs",
+    "crates/router/src/core/payments/helpers.rs",
+    "crates/router/src/core/payments/transformers.rs",
+    "crates/router/src/core/refunds.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/refunds.rs::function::validate_and_create_refund",
+      "file": "crates/router/src/core/refunds.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn validate_and_create_refund(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    payment_attempt: &storage::PaymentAttempt,\n    payment_intent: &storage::PaymentIntent,\n    refund_amount: MinorUnit,\n    req: refunds::RefundRequest,\n    creds_identifier: Option<String>,\n) -> RouterResult<refunds::RefundResponse> {\n    let db = &*state.store;\n\n    let split_refunds = match payment_intent.split_payments.as_ref() {\n        Some(SplitPaymentsRequest::StripeSplitPayment(stripe_payment)) => {\n            let refund_request = req\n                .split_refunds\n                .clone()\n                .get_required_value(\"split_refunds\")?;\n\n            let options =\n                validator::validate_charge_refund(&refund_request, &stripe_payment.charge_type)?;\n\n            let charge_id = payment_attempt.charge_id.clone().ok_or_else(|| {\n                report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n                    \"Transaction in invalid. Missing field \\\"charge_id\\\" in payment_attempt.\",\n                )\n            })?;\n\n            Some(SplitRefundsRequest::StripeSplitRefund(StripeSplitRefund {\n                charge_id,\n                charge_type: stripe_payment.charge_type.clone(),\n                transfer_account_id: stripe_payment.transfer_account_id.clone(),\n                options,\n            }))\n        }\n        _ => None,\n    };\n\n    // let split_refunds = match (\n    //     payment_intent.split_payments.as_ref(),\n    //     payment_attempt.charge_id.as_ref(),\n    // ) {\n    //     (Some(split_payments), Some(charge_id)) => {\n    //         let refund_request = req\n    //             .split_refunds\n    //             .clone()\n    //             .get_required_value(\"split_refunds\")?;\n\n    //         // let stripe_refund = match refund_request {\n    //         //     SplitRefundRequest::StripeSplitRefundRequest(ref stripe_refund) => stripe_refund,\n    //         // };\n    //         let SplitRefundRequest::StripeSplitRefundRequest(ref stripe_refund) = refund_request;\n\n    //         // utils::when(*charge_id != stripe_refund.charge_id, || {\n    //         //     Err(report!(errors::ApiErrorResponse::InvalidDataValue {\n    //         //         field_name: \"split_refunds.charge_id\",\n    //         //     }))\n    //         //     .attach_printable(\"charge_id sent in request mismatches with original charge_id\")\n    //         // })?;\n\n    //         // let stripe_payment = match split_payments {\n    //         //     SplitPaymentsRequest::StripeSplitPayment(payment) => payment,\n    //         // };\n    //         let SplitPaymentsRequest::StripeSplitPayment(stripe_payment) = split_payments;\n\n    //         let options =\n    //             validator::validate_charge_refund(&refund_request, &stripe_payment.charge_type)?;\n\n    //         let charge_id = payment_attempt.charge_id.clone().ok_or_else(|| {\n    //             report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n    //                 \"Transaction in invalid. Missing field \\\"charge_id\\\" in payment_attempt.\",\n    //             )\n    //         })?;\n\n    //         // Construct SplitRefundsRequest\n    //         Some(SplitRefundsRequest::StripeSplitRefund(StripeSplitRefund {\n    //             charge_id,\n    //             charge_type: stripe_payment.charge_type.clone(),\n    //             transfer_account_id: stripe_payment.transfer_account_id.clone(),\n    //             options,\n    //         }))\n    //     }\n    //     _ => None,\n    // };\n\n    // Only for initial dev and testing\n    let refund_type = req.refund_type.unwrap_or_default();\n\n    // If Refund Id not passed in request Generate one.\n\n    let refund_id = core_utils::get_or_generate_id(\"refund_id\", &req.refund_id, \"ref\")?;\n\n    let predicate = req\n        .merchant_id\n        .as_ref()\n        .map(|merchant_id| merchant_id != merchant_account.get_id());\n\n    utils::when(predicate.unwrap_or(false), || {\n        Err(report!(errors::ApiErrorResponse::InvalidDataFormat {\n            field_name: \"merchant_id\".to_string(),\n            expected_format: \"merchant_id from merchant account\".to_string()\n        })\n        .attach_printable(\"invalid merchant_id in request\"))\n    })?;\n\n    let connector_transaction_id = payment_attempt.clone().connector_transaction_id.ok_or_else(|| {\n        report!(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Transaction in invalid. Missing field \\\"connector_transaction_id\\\" in payment_attempt.\")\n    })?;\n\n    let all_refunds = db\n        .find_refund_by_merchant_id_connector_transaction_id(\n            merchant_account.get_id(),\n            &connector_transaction_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::RefundNotFound)?;\n\n    let currency = payment_attempt.currency.get_required_value(\"currency\")?;\n\n    //[#249]: Add Connector Based Validation here.\n    validator::validate_payment_order_age(&payment_intent.created_at, state.conf.refund.max_age)\n        .change_context(errors::ApiErrorResponse::InvalidDataFormat {\n            field_name: \"created_at\".to_string(),\n            expected_format: format!(\n                \"created_at not older than {} days\",\n                state.conf.refund.max_age,\n            ),\n        })?;\n\n    let total_amount_captured = payment_intent\n        .amount_captured\n        .unwrap_or(payment_attempt.get_total_amount());\n\n    validator::validate_refund_amount(\n        total_amount_captured.get_amount_as_i64(),\n        &all_refunds,\n        refund_amount.get_amount_as_i64(),\n    )\n    .change_context(errors::ApiErrorResponse::RefundAmountExceedsPaymentAmount)?;\n\n    validator::validate_maximum_refund_against_payment_attempt(\n        &all_refunds,\n        state.conf.refund.max_attempts,\n    )\n    .change_context(errors::ApiErrorResponse::MaximumRefundCount)?;\n\n    let connector = payment_attempt\n        .connector\n        .clone()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"No connector populated in payment attempt\")?;\n    let (connector_transaction_id, connector_transaction_data) =\n        ConnectorTransactionId::form_id_and_data(connector_transaction_id);\n    let refund_create_req = storage::RefundNew {\n        refund_id: refund_id.to_string(),\n        internal_reference_id: utils::generate_id(consts::ID_LENGTH, \"refid\"),\n        external_reference_id: Some(refund_id.clone()),\n        payment_id: req.payment_id,\n        merchant_id: merchant_account.get_id().clone(),\n        connector_transaction_id,\n        connector,\n        refund_type: req.refund_type.unwrap_or_default().foreign_into(),\n        total_amount: payment_attempt.get_total_amount(),\n        refund_amount,\n        currency,\n        created_at: common_utils::date_time::now(),\n        modified_at: common_utils::date_time::now(),\n        refund_status: enums::RefundStatus::Pending,\n        metadata: req.metadata,\n        description: req.reason.clone(),\n        attempt_id: payment_attempt.attempt_id.clone(),\n        refund_reason: req.reason,\n        profile_id: payment_intent.profile_id.clone(),\n        merchant_connector_id: payment_attempt.merchant_connector_id.clone(),\n        charges: None,\n        split_refunds: req.split_refunds,\n        connector_refund_id: None,\n        sent_to_gateway: Default::default(),\n        refund_arn: None,\n        updated_by: Default::default(),\n        organization_id: merchant_account.organization_id.clone(),\n        connector_refund_data: None,\n        connector_transaction_data,\n    };\n\n    let refund = match db\n        .insert_refund(refund_create_req, merchant_account.storage_scheme)\n        .await\n    {\n        Ok(refund) => {\n            Box::pin(schedule_refund_execution(\n                state,\n                refund.clone(),\n                refund_type,\n                merchant_account,\n                key_store,\n                payment_attempt,\n                payment_intent,\n                creds_identifier,\n                split_refunds,\n            ))\n            .await?\n        }\n        Err(err) => {\n            if err.current_context().is_db_unique_violation() {\n                Err(errors::ApiErrorResponse::DuplicateRefundRequest)?\n            } else {\n                return Err(err)\n                    .change_context(errors::ApiErrorResponse::RefundNotFound)\n                    .attach_printable(\"Inserting Refund failed\");\n            }\n        }\n    };\n\n    Ok(refund.foreign_into())\n}",
+      "after_code": "pub async fn validate_and_create_refund(\n    state: &SessionState,\n    merchant_account: &domain::MerchantAccount,\n    key_store: &domain::MerchantKeyStore,\n    payment_attempt: &storage::PaymentAttempt,\n    payment_intent: &storage::PaymentIntent,\n    refund_amount: MinorUnit,\n    req: refunds::RefundRequest,\n    creds_identifier: Option<String>,\n) -> RouterResult<refunds::RefundResponse> {\n    let db = &*state.store;\n\n    let split_refunds = match payment_intent.split_payments.as_ref() {\n        Some(SplitPaymentsRequest::StripeSplitPayment(stripe_payment)) => {\n            let refund_request = req\n                .split_refunds\n                .clone()\n                .get_required_value(\"split_refunds\")?;\n\n            let options =\n                validator::validate_charge_refund(&refund_request, &stripe_payment.charge_type)?;\n\n            let charge_id = payment_attempt.charge_id.clone().ok_or_else(|| {\n                report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n                    \"Transaction in invalid. Missing field \\\"charge_id\\\" in payment_attempt.\",\n                )\n            })?;\n\n            Some(SplitRefundsRequest::StripeSplitRefund(StripeSplitRefund {\n                charge_id,\n                charge_type: stripe_payment.charge_type.clone(),\n                transfer_account_id: stripe_payment.transfer_account_id.clone(),\n                options,\n            }))\n        }\n        _ => None,\n    };\n\n    // Only for initial dev and testing\n    let refund_type = req.refund_type.unwrap_or_default();\n\n    // If Refund Id not passed in request Generate one.\n\n    let refund_id = core_utils::get_or_generate_id(\"refund_id\", &req.refund_id, \"ref\")?;\n\n    let predicate = req\n        .merchant_id\n        .as_ref()\n        .map(|merchant_id| merchant_id != merchant_account.get_id());\n\n    utils::when(predicate.unwrap_or(false), || {\n        Err(report!(errors::ApiErrorResponse::InvalidDataFormat {\n            field_name: \"merchant_id\".to_string(),\n            expected_format: \"merchant_id from merchant account\".to_string()\n        })\n        .attach_printable(\"invalid merchant_id in request\"))\n    })?;\n\n    let connector_transaction_id = payment_attempt.clone().connector_transaction_id.ok_or_else(|| {\n        report!(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Transaction in invalid. Missing field \\\"connector_transaction_id\\\" in payment_attempt.\")\n    })?;\n\n    let all_refunds = db\n        .find_refund_by_merchant_id_connector_transaction_id(\n            merchant_account.get_id(),\n            &connector_transaction_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::RefundNotFound)?;\n\n    let currency = payment_attempt.currency.get_required_value(\"currency\")?;\n\n    //[#249]: Add Connector Based Validation here.\n    validator::validate_payment_order_age(&payment_intent.created_at, state.conf.refund.max_age)\n        .change_context(errors::ApiErrorResponse::InvalidDataFormat {\n            field_name: \"created_at\".to_string(),\n            expected_format: format!(\n                \"created_at not older than {} days\",\n                state.conf.refund.max_age,\n            ),\n        })?;\n\n    let total_amount_captured = payment_intent\n        .amount_captured\n        .unwrap_or(payment_attempt.get_total_amount());\n\n    validator::validate_refund_amount(\n        total_amount_captured.get_amount_as_i64(),\n        &all_refunds,\n        refund_amount.get_amount_as_i64(),\n    )\n    .change_context(errors::ApiErrorResponse::RefundAmountExceedsPaymentAmount)?;\n\n    validator::validate_maximum_refund_against_payment_attempt(\n        &all_refunds,\n        state.conf.refund.max_attempts,\n    )\n    .change_context(errors::ApiErrorResponse::MaximumRefundCount)?;\n\n    let connector = payment_attempt\n        .connector\n        .clone()\n        .ok_or(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"No connector populated in payment attempt\")?;\n    let (connector_transaction_id, connector_transaction_data) =\n        ConnectorTransactionId::form_id_and_data(connector_transaction_id);\n    let refund_create_req = storage::RefundNew {\n        refund_id: refund_id.to_string(),\n        internal_reference_id: utils::generate_id(consts::ID_LENGTH, \"refid\"),\n        external_reference_id: Some(refund_id.clone()),\n        payment_id: req.payment_id,\n        merchant_id: merchant_account.get_id().clone(),\n        connector_transaction_id,\n        connector,\n        refund_type: req.refund_type.unwrap_or_default().foreign_into(),\n        total_amount: payment_attempt.get_total_amount(),\n        refund_amount,\n        currency,\n        created_at: common_utils::date_time::now(),\n        modified_at: common_utils::date_time::now(),\n        refund_status: enums::RefundStatus::Pending,\n        metadata: req.metadata,\n        description: req.reason.clone(),\n        attempt_id: payment_attempt.attempt_id.clone(),\n        refund_reason: req.reason,\n        profile_id: payment_intent.profile_id.clone(),\n        merchant_connector_id: payment_attempt.merchant_connector_id.clone(),\n        charges: None,\n        split_refunds: req.split_refunds,\n        connector_refund_id: None,\n        sent_to_gateway: Default::default(),\n        refund_arn: None,\n        updated_by: Default::default(),\n        organization_id: merchant_account.organization_id.clone(),\n        connector_refund_data: None,\n        connector_transaction_data,\n    };\n\n    let refund = match db\n        .insert_refund(refund_create_req, merchant_account.storage_scheme)\n        .await\n    {\n        Ok(refund) => {\n            Box::pin(schedule_refund_execution(\n                state,\n                refund.clone(),\n                refund_type,\n                merchant_account,\n                key_store,\n                payment_attempt,\n                payment_intent,\n                creds_identifier,\n                split_refunds,\n            ))\n            .await?\n        }\n        Err(err) => {\n            if err.current_context().is_db_unique_violation() {\n                Err(errors::ApiErrorResponse::DuplicateRefundRequest)?\n            } else {\n                return Err(err)\n                    .change_context(errors::ApiErrorResponse::RefundNotFound)\n                    .attach_printable(\"Inserting Refund failed\");\n            }\n        }\n    };\n\n    Ok(refund.foreign_into())\n}",
+      "diff_span": {
+        "before": "        _ => None,\n    };\n\n    // let split_refunds = match (\n    //     payment_intent.split_payments.as_ref(),\n    //     payment_attempt.charge_id.as_ref(),\n    // ) {\n    //     (Some(split_payments), Some(charge_id)) => {\n    //         let refund_request = req\n    //             .split_refunds\n    //             .clone()\n    //             .get_required_value(\"split_refunds\")?;\n\n    //         // let stripe_refund = match refund_request {\n    //         //     SplitRefundRequest::StripeSplitRefundRequest(ref stripe_refund) => stripe_refund,\n    //         // };\n    //         let SplitRefundRequest::StripeSplitRefundRequest(ref stripe_refund) = refund_request;\n\n    //         // utils::when(*charge_id != stripe_refund.charge_id, || {\n    //         //     Err(report!(errors::ApiErrorResponse::InvalidDataValue {\n    //         //         field_name: \"split_refunds.charge_id\",\n    //         //     }))\n    //         //     .attach_printable(\"charge_id sent in request mismatches with original charge_id\")\n    //         // })?;\n\n    //         // let stripe_payment = match split_payments {\n    //         //     SplitPaymentsRequest::StripeSplitPayment(payment) => payment,\n    //         // };\n    //         let SplitPaymentsRequest::StripeSplitPayment(stripe_payment) = split_payments;\n\n    //         let options =\n    //             validator::validate_charge_refund(&refund_request, &stripe_payment.charge_type)?;\n\n    //         let charge_id = payment_attempt.charge_id.clone().ok_or_else(|| {\n    //             report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n    //                 \"Transaction in invalid. Missing field \\\"charge_id\\\" in payment_attempt.\",\n    //             )\n    //         })?;\n\n    //         // Construct SplitRefundsRequest\n    //         Some(SplitRefundsRequest::StripeSplitRefund(StripeSplitRefund {\n    //             charge_id,\n    //             charge_type: stripe_payment.charge_type.clone(),\n    //             transfer_account_id: stripe_payment.transfer_account_id.clone(),\n    //             options,\n    //         }))\n    //     }\n    //     _ => None,\n    // };\n\n    // Only for initial dev and testing",
+        "after": ""
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/router/src/core/payments/transformers.rs::function::construct_router_data_for_psync",
+      "file": "crates/router/src/core/payments/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn construct_router_data_for_psync<'a>(\n    state: &'a SessionState,\n    payment_data: hyperswitch_domain_models::payments::PaymentStatusData<api::PSync>,\n    connector_id: &str,\n    merchant_account: &domain::MerchantAccount,\n    _key_store: &domain::MerchantKeyStore,\n    customer: &'a Option<domain::Customer>,\n    merchant_connector_account: &domain::MerchantConnectorAccount,\n    _merchant_recipient_data: Option<types::MerchantRecipientData>,\n    header_payload: Option<hyperswitch_domain_models::payments::HeaderPayload>,\n) -> RouterResult<types::PaymentsSyncRouterData> {\n    use masking::ExposeOptionInterface;\n\n    fp_utils::when(merchant_connector_account.is_disabled(), || {\n        Err(errors::ApiErrorResponse::MerchantConnectorAccountDisabled)\n    })?;\n\n    // TODO: Take Globalid / CustomerReferenceId and convert to connector reference id\n    let customer_id = None;\n\n    let payment_intent = payment_data.payment_intent;\n\n    let auth_type: types::ConnectorAuthType = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed while parsing value for ConnectorAuthType\")?;\n\n    let attempt = &payment_data\n        .payment_attempt\n        .get_required_value(\"attempt\")\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Payment Attempt is not available in payment data\")?;\n\n    let connector_request_reference_id = payment_intent\n        .merchant_reference_id\n        .map(|id| id.get_string_repr().to_owned())\n        .unwrap_or(attempt.id.get_string_repr().to_owned());\n\n    let request = types::PaymentsSyncData {\n        amount: attempt.amount_details.net_amount,\n        integrity_object: None,\n        mandate_id: None,\n        connector_transaction_id: match attempt.get_connector_payment_id() {\n            Some(connector_txn_id) => {\n                types::ResponseId::ConnectorTransactionId(connector_txn_id.to_owned())\n            }\n            None => types::ResponseId::NoResponseId,\n        },\n        encoded_data: attempt.encoded_data.clone().expose_option(),\n        capture_method: Some(payment_intent.capture_method),\n        connector_meta: attempt.connector_metadata.clone().expose_option(),\n        sync_type: types::SyncRequestType::SinglePaymentSync,\n        payment_method_type: Some(attempt.payment_method_subtype),\n        currency: payment_intent.amount_details.currency,\n        // TODO: Get the charges object from\n        split_payments: None,\n        payment_experience: None,\n    };\n\n    // TODO: evaluate the fields in router data, if they are required or not\n    let router_data = types::RouterData {\n        flow: PhantomData,\n        merchant_id: merchant_account.get_id().clone(),\n        // TODO: evaluate why we need customer id at the connector level. We already have connector customer id.\n        customer_id,\n        connector: connector_id.to_owned(),\n        // TODO: evaluate why we need payment id at the connector level. We already have connector reference id\n        payment_id: payment_intent.id.get_string_repr().to_owned(),\n        // TODO: evaluate why we need attempt id at the connector level. We already have connector reference id\n        attempt_id: attempt.get_id().get_string_repr().to_owned(),\n        status: attempt.status,\n        payment_method: attempt.payment_method_type,\n        connector_auth_type: auth_type,\n        description: payment_intent\n            .description\n            .as_ref()\n            .map(|description| description.get_string_repr())\n            .map(ToOwned::to_owned),\n        // TODO: evaluate why we need to send merchant's return url here\n        // This should be the return url of application, since application takes care of the redirection\n        return_url: payment_intent\n            .return_url\n            .as_ref()\n            .map(|description| description.get_string_repr())\n            .map(ToOwned::to_owned),\n        // TODO: Create unified address\n        address: hyperswitch_domain_models::payment_address::PaymentAddress::default(),\n        auth_type: attempt.authentication_type,\n        connector_meta_data: None,\n        connector_wallets_details: None,\n        request,\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n        amount_captured: None,\n        minor_amount_captured: None,\n        access_token: None,\n        session_token: None,\n        reference_id: None,\n        payment_method_status: None,\n        payment_method_token: None,\n        connector_customer: None,\n        recurring_mandate_payment_data: None,\n        // TODO: This has to be generated as the reference id based on the connector configuration\n        // Some connectros might not accept accept the global id. This has to be done when generating the reference id\n        connector_request_reference_id,\n        preprocessing_id: attempt.preprocessing_step_id.clone(),\n        #[cfg(feature = \"payouts\")]\n        payout_method_data: None,\n        #[cfg(feature = \"payouts\")]\n        quote_id: None,\n        // TODO: take this based on the env\n        test_mode: Some(true),\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,\n        connector_mandate_request_reference_id: None,\n        psd2_sca_exemption_type: None,\n    };\n\n    Ok(router_data)\n}",
+      "after_code": "pub async fn construct_router_data_for_psync<'a>(\n    state: &'a SessionState,\n    payment_data: hyperswitch_domain_models::payments::PaymentStatusData<api::PSync>,\n    connector_id: &str,\n    merchant_account: &domain::MerchantAccount,\n    _key_store: &domain::MerchantKeyStore,\n    customer: &'a Option<domain::Customer>,\n    merchant_connector_account: &domain::MerchantConnectorAccount,\n    _merchant_recipient_data: Option<types::MerchantRecipientData>,\n    header_payload: Option<hyperswitch_domain_models::payments::HeaderPayload>,\n) -> RouterResult<types::PaymentsSyncRouterData> {\n    use masking::ExposeOptionInterface;\n\n    fp_utils::when(merchant_connector_account.is_disabled(), || {\n        Err(errors::ApiErrorResponse::MerchantConnectorAccountDisabled)\n    })?;\n\n    // TODO: Take Globalid / CustomerReferenceId and convert to connector reference id\n    let customer_id = None;\n\n    let payment_intent = payment_data.payment_intent;\n\n    let auth_type: types::ConnectorAuthType = merchant_connector_account\n        .get_connector_account_details()\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Failed while parsing value for ConnectorAuthType\")?;\n\n    let attempt = &payment_data\n        .payment_attempt\n        .get_required_value(\"attempt\")\n        .change_context(errors::ApiErrorResponse::InternalServerError)\n        .attach_printable(\"Payment Attempt is not available in payment data\")?;\n\n    let connector_request_reference_id = payment_intent\n        .merchant_reference_id\n        .map(|id| id.get_string_repr().to_owned())\n        .unwrap_or(attempt.id.get_string_repr().to_owned());\n\n    let request = types::PaymentsSyncData {\n        amount: attempt.amount_details.net_amount,\n        integrity_object: None,\n        mandate_id: None,\n        connector_transaction_id: match attempt.get_connector_payment_id() {\n            Some(connector_txn_id) => {\n                types::ResponseId::ConnectorTransactionId(connector_txn_id.to_owned())\n            }\n            None => types::ResponseId::NoResponseId,\n        },\n        encoded_data: attempt.encoded_data.clone().expose_option(),\n        capture_method: Some(payment_intent.capture_method),\n        connector_meta: attempt.connector_metadata.clone().expose_option(),\n        sync_type: types::SyncRequestType::SinglePaymentSync,\n        payment_method_type: Some(attempt.payment_method_subtype),\n        currency: payment_intent.amount_details.currency,\n        // TODO: Get the charges object from feature metadata\n        split_payments: None,\n        payment_experience: None,\n    };\n\n    // TODO: evaluate the fields in router data, if they are required or not\n    let router_data = types::RouterData {\n        flow: PhantomData,\n        merchant_id: merchant_account.get_id().clone(),\n        // TODO: evaluate why we need customer id at the connector level. We already have connector customer id.\n        customer_id,\n        connector: connector_id.to_owned(),\n        // TODO: evaluate why we need payment id at the connector level. We already have connector reference id\n        payment_id: payment_intent.id.get_string_repr().to_owned(),\n        // TODO: evaluate why we need attempt id at the connector level. We already have connector reference id\n        attempt_id: attempt.get_id().get_string_repr().to_owned(),\n        status: attempt.status,\n        payment_method: attempt.payment_method_type,\n        connector_auth_type: auth_type,\n        description: payment_intent\n            .description\n            .as_ref()\n            .map(|description| description.get_string_repr())\n            .map(ToOwned::to_owned),\n        // TODO: evaluate why we need to send merchant's return url here\n        // This should be the return url of application, since application takes care of the redirection\n        return_url: payment_intent\n            .return_url\n            .as_ref()\n            .map(|description| description.get_string_repr())\n            .map(ToOwned::to_owned),\n        // TODO: Create unified address\n        address: hyperswitch_domain_models::payment_address::PaymentAddress::default(),\n        auth_type: attempt.authentication_type,\n        connector_meta_data: None,\n        connector_wallets_details: None,\n        request,\n        response: Err(hyperswitch_domain_models::router_data::ErrorResponse::default()),\n        amount_captured: None,\n        minor_amount_captured: None,\n        access_token: None,\n        session_token: None,\n        reference_id: None,\n        payment_method_status: None,\n        payment_method_token: None,\n        connector_customer: None,\n        recurring_mandate_payment_data: None,\n        // TODO: This has to be generated as the reference id based on the connector configuration\n        // Some connectros might not accept accept the global id. This has to be done when generating the reference id\n        connector_request_reference_id,\n        preprocessing_id: attempt.preprocessing_step_id.clone(),\n        #[cfg(feature = \"payouts\")]\n        payout_method_data: None,\n        #[cfg(feature = \"payouts\")]\n        quote_id: None,\n        // TODO: take this based on the env\n        test_mode: Some(true),\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,\n        connector_mandate_request_reference_id: None,\n        psd2_sca_exemption_type: None,\n    };\n\n    Ok(router_data)\n}",
+      "diff_span": {
+        "before": "        payment_method_type: Some(attempt.payment_method_subtype),\n        currency: payment_intent.amount_details.currency,\n        // TODO: Get the charges object from\n        split_payments: None,\n        payment_experience: None,",
+        "after": "        payment_method_type: Some(attempt.payment_method_subtype),\n        currency: payment_intent.amount_details.currency,\n        // TODO: Get the charges object from feature metadata\n        split_payments: None,\n        payment_experience: None,"
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/router/src/core/payments/transformers.rs::impl::types::PaymentsAuthorizeData",
+      "file": "crates/router/src/core/payments/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsAuthorizeData {\n    type Error = error_stack::Report<errors::ApiErrorResponse>;\n\n    fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {\n        let payment_data = additional_data.payment_data.clone();\n        let router_base_url = &additional_data.router_base_url;\n        let connector_name = &additional_data.connector_name;\n        let attempt = &payment_data.payment_attempt;\n        let browser_info: Option<types::BrowserInformation> = attempt\n            .browser_info\n            .clone()\n            .map(|b| b.parse_value(\"BrowserInformation\"))\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                field_name: \"browser_info\",\n            })?;\n\n        let order_category = additional_data\n            .payment_data\n            .payment_intent\n            .connector_metadata\n            .map(|cm| {\n                cm.parse_value::<api_models::payments::ConnectorMetadata>(\"ConnectorMetadata\")\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed parsing ConnectorMetadata\")\n            })\n            .transpose()?\n            .and_then(|cm| cm.noon.and_then(|noon| noon.order_category));\n\n        let order_details = additional_data\n            .payment_data\n            .payment_intent\n            .order_details\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|data| {\n                        data.to_owned()\n                            .parse_value(\"OrderDetailsWithAmount\")\n                            .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                                field_name: \"OrderDetailsWithAmount\",\n                            })\n                            .attach_printable(\"Unable to parse OrderDetailsWithAmount\")\n                    })\n                    .collect::<Result<Vec<_>, _>>()\n            })\n            .transpose()?;\n\n        let complete_authorize_url = Some(helpers::create_complete_authorize_url(\n            router_base_url,\n            attempt,\n            connector_name,\n        ));\n\n        let webhook_url = Some(helpers::create_webhook_url(\n            router_base_url,\n            &attempt.merchant_id,\n            connector_name,\n        ));\n        let router_return_url = Some(helpers::create_redirect_url(\n            router_base_url,\n            attempt,\n            connector_name,\n            payment_data.creds_identifier.as_deref(),\n        ));\n\n        let additional_payment_method_data = if payment_data.mandate_id.is_some() {\n            let parsed_additional_payment_data: Option<api_models::payments::AdditionalPaymentData> =\n                payment_data.payment_attempt\n                    .payment_method_data\n                    .as_ref().map(|data| data.clone().parse_value(\"AdditionalPaymentData\"))\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to parse AdditionalPaymentData from payment_data.payment_attempt.payment_method_data\")?;\n            parsed_additional_payment_data\n        } else {\n            None\n        };\n\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        let payment_method_data = payment_data.payment_method_data.or_else(|| {\n            if payment_data.mandate_id.is_some() {\n                Some(domain::PaymentMethodData::MandatePayment)\n            } else {\n                None\n            }\n        });\n        let amount = payment_data.payment_attempt.get_total_amount();\n\n        let customer_name = additional_data\n            .customer_data\n            .as_ref()\n            .and_then(|customer_data| {\n                customer_data\n                    .name\n                    .as_ref()\n                    .map(|customer| customer.clone().into_inner())\n            });\n\n        let customer_id = additional_data\n            .customer_data\n            .as_ref()\n            .map(|data| data.customer_id.clone());\n\n        let merchant_order_reference_id = payment_data\n            .payment_intent\n            .merchant_order_reference_id\n            .clone();\n        let shipping_cost = payment_data.payment_intent.shipping_cost;\n\n        Ok(Self {\n            payment_method_data: (payment_method_data.get_required_value(\"payment_method_data\")?),\n            setup_future_usage: payment_data.payment_intent.setup_future_usage,\n            mandate_id: payment_data.mandate_id.clone(),\n            off_session: payment_data.mandate_id.as_ref().map(|_| true),\n            setup_mandate_details: payment_data.setup_mandate.clone(),\n            confirm: payment_data.payment_attempt.confirm,\n            statement_descriptor_suffix: payment_data.payment_intent.statement_descriptor_suffix,\n            statement_descriptor: payment_data.payment_intent.statement_descriptor_name,\n            capture_method: payment_data.payment_attempt.capture_method,\n            amount: amount.get_amount_as_i64(),\n            minor_amount: amount,\n            currency: payment_data.currency,\n            browser_info,\n            email: payment_data.email,\n            customer_name,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n            order_details,\n            order_category,\n            session_token: None,\n            enrolled_for_3ds: true,\n            related_transaction_id: None,\n            payment_method_type: payment_data.payment_attempt.payment_method_type,\n            router_return_url,\n            webhook_url,\n            complete_authorize_url,\n            customer_id,\n            surcharge_details: payment_data.surcharge_details,\n            request_incremental_authorization: matches!(\n                payment_data\n                    .payment_intent\n                    .request_incremental_authorization,\n                Some(RequestIncrementalAuthorization::True)\n                    | Some(RequestIncrementalAuthorization::Default)\n            ),\n            metadata: additional_data.payment_data.payment_intent.metadata,\n            authentication_data: payment_data\n                .authentication\n                .as_ref()\n                .map(AuthenticationData::foreign_try_from)\n                .transpose()?,\n            customer_acceptance: payment_data.customer_acceptance,\n            split_payments,\n            merchant_order_reference_id,\n            integrity_object: None,\n            additional_payment_method_data,\n            shipping_cost,\n        })\n    }\n}",
+      "after_code": "impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsAuthorizeData {\n    type Error = error_stack::Report<errors::ApiErrorResponse>;\n\n    fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {\n        let payment_data = additional_data.payment_data.clone();\n        let router_base_url = &additional_data.router_base_url;\n        let connector_name = &additional_data.connector_name;\n        let attempt = &payment_data.payment_attempt;\n        let browser_info: Option<types::BrowserInformation> = attempt\n            .browser_info\n            .clone()\n            .map(|b| b.parse_value(\"BrowserInformation\"))\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                field_name: \"browser_info\",\n            })?;\n\n        let order_category = additional_data\n            .payment_data\n            .payment_intent\n            .connector_metadata\n            .map(|cm| {\n                cm.parse_value::<api_models::payments::ConnectorMetadata>(\"ConnectorMetadata\")\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed parsing ConnectorMetadata\")\n            })\n            .transpose()?\n            .and_then(|cm| cm.noon.and_then(|noon| noon.order_category));\n\n        let order_details = additional_data\n            .payment_data\n            .payment_intent\n            .order_details\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|data| {\n                        data.to_owned()\n                            .parse_value(\"OrderDetailsWithAmount\")\n                            .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                                field_name: \"OrderDetailsWithAmount\",\n                            })\n                            .attach_printable(\"Unable to parse OrderDetailsWithAmount\")\n                    })\n                    .collect::<Result<Vec<_>, _>>()\n            })\n            .transpose()?;\n\n        let complete_authorize_url = Some(helpers::create_complete_authorize_url(\n            router_base_url,\n            attempt,\n            connector_name,\n        ));\n\n        let webhook_url = Some(helpers::create_webhook_url(\n            router_base_url,\n            &attempt.merchant_id,\n            connector_name,\n        ));\n        let router_return_url = Some(helpers::create_redirect_url(\n            router_base_url,\n            attempt,\n            connector_name,\n            payment_data.creds_identifier.as_deref(),\n        ));\n\n        let additional_payment_method_data = if payment_data.mandate_id.is_some() {\n            let parsed_additional_payment_data: Option<api_models::payments::AdditionalPaymentData> =\n                payment_data.payment_attempt\n                    .payment_method_data\n                    .as_ref().map(|data| data.clone().parse_value(\"AdditionalPaymentData\"))\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to parse AdditionalPaymentData from payment_data.payment_attempt.payment_method_data\")?;\n            parsed_additional_payment_data\n        } else {\n            None\n        };\n        let payment_method_data = payment_data.payment_method_data.or_else(|| {\n            if payment_data.mandate_id.is_some() {\n                Some(domain::PaymentMethodData::MandatePayment)\n            } else {\n                None\n            }\n        });\n        let amount = payment_data.payment_attempt.get_total_amount();\n\n        let customer_name = additional_data\n            .customer_data\n            .as_ref()\n            .and_then(|customer_data| {\n                customer_data\n                    .name\n                    .as_ref()\n                    .map(|customer| customer.clone().into_inner())\n            });\n\n        let customer_id = additional_data\n            .customer_data\n            .as_ref()\n            .map(|data| data.customer_id.clone());\n\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        let merchant_order_reference_id = payment_data\n            .payment_intent\n            .merchant_order_reference_id\n            .clone();\n        let shipping_cost = payment_data.payment_intent.shipping_cost;\n\n        Ok(Self {\n            payment_method_data: (payment_method_data.get_required_value(\"payment_method_data\")?),\n            setup_future_usage: payment_data.payment_intent.setup_future_usage,\n            mandate_id: payment_data.mandate_id.clone(),\n            off_session: payment_data.mandate_id.as_ref().map(|_| true),\n            setup_mandate_details: payment_data.setup_mandate.clone(),\n            confirm: payment_data.payment_attempt.confirm,\n            statement_descriptor_suffix: payment_data.payment_intent.statement_descriptor_suffix,\n            statement_descriptor: payment_data.payment_intent.statement_descriptor_name,\n            capture_method: payment_data.payment_attempt.capture_method,\n            amount: amount.get_amount_as_i64(),\n            minor_amount: amount,\n            currency: payment_data.currency,\n            browser_info,\n            email: payment_data.email,\n            customer_name,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n            order_details,\n            order_category,\n            session_token: None,\n            enrolled_for_3ds: true,\n            related_transaction_id: None,\n            payment_method_type: payment_data.payment_attempt.payment_method_type,\n            router_return_url,\n            webhook_url,\n            complete_authorize_url,\n            customer_id,\n            surcharge_details: payment_data.surcharge_details,\n            request_incremental_authorization: matches!(\n                payment_data\n                    .payment_intent\n                    .request_incremental_authorization,\n                Some(RequestIncrementalAuthorization::True)\n                    | Some(RequestIncrementalAuthorization::Default)\n            ),\n            metadata: additional_data.payment_data.payment_intent.metadata,\n            authentication_data: payment_data\n                .authentication\n                .as_ref()\n                .map(AuthenticationData::foreign_try_from)\n                .transpose()?,\n            customer_acceptance: payment_data.customer_acceptance,\n            split_payments,\n            merchant_order_reference_id,\n            integrity_object: None,\n            additional_payment_method_data,\n            shipping_cost,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "            None\n        };\n\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        let payment_method_data = payment_data.payment_method_data.or_else(|| {\n            if payment_data.mandate_id.is_some() {",
+        "after": "            .as_ref()\n            .map(|data| data.customer_id.clone());\n\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        let merchant_order_reference_id = payment_data"
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/router/src/core/payments/transformers.rs::types::PaymentsAuthorizeData::function::try_from",
+      "file": "crates/router/src/core/payments/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {\n        let payment_data = additional_data.payment_data.clone();\n        let router_base_url = &additional_data.router_base_url;\n        let connector_name = &additional_data.connector_name;\n        let attempt = &payment_data.payment_attempt;\n        let browser_info: Option<types::BrowserInformation> = attempt\n            .browser_info\n            .clone()\n            .map(|b| b.parse_value(\"BrowserInformation\"))\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                field_name: \"browser_info\",\n            })?;\n\n        let order_category = additional_data\n            .payment_data\n            .payment_intent\n            .connector_metadata\n            .map(|cm| {\n                cm.parse_value::<api_models::payments::ConnectorMetadata>(\"ConnectorMetadata\")\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed parsing ConnectorMetadata\")\n            })\n            .transpose()?\n            .and_then(|cm| cm.noon.and_then(|noon| noon.order_category));\n\n        let order_details = additional_data\n            .payment_data\n            .payment_intent\n            .order_details\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|data| {\n                        data.to_owned()\n                            .parse_value(\"OrderDetailsWithAmount\")\n                            .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                                field_name: \"OrderDetailsWithAmount\",\n                            })\n                            .attach_printable(\"Unable to parse OrderDetailsWithAmount\")\n                    })\n                    .collect::<Result<Vec<_>, _>>()\n            })\n            .transpose()?;\n\n        let complete_authorize_url = Some(helpers::create_complete_authorize_url(\n            router_base_url,\n            attempt,\n            connector_name,\n        ));\n\n        let webhook_url = Some(helpers::create_webhook_url(\n            router_base_url,\n            &attempt.merchant_id,\n            connector_name,\n        ));\n        let router_return_url = Some(helpers::create_redirect_url(\n            router_base_url,\n            attempt,\n            connector_name,\n            payment_data.creds_identifier.as_deref(),\n        ));\n\n        let additional_payment_method_data = if payment_data.mandate_id.is_some() {\n            let parsed_additional_payment_data: Option<api_models::payments::AdditionalPaymentData> =\n                payment_data.payment_attempt\n                    .payment_method_data\n                    .as_ref().map(|data| data.clone().parse_value(\"AdditionalPaymentData\"))\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to parse AdditionalPaymentData from payment_data.payment_attempt.payment_method_data\")?;\n            parsed_additional_payment_data\n        } else {\n            None\n        };\n\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        let payment_method_data = payment_data.payment_method_data.or_else(|| {\n            if payment_data.mandate_id.is_some() {\n                Some(domain::PaymentMethodData::MandatePayment)\n            } else {\n                None\n            }\n        });\n        let amount = payment_data.payment_attempt.get_total_amount();\n\n        let customer_name = additional_data\n            .customer_data\n            .as_ref()\n            .and_then(|customer_data| {\n                customer_data\n                    .name\n                    .as_ref()\n                    .map(|customer| customer.clone().into_inner())\n            });\n\n        let customer_id = additional_data\n            .customer_data\n            .as_ref()\n            .map(|data| data.customer_id.clone());\n\n        let merchant_order_reference_id = payment_data\n            .payment_intent\n            .merchant_order_reference_id\n            .clone();\n        let shipping_cost = payment_data.payment_intent.shipping_cost;\n\n        Ok(Self {\n            payment_method_data: (payment_method_data.get_required_value(\"payment_method_data\")?),\n            setup_future_usage: payment_data.payment_intent.setup_future_usage,\n            mandate_id: payment_data.mandate_id.clone(),\n            off_session: payment_data.mandate_id.as_ref().map(|_| true),\n            setup_mandate_details: payment_data.setup_mandate.clone(),\n            confirm: payment_data.payment_attempt.confirm,\n            statement_descriptor_suffix: payment_data.payment_intent.statement_descriptor_suffix,\n            statement_descriptor: payment_data.payment_intent.statement_descriptor_name,\n            capture_method: payment_data.payment_attempt.capture_method,\n            amount: amount.get_amount_as_i64(),\n            minor_amount: amount,\n            currency: payment_data.currency,\n            browser_info,\n            email: payment_data.email,\n            customer_name,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n            order_details,\n            order_category,\n            session_token: None,\n            enrolled_for_3ds: true,\n            related_transaction_id: None,\n            payment_method_type: payment_data.payment_attempt.payment_method_type,\n            router_return_url,\n            webhook_url,\n            complete_authorize_url,\n            customer_id,\n            surcharge_details: payment_data.surcharge_details,\n            request_incremental_authorization: matches!(\n                payment_data\n                    .payment_intent\n                    .request_incremental_authorization,\n                Some(RequestIncrementalAuthorization::True)\n                    | Some(RequestIncrementalAuthorization::Default)\n            ),\n            metadata: additional_data.payment_data.payment_intent.metadata,\n            authentication_data: payment_data\n                .authentication\n                .as_ref()\n                .map(AuthenticationData::foreign_try_from)\n                .transpose()?,\n            customer_acceptance: payment_data.customer_acceptance,\n            split_payments,\n            merchant_order_reference_id,\n            integrity_object: None,\n            additional_payment_method_data,\n            shipping_cost,\n        })\n    }",
+      "after_code": "fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {\n        let payment_data = additional_data.payment_data.clone();\n        let router_base_url = &additional_data.router_base_url;\n        let connector_name = &additional_data.connector_name;\n        let attempt = &payment_data.payment_attempt;\n        let browser_info: Option<types::BrowserInformation> = attempt\n            .browser_info\n            .clone()\n            .map(|b| b.parse_value(\"BrowserInformation\"))\n            .transpose()\n            .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                field_name: \"browser_info\",\n            })?;\n\n        let order_category = additional_data\n            .payment_data\n            .payment_intent\n            .connector_metadata\n            .map(|cm| {\n                cm.parse_value::<api_models::payments::ConnectorMetadata>(\"ConnectorMetadata\")\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed parsing ConnectorMetadata\")\n            })\n            .transpose()?\n            .and_then(|cm| cm.noon.and_then(|noon| noon.order_category));\n\n        let order_details = additional_data\n            .payment_data\n            .payment_intent\n            .order_details\n            .map(|order_details| {\n                order_details\n                    .iter()\n                    .map(|data| {\n                        data.to_owned()\n                            .parse_value(\"OrderDetailsWithAmount\")\n                            .change_context(errors::ApiErrorResponse::InvalidDataValue {\n                                field_name: \"OrderDetailsWithAmount\",\n                            })\n                            .attach_printable(\"Unable to parse OrderDetailsWithAmount\")\n                    })\n                    .collect::<Result<Vec<_>, _>>()\n            })\n            .transpose()?;\n\n        let complete_authorize_url = Some(helpers::create_complete_authorize_url(\n            router_base_url,\n            attempt,\n            connector_name,\n        ));\n\n        let webhook_url = Some(helpers::create_webhook_url(\n            router_base_url,\n            &attempt.merchant_id,\n            connector_name,\n        ));\n        let router_return_url = Some(helpers::create_redirect_url(\n            router_base_url,\n            attempt,\n            connector_name,\n            payment_data.creds_identifier.as_deref(),\n        ));\n\n        let additional_payment_method_data = if payment_data.mandate_id.is_some() {\n            let parsed_additional_payment_data: Option<api_models::payments::AdditionalPaymentData> =\n                payment_data.payment_attempt\n                    .payment_method_data\n                    .as_ref().map(|data| data.clone().parse_value(\"AdditionalPaymentData\"))\n                    .transpose()\n                    .change_context(errors::ApiErrorResponse::InternalServerError)\n                    .attach_printable(\"Failed to parse AdditionalPaymentData from payment_data.payment_attempt.payment_method_data\")?;\n            parsed_additional_payment_data\n        } else {\n            None\n        };\n        let payment_method_data = payment_data.payment_method_data.or_else(|| {\n            if payment_data.mandate_id.is_some() {\n                Some(domain::PaymentMethodData::MandatePayment)\n            } else {\n                None\n            }\n        });\n        let amount = payment_data.payment_attempt.get_total_amount();\n\n        let customer_name = additional_data\n            .customer_data\n            .as_ref()\n            .and_then(|customer_data| {\n                customer_data\n                    .name\n                    .as_ref()\n                    .map(|customer| customer.clone().into_inner())\n            });\n\n        let customer_id = additional_data\n            .customer_data\n            .as_ref()\n            .map(|data| data.customer_id.clone());\n\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        let merchant_order_reference_id = payment_data\n            .payment_intent\n            .merchant_order_reference_id\n            .clone();\n        let shipping_cost = payment_data.payment_intent.shipping_cost;\n\n        Ok(Self {\n            payment_method_data: (payment_method_data.get_required_value(\"payment_method_data\")?),\n            setup_future_usage: payment_data.payment_intent.setup_future_usage,\n            mandate_id: payment_data.mandate_id.clone(),\n            off_session: payment_data.mandate_id.as_ref().map(|_| true),\n            setup_mandate_details: payment_data.setup_mandate.clone(),\n            confirm: payment_data.payment_attempt.confirm,\n            statement_descriptor_suffix: payment_data.payment_intent.statement_descriptor_suffix,\n            statement_descriptor: payment_data.payment_intent.statement_descriptor_name,\n            capture_method: payment_data.payment_attempt.capture_method,\n            amount: amount.get_amount_as_i64(),\n            minor_amount: amount,\n            currency: payment_data.currency,\n            browser_info,\n            email: payment_data.email,\n            customer_name,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n            order_details,\n            order_category,\n            session_token: None,\n            enrolled_for_3ds: true,\n            related_transaction_id: None,\n            payment_method_type: payment_data.payment_attempt.payment_method_type,\n            router_return_url,\n            webhook_url,\n            complete_authorize_url,\n            customer_id,\n            surcharge_details: payment_data.surcharge_details,\n            request_incremental_authorization: matches!(\n                payment_data\n                    .payment_intent\n                    .request_incremental_authorization,\n                Some(RequestIncrementalAuthorization::True)\n                    | Some(RequestIncrementalAuthorization::Default)\n            ),\n            metadata: additional_data.payment_data.payment_intent.metadata,\n            authentication_data: payment_data\n                .authentication\n                .as_ref()\n                .map(AuthenticationData::foreign_try_from)\n                .transpose()?,\n            customer_acceptance: payment_data.customer_acceptance,\n            split_payments,\n            merchant_order_reference_id,\n            integrity_object: None,\n            additional_payment_method_data,\n            shipping_cost,\n        })\n    }",
+      "diff_span": {
+        "before": "            None\n        };\n\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        let payment_method_data = payment_data.payment_method_data.or_else(|| {\n            if payment_data.mandate_id.is_some() {",
+        "after": "            .as_ref()\n            .map(|data| data.customer_id.clone());\n\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        let merchant_order_reference_id = payment_data"
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/router/src/core/payments/helpers.rs::function::validate_platform_fees_for_marketplace",
+      "file": "crates/router/src/core/payments/helpers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub fn validate_platform_fees_for_marketplace(\n    amount: api::Amount,\n    split_payments: Option<SplitPaymentsRequest>,\n) -> Result<(), errors::ApiErrorResponse> {\n    if let Some(SplitPaymentsRequest::StripeSplitPayment(stripe_split_payment)) = split_payments {\n        match amount {\n            api::Amount::Zero => {\n                if stripe_split_payment.application_fees.get_amount_as_i64() != 0 {\n                    return Err(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"split_payments.fees\",\n                    });\n                }\n            }\n            api::Amount::Value(amount) => {\n                if stripe_split_payment.application_fees.get_amount_as_i64() > amount.into() {\n                    return Err(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"split_payments.fees\",\n                    });\n                }\n            }\n        }\n    }\n    Ok(())\n}",
+      "after_code": "pub fn validate_platform_fees_for_marketplace(\n    amount: api::Amount,\n    split_payments: Option<SplitPaymentsRequest>,\n) -> Result<(), errors::ApiErrorResponse> {\n    if let Some(SplitPaymentsRequest::StripeSplitPayment(stripe_split_payment)) = split_payments {\n        match amount {\n            api::Amount::Zero => {\n                if stripe_split_payment.application_fees.get_amount_as_i64() != 0 {\n                    return Err(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"split_payments.stripe_split_payment.application_fees\",\n                    });\n                }\n            }\n            api::Amount::Value(amount) => {\n                if stripe_split_payment.application_fees.get_amount_as_i64() > amount.into() {\n                    return Err(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"split_payments.stripe_split_payment.application_fees\",\n                    });\n                }\n            }\n        }\n    }\n    Ok(())\n}",
+      "diff_span": {
+        "before": "                if stripe_split_payment.application_fees.get_amount_as_i64() != 0 {\n                    return Err(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"split_payments.fees\",\n                    });\n                }\n            }\n            api::Amount::Value(amount) => {\n                if stripe_split_payment.application_fees.get_amount_as_i64() > amount.into() {\n                    return Err(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"split_payments.fees\",\n                    });\n                }",
+        "after": "                if stripe_split_payment.application_fees.get_amount_as_i64() != 0 {\n                    return Err(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"split_payments.stripe_split_payment.application_fees\",\n                    });\n                }\n            }\n            api::Amount::Value(amount) => {\n                if stripe_split_payment.application_fees.get_amount_as_i64() > amount.into() {\n                    return Err(errors::ApiErrorResponse::InvalidDataValue {\n                        field_name: \"split_payments.stripe_split_payment.application_fees\",\n                    });\n                }"
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/common_utils/src/types.rs::struct::StripeSplitPayment",
+      "file": "crates/common_utils/src/types.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct StripeSplitPayment {\n    /// Payment charge type\n    #[schema(value_type = PaymentChargeType, example = \"direct\")]\n    pub charge_type: enums::PaymentChargeType,\n\n    /// Platform fees to be collected on the payment\n    #[schema(value_type = i64, example = 6540)]\n    pub application_fees: MinorUnit,\n\n    /// Identifier for the reseller's account to send the funds to\n    pub transfer_account_id: String,\n}",
+      "after_code": "pub struct StripeSplitPayment {\n    /// Stripe's charge type\n    #[schema(value_type = PaymentChargeType, example = \"direct\")]\n    pub charge_type: enums::PaymentChargeType,\n\n    /// Platform fees to be collected on the payment\n    #[schema(value_type = i64, example = 6540)]\n    pub application_fees: MinorUnit,\n\n    /// Identifier for the reseller's account to send the funds to\n    pub transfer_account_id: String,\n}",
+      "diff_span": {
+        "before": "pub struct StripeSplitPayment {\n    /// Payment charge type\n    #[schema(value_type = PaymentChargeType, example = \"direct\")]\n    pub charge_type: enums::PaymentChargeType,",
+        "after": "pub struct StripeSplitPayment {\n    /// Stripe's charge type\n    #[schema(value_type = PaymentChargeType, example = \"direct\")]\n    pub charge_type: enums::PaymentChargeType,"
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/common_utils/src/types.rs::struct::StripeSplitRefundRequest",
+      "file": "crates/common_utils/src/types.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct StripeSplitRefundRequest {\n    /// Identifier for charge created for the payment\n    // pub charge_id: String,\n\n    /// Toggle for reverting the application fee that was collected for the payment.\n    /// If set to false, the funds are pulled from the destination account.\n    pub revert_platform_fee: Option<bool>,\n\n    /// Toggle for reverting the transfer that was made during the charge.\n    /// If set to false, the funds are pulled from the main platform's account.\n    pub revert_transfer: Option<bool>,\n}",
+      "after_code": "pub struct StripeSplitRefundRequest {\n    /// Toggle for reverting the application fee that was collected for the payment.\n    /// If set to false, the funds are pulled from the destination account.\n    pub revert_platform_fee: Option<bool>,\n\n    /// Toggle for reverting the transfer that was made during the charge.\n    /// If set to false, the funds are pulled from the main platform's account.\n    pub revert_transfer: Option<bool>,\n}",
+      "diff_span": {
+        "before": "pub struct StripeSplitRefundRequest {\n    /// Identifier for charge created for the payment\n    // pub charge_id: String,\n\n    /// Toggle for reverting the application fee that was collected for the payment.\n    /// If set to false, the funds are pulled from the destination account.",
+        "after": ""
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/router/src/core/refunds.rs::function::trigger_refund_execute_workflow",
+      "file": "crates/router/src/core/refunds.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn trigger_refund_execute_workflow(\n    state: &SessionState,\n    refund_tracker: &storage::ProcessTracker,\n) -> Result<(), errors::ProcessTrackerError> {\n    let db = &*state.store;\n    let refund_core =\n        serde_json::from_value::<storage::RefundCoreWorkflow>(refund_tracker.tracking_data.clone())\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable_lazy(|| {\n                format!(\n                    \"unable to convert into refund_core {:?}\",\n                    refund_tracker.tracking_data\n                )\n            })?;\n    let key_manager_state = &state.into();\n    let key_store = state\n        .store\n        .get_merchant_key_store_by_merchant_id(\n            key_manager_state,\n            &refund_core.merchant_id,\n            &state.store.get_master_key().to_vec().into(),\n        )\n        .await?;\n\n    let merchant_account = db\n        .find_merchant_account_by_merchant_id(\n            key_manager_state,\n            &refund_core.merchant_id,\n            &key_store,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let refund = db\n        .find_refund_by_internal_reference_id_merchant_id(\n            &refund_core.refund_internal_reference_id,\n            &refund_core.merchant_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::RefundNotFound)?;\n    match (&refund.sent_to_gateway, &refund.refund_status) {\n        (false, enums::RefundStatus::Pending) => {\n            let merchant_account = db\n                .find_merchant_account_by_merchant_id(\n                    key_manager_state,\n                    &refund.merchant_id,\n                    &key_store,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n            let payment_attempt = db\n                .find_payment_attempt_by_connector_transaction_id_payment_id_merchant_id(\n                    &refund.connector_transaction_id,\n                    &refund_core.payment_id,\n                    &refund.merchant_id,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n            let payment_intent = db\n                .find_payment_intent_by_payment_id_merchant_id(\n                    &(state.into()),\n                    &payment_attempt.payment_id,\n                    &refund.merchant_id,\n                    &key_store,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n            let split_refunds = match payment_intent.split_payments.as_ref() {\n                Some(SplitPaymentsRequest::StripeSplitPayment(stripe_payment)) => {\n                    let refund_request = refund\n                        .split_refunds\n                        .clone()\n                        .get_required_value(\"split_refunds\")?;\n\n                    let options = validator::validate_charge_refund(\n                        &refund_request,\n                        &stripe_payment.charge_type,\n                    )?;\n\n                    let charge_id = payment_attempt.charge_id.clone().ok_or_else(|| {\n                        report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n                \"Transaction in invalid. Missing field \\\"charge_id\\\" in payment_attempt.\",\n            )\n                    })?;\n\n                    Some(SplitRefundsRequest::StripeSplitRefund(StripeSplitRefund {\n                        charge_id,\n                        charge_type: stripe_payment.charge_type.clone(),\n                        transfer_account_id: stripe_payment.transfer_account_id.clone(),\n                        options,\n                    }))\n                }\n                _ => None,\n            };\n\n            // let split_refunds = match (\n            //     payment_intent.split_payments.as_ref(),\n            //     payment_attempt.charge_id.as_ref(),\n            // ) {\n            //     (Some(split_payments), Some(charge_id)) => {\n            //         let refund_request = refund\n            //             .split_refunds\n            //             .clone()\n            //             .get_required_value(\"split_refunds\")?;\n\n            //         // Match the enum variant of SplitRefundRequest\n            //         // let stripe_refund = match refund_request {\n            //         //     SplitRefundRequest::StripeSplitRefundRequest(ref stripe_refund) => {\n            //         //         stripe_refund\n            //         //     }\n            //         // };\n            //         let SplitRefundRequest::StripeSplitRefundRequest(ref stripe_refund) =\n            //             refund_request;\n\n            //         // Validate charge_id\n            //         // utils::when(*charge_id != stripe_refund.charge_id, || {\n            //         //     Err(report!(errors::ApiErrorResponse::InvalidDataValue {\n            //         //         field_name: \"split_refunds.charge_id\",\n            //         //     }))\n            //         //     .attach_printable(\n            //         //         \"charge_id sent in request mismatches with original charge_id\",\n            //         //     )\n            //         // })?;\n\n            //         // Match the variant of SplitPaymentsRequest\n            //         // let stripe_payment = match split_payments {\n            //         //     SplitPaymentsRequest::StripeSplitPayment(payment) => payment,\n            //         // };\n            //         let SplitPaymentsRequest::StripeSplitPayment(stripe_payment) = split_payments;\n\n            //         // Validate refund options with correct `charge_type`\n            //         let options = validator::validate_charge_refund(\n            //             &refund_request,\n            //             &stripe_payment.charge_type,\n            //         )?;\n            //         let charge_id = payment_attempt.charge_id.clone().ok_or_else(|| {\n            //             report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n            //                 \"Transaction in invalid. Missing field \\\"charge_id\\\" in payment_attempt.\",\n            //             )\n            //         })?;\n            //         // Construct SplitRefundsRequest\n            //         Some(SplitRefundsRequest::StripeSplitRefund(StripeSplitRefund {\n            //             charge_id,\n            //             charge_type: stripe_payment.charge_type.clone(),\n            //             transfer_account_id: stripe_payment.transfer_account_id.clone(),\n            //             options,\n            //         }))\n            //     }\n            //     _ => None,\n            // };\n            //trigger refund request to gateway\n            let updated_refund = Box::pin(trigger_refund_to_gateway(\n                state,\n                &refund,\n                &merchant_account,\n                &key_store,\n                &payment_attempt,\n                &payment_intent,\n                None,\n                split_refunds,\n            ))\n            .await?;\n            add_refund_sync_task(\n                db,\n                &updated_refund,\n                storage::ProcessTrackerRunner::RefundWorkflowRouter,\n            )\n            .await?;\n        }\n        (true, enums::RefundStatus::Pending) => {\n            // create sync task\n            add_refund_sync_task(\n                db,\n                &refund,\n                storage::ProcessTrackerRunner::RefundWorkflowRouter,\n            )\n            .await?;\n        }\n        (_, _) => {\n            //mark task as finished\n            db.as_scheduler()\n                .finish_process_with_business_status(\n                    refund_tracker.clone(),\n                    business_status::COMPLETED_BY_PT,\n                )\n                .await?;\n        }\n    };\n    Ok(())\n}",
+      "after_code": "pub async fn trigger_refund_execute_workflow(\n    state: &SessionState,\n    refund_tracker: &storage::ProcessTracker,\n) -> Result<(), errors::ProcessTrackerError> {\n    let db = &*state.store;\n    let refund_core =\n        serde_json::from_value::<storage::RefundCoreWorkflow>(refund_tracker.tracking_data.clone())\n            .change_context(errors::ApiErrorResponse::InternalServerError)\n            .attach_printable_lazy(|| {\n                format!(\n                    \"unable to convert into refund_core {:?}\",\n                    refund_tracker.tracking_data\n                )\n            })?;\n    let key_manager_state = &state.into();\n    let key_store = state\n        .store\n        .get_merchant_key_store_by_merchant_id(\n            key_manager_state,\n            &refund_core.merchant_id,\n            &state.store.get_master_key().to_vec().into(),\n        )\n        .await?;\n\n    let merchant_account = db\n        .find_merchant_account_by_merchant_id(\n            key_manager_state,\n            &refund_core.merchant_id,\n            &key_store,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n    let refund = db\n        .find_refund_by_internal_reference_id_merchant_id(\n            &refund_core.refund_internal_reference_id,\n            &refund_core.merchant_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::RefundNotFound)?;\n    match (&refund.sent_to_gateway, &refund.refund_status) {\n        (false, enums::RefundStatus::Pending) => {\n            let merchant_account = db\n                .find_merchant_account_by_merchant_id(\n                    key_manager_state,\n                    &refund.merchant_id,\n                    &key_store,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::MerchantAccountNotFound)?;\n\n            let payment_attempt = db\n                .find_payment_attempt_by_connector_transaction_id_payment_id_merchant_id(\n                    &refund.connector_transaction_id,\n                    &refund_core.payment_id,\n                    &refund.merchant_id,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n            let payment_intent = db\n                .find_payment_intent_by_payment_id_merchant_id(\n                    &(state.into()),\n                    &payment_attempt.payment_id,\n                    &refund.merchant_id,\n                    &key_store,\n                    merchant_account.storage_scheme,\n                )\n                .await\n                .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n            let split_refunds = match payment_intent.split_payments.as_ref() {\n                Some(SplitPaymentsRequest::StripeSplitPayment(stripe_payment)) => {\n                    let refund_request = refund\n                        .split_refunds\n                        .clone()\n                        .get_required_value(\"split_refunds\")?;\n\n                    let options = validator::validate_charge_refund(\n                        &refund_request,\n                        &stripe_payment.charge_type,\n                    )?;\n\n                    let charge_id = payment_attempt.charge_id.clone().ok_or_else(|| {\n                        report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n                \"Transaction in invalid. Missing field \\\"charge_id\\\" in payment_attempt.\",\n            )\n                    })?;\n\n                    Some(SplitRefundsRequest::StripeSplitRefund(StripeSplitRefund {\n                        charge_id,\n                        charge_type: stripe_payment.charge_type.clone(),\n                        transfer_account_id: stripe_payment.transfer_account_id.clone(),\n                        options,\n                    }))\n                }\n                _ => None,\n            };\n\n            //trigger refund request to gateway\n            let updated_refund = Box::pin(trigger_refund_to_gateway(\n                state,\n                &refund,\n                &merchant_account,\n                &key_store,\n                &payment_attempt,\n                &payment_intent,\n                None,\n                split_refunds,\n            ))\n            .await?;\n            add_refund_sync_task(\n                db,\n                &updated_refund,\n                storage::ProcessTrackerRunner::RefundWorkflowRouter,\n            )\n            .await?;\n        }\n        (true, enums::RefundStatus::Pending) => {\n            // create sync task\n            add_refund_sync_task(\n                db,\n                &refund,\n                storage::ProcessTrackerRunner::RefundWorkflowRouter,\n            )\n            .await?;\n        }\n        (_, _) => {\n            //mark task as finished\n            db.as_scheduler()\n                .finish_process_with_business_status(\n                    refund_tracker.clone(),\n                    business_status::COMPLETED_BY_PT,\n                )\n                .await?;\n        }\n    };\n    Ok(())\n}",
+      "diff_span": {
+        "before": "            };\n\n            // let split_refunds = match (\n            //     payment_intent.split_payments.as_ref(),\n            //     payment_attempt.charge_id.as_ref(),\n            // ) {\n            //     (Some(split_payments), Some(charge_id)) => {\n            //         let refund_request = refund\n            //             .split_refunds\n            //             .clone()\n            //             .get_required_value(\"split_refunds\")?;\n\n            //         // Match the enum variant of SplitRefundRequest\n            //         // let stripe_refund = match refund_request {\n            //         //     SplitRefundRequest::StripeSplitRefundRequest(ref stripe_refund) => {\n            //         //         stripe_refund\n            //         //     }\n            //         // };\n            //         let SplitRefundRequest::StripeSplitRefundRequest(ref stripe_refund) =\n            //             refund_request;\n\n            //         // Validate charge_id\n            //         // utils::when(*charge_id != stripe_refund.charge_id, || {\n            //         //     Err(report!(errors::ApiErrorResponse::InvalidDataValue {\n            //         //         field_name: \"split_refunds.charge_id\",\n            //         //     }))\n            //         //     .attach_printable(\n            //         //         \"charge_id sent in request mismatches with original charge_id\",\n            //         //     )\n            //         // })?;\n\n            //         // Match the variant of SplitPaymentsRequest\n            //         // let stripe_payment = match split_payments {\n            //         //     SplitPaymentsRequest::StripeSplitPayment(payment) => payment,\n            //         // };\n            //         let SplitPaymentsRequest::StripeSplitPayment(stripe_payment) = split_payments;\n\n            //         // Validate refund options with correct `charge_type`\n            //         let options = validator::validate_charge_refund(\n            //             &refund_request,\n            //             &stripe_payment.charge_type,\n            //         )?;\n            //         let charge_id = payment_attempt.charge_id.clone().ok_or_else(|| {\n            //             report!(errors::ApiErrorResponse::InternalServerError).attach_printable(\n            //                 \"Transaction in invalid. Missing field \\\"charge_id\\\" in payment_attempt.\",\n            //             )\n            //         })?;\n            //         // Construct SplitRefundsRequest\n            //         Some(SplitRefundsRequest::StripeSplitRefund(StripeSplitRefund {\n            //             charge_id,\n            //             charge_type: stripe_payment.charge_type.clone(),\n            //             transfer_account_id: stripe_payment.transfer_account_id.clone(),\n            //             options,\n            //         }))\n            //     }\n            //     _ => None,\n            // };\n            //trigger refund request to gateway\n            let updated_refund = Box::pin(trigger_refund_to_gateway(",
+        "after": ""
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/router/src/core/payments/transformers.rs::types::PaymentsSyncData::function::try_from",
+      "file": "crates/router/src/core/payments/transformers.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {\n        let payment_data = additional_data.payment_data;\n        let capture_method = payment_data.get_capture_method();\n        let amount = payment_data.payment_attempt.get_total_amount();\n\n        let payment_method_type = payment_data\n            .payment_attempt\n            .get_payment_method_type()\n            .to_owned();\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        Ok(Self {\n            amount,\n            integrity_object: None,\n            mandate_id: payment_data.mandate_id.clone(),\n            connector_transaction_id: match payment_data.payment_attempt.get_connector_payment_id()\n            {\n                Some(connector_txn_id) => {\n                    types::ResponseId::ConnectorTransactionId(connector_txn_id.to_owned())\n                }\n                None => types::ResponseId::NoResponseId,\n            },\n            encoded_data: payment_data.payment_attempt.encoded_data,\n            capture_method,\n            connector_meta: payment_data.payment_attempt.connector_metadata,\n            sync_type: match payment_data.multiple_capture_data {\n                Some(multiple_capture_data) => types::SyncRequestType::MultipleCaptureSync(\n                    multiple_capture_data.get_pending_connector_capture_ids(),\n                ),\n                None => types::SyncRequestType::SinglePaymentSync,\n            },\n            payment_method_type,\n            currency: payment_data.currency,\n            split_payments,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n        })\n    }",
+      "after_code": "fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {\n        let payment_data = additional_data.payment_data;\n        let capture_method = payment_data.get_capture_method();\n        let amount = payment_data.payment_attempt.get_total_amount();\n\n        let payment_method_type = payment_data\n            .payment_attempt\n            .get_payment_method_type()\n            .to_owned();\n        Ok(Self {\n            amount,\n            integrity_object: None,\n            mandate_id: payment_data.mandate_id.clone(),\n            connector_transaction_id: match payment_data.payment_attempt.get_connector_payment_id()\n            {\n                Some(connector_txn_id) => {\n                    types::ResponseId::ConnectorTransactionId(connector_txn_id.to_owned())\n                }\n                None => types::ResponseId::NoResponseId,\n            },\n            encoded_data: payment_data.payment_attempt.encoded_data,\n            capture_method,\n            connector_meta: payment_data.payment_attempt.connector_metadata,\n            sync_type: match payment_data.multiple_capture_data {\n                Some(multiple_capture_data) => types::SyncRequestType::MultipleCaptureSync(\n                    multiple_capture_data.get_pending_connector_capture_ids(),\n                ),\n                None => types::SyncRequestType::SinglePaymentSync,\n            },\n            payment_method_type,\n            currency: payment_data.currency,\n            split_payments: payment_data.payment_intent.split_payments,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n        })\n    }",
+      "diff_span": {
+        "before": "            .get_payment_method_type()\n            .to_owned();\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        Ok(Self {\n            amount,\n            integrity_object: None,\n            mandate_id: payment_data.mandate_id.clone(),\n            connector_transaction_id: match payment_data.payment_attempt.get_connector_payment_id()\n            {\n                Some(connector_txn_id) => {\n                    types::ResponseId::ConnectorTransactionId(connector_txn_id.to_owned())\n                }\n                None => types::ResponseId::NoResponseId,\n            },\n            encoded_data: payment_data.payment_attempt.encoded_data,\n            capture_method,\n            connector_meta: payment_data.payment_attempt.connector_metadata,\n            sync_type: match payment_data.multiple_capture_data {\n                Some(multiple_capture_data) => types::SyncRequestType::MultipleCaptureSync(\n                    multiple_capture_data.get_pending_connector_capture_ids(),\n                ),\n                None => types::SyncRequestType::SinglePaymentSync,\n            },\n            payment_method_type,\n            currency: payment_data.currency,\n            split_payments,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n        })",
+        "after": "            payment_method_type,\n            currency: payment_data.currency,\n            split_payments: payment_data.payment_intent.split_payments,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n        })"
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/router/src/core/payments/transformers.rs::impl::types::PaymentsSyncData",
+      "file": "crates/router/src/core/payments/transformers.rs",
+      "kind": "impl_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsSyncData {\n    type Error = error_stack::Report<errors::ApiErrorResponse>;\n\n    fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {\n        let payment_data = additional_data.payment_data;\n        let capture_method = payment_data.get_capture_method();\n        let amount = payment_data.payment_attempt.get_total_amount();\n\n        let payment_method_type = payment_data\n            .payment_attempt\n            .get_payment_method_type()\n            .to_owned();\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        Ok(Self {\n            amount,\n            integrity_object: None,\n            mandate_id: payment_data.mandate_id.clone(),\n            connector_transaction_id: match payment_data.payment_attempt.get_connector_payment_id()\n            {\n                Some(connector_txn_id) => {\n                    types::ResponseId::ConnectorTransactionId(connector_txn_id.to_owned())\n                }\n                None => types::ResponseId::NoResponseId,\n            },\n            encoded_data: payment_data.payment_attempt.encoded_data,\n            capture_method,\n            connector_meta: payment_data.payment_attempt.connector_metadata,\n            sync_type: match payment_data.multiple_capture_data {\n                Some(multiple_capture_data) => types::SyncRequestType::MultipleCaptureSync(\n                    multiple_capture_data.get_pending_connector_capture_ids(),\n                ),\n                None => types::SyncRequestType::SinglePaymentSync,\n            },\n            payment_method_type,\n            currency: payment_data.currency,\n            split_payments,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n        })\n    }\n}",
+      "after_code": "impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsSyncData {\n    type Error = error_stack::Report<errors::ApiErrorResponse>;\n\n    fn try_from(additional_data: PaymentAdditionalData<'_, F>) -> Result<Self, Self::Error> {\n        let payment_data = additional_data.payment_data;\n        let capture_method = payment_data.get_capture_method();\n        let amount = payment_data.payment_attempt.get_total_amount();\n\n        let payment_method_type = payment_data\n            .payment_attempt\n            .get_payment_method_type()\n            .to_owned();\n        Ok(Self {\n            amount,\n            integrity_object: None,\n            mandate_id: payment_data.mandate_id.clone(),\n            connector_transaction_id: match payment_data.payment_attempt.get_connector_payment_id()\n            {\n                Some(connector_txn_id) => {\n                    types::ResponseId::ConnectorTransactionId(connector_txn_id.to_owned())\n                }\n                None => types::ResponseId::NoResponseId,\n            },\n            encoded_data: payment_data.payment_attempt.encoded_data,\n            capture_method,\n            connector_meta: payment_data.payment_attempt.connector_metadata,\n            sync_type: match payment_data.multiple_capture_data {\n                Some(multiple_capture_data) => types::SyncRequestType::MultipleCaptureSync(\n                    multiple_capture_data.get_pending_connector_capture_ids(),\n                ),\n                None => types::SyncRequestType::SinglePaymentSync,\n            },\n            payment_method_type,\n            currency: payment_data.currency,\n            split_payments: payment_data.payment_intent.split_payments,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n        })\n    }\n}",
+      "diff_span": {
+        "before": "            .get_payment_method_type()\n            .to_owned();\n        let split_payments = payment_data.payment_intent.split_payments.clone();\n\n        Ok(Self {\n            amount,\n            integrity_object: None,\n            mandate_id: payment_data.mandate_id.clone(),\n            connector_transaction_id: match payment_data.payment_attempt.get_connector_payment_id()\n            {\n                Some(connector_txn_id) => {\n                    types::ResponseId::ConnectorTransactionId(connector_txn_id.to_owned())\n                }\n                None => types::ResponseId::NoResponseId,\n            },\n            encoded_data: payment_data.payment_attempt.encoded_data,\n            capture_method,\n            connector_meta: payment_data.payment_attempt.connector_metadata,\n            sync_type: match payment_data.multiple_capture_data {\n                Some(multiple_capture_data) => types::SyncRequestType::MultipleCaptureSync(\n                    multiple_capture_data.get_pending_connector_capture_ids(),\n                ),\n                None => types::SyncRequestType::SinglePaymentSync,\n            },\n            payment_method_type,\n            currency: payment_data.currency,\n            split_payments,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n        })",
+        "after": "            payment_method_type,\n            currency: payment_data.currency,\n            split_payments: payment_data.payment_intent.split_payments,\n            payment_experience: payment_data.payment_attempt.payment_experience,\n        })"
+      },
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/common_enums/src/enums.rs::impl::PaymentChargeType",
+      "file": "crates/common_enums/src/enums.rs",
+      "kind": "impl_item",
+      "status": "removed",
+      "before_code": "impl Default for PaymentChargeType {\n    fn default() -> Self {\n        Self::Stripe(StripeChargeType::default())\n    }\n}",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    },
+    {
+      "id": "crates/common_enums/src/enums.rs::PaymentChargeType::function::default",
+      "file": "crates/common_enums/src/enums.rs",
+      "kind": "function_item",
+      "status": "removed",
+      "before_code": "fn default() -> Self {\n        Self::Stripe(StripeChargeType::default())\n    }",
+      "after_code": null,
+      "diff_span": null,
+      "commit_sha": "4e70d2136a76f6a5ea7b158ded7808149fa85494"
+    }
+  ]
+}

diffs/pr_6706/570c056/diff.json

@@ -0,0 +1,9 @@
+{
+  "commit_sha": "570c0561d7530c0887abfbdf46a55bfe9602eb44",
+  "pr_number": 6706,
+  "rust_files": [
+    "crates/openapi/src/openapi.rs",
+    "crates/openapi/src/openapi_v2.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6706/9a34e69/diff.json

@@ -0,0 +1,9 @@
+{
+  "commit_sha": "9a34e69e3506a4fe3afb33a8c461a9a69f63096b",
+  "pr_number": 6706,
+  "rust_files": [
+    "crates/openapi/src/openapi.rs",
+    "crates/openapi/src/openapi_v2.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6706/bb8ae08/diff.json

@@ -0,0 +1,26 @@
+{
+  "commit_sha": "bb8ae08483ab16b27d5595734ba1f0572f37ae07",
+  "pr_number": 6706,
+  "rust_files": [
+    "crates/api_models/src/refunds.rs",
+    "crates/openapi/src/openapi.rs",
+    "crates/openapi/src/openapi_v2.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/api_models/src/refunds.rs::struct::RefundRequest",
+      "file": "crates/api_models/src/refunds.rs",
+      "kind": "struct_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub struct RefundRequest {\n    /// The payment id against which refund is to be initiated\n    #[schema(\n        max_length = 30,\n        min_length = 30,\n        example = \"pay_mbabizu24mvu3mela5njyhpit4\",\n        value_type = String,\n    )]\n    pub payment_id: common_utils::id_type::PaymentId,\n\n    /// Unique Identifier for the Refund. This is to ensure idempotency for multiple partial refunds initiated against the same payment. If this is not passed by the merchant, this field shall be auto generated and provided in the API response. It is recommended to generate uuid(v4) as the refund_id.\n    #[schema(\n        max_length = 30,\n        min_length = 30,\n        example = \"ref_mbabizu24mvu3mela5njyhpit4\"\n    )]\n    pub refund_id: Option<String>,\n\n    /// The identifier for the Merchant Account\n    #[schema(max_length = 255, example = \"y3oqhf46pyzuxjbcn2giaqnb44\", value_type = Option<String>)]\n    pub merchant_id: Option<common_utils::id_type::MerchantId>,\n\n    /// Total amount for which the refund is to be initiated. Amount for the payment in lowest denomination of the currency. (i.e) in cents for USD denomination, in paisa for INR denomination etc., If not provided, this will default to the full payment amount\n    #[schema(value_type = Option<i64> , minimum = 100, example = 6540)]\n    pub amount: Option<MinorUnit>,\n\n    /// Reason for the refund. Often useful for displaying to users and your customer support executive. In case the payment went through Stripe, this field needs to be passed with one of these enums: `duplicate`, `fraudulent`, or `requested_by_customer`\n    #[schema(max_length = 255, example = \"Customer returned the product\")]\n    pub reason: Option<String>,\n\n    /// To indicate whether to refund needs to be instant or scheduled. Default value is instant\n    #[schema(default = \"Instant\", example = \"Instant\")]\n    pub refund_type: Option<RefundType>,\n\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.\n    #[schema(value_type  = Option<Object>, example = r#\"{ \"city\": \"NY\", \"unit\": \"245\" }\"#)]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// Merchant connector details used to make payments.\n    #[schema(value_type = Option<MerchantConnectorDetailsWrap>)]\n    pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,\n\n    /// Charge specific fields for controlling the revert of funds from either platform or connected account\n    #[schema(value_type = Option<SplitRefundRequest>)]\n    pub split_refunds: Option<SplitRefund>,\n}",
+      "after_code": "pub struct RefundRequest {\n    /// The payment id against which refund is to be initiated\n    #[schema(\n        max_length = 30,\n        min_length = 30,\n        example = \"pay_mbabizu24mvu3mela5njyhpit4\",\n        value_type = String,\n    )]\n    pub payment_id: common_utils::id_type::PaymentId,\n\n    /// Unique Identifier for the Refund. This is to ensure idempotency for multiple partial refunds initiated against the same payment. If this is not passed by the merchant, this field shall be auto generated and provided in the API response. It is recommended to generate uuid(v4) as the refund_id.\n    #[schema(\n        max_length = 30,\n        min_length = 30,\n        example = \"ref_mbabizu24mvu3mela5njyhpit4\"\n    )]\n    pub refund_id: Option<String>,\n\n    /// The identifier for the Merchant Account\n    #[schema(max_length = 255, example = \"y3oqhf46pyzuxjbcn2giaqnb44\", value_type = Option<String>)]\n    pub merchant_id: Option<common_utils::id_type::MerchantId>,\n\n    /// Total amount for which the refund is to be initiated. Amount for the payment in lowest denomination of the currency. (i.e) in cents for USD denomination, in paisa for INR denomination etc., If not provided, this will default to the full payment amount\n    #[schema(value_type = Option<i64> , minimum = 100, example = 6540)]\n    pub amount: Option<MinorUnit>,\n\n    /// Reason for the refund. Often useful for displaying to users and your customer support executive. In case the payment went through Stripe, this field needs to be passed with one of these enums: `duplicate`, `fraudulent`, or `requested_by_customer`\n    #[schema(max_length = 255, example = \"Customer returned the product\")]\n    pub reason: Option<String>,\n\n    /// To indicate whether to refund needs to be instant or scheduled. Default value is instant\n    #[schema(default = \"Instant\", example = \"Instant\")]\n    pub refund_type: Option<RefundType>,\n\n    /// You can specify up to 50 keys, with key names up to 40 characters long and values up to 500 characters long. Metadata is useful for storing additional, structured information on an object.\n    #[schema(value_type  = Option<Object>, example = r#\"{ \"city\": \"NY\", \"unit\": \"245\" }\"#)]\n    pub metadata: Option<pii::SecretSerdeValue>,\n\n    /// Merchant connector details used to make payments.\n    #[schema(value_type = Option<MerchantConnectorDetailsWrap>)]\n    pub merchant_connector_details: Option<admin::MerchantConnectorDetailsWrap>,\n\n    /// Charge specific fields for controlling the revert of funds from either platform or connected account\n    #[schema(value_type = Option<SplitRefund>)]\n    pub split_refunds: Option<SplitRefund>,\n}",
+      "diff_span": {
+        "before": "\n    /// Charge specific fields for controlling the revert of funds from either platform or connected account\n    #[schema(value_type = Option<SplitRefundRequest>)]\n    pub split_refunds: Option<SplitRefund>,\n}",
+        "after": "\n    /// Charge specific fields for controlling the revert of funds from either platform or connected account\n    #[schema(value_type = Option<SplitRefund>)]\n    pub split_refunds: Option<SplitRefund>,\n}"
+      },
+      "commit_sha": "bb8ae08483ab16b27d5595734ba1f0572f37ae07"
+    }
+  ]
+}

diffs/pr_6706/c46282c/diff.json

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

diffs/pr_6706/cc56676/diff.json

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

diffs/pr_6706/d1ee42b/diff.json

@@ -0,0 +1,24 @@
+{
+  "commit_sha": "d1ee42b2e0cb5692f5b440ed2dd19abb71796336",
+  "pr_number": 6706,
+  "rust_files": [
+    "crates/router/src/core/refunds.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/router/src/core/refunds.rs::function::refund_retrieve_core",
+      "file": "crates/router/src/core/refunds.rs",
+      "kind": "function_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub async fn refund_retrieve_core(\n    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    profile_id: Option<common_utils::id_type::ProfileId>,\n    key_store: domain::MerchantKeyStore,\n    request: refunds::RefundsRetrieveRequest,\n    refund: storage::Refund,\n) -> RouterResult<storage::Refund> {\n    let db = &*state.store;\n    let merchant_id = merchant_account.get_id();\n    core_utils::validate_profile_id_from_auth_layer(profile_id, &refund)?;\n    let payment_id = &refund.payment_id;\n    let payment_intent = db\n        .find_payment_intent_by_payment_id_merchant_id(\n            &(&state).into(),\n            payment_id,\n            merchant_id,\n            &key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n    let payment_attempt = db\n        .find_payment_attempt_by_connector_transaction_id_payment_id_merchant_id(\n            &refund.connector_transaction_id,\n            payment_id,\n            merchant_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::InternalServerError)?;\n\n    let creds_identifier = request\n        .merchant_connector_details\n        .as_ref()\n        .map(|mcd| mcd.creds_identifier.to_owned());\n    request\n        .merchant_connector_details\n        .to_owned()\n        .async_map(|mcd| async {\n            payments::helpers::insert_merchant_connector_creds_to_config(db, merchant_id, mcd).await\n        })\n        .await\n        .transpose()?;\n\n    let split_refunds_req: Option<SplitRefundsRequest> = payment_intent\n        .split_payments\n        .clone()\n        .zip(refund.split_refunds.clone())\n        .map(|(split_payments, split_refunds)| {\n            SplitRefundInput {\n                refund_request: split_refunds,\n                payment_charges: split_payments,\n                charge_id: payment_attempt.charge_id.clone(),\n            }\n            .try_into()\n        })\n        .transpose()?;\n\n    let response = if should_call_refund(&refund, request.force_sync.unwrap_or(false)) {\n        Box::pin(sync_refund_with_gateway(\n            &state,\n            &merchant_account,\n            &key_store,\n            &payment_attempt,\n            &payment_intent,\n            &refund,\n            creds_identifier,\n            split_refunds_req,\n        ))\n        .await\n    } else {\n        Ok(refund)\n    }?;\n\n    Ok(response)\n}",
+      "after_code": "pub async fn refund_retrieve_core(\n    state: SessionState,\n    merchant_account: domain::MerchantAccount,\n    profile_id: Option<common_utils::id_type::ProfileId>,\n    key_store: domain::MerchantKeyStore,\n    request: refunds::RefundsRetrieveRequest,\n    refund: storage::Refund,\n) -> RouterResult<storage::Refund> {\n    let db = &*state.store;\n    let merchant_id = merchant_account.get_id();\n    core_utils::validate_profile_id_from_auth_layer(profile_id, &refund)?;\n    let payment_id = &refund.payment_id;\n    let payment_intent = db\n        .find_payment_intent_by_payment_id_merchant_id(\n            &(&state).into(),\n            payment_id,\n            merchant_id,\n            &key_store,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;\n\n    let payment_attempt = db\n        .find_payment_attempt_by_connector_transaction_id_payment_id_merchant_id(\n            &refund.connector_transaction_id,\n            payment_id,\n            merchant_id,\n            merchant_account.storage_scheme,\n        )\n        .await\n        .to_not_found_response(errors::ApiErrorResponse::InternalServerError)?;\n\n    let creds_identifier = request\n        .merchant_connector_details\n        .as_ref()\n        .map(|mcd| mcd.creds_identifier.to_owned());\n    request\n        .merchant_connector_details\n        .to_owned()\n        .async_map(|mcd| async {\n            payments::helpers::insert_merchant_connector_creds_to_config(db, merchant_id, mcd).await\n        })\n        .await\n        .transpose()?;\n\n    let split_refunds_req: Option<SplitRefundsRequest> = payment_intent\n        .split_payments\n        .clone()\n        .zip(refund.split_refunds.clone())\n        .map(|(split_payments, split_refunds)| {\n            SplitRefundsRequest::try_from(SplitRefundInput {\n                refund_request: split_refunds,\n                payment_charges: split_payments,\n                charge_id: payment_attempt.charge_id.clone(),\n            })\n        })\n        .transpose()?;\n\n    let response = if should_call_refund(&refund, request.force_sync.unwrap_or(false)) {\n        Box::pin(sync_refund_with_gateway(\n            &state,\n            &merchant_account,\n            &key_store,\n            &payment_attempt,\n            &payment_intent,\n            &refund,\n            creds_identifier,\n            split_refunds_req,\n        ))\n        .await\n    } else {\n        Ok(refund)\n    }?;\n\n    Ok(response)\n}",
+      "diff_span": {
+        "before": "        .zip(refund.split_refunds.clone())\n        .map(|(split_payments, split_refunds)| {\n            SplitRefundInput {\n                refund_request: split_refunds,\n                payment_charges: split_payments,\n                charge_id: payment_attempt.charge_id.clone(),\n            }\n            .try_into()\n        })\n        .transpose()?;",
+        "after": "        .zip(refund.split_refunds.clone())\n        .map(|(split_payments, split_refunds)| {\n            SplitRefundsRequest::try_from(SplitRefundInput {\n                refund_request: split_refunds,\n                payment_charges: split_payments,\n                charge_id: payment_attempt.charge_id.clone(),\n            })\n        })\n        .transpose()?;"
+      },
+      "commit_sha": "d1ee42b2e0cb5692f5b440ed2dd19abb71796336"
+    }
+  ]
+}

diffs/pr_6706/d1f446c/diff.json

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

diffs/pr_6706/f363b77/diff.json

@@ -0,0 +1,10 @@
+{
+  "commit_sha": "f363b775fdd3f3a6e3abd5be613919cd5588dad9",
+  "pr_number": 6706,
+  "rust_files": [
+    "crates/diesel_models/src/payment_intent.rs",
+    "crates/diesel_models/src/schema_v2.rs",
+    "crates/hyperswitch_domain_models/src/payments/payment_intent.rs"
+  ],
+  "diffs": []
+}

diffs/pr_6757/12df43a/diff.json

@@ -0,0 +1,26 @@
+{
+  "commit_sha": "12df43a10afc31e5b08c5ca0ea77231f8dcdb642",
+  "pr_number": 6757,
+  "rust_files": [
+    "crates/hyperswitch_domain_models/src/business_profile.rs",
+    "crates/openapi/src/openapi.rs",
+    "crates/openapi/src/openapi_v2.rs"
+  ],
+  "diffs": [
+    {
+      "id": "crates/hyperswitch_domain_models/src/business_profile.rs::enum::ProfileUpdate",
+      "file": "crates/hyperswitch_domain_models/src/business_profile.rs",
+      "kind": "enum_item",
+      "status": "modified",
+      "code_changed": true,
+      "imports_changed": false,
+      "before_code": "pub enum ProfileUpdate {\n    Update(Box<ProfileGeneralUpdate>),\n    RoutingAlgorithmUpdate {\n        routing_algorithm_id: Option<common_utils::id_type::RoutingId>,\n        payout_routing_algorithm_id: Option<common_utils::id_type::RoutingId>,\n    },\n    DefaultRoutingFallbackUpdate {\n        default_fallback_routing: Option<pii::SecretSerdeValue>,\n    },\n    ExtendedCardInfoUpdate {\n        is_extended_card_info_enabled: bool,\n    },\n    ConnectorAgnosticMitUpdate {\n        is_connector_agnostic_mit_enabled: bool,\n    },\n    NetworkTokenizationUpdate {\n        is_network_tokenization_enabled: bool,\n    },\n    CollectCvvDuringPaymentUpdate {\n        should_collect_cvv_during_payment: bool,\n    },\n    ClickToPayUpdate {\n        is_click_to_pay_enabled: bool,\n    },\n}",
+      "after_code": "pub enum ProfileUpdate {\n    Update(Box<ProfileGeneralUpdate>),\n    RoutingAlgorithmUpdate {\n        routing_algorithm_id: Option<common_utils::id_type::RoutingId>,\n        payout_routing_algorithm_id: Option<common_utils::id_type::RoutingId>,\n    },\n    DefaultRoutingFallbackUpdate {\n        default_fallback_routing: Option<pii::SecretSerdeValue>,\n    },\n    ExtendedCardInfoUpdate {\n        is_extended_card_info_enabled: bool,\n    },\n    ConnectorAgnosticMitUpdate {\n        is_connector_agnostic_mit_enabled: bool,\n    },\n    NetworkTokenizationUpdate {\n        is_network_tokenization_enabled: bool,\n    },\n    CollectCvvDuringPaymentUpdate {\n        should_collect_cvv_during_payment: bool,\n    },\n}",
+      "diff_span": {
+        "before": "        should_collect_cvv_during_payment: bool,\n    },\n    ClickToPayUpdate {\n        is_click_to_pay_enabled: bool,\n    },\n}",
+        "after": ""
+      },
+      "commit_sha": "12df43a10afc31e5b08c5ca0ea77231f8dcdb642"
+    }
+  ]
+}