feat(router): added retrieval flow for connector file uploads and added support for stripe connector

crates/common_enums/src/enums.rs

@@ -313,3 +313,25 @@ pub enum Country {
     Zambia,
     Zimbabwe,
 }
+
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Eq,
+    PartialEq,
+    Default,
+    serde::Deserialize,
+    serde::Serialize,
+    strum::Display,
+    strum::EnumString,
+)]
+#[router_derive::diesel_enum(storage_type = "text")]
+#[serde(rename_all = "snake_case")]
+#[strum(serialize_all = "snake_case")]
+pub enum FileUploadProvider {
+    #[default]
+    Router,
+    Stripe,
+    Checkout,
+}

crates/router/src/connector/checkout.rs

@@ -118,6 +118,7 @@ impl api::ConnectorAccessToken for Checkout {}
 impl api::AcceptDispute for Checkout {}
 impl api::PaymentToken for Checkout {}
 impl api::Dispute for Checkout {}
+impl api::RetrieveFile for Checkout {}
 impl api::DefendDispute for Checkout {}
 
 impl
@@ -773,6 +774,12 @@ impl
 
 impl api::UploadFile for Checkout {}
 
+impl
+    ConnectorIntegration<api::Retrieve, types::RetrieveFileRequestData, types::RetrieveFileResponse>
+    for Checkout
+{
+}
+
 #[async_trait::async_trait]
 impl api::FileUpload for Checkout {
     fn validate_file_upload(

crates/router/src/connector/stripe.rs

@@ -1194,6 +1194,98 @@ impl
     }
 }
 
+impl api::RetrieveFile for Stripe {}
+
+impl
+    services::ConnectorIntegration<
+        api::Retrieve,
+        types::RetrieveFileRequestData,
+        types::RetrieveFileResponse,
+    > for Stripe
+{
+    fn get_headers(
+        &self,
+        req: &types::RouterData<
+            api::Retrieve,
+            types::RetrieveFileRequestData,
+            types::RetrieveFileResponse,
+        >,
+        _connectors: &settings::Connectors,
+    ) -> CustomResult<Vec<(String, String)>, errors::ConnectorError> {
+        self.get_auth_header(&req.connector_auth_type)
+    }
+
+    fn get_url(
+        &self,
+        req: &types::RetrieveFileRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<String, errors::ConnectorError> {
+        Ok(format!(
+            "{}v1/files/{}/contents",
+            connectors.stripe.base_url_file_upload, req.request.provider_file_id
+        ))
+    }
+
+    fn build_request(
+        &self,
+        req: &types::RetrieveFileRouterData,
+        connectors: &settings::Connectors,
+    ) -> CustomResult<Option<services::Request>, errors::ConnectorError> {
+        Ok(Some(
+            services::RequestBuilder::new()
+                .method(services::Method::Get)
+                .url(&types::RetrieveFileType::get_url(self, req, connectors)?)
+                .attach_default_headers()
+                .headers(types::RetrieveFileType::get_headers(self, req, connectors)?)
+                .build(),
+        ))
+    }
+
+    #[instrument(skip_all)]
+    fn handle_response(
+        &self,
+        data: &types::RetrieveFileRouterData,
+        res: types::Response,
+    ) -> CustomResult<
+        types::RouterData<
+            api::Retrieve,
+            types::RetrieveFileRequestData,
+            types::RetrieveFileResponse,
+        >,
+        errors::ConnectorError,
+    > {
+        let response = res.response;
+        Ok(types::RetrieveFileRouterData {
+            response: Ok(types::RetrieveFileResponse {
+                file_data: response.to_vec(),
+            }),
+            ..data.clone()
+        })
+    }
+
+    fn get_error_response(
+        &self,
+        res: types::Response,
+    ) -> CustomResult<types::ErrorResponse, errors::ConnectorError> {
+        let response: stripe::ErrorResponse = res
+            .response
+            .parse_struct("ErrorResponse")
+            .change_context(errors::ConnectorError::ResponseDeserializationFailed)?;
+        Ok(types::ErrorResponse {
+            status_code: res.status_code,
+            code: response
+                .error
+                .code
+                .unwrap_or_else(|| consts::NO_ERROR_CODE.to_string()),
+            message: response
+                .error
+                .message
+                .unwrap_or_else(|| consts::NO_ERROR_MESSAGE.to_string()),
+            reason: None,
+        })
+    }
+}
+
 impl api::SubmitEvidence for Stripe {}
 
 impl

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

@@ -17,47 +17,54 @@ pub async fn get_evidence_request_data(
             state,
             evidence_request.cancellation_policy,
             merchant_account,
+            false,
         )
         .await?;
     let (customer_communication, customer_communication_provider_file_id) =
         retrieve_file_and_provider_file_id_from_file_id(
             state,
             evidence_request.customer_communication,
             merchant_account,
+            false,
         )
         .await?;
     let (customer_signature, customer_signature_provider_file_id) =
         retrieve_file_and_provider_file_id_from_file_id(
             state,
             evidence_request.customer_signature,
             merchant_account,
+            false,
         )
         .await?;
     let (receipt, receipt_provider_file_id) = retrieve_file_and_provider_file_id_from_file_id(
         state,
         evidence_request.receipt,
         merchant_account,
+        false,
     )
     .await?;
     let (refund_policy, refund_policy_provider_file_id) =
         retrieve_file_and_provider_file_id_from_file_id(
             state,
             evidence_request.refund_policy,
             merchant_account,
+            false,
         )
         .await?;
     let (service_documentation, service_documentation_provider_file_id) =
         retrieve_file_and_provider_file_id_from_file_id(
             state,
             evidence_request.service_documentation,
             merchant_account,
+            false,
         )
         .await?;
     let (shipping_documentation, shipping_documentation_provider_file_id) =
         retrieve_file_and_provider_file_id_from_file_id(
             state,
             evidence_request.shipping_documentation,
             merchant_account,
+            false,
         )
         .await?;
     let (
@@ -67,20 +74,23 @@ pub async fn get_evidence_request_data(
         state,
         evidence_request.invoice_showing_distinct_transactions,
         merchant_account,
+        false,
     )
     .await?;
     let (recurring_transaction_agreement, recurring_transaction_agreement_provider_file_id) =
         retrieve_file_and_provider_file_id_from_file_id(
             state,
             evidence_request.recurring_transaction_agreement,
             merchant_account,
+            false,
         )
         .await?;
     let (uncategorized_file, uncategorized_file_provider_file_id) =
         retrieve_file_and_provider_file_id_from_file_id(
             state,
             evidence_request.uncategorized_file,
             merchant_account,
+            false,
         )
         .await?;
     Ok(SubmitEvidenceRequestData {

crates/router/src/core/files.rs

@@ -13,7 +13,7 @@ use crate::{
     consts,
     routes::AppState,
     services::{self, ApplicationResponse},
-    types::{api, storage, transformers::ForeignInto},
+    types::{api, storage},
 };
 
 pub async fn files_create_core(
@@ -37,15 +37,16 @@ pub async fn files_create_core(
         provider_file_id: None,
         file_upload_provider: None,
         available: false,
+        connector_label: None,
     };
     let file_metadata_object = state
         .store
         .insert_file_metadata(file_new)
         .await
         .change_context(errors::ApiErrorResponse::InternalServerError)
         .attach_printable("Unable to insert file_metadata")?;
-    let (provider_file_id, file_upload_provider) =
-        helpers::upload_and_get_provider_provider_file_id(
+    let (provider_file_id, file_upload_provider, connector_label) =
+        helpers::upload_and_get_provider_provider_file_id_connector_label(
             state,
             &merchant_account,
             &create_file_request,
@@ -55,8 +56,9 @@ pub async fn files_create_core(
     //Update file metadata
     let update_file_metadata = storage_models::file::FileMetadataUpdate::Update {
         provider_file_id: Some(provider_file_id),
-        file_upload_provider: Some(file_upload_provider.foreign_into()),
+        file_upload_provider: Some(file_upload_provider),
         available: true,
+        connector_label,
     };
     state
         .store
@@ -102,6 +104,7 @@ pub async fn files_retrieve_core(
             state,
             Some(req.file_id),
             &merchant_account,
+            true,
         )
         .await?;
     let content_type = file_metadata_object