feat(connector): [Trustpay] add authorize (cards 3ds, no3ds and bank redirects), refund, psync, rsync (#717)

Co-authored-by: Sangamesh <sangamesh.kulkarni@juspay.in>
Co-authored-by: sai harsha <sai.harsha@sai.harsha-MacBookPro>
Co-authored-by: Arun Raj M <jarnura47@gmail.com>

config/Development.toml

@@ -65,6 +65,7 @@ cards = [
     "stripe",
     "worldline",
     "worldpay",
+    "trustpay",
 ]
 
 [refund]
@@ -103,6 +104,8 @@ shift4.base_url = "https://api.shift4.com/"
 stripe.base_url = "https://api.stripe.com/"
 worldline.base_url = "https://eu.sandbox.api-ingenico.com/"
 worldpay.base_url = "https://try.access.worldpay.com/"
+trustpay.base_url = "https://test-tpgw.trustpay.eu/"
+trustpay.base_url_bank_redirects = "https://aapi.trustpay.eu/"
 
 [scheduler]
 stream = "SCHEDULER_STREAM"

config/config.example.toml

@@ -144,6 +144,8 @@ shift4.base_url = "https://api.shift4.com/"
 stripe.base_url = "https://api.stripe.com/"
 worldline.base_url = "https://eu.sandbox.api-ingenico.com/"
 worldpay.base_url = "https://try.access.worldpay.com/"
+trustpay.base_url = "https://test-tpgw.trustpay.eu/"
+trustpay.base_url_bank_redirects = "https://aapi.trustpay.eu/"
 
 # This data is used to call respective connectors for wallets and cards
 [connectors.supported]

config/docker_compose.toml

@@ -89,6 +89,8 @@ shift4.base_url = "https://api.shift4.com/"
 stripe.base_url = "https://api.stripe.com/"
 worldline.base_url = "https://eu.sandbox.api-ingenico.com/"
 worldpay.base_url = "https://try.access.worldpay.com/"
+trustpay.base_url = "https://test-tpgw.trustpay.eu/"
+trustpay.base_url_bank_redirects = "https://aapi.trustpay.eu/"
 
 [connectors.supported]
 wallets = ["klarna", "braintree", "applepay"]
@@ -112,6 +114,7 @@ cards = [
     "stripe",
     "worldline",
     "worldpay",
+    "trustpay",
 ]
 
 

crates/api_models/src/enums.rs

@@ -539,6 +539,7 @@ pub enum MandateStatus {
     strum::Display,
     strum::EnumString,
     frunk::LabelledGeneric,
+    Hash,
 )]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
@@ -567,11 +568,18 @@ pub enum Connector {
     Stripe,
     Worldline,
     Worldpay,
+    Trustpay,
 }
 
 impl Connector {
-    pub fn supports_access_token(&self) -> bool {
+    pub fn supports_access_token(&self, payment_method: PaymentMethod) -> bool {
-        matches!(self, Self::Airwallex | Self::Globalpay | Self::Payu)
+        matches!(
+            (self, payment_method),
+            (Self::Airwallex, _)
+                | (Self::Globalpay, _)
+                | (Self::Payu, _)
+                | (Self::Trustpay, PaymentMethod::BankRedirect)
+        )
     }
 }
 
@@ -611,6 +619,7 @@ pub enum RoutableConnectors {
     Worldline,
     Worldpay,
     Multisafepay,
+    Trustpay,
 }
 
 /// Wallets which support obtaining session object

crates/common_utils/src/ext_traits.rs

@@ -44,7 +44,7 @@ where
     /// Functionality, for specifically encoding `Self` into `String`
     /// after serialization by using `serde::Serialize`
     ///
-    fn encode(&'e self) -> CustomResult<String, errors::ParsingError>
+    fn url_encode(&'e self) -> CustomResult<String, errors::ParsingError>
     where
         Self: Serialize;
 
@@ -103,7 +103,7 @@ where
     }
 
     // Check without two functions can we combine this
-    fn encode(&'e self) -> CustomResult<String, errors::ParsingError>
+    fn url_encode(&'e self) -> CustomResult<String, errors::ParsingError>
     where
         Self: Serialize,
     {

crates/router/src/configs/settings.rs

@@ -251,6 +251,7 @@ pub struct Connectors {
     pub stripe: ConnectorParams,
     pub worldline: ConnectorParams,
     pub worldpay: ConnectorParams,
+    pub trustpay: ConnectorParamsWithMoreUrls,
 
     // Keep this field separate from the remaining fields
     pub supported: SupportedConnectors,
@@ -262,6 +263,13 @@ pub struct ConnectorParams {
     pub base_url: String,
 }
 
+#[derive(Debug, Deserialize, Clone, Default)]
+#[serde(default)]
+pub struct ConnectorParamsWithMoreUrls {
+    pub base_url: String,
+    pub base_url_bank_redirects: String,
+}
+
 #[derive(Debug, Clone, Deserialize)]
 #[serde(default)]
 pub struct SchedulerSettings {

crates/router/src/connector.rs

@@ -18,6 +18,7 @@ pub mod payu;
 pub mod rapyd;
 pub mod shift4;
 pub mod stripe;
+pub mod trustpay;
 pub mod utils;
 pub mod worldline;
 pub mod worldpay;
@@ -27,5 +28,6 @@ pub use self::{
     authorizedotnet::Authorizedotnet, bambora::Bambora, bluesnap::Bluesnap, braintree::Braintree,
     checkout::Checkout, cybersource::Cybersource, dlocal::Dlocal, fiserv::Fiserv,
     globalpay::Globalpay, klarna::Klarna, multisafepay::Multisafepay, nuvei::Nuvei, payu::Payu,
-    rapyd::Rapyd, shift4::Shift4, stripe::Stripe, worldline::Worldline, worldpay::Worldpay,
+    rapyd::Rapyd, shift4::Shift4, stripe::Stripe, trustpay::Trustpay, worldline::Worldline,
+    worldpay::Worldpay,
 };

crates/router/src/connector/stripe.rs

@@ -346,7 +346,7 @@ impl
         req: &types::PaymentsAuthorizeRouterData,
     ) -> CustomResult<Option<String>, errors::ConnectorError> {
         let req = stripe::PaymentIntentRequest::try_from(req)?;
-        let stripe_req = utils::Encode::<stripe::PaymentIntentRequest>::encode(&req)
+        let stripe_req = utils::Encode::<stripe::PaymentIntentRequest>::url_encode(&req)
             .change_context(errors::ConnectorError::RequestEncodingFailed)?;
         Ok(Some(stripe_req))
     }

crates/router/src/connector/trustpay.rs

@@ -0,0 +1,630 @@
+mod transformers;
+
+use std::fmt::Debug;
+
+use base64::Engine;
+use error_stack::{IntoReport, ResultExt};
+use transformers as trustpay;
+
+use crate::{
+    configs::settings,
+    consts,
+    core::{
+        errors::{self, CustomResult},
+        payments,
+    },
+    headers,
+    services::{self, ConnectorIntegration},
+    types::{
+        self,
+        api::{self, ConnectorCommon, ConnectorCommonExt},
+        ErrorResponse, Response,
+    },
+    utils::{self, BytesExt},
+};
+
+#[derive(Debug, Clone)]
+pub struct Trustpay;
+
+impl<Flow, Request, Response> ConnectorCommonExt<Flow, Request, Response> for Trustpay
+where
+    Self: ConnectorIntegration<Flow, Request, Response>,
+{
+    fn build_headers(
+        &self,
+        req: &types::RouterData<Flow, Request, Response>,
+        _connectors: &settings::Connectors,
+    ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
+        match req.payment_method {
+            storage_models::enums::PaymentMethod::BankRedirect => {
+                let token = req
+                    .access_token
+                    .clone()
+                    .ok_or(errors::ConnectorError::FailedToObtainAuthType)?;
+                Ok(vec![
+                    (
+                        headers::CONTENT_TYPE.to_string(),
+                        "application/json".to_owned(),
+                    ),
+                    (
+                        headers::AUTHORIZATION.to_string(),
+                        format!("Bearer {}", token.token),
+                    ),
+                ])
+            }
+            _ => {
+                let mut header = vec![(
+                    headers::CONTENT_TYPE.to_string(),
+                    self.get_content_type().to_string(),
+                )];
+                let mut api_key = self.get_auth_header(&req.connector_auth_type)?;
+                header.append(&mut api_key);
+                Ok(header)
+            }
+        }
+    }
+}
+
+impl ConnectorCommon for Trustpay {
+    fn id(&self) -> &'static str {
+        "trustpay"
+    }
+
+    fn common_get_content_type(&self) -> &'static str {
+        "application/x-www-form-urlencoded"
+    }
+
+    fn base_url<'a>(&self, connectors: &'a settings::Connectors) -> &'a str {
+        connectors.trustpay.base_url.as_ref()
+    }
+
+    fn get_auth_header(
+        &self,
+        auth_type: &types::ConnectorAuthType,
+    ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
+        let auth = trustpay::TrustpayAuthType::try_from(auth_type)
+            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+        Ok(vec![(headers::X_API_KEY.to_string(), auth.api_key)])
+    }
+
+    fn build_error_response(
+        &self,
+        res: Response,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        let response: trustpay::TrustpayErrorResponse = res
+            .response
+            .parse_struct("trustpay ErrorResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        let default_error = trustpay::Errors {
+            code: 0,
+            description: consts::NO_ERROR_CODE.to_string(),
+        };
+        Ok(ErrorResponse {
+            status_code: res.status_code,
+            code: response.status.to_string(),
+            message: format!("{:?}", response.errors.first().unwrap_or(&default_error)),
+            reason: None,
+        })
+    }
+}
+
+impl api::Payment for Trustpay {}
+
+impl api::PreVerify for Trustpay {}
+impl ConnectorIntegration<api::Verify, types::VerifyRequestData, types::PaymentsResponseData>
+    for Trustpay
+{
+}
+
+impl api::PaymentVoid for Trustpay {}
+
+impl ConnectorIntegration<api::Void, types::PaymentsCancelData, types::PaymentsResponseData>
+    for Trustpay
+{
+}
+
+impl api::ConnectorAccessToken for Trustpay {}
+
+impl ConnectorIntegration<api::AccessTokenAuth, types::AccessTokenRequestData, types::AccessToken>
+    for Trustpay
+{
+    fn get_url(
+        &self,
+        _req: &types::RefreshTokenRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        Ok(format!(
+            "{}{}",
+            connectors.trustpay.base_url_bank_redirects, "api/oauth2/token"
+        ))
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_headers(
+        &self,
+        req: &types::RefreshTokenRouterData,
+        _connectors: &settings::Connectors,
+    ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
+        let auth = trustpay::TrustpayAuthType::try_from(&req.connector_auth_type)
+            .change_context(errors::ConnectorError::FailedToObtainAuthType)?;
+        let auth_value = format!(
+            "Basic {}",
+            consts::BASE64_ENGINE.encode(format!("{}:{}", auth.project_id, auth.secret_key))
+        );
+        Ok(vec![
+            (
+                headers::CONTENT_TYPE.to_string(),
+                types::RefreshTokenType::get_content_type(self).to_string(),
+            ),
+            (headers::AUTHORIZATION.to_string(), auth_value),
+        ])
+    }
+
+    fn get_request_body(
+        &self,
+        req: &types::RefreshTokenRouterData,
+    ) -> CustomResult<Option<String>, errors::ConnectorError> {
+        let trustpay_req =
+            utils::Encode::<trustpay::TrustpayAuthUpdateRequest>::convert_and_url_encode(req)
+                .change_context(errors::ConnectorError::RequestEncodingFailed)?;
+        Ok(Some(trustpay_req))
+    }
+
+    fn build_request(
+        &self,
+        req: &types::RefreshTokenRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        let req = Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Post)
+                .headers(types::RefreshTokenType::get_headers(self, req, connectors)?)
+                .url(&types::RefreshTokenType::get_url(self, req, connectors)?)
+                .body(types::RefreshTokenType::get_request_body(self, req)?)
+                .build(),
+        );
+        Ok(req)
+    }
+
+    fn handle_response(
+        &self,
+        data: &types::RefreshTokenRouterData,
+        res: Response,
+    ) -> CustomResult<types::RefreshTokenRouterData, errors::ConnectorError> {
+        let response: trustpay::TrustpayAuthUpdateResponse = res
+            .response
+            .parse_struct("trustpay TrustpayAuthUpdateResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        let response: trustpay::TrustpayAccessTokenErrorResponse = res
+            .response
+            .parse_struct("Trustpay AccessTokenErrorResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        Ok(ErrorResponse {
+            status_code: res.status_code,
+            code: response.result_info.result_code.to_string(),
+            message: response.result_info.additional_info.unwrap_or_default(),
+            reason: None,
+        })
+    }
+}
+
+impl api::PaymentSync for Trustpay {}
+impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsResponseData>
+    for Trustpay
+{
+    fn get_headers(
+        &self,
+        req: &types::PaymentsSyncRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &types::PaymentsSyncRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        let id = req.request.connector_transaction_id.clone();
+        match req.payment_method {
+            storage_models::enums::PaymentMethod::BankRedirect => Ok(format!(
+                "{}{}/{}",
+                connectors.trustpay.base_url_bank_redirects,
+                "api/Payments/Payment",
+                id.get_connector_transaction_id()
+                    .change_context(errors::ConnectorError::MissingConnectorTransactionID)?
+            )),
+            _ => Ok(format!(
+                "{}{}/{}",
+                self.base_url(connectors),
+                "api/v1/instance",
+                id.get_connector_transaction_id()
+                    .change_context(errors::ConnectorError::MissingConnectorTransactionID)?
+            )),
+        }
+    }
+
+    fn build_request(
+        &self,
+        req: &types::PaymentsSyncRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Get)
+                .url(&types::PaymentsSyncType::get_url(self, req, connectors)?)
+                .headers(types::PaymentsSyncType::get_headers(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res)
+    }
+
+    fn handle_response(
+        &self,
+        data: &types::PaymentsSyncRouterData,
+        res: Response,
+    ) -> CustomResult<types::PaymentsSyncRouterData, errors::ConnectorError> {
+        let response: trustpay::TrustpayPaymentsResponse = res
+            .response
+            .parse_struct("trustpay PaymentsResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+    }
+}
+
+impl api::PaymentCapture for Trustpay {}
+impl ConnectorIntegration<api::Capture, types::PaymentsCaptureData, types::PaymentsResponseData>
+    for Trustpay
+{
+}
+
+impl api::PaymentSession for Trustpay {}
+
+impl ConnectorIntegration<api::Session, types::PaymentsSessionData, types::PaymentsResponseData>
+    for Trustpay
+{
+}
+
+impl api::PaymentAuthorize for Trustpay {}
+
+impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::PaymentsResponseData>
+    for Trustpay
+{
+    fn get_headers(
+        &self,
+        req: &types::PaymentsAuthorizeRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &types::PaymentsAuthorizeRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        match req.payment_method {
+            storage_models::enums::PaymentMethod::BankRedirect => Ok(format!(
+                "{}{}",
+                connectors.trustpay.base_url_bank_redirects, "api/Payments/Payment"
+            )),
+            _ => Ok(format!(
+                "{}{}",
+                self.base_url(connectors),
+                "api/v1/purchase"
+            )),
+        }
+    }
+
+    fn get_request_body(
+        &self,
+        req: &types::PaymentsAuthorizeRouterData,
+    ) -> CustomResult<Option<String>, errors::ConnectorError> {
+        let trustpay_req = trustpay::TrustpayPaymentsRequest::try_from(req)?;
+        let trustpay_req_string = match req.payment_method {
+            storage_models::enums::PaymentMethod::BankRedirect => {
+                utils::Encode::<trustpay::PaymentRequestBankRedirect>::encode_to_string_of_json(
+                    &trustpay_req,
+                )
+                .change_context(errors::ConnectorError::RequestEncodingFailed)?
+            }
+            _ => utils::Encode::<trustpay::PaymentRequestCards>::url_encode(&trustpay_req)
+                .change_context(errors::ConnectorError::RequestEncodingFailed)?,
+        };
+        Ok(Some(trustpay_req_string))
+    }
+
+    fn build_request(
+        &self,
+        req: &types::PaymentsAuthorizeRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Post)
+                .url(&types::PaymentsAuthorizeType::get_url(
+                    self, req, connectors,
+                )?)
+                .headers(types::PaymentsAuthorizeType::get_headers(
+                    self, req, connectors,
+                )?)
+                .body(types::PaymentsAuthorizeType::get_request_body(self, req)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &types::PaymentsAuthorizeRouterData,
+        res: Response,
+    ) -> CustomResult<types::PaymentsAuthorizeRouterData, errors::ConnectorError> {
+        let response: trustpay::TrustpayPaymentsResponse = res
+            .response
+            .parse_struct("trustpay PaymentsResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res)
+    }
+}
+
+impl api::Refund for Trustpay {}
+impl api::RefundExecute for Trustpay {}
+impl api::RefundSync for Trustpay {}
+
+impl ConnectorIntegration<api::Execute, types::RefundsData, types::RefundsResponseData>
+    for Trustpay
+{
+    fn get_headers(
+        &self,
+        req: &types::RefundsRouterData<api::Execute>,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &types::RefundsRouterData<api::Execute>,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        match req.payment_method {
+            storage_models::enums::PaymentMethod::BankRedirect => Ok(format!(
+                "{}{}{}{}",
+                connectors.trustpay.base_url_bank_redirects,
+                "api/Payments/Payment/",
+                req.request.connector_transaction_id,
+                "/Refund"
+            )),
+            _ => Ok(format!("{}{}", self.base_url(connectors), "api/v1/Reverse")),
+        }
+    }
+
+    fn get_request_body(
+        &self,
+        req: &types::RefundsRouterData<api::Execute>,
+    ) -> CustomResult<Option<String>, errors::ConnectorError> {
+        let trustpay_req = trustpay::TrustpayRefundRequest::try_from(req)?;
+        let trustpay_req_string = match req.payment_method {
+            storage_models::enums::PaymentMethod::BankRedirect => utils::Encode::<
+                trustpay::TrustpayRefundRequestBankRedirect,
+            >::encode_to_string_of_json(
+                &trustpay_req
+            )
+            .change_context(errors::ConnectorError::RequestEncodingFailed)?,
+            _ => utils::Encode::<trustpay::TrustpayRefundRequestCards>::url_encode(&trustpay_req)
+                .change_context(errors::ConnectorError::RequestEncodingFailed)?,
+        };
+        Ok(Some(trustpay_req_string))
+    }
+
+    fn build_request(
+        &self,
+        req: &types::RefundsRouterData<api::Execute>,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        let request = services::RequestBuilder::new()
+            .method(services::Method::Post)
+            .url(&types::RefundExecuteType::get_url(self, req, connectors)?)
+            .headers(types::RefundExecuteType::get_headers(
+                self, req, connectors,
+            )?)
+            .body(types::RefundExecuteType::get_request_body(self, req)?)
+            .build();
+        Ok(Some(request))
+    }
+
+    fn handle_response(
+        &self,
+        data: &types::RefundsRouterData<api::Execute>,
+        res: Response,
+    ) -> CustomResult<types::RefundsRouterData<api::Execute>, errors::ConnectorError> {
+        let response: trustpay::RefundResponse = res
+            .response
+            .parse_struct("trustpay RefundResponse")
+            .change_context(errors::ConnectorError::RequestEncodingFailed)?;
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res)
+    }
+}
+
+impl ConnectorIntegration<api::RSync, types::RefundsData, types::RefundsResponseData> for Trustpay {
+    fn get_headers(
+        &self,
+        req: &types::RefundSyncRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
+        self.build_headers(req, connectors)
+    }
+
+    fn get_content_type(&self) -> &'static str {
+        self.common_get_content_type()
+    }
+
+    fn get_url(
+        &self,
+        req: &types::RefundSyncRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        let id = req
+            .request
+            .connector_refund_id
+            .to_owned()
+            .ok_or_else(|| errors::ConnectorError::MissingConnectorRefundID)?;
+        match req.payment_method {
+            storage_models::enums::PaymentMethod::BankRedirect => Ok(format!(
+                "{}{}/{}",
+                connectors.trustpay.base_url_bank_redirects, "api/Payments/Payment", id
+            )),
+            _ => Ok(format!(
+                "{}{}/{}",
+                self.base_url(connectors),
+                "api/v1/instance",
+                id
+            )),
+        }
+    }
+
+    fn build_request(
+        &self,
+        req: &types::RefundSyncRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Get)
+                .url(&types::RefundSyncType::get_url(self, req, connectors)?)
+                .headers(types::RefundSyncType::get_headers(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    fn handle_response(
+        &self,
+        data: &types::RefundSyncRouterData,
+        res: Response,
+    ) -> CustomResult<types::RefundSyncRouterData, errors::ConnectorError> {
+        let response: trustpay::RefundResponse = res
+            .response
+            .parse_struct("trustpay RefundResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        types::RouterData::try_from(types::ResponseRouterData {
+            response,
+            data: data.clone(),
+            http_code: res.status_code,
+        })
+        .change_context(errors::ConnectorError::ResponseHandlingFailed)
+    }
+
+    fn get_error_response(
+        &self,
+        res: Response,
+    ) -> CustomResult<ErrorResponse, errors::ConnectorError> {
+        self.build_error_response(res)
+    }
+}
+
+#[async_trait::async_trait]
+impl api::IncomingWebhook for Trustpay {
+    fn get_webhook_object_reference_id(
+        &self,
+        _request: &api::IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
+    }
+
+    fn get_webhook_event_type(
+        &self,
+        _request: &api::IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<api::IncomingWebhookEvent, errors::ConnectorError> {
+        Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
+    }
+
+    fn get_webhook_resource_object(
+        &self,
+        _request: &api::IncomingWebhookRequestDetails<'_>,
+    ) -> CustomResult<serde_json::Value, errors::ConnectorError> {
+        Err(errors::ConnectorError::WebhooksNotImplemented).into_report()
+    }
+}
+
+impl services::ConnectorRedirectResponse for Trustpay {
+    fn get_flow_type(
+        &self,
+        query_params: &str,
+    ) -> CustomResult<payments::CallConnectorAction, errors::ConnectorError> {
+        let query =
+            serde_urlencoded::from_str::<transformers::TrustpayRedirectResponse>(query_params)
+                .into_report()
+                .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        crate::logger::debug!(trustpay_redirect_response=?query);
+        Ok(query.status.map_or(
+            payments::CallConnectorAction::Trigger,
+            |status| match status.as_str() {
+                "SuccessOk" => payments::CallConnectorAction::StatusUpdate(
+                    storage_models::enums::AttemptStatus::Charged,
+                ),
+                _ => payments::CallConnectorAction::Trigger,
+            },
+        ))
+    }
+}

crates/router/src/connector/utils.rs

@@ -222,6 +222,7 @@ pub enum CardIssuer {
 pub trait CardData {
     fn get_card_expiry_year_2_digit(&self) -> Secret<String>;
     fn get_card_issuer(&self) -> Result<CardIssuer, Error>;
+    fn get_card_expiry_month_year_2_digit_with_delimiter(&self, delimiter: String) -> String;
 }
 
 impl CardData for api::Card {
@@ -237,6 +238,15 @@ impl CardData for api::Card {
             .map(|card| card.split_whitespace().collect());
         get_card_issuer(card.peek().clone().as_str())
     }
+    fn get_card_expiry_month_year_2_digit_with_delimiter(&self, delimiter: String) -> String {
+        let year = self.get_card_expiry_year_2_digit();
+        format!(
+            "{}{}{}",
+            self.card_exp_month.peek().clone(),
+            delimiter,
+            year.peek()
+        )
+    }
 }
 
 fn get_card_issuer(card_number: &str) -> Result<CardIssuer, Error> {

crates/router/src/core/payment_methods/transformers.rs

@@ -86,7 +86,7 @@ pub fn mk_add_card_request(
         name_on_card: Some("John Doe".to_string().into()),         // [#256]
         nickname: Some("router".to_string()),                      //
     };
-    let body = utils::Encode::<AddCardRequest<'_>>::encode(&add_card_req)
+    let body = utils::Encode::<AddCardRequest<'_>>::url_encode(&add_card_req)
         .change_context(errors::VaultError::RequestEncodingFailed)?;
     let mut url = locker.host.to_owned();
     url.push_str("/card/addCard");
@@ -139,7 +139,7 @@ pub fn mk_get_card_request<'a>(
         card_id,
     };
 
-    let body = utils::Encode::<GetCard<'_>>::encode(&get_card_req)
+    let body = utils::Encode::<GetCard<'_>>::url_encode(&get_card_req)
         .change_context(errors::VaultError::RequestEncodingFailed)?;
     let mut url = locker.host.to_owned();
     url.push_str("/card/getCard");
@@ -158,7 +158,7 @@ pub fn mk_delete_card_request<'a>(
         merchant_id,
         card_id,
     };
-    let body = utils::Encode::<GetCard<'_>>::encode(&delete_card_req)
+    let body = utils::Encode::<GetCard<'_>>::url_encode(&delete_card_req)
         .change_context(errors::VaultError::RequestEncodingFailed)?;
     let mut url = locker.host.to_owned();
     url.push_str("/card/deleteCard");

crates/router/src/core/payments/access_token.rs

@@ -10,7 +10,7 @@ use crate::{
     },
     routes::AppState,
     services,
-    types::{self, api as api_types, storage},
+    types::{self, api as api_types, storage, transformers::ForeignInto},
 };
 
 /// This function replaces the request and response type of routerdata with the
@@ -82,7 +82,10 @@ pub async fn add_access_token<
     merchant_account: &storage::MerchantAccount,
     router_data: &types::RouterData<F, Req, Res>,
 ) -> RouterResult<types::AddAccessTokenResult> {
-    if connector.connector_name.supports_access_token() {
+    if connector
+        .connector_name
+        .supports_access_token(router_data.payment_method.foreign_into())
+    {
         let merchant_id = &merchant_account.merchant_id;
         let store = &*state.store;
         let old_access_token = store

crates/router/src/types/api.rs

@@ -182,6 +182,7 @@ impl ConnectorData {
             "worldline" => Ok(Box::new(&connector::Worldline)),
             "worldpay" => Ok(Box::new(&connector::Worldpay)),
             "multisafepay" => Ok(Box::new(&connector::Multisafepay)),
+            "trustpay" => Ok(Box::new(&connector::Trustpay)),
             _ => Err(report!(errors::ConnectorError::InvalidConnectorName)
                 .attach_printable(format!("invalid connector name: {connector_name}")))
             .change_context(errors::ApiErrorResponse::InternalServerError),

crates/router/tests/connectors/connector_auth.rs

@@ -22,6 +22,7 @@ pub(crate) struct ConnectorAuthentication {
     pub stripe: Option<HeaderKey>,
     pub worldpay: Option<BodyKey>,
     pub worldline: Option<SignatureKey>,
+    pub trustpay: Option<SignatureKey>,
 }
 
 impl ConnectorAuthentication {

crates/router/tests/connectors/main.rs

@@ -18,6 +18,7 @@ mod payu;
 mod rapyd;
 mod shift4;
 mod stripe;
+mod trustpay;
 mod utils;
 mod worldline;
 mod worldpay;

crates/router/tests/connectors/trustpay.rs

@@ -0,0 +1,245 @@
+use masking::Secret;
+use router::types::{self, api, storage::enums, BrowserInformation};
+
+use crate::{
+    connector_auth,
+    utils::{self, ConnectorActions},
+};
+
+#[derive(Clone, Copy)]
+struct TrustpayTest;
+impl ConnectorActions for TrustpayTest {}
+impl utils::Connector for TrustpayTest {
+    fn get_data(&self) -> types::api::ConnectorData {
+        use router::connector::Trustpay;
+        types::api::ConnectorData {
+            connector: Box::new(&Trustpay),
+            connector_name: types::Connector::Trustpay,
+            get_token: types::api::GetToken::Connector,
+        }
+    }
+
+    fn get_auth_token(&self) -> types::ConnectorAuthType {
+        types::ConnectorAuthType::from(
+            connector_auth::ConnectorAuthentication::new()
+                .trustpay
+                .expect("Missing connector authentication configuration"),
+        )
+    }
+
+    fn get_name(&self) -> String {
+        "trustpay".to_string()
+    }
+}
+
+fn get_default_browser_info() -> BrowserInformation {
+    BrowserInformation {
+        color_depth: 24,
+        java_enabled: false,
+        java_script_enabled: true,
+        language: "en-US".to_string(),
+        screen_height: 1080,
+        screen_width: 1920,
+        time_zone: 3600,
+        accept_header: "*".to_string(),
+        user_agent: "none".to_string(),
+        ip_address: None,
+    }
+}
+
+fn get_default_payment_authorize_data() -> Option<types::PaymentsAuthorizeData> {
+    Some(types::PaymentsAuthorizeData {
+        payment_method_data: types::api::PaymentMethodData::Card(api::Card {
+            card_number: Secret::new("4200000000000000".to_string()),
+            card_exp_year: Secret::new("25".to_string()),
+            card_cvc: Secret::new("123".to_string()),
+            ..utils::CCardType::default().0
+        }),
+        browser_info: Some(get_default_browser_info()),
+        ..utils::PaymentAuthorizeType::default().0
+    })
+}
+
+fn get_default_payment_info() -> Option<utils::PaymentInfo> {
+    Some(utils::PaymentInfo {
+        address: Some(types::PaymentAddress {
+            billing: Some(api::Address {
+                address: Some(api::AddressDetails {
+                    first_name: Some(Secret::new("first".to_string())),
+                    last_name: Some(Secret::new("last".to_string())),
+                    line1: Some(Secret::new("line1".to_string())),
+                    line2: Some(Secret::new("line2".to_string())),
+                    city: Some("city".to_string()),
+                    zip: Some(Secret::new("zip".to_string())),
+                    country: Some("IN".to_string()),
+                    ..Default::default()
+                }),
+                phone: None,
+            }),
+            ..Default::default()
+        }),
+        router_return_url: Some(String::from("http://localhost:8080")),
+        ..Default::default()
+    })
+}
+
+static CONNECTOR: TrustpayTest = TrustpayTest {};
+
+// Cards Positive Tests
+// Creates a payment using the automatic capture flow (Non 3DS).
+#[actix_web::test]
+async fn should_make_payment() {
+    let authorize_response = CONNECTOR
+        .make_payment(
+            get_default_payment_authorize_data(),
+            get_default_payment_info(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
+}
+
+// Synchronizes a payment using the automatic capture flow (Non 3DS).
+#[actix_web::test]
+async fn should_sync_auto_captured_payment() {
+    let authorize_response = CONNECTOR
+        .make_payment(
+            get_default_payment_authorize_data(),
+            get_default_payment_info(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(authorize_response.status, enums::AttemptStatus::Charged);
+    let txn_id = utils::get_connector_transaction_id(authorize_response.response);
+    assert_ne!(txn_id, None, "Empty connector transaction id");
+    let response = CONNECTOR
+        .psync_retry_till_status_matches(
+            enums::AttemptStatus::Charged,
+            Some(types::PaymentsSyncData {
+                connector_transaction_id: router::types::ResponseId::ConnectorTransactionId(
+                    txn_id.unwrap(),
+                ),
+                encoded_data: None,
+                capture_method: None,
+            }),
+            None,
+        )
+        .await
+        .unwrap();
+    assert_eq!(response.status, enums::AttemptStatus::Charged,);
+}
+
+// Refunds a payment using the automatic capture flow (Non 3DS).
+#[actix_web::test]
+async fn should_refund_auto_captured_payment() {
+    let response = CONNECTOR
+        .make_payment_and_refund(
+            get_default_payment_authorize_data(),
+            None,
+            get_default_payment_info(),
+        )
+        .await
+        .unwrap();
+    assert_eq!(
+        response.response.unwrap().refund_status,
+        enums::RefundStatus::Success,
+    );
+}
+
+// Synchronizes a refund using the automatic capture flow (Non 3DS).
+#[actix_web::test]
+async fn should_sync_refund() {
+    let refund_response = CONNECTOR
+        .make_payment_and_refund(
+            get_default_payment_authorize_data(),
+            None,
+            get_default_payment_info(),
+        )
+        .await
+        .unwrap();
+    let response = CONNECTOR
+        .rsync_retry_till_status_matches(
+            enums::RefundStatus::Success,
+            refund_response.response.unwrap().connector_refund_id,
+            None,
+            None,
+        )
+        .await
+        .unwrap();
+    assert_eq!(
+        response.response.unwrap().refund_status,
+        enums::RefundStatus::Success,
+    );
+}
+
+// Cards Negative scenerios
+// Creates a payment with incorrect card number.
+#[actix_web::test]
+async fn should_fail_payment_for_incorrect_card_number() {
+    let payment_authorize_data = types::PaymentsAuthorizeData {
+        payment_method_data: types::api::PaymentMethodData::Card(api::Card {
+            card_number: Secret::new("1234567891011".to_string()),
+            card_exp_year: Secret::new("25".to_string()),
+            card_cvc: Secret::new("123".to_string()),
+            ..utils::CCardType::default().0
+        }),
+        browser_info: Some(get_default_browser_info()),
+        ..utils::PaymentAuthorizeType::default().0
+    };
+    let response = CONNECTOR
+        .make_payment(Some(payment_authorize_data), get_default_payment_info())
+        .await
+        .unwrap();
+    assert_eq!(
+        response.response.unwrap_err().message,
+        "Errors { code: 61, description: \"invalid payment data (country or brand)\" }".to_string(),
+    );
+}
+
+// Creates a payment with empty card number.
+#[actix_web::test]
+async fn should_fail_payment_for_empty_card_number() {
+    let payment_authorize_data = types::PaymentsAuthorizeData {
+        payment_method_data: types::api::PaymentMethodData::Card(api::Card {
+            card_number: Secret::new("".to_string()),
+            card_exp_year: Secret::new("25".to_string()),
+            card_cvc: Secret::new("123".to_string()),
+            ..utils::CCardType::default().0
+        }),
+        browser_info: Some(get_default_browser_info()),
+        ..utils::PaymentAuthorizeType::default().0
+    };
+    let response = CONNECTOR
+        .make_payment(Some(payment_authorize_data), get_default_payment_info())
+        .await
+        .unwrap();
+    let x = response.response.unwrap_err();
+    assert_eq!(
+        x.message,
+        "Errors { code: 61, description: \"invalid payment data (country or brand)\" }",
+    );
+}
+
+// Creates a payment with incorrect expiry year.
+#[actix_web::test]
+async fn should_fail_payment_for_incorrect_expiry_year() {
+    let payment_authorize_data = Some(types::PaymentsAuthorizeData {
+        payment_method_data: types::api::PaymentMethodData::Card(api::Card {
+            card_number: Secret::new("4200000000000000".to_string()),
+            card_exp_year: Secret::new("22".to_string()),
+            card_cvc: Secret::new("123".to_string()),
+            ..utils::CCardType::default().0
+        }),
+        browser_info: Some(get_default_browser_info()),
+        ..utils::PaymentAuthorizeType::default().0
+    });
+    let response = CONNECTOR
+        .make_payment(payment_authorize_data, get_default_payment_info())
+        .await
+        .unwrap();
+    assert_eq!(
+        response.response.unwrap_err().message,
+        "Errors { code: 15, description: \"the provided expiration year is not valid\" }"
+            .to_string(),
+    );
+}

loadtest/config/Development.toml

@@ -75,6 +75,8 @@ shift4.base_url = "https://api.shift4.com/"
 stripe.base_url = "https://api.stripe.com/"
 worldline.base_url = "https://eu.sandbox.api-ingenico.com/"
 worldpay.base_url = "https://try.access.worldpay.com/"
+trustpay.base_url = "https://test-tpgw.trustpay.eu/"
+trustpay.base_url_bank_redirects = "https://aapi.trustpay.eu/"
 
 [connectors.supported]
 wallets = ["klarna", "braintree", "applepay"]
@@ -98,4 +100,5 @@ cards = [
     "stripe",
     "worldline",
     "worldpay",
+    "trustpay",
 ]