dvla-application_helper 5.1.5

data/lib/dvla/application_helper/services/application_diary.rb

@@ -0,0 +1,123 @@
+module DVLA
+  module Application
+    module ApplicationDiary
+
+      def self.delete_single_trigger(application_id:, trigger_type:)
+        request_data = DVLAApplicationDiaryServiceOpenAPIClient::DeleteTriggerRequest.new(
+          application_id: application_id,
+          trigger_type: trigger_type,
+        )
+        make_diary_endpoint_call(endpoint: 'delete_trigger_with_http_info', request_data: request_data)
+      end
+
+      def self.delete_all_app_triggers(application_id:)
+        request_data = DVLAApplicationDiaryServiceOpenAPIClient::DeleteTriggersRequest.new(
+          application_id: application_id,
+          )
+        make_diary_endpoint_call(endpoint: 'delete_triggers_by_application_id_with_http_info', request_data: request_data)
+      end
+
+      def self.extend_call_to_action_trigger(application_id:, application_type:, time_to_trigger:, product_type: 'Driving Licence')
+        request_data = DVLAApplicationDiaryServiceOpenAPIClient::ExtendCallToActionTriggersRequest.new(
+          application_id: application_id,
+          product_type: product_type,
+          application_type: application_type,
+          time_to_trigger: time_to_trigger,
+          )
+        make_diary_endpoint_call(endpoint: 'extend_call_to_action_triggers_with_http_info', request_data: request_data)
+      end
+
+      def self.find_triggers_by_app_id(application_id:)
+        request_data = DVLAApplicationDiaryServiceOpenAPIClient::FindTriggersByApplicationIdRequest.new(
+          application_id: application_id,
+        )
+        make_diary_endpoint_call(endpoint: 'find_triggers_by_application_id_with_http_info', request_data: request_data)
+      end
+
+      def self.put_external_triggers(application_id:, application_type:, product_type: 'Driving Licence')
+        request_data = DVLAApplicationDiaryServiceOpenAPIClient::PutExternalTaskTriggersRequest.new(
+          application_id: application_id,
+          product_type: product_type,
+          application_type: application_type,
+          )
+
+        make_diary_endpoint_call(endpoint: 'put_external_task_triggers_with_http_info', request_data: request_data)
+      end
+
+      def self.put_triggers(application_id:, trigger_type:, application_type:, time_to_trigger:, product_type: 'Driving Licence')
+        request_data = DVLAApplicationDiaryServiceOpenAPIClient::PutTriggerRequest.new(
+          application_id: application_id,
+          trigger_type: trigger_type,
+          product_type: product_type,
+          application_type: application_type,
+          time_to_trigger: time_to_trigger,
+        )
+
+        make_diary_endpoint_call(endpoint: 'put_trigger_with_http_info', request_data: request_data)
+      end
+
+
+
+      def self.initialize_diary_api_instance
+        api_id = ENV.fetch('APPLICATION_DIARY_API_ID', Settings.application_helper.services.application_diary.api_id)
+        vpce_id = ENV.fetch('APPLICATION_DIARY_VPCE_ID', Settings.application_helper.services.aws.vpce_id)
+
+        config = DVLAApplicationDiaryServiceOpenAPIClient::Configuration.new
+        config.base_path = ENV.fetch('APPLICATION_DIARY_STAGE_NAME', Settings.application_helper.services.application_diary.stage_name)
+        config.scheme = 'https'
+        config.host = "#{api_id}-vpce-#{vpce_id}.execute-api.eu-west-2.amazonaws.com"
+        config.server_index = nil
+        client = RequestSigningDiaryApiClient.new(config)
+        DVLAApplicationDiaryServiceOpenAPIClient::DefaultApi.new(client)
+      end
+
+      def self.application_diary_test_headers
+        {
+          dvla_resource: RequestHeaders::DVLA_RESOURCE,
+          dvla_origin_resource: RequestHeaders::DVLA_ORIGIN_RESOURCE,
+          x_correlation_id: RequestHeaders::X_CORRELATION_ID,
+          origin_timestamp: RequestHeaders::ORIGIN_TIMESTAMP,
+          dvla_session_id: RequestHeaders::DVLA_SESSION_ID,
+        }
+      end
+
+      # Generic endpoint call method
+      # @Param [endpoint](String), references endpoint to make call to
+      # @Param [request_data](Object), is an object of type related to the endpoint, DVLAApplicationDiaryServiceOpenAPIClient methods used to generate these
+      def self.make_diary_endpoint_call(endpoint:, request_data:)
+        api_instance = initialize_diary_api_instance
+        opts = application_diary_test_headers
+
+        begin
+          # makes call to specified endpoint using the correct request_input data
+          data, status_code, _headers = api_instance.method(endpoint).call(RequestHeaders::DVLA_RESOURCE,
+                                                                           RequestHeaders::DVLA_ORIGIN_RESOURCE,
+                                                                           request_data,
+                                                                           opts)
+
+          DVLA::Application.logger.info("Call made to Diary endpoint: #{endpoint}, Status code response: #{status_code}".blue)
+        rescue DVLAApplicationDiaryServiceOpenAPIClient::ApiError => e
+          raise(StandardError, DVLA::Application.logger.info { "Error when calling DefaultApi->#{endpoint}: #{e}".red })
+        end
+        data
+      end
+
+      class RequestSigningDiaryApiClient < DVLAApplicationDiaryServiceOpenAPIClient::ApiClient
+        def initialize(config = nil)
+          @signer = AWS.create_signer
+          super
+        end
+
+        def call_api(http_method, path, opts = nil)
+          signed_request = @signer.sign_request(
+            http_method:,
+            url: build_request_url(path),
+            body: opts[:body],
+            )
+          opts[:header_params].merge!(signed_request.headers)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dvla/application_helper/services/application_domain.rb

@@ -0,0 +1,239 @@
+module DVLA
+  module Application
+    module ApplicationDomain
+
+      # @param **application_id [String](UUID)
+      # @param **image [Object]
+      def self.add_image(application_id:, image:, request_data: DVLAApplicationDomainServiceOpenAPIClient::AddImageRequest.new({ application_id:, image: }))
+        DVLA::Application.logger.info("Adding image for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'add_image_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **payment [Object] { paymentId: [Integer], paymentStatus: [Enum], paymentAmount: [String] }
+      def self.add_payment(application_id:, payment:, request_data: DVLAApplicationDomainServiceOpenAPIClient::AddPaymentRequest.new({ application_id:, payment: }))
+        DVLA::Application.logger.info("Adding payment for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'add_payment_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **validation [Object] { validationId: [String](UUID), timeCreated: [String](DateTime), outcome: [Enum] Approved,Returned,Unapproved }
+      def self.add_validation(application_id:, validation:, request_data: DVLAApplicationDomainServiceOpenAPIClient::AddValidationRequest.new({ application_id:, validation: }))
+        DVLA::Application.logger.info("Adding Validation for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'add_validation_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application [Object]
+      def self.create_application(application:)
+        DVLA::Application.logger.info("applicationID: #{application.application_id.green}")
+        DVLA::Application.logger.info("customerID: #{application.customer_id.green}")
+        DVLA::Application.logger.info('Calling create-application')
+        make_domain_endpoint_call(endpoint: 'create_application_with_http_info',
+                                  request_data: application)
+      end
+
+      # @param **application [Object]
+      def self.create_test_application(application:)
+        DVLA::Application.logger.info("applicationID: #{application.application_id.green}")
+        DVLA::Application.logger.info("customerID: #{application.customer_id.inspect.green}")
+        DVLA::Application.logger.info('Calling create-test-application')
+        make_domain_endpoint_call(endpoint: 'create_test_application_with_http_info',
+                                  request_data: application)
+      end
+
+      # @param **application_id [String](UUID)
+      def self.delete_application(application_id:, request_data: DVLAApplicationDomainServiceOpenAPIClient::DeleteApplicationRequest.new({ application_id: }))
+        DVLA::Application.logger.info("Deleting application: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'delete_application_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **customer_id [String](UUID)
+      # Returns application
+      # Return [Array]
+      def self.find_applications_by_customer_id(customer_id:, request_data: DVLAApplicationDomainServiceOpenAPIClient::FindApplicationsByCustomerIdRequest.new({ customer_id: }))
+        DVLA::Application.logger.info("Finding application by customerId: #{customer_id.green}")
+        make_domain_endpoint_call(endpoint: 'find_applications_by_customer_id_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # Returns action history of application
+      # Return [Array]
+      def self.find_action_history(application_id:, request_data: DVLAApplicationDomainServiceOpenAPIClient::FindActionsByApplicationIdRequest.new({ application_id: }))
+        DVLA::Application.logger.info("finding actions for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'find_actions_by_application_id_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_type [String]
+      def self.generate_application_reference(application_type:, request_data: DVLAApplicationDomainServiceOpenAPIClient::GenerateApplicationReferenceRequest.new({ application_type: }))
+        DVLA::Application.logger.info("Generating V1 reference number for application type: #{application_type.green}")
+        make_domain_endpoint_call(endpoint: 'generate_application_reference_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **prefix [Enum]  FP,TY,CP,DU,CD
+      def self.generate_application_reference_v2(prefix:, request_data: DVLAApplicationDomainServiceOpenAPIClient::GenerateApplicationReferenceRequest1.new({ prefix: }))
+        DVLA::Application.logger.info("Generating V2 reference number with prefix: #{prefix.green}")
+        make_domain_endpoint_call(endpoint: 'generate_application_reference_v2_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **validation_id [String](UUID)
+      # @param **casework [Object] { service: [String], status: [String], outcome [String], timeCreated [String](date-time), timeCompleted [String](date-time) }
+      def self.put_casework(application_id:, casework:, validation_id:, request_data: DVLAApplicationDomainServiceOpenAPIClient::PutCaseworkRequest.new({ application_id:, casework:, validation_id: }))
+        DVLA::Application.logger.info("Adding casework for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'put_casework_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **image_id [String](UUID)
+      # @param **image_type [Enum] Photo, Signature
+      # @param **review [Object] { reviewLevel: [Enum], outcome: [String], outcomeReasons [String], timeCompleted [String](date-time) }
+      def self.put_image_review(application_id:, image_id:, image_type:, review:, request_data: DVLAApplicationDomainServiceOpenAPIClient::PutImageReviewRequest.new({ application_id:, image_id:, image_type:, review: }))
+        DVLA::Application.logger.info("Adding image review for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'put_image_review_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # Returns application
+      # Return [Object]
+      def self.retrieve_application_by_app_id(application_id:, request_data: DVLAApplicationDomainServiceOpenAPIClient::RetrieveApplicationRequest.new({ application_id: }))
+        DVLA::Application.logger.info("Retrieving application data for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'retrieve_application_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_reference_number [String](UUID)
+      # Returns application
+      # Return [Object]
+      def self.retrieve_application_by_application_reference_number(application_reference_number:, request_data: DVLAApplicationDomainServiceOpenAPIClient::RetrieveApplicationByApplicationReferenceNumberRequest.new({ application_reference_number: }))
+        DVLA::Application.logger.info("Retrieving application data for reference number: #{application_reference_number.green}")
+        make_domain_endpoint_call(endpoint: 'retrieve_application_by_application_reference_number_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **current_image_id [String](UUID)
+      # @param **previous_image_id [String](UUID)
+      def self.revert_to_previous_image(application_id:, current_image_id:, previous_image_id:, request_data: DVLAApplicationDomainServiceOpenAPIClient::RevertToPreviousImageRequest.new({ application_id:, current_image_id:, previous_image_id: }))
+        DVLA::Application.logger.info("revert to previous image for application_id: #{application_id.green}, current_image_id: #{current_image_id} , previous_image_id: #{previous_image_id}")
+        make_domain_endpoint_call(endpoint: 'revert_to_previous_image_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_reference_number [String](UUID)
+      # @param **image [Object]
+      # @param **source_image_id [String](UUID)
+      # @param **source_image_status [Enum] Active,Replaced,Moved,Deleted
+      def self.supersede_image(application_id:, image:, source_image_id:, source_image_status:, request_data: DVLAApplicationDomainServiceOpenAPIClient::SupersedeImageRequest.new({ application_id:, image:, source_image_id:, source_image_status: }))
+        DVLA::Application.logger.info("supersede image for application_id: #{application_id.green}, previous_image_id: #{source_image_id} , new_image: #{image}")
+        make_domain_endpoint_call(endpoint: 'supersede_image_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **application_state [Object] { status [Enum], reason [Enum] }
+      def self.update_application_status(application_id:, application_state:, request_data: DVLAApplicationDomainServiceOpenAPIClient::UpdateApplicationStatusRequest.new(application_id:, application_state:))
+        DVLA::Application.logger.info("Updating application status for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'update_application_status_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **call_to_action_deadline_date [String](Time / Date, utc, iso8601)
+      def self.update_call_to_action_deadline_date(application_id:, call_to_action_deadline_date:, request_data: DVLAApplicationDomainServiceOpenAPIClient::UpdateCallToActionDeadlineDateRequest.new(application_id:, call_to_action_deadline_date:))
+        make_domain_endpoint_call(endpoint: 'update_call_to_action_deadline_date_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **image_id [String](UUID)
+      # @param **image_type [Enum] Photo, Signature
+      # @param **image_status [String]
+      def self.update_image_status(application_id:, image_id:, image_type:, image_status:, request_data: DVLAApplicationDomainServiceOpenAPIClient::UpdateImageStatusRequest.new({ application_id:, image_id:, image_type:, image_status: }))
+        make_domain_endpoint_call(endpoint: 'update_image_status_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # @param **application_id [String](UUID)
+      # @param **payment_amount [String]
+      # @param **payment_id [Integer]
+      # @param **payment_status [Enum]
+      def self.update_payment(application_id:, payment_amount:, payment_id:, payment_status:, request_data: DVLAApplicationDomainServiceOpenAPIClient::UpdatePaymentRequest.new({ application_id:, payment_amount:, payment_id:, payment_status: }))
+        DVLA::Application.logger.info("Updating payment for application_id: #{application_id.green}")
+        make_domain_endpoint_call(endpoint: 'update_payment_with_http_info',
+                                  request_data: request_data)
+      end
+
+      # The below help setup the client for the above endpoint calls
+      def self.initialize_domain_api_instance
+        api_id = ENV.fetch('APPLICATION_DOMAIN_API_ID', Settings.application_helper.services.application_domain.api_id)
+        vpce_id = ENV.fetch('APPLICATION_DOMAIN_VPCE_ID', Settings.application_helper.services.aws.vpce_id)
+
+        config = DVLAApplicationDomainServiceOpenAPIClient::Configuration.new
+        config.base_path = ENV.fetch('APPLICATION_DOMAIN_STAGE_NAME', Settings.application_helper.services.application_domain.stage_name)
+        config.scheme = 'https'
+        config.host = "#{api_id}-vpce-#{vpce_id}.execute-api.eu-west-2.amazonaws.com"
+        config.server_index = nil
+        client = RequestSigningDomainApiClient.new(config)
+        DVLAApplicationDomainServiceOpenAPIClient::DefaultApi.new(client)
+      end
+
+      def self.application_domain_test_headers
+        {
+          dvla_resource: RequestHeaders::DVLA_RESOURCE,
+          dvla_origin_resource: RequestHeaders::DVLA_ORIGIN_RESOURCE,
+          x_correlation_id: RequestHeaders::X_CORRELATION_ID,
+          origin_timestamp: RequestHeaders::ORIGIN_TIMESTAMP,
+          dvla_session_id: RequestHeaders::DVLA_SESSION_ID,
+        }
+      end
+
+      # Generic endpoint call method
+      # @Param [endpoint](String), references endpoint to make call to
+      # @Param [request_data](Object), is an object of type related to the endpoint, DVLAApplicationDomainServiceOpenAPIClient methods used to generate these
+      def self.make_domain_endpoint_call(endpoint:, request_data:)
+        api_instance = initialize_domain_api_instance
+        opts = application_domain_test_headers
+
+        begin
+          # makes call to specified endpoint using the correct request_input data
+          data, status_code, _headers = api_instance.method(endpoint).call(RequestHeaders::DVLA_RESOURCE,
+                                                                           RequestHeaders::DVLA_ORIGIN_RESOURCE,
+                                                                           request_data,
+                                                                           opts)
+
+          DVLA::Application.logger.info("Call made to Domain endpoint: #{endpoint}, Status code response: #{status_code}".blue)
+        rescue DVLAApplicationDomainServiceOpenAPIClient::ApiError => e
+          raise(StandardError, DVLA::Application.logger.info { "Error when calling DefaultApi->#{endpoint}: #{e}".red })
+        end
+        data
+      end
+
+      class RequestSigningDomainApiClient < DVLAApplicationDomainServiceOpenAPIClient::ApiClient
+        def initialize(config = nil)
+          @signer = AWS.create_signer
+          super
+        end
+
+        def call_api(http_method, path, opts = nil)
+          signed_request = @signer.sign_request(
+            http_method:,
+            url: build_request_url(path),
+            body: opts[:body],
+            )
+          opts[:header_params].merge!(signed_request.headers)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dvla/application_helper/services/application_process_engine.rb

@@ -0,0 +1,120 @@
+module DVLA
+  module Application
+    module ApplicationProcessEngine
+
+      # @param *application_id [String] (UUID), required
+      def self.start_processing(application_id:, request_data: DVLAApplicationProcessEngineOpenAPIClient::StartProcessingRequest.new({ application_id: }))
+        make_ape_endpoint_call(application_id:,
+                               endpoint: 'start_processing_request_with_http_info',
+                               request_data: request_data)
+      end
+
+      # @param *application_id [String] (date), required
+      # @param *call_to_action_deadline_date [String] (Date-Time), required, UTC format, eg "2022-01-01T09:00:00Z"
+      def self.extend_application(application_id:, call_to_action_deadline_date:, request_data: DVLAApplicationProcessEngineOpenAPIClient::ExtendApplicationRequest.new({ application_id:, call_to_action_deadline_date: }))
+        make_ape_endpoint_call(application_id:,
+                               endpoint: 'extend_application_request_with_http_info',
+                               request_data: request_data)
+      end
+
+      # @param *application_id [String] (date), required
+      def self.manual_cancel_application(application_id:, request_data: DVLAApplicationProcessEngineOpenAPIClient::ManualCancelApplicationRequest.new({ application_id: }))
+        make_ape_endpoint_call(application_id:,
+                               endpoint: 'manual_cancel_application_request_with_http_info',
+                               request_data: request_data)
+      end
+
+      # @param *application_id [String] (date), required
+      # @param *execution_status [String] (Enum), optional, 'RUNNING,SUCCEEDED,FAILED,TIMED_OUT,ABORTED'
+      def self.retrieve_executions(application_id:, execution_status: nil, request_data: DVLAApplicationProcessEngineOpenAPIClient::RetrieveExecutionsRequest.new({ application_id:, execution_status: }))
+        make_ape_endpoint_call(endpoint: 'retrieve_executions_request_with_http_info',
+                               request_data: request_data)
+      end
+
+      # @param *application_id [String] (date), required
+      # @param *execution_type [String] (Enum), required, 'Fulfilment,Deletion,SevenDaysBeforeTimeout,NinetyDaysAfterApproved'
+      # @param *failed_execution_arn [String] (AWS Arn), required
+      def self.restart_execution(application_id:, execution_type:, failed_execution_arn:, request_data: DVLAApplicationProcessEngineOpenAPIClient::RestartExecutionRequest.new({ application_id:, execution_type:, failed_execution_arn: }))
+        make_ape_endpoint_call(application_id:,
+                               endpoint: 'restart_execution_request_with_http_info',
+                               request_data: request_data)
+      end
+
+      def self.health_check
+        api_instance = initialize_ape_api_instance
+        api_instance.health_check_with_http_info
+      end
+
+      def self.make_ape_endpoint_call(endpoint:, request_data:, application_id: nil)
+        api_instance = initialize_ape_api_instance
+        opts = application_process_engine_test_headers
+
+        begin
+          params = [application_id,
+                    RequestHeaders::DVLA_RESOURCE,
+                    RequestHeaders::DVLA_ORIGIN_RESOURCE,
+                    request_data,
+                    opts]
+
+          # This has been added to amend the params passed into a retrieve execution call, as this endpoint doesn't use middleware it does not need
+          # the application_id in the call parameters
+          params.delete(application_id) if endpoint == 'retrieve_executions_request_with_http_info'
+
+          # makes call to specified endpoint using the correct request_input data
+          data, status_code, _headers = api_instance.method(endpoint).call(*params)
+
+          DVLA::Application.logger.info("Call made to APE endpoint: #{endpoint}, Status code response: #{status_code}".blue)
+        rescue DVLAApplicationProcessEngineOpenAPIClient::ApiError => e
+          DVLA::Application.logger.info { "Error when calling DefaultApi->#{endpoint}: #{e}".red }
+          return {response_data: e, status_code: e.code}
+        end
+        {response_data: data, status_code: status_code}
+      end
+
+      def self.initialize_ape_api_instance
+        api_id = ENV.fetch('APPLICATION_PROCESS_ENGINE_API_ID', Settings.application_helper.services.application_process_engine.api_id)
+        vpce_id = ENV.fetch('APPLICATION_PROCESS_ENGINE_VPCE_ID', Settings.application_helper.services.aws.vpce_id)
+
+        config = DVLAApplicationProcessEngineOpenAPIClient::Configuration.new
+        config.base_path = ENV.fetch('APPLICATION_PROCESS_ENGINE_STAGE_NAME', Settings.application_helper.services.application_process_engine.stage_name)
+        config.scheme = 'https'
+        config.host = "#{api_id}-vpce-#{vpce_id}.execute-api.eu-west-2.amazonaws.com"
+        config.server_index = nil
+        client = RequestSigningApeApiClient.new(config)
+        DVLAApplicationProcessEngineOpenAPIClient::DefaultApi.new(client)
+      end
+
+      def self.application_process_engine_test_headers
+        {
+          dvla_user: RequestHeaders::DVLA_USER,
+          x_correlation_id: RequestHeaders::X_CORRELATION_ID,
+          origin_timestamp: RequestHeaders::ORIGIN_TIMESTAMP,
+          dvla_session_id: RequestHeaders::DVLA_SESSION_ID,
+        }
+      end
+
+      class RequestSigningApeApiClient < DVLAApplicationProcessEngineOpenAPIClient::ApiClient
+        def initialize(config = nil)
+          @signer = Aws::Sigv4::Signer.new(
+            service: 'execute-api',
+            region: 'eu-west-2',
+            access_key_id: ENV.fetch('AWS_ACCESS_KEY_ID'),
+            secret_access_key: ENV.fetch('AWS_SECRET_ACCESS_KEY'),
+            session_token: ENV.fetch('AWS_SESSION_TOKEN'),
+            )
+          super
+        end
+
+        def call_api(http_method, path, opts = nil)
+          signed_request = @signer.sign_request(
+            http_method: http_method,
+            url: build_request_url(path),
+            body: opts[:body],
+            )
+          opts[:header_params].merge!(signed_request.headers)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dvla/application_helper/services/check_aws_credentials.rb

@@ -0,0 +1,24 @@
+module DVLA
+  module Application
+    class AwsCredentialsError < StandardError
+    end
+
+    def self.check_aws_credentials
+      # First check if required environment variables exist
+      required_keys = %w[AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN]
+      missing_keys = required_keys.select { |key| ENV[key].nil? || ENV[key].empty? }
+      unless missing_keys.empty?
+        raise AwsCredentialsError, "Missing AWS credentials: #{missing_keys.join(', ')}"
+      end
+
+      # Then verify the credentials are valid
+      sts_client = Aws::STS::Client.new
+      begin
+        sts_client.get_caller_identity
+        DVLA::Application.logger.info 'All AWS required credentials are present and valid.'
+      rescue Aws::STS::Errors::InvalidClientTokenId, Aws::STS::Errors::ExpiredToken
+        raise AwsCredentialsError, 'AWS credentials are expired or invalid, please log back into AWS to continue'
+      end
+    end
+  end
+end

data/lib/dvla/application_helper/services/driving_licence_channel_api.rb

@@ -0,0 +1,67 @@
+module DVLA
+  module Application
+    module ChannelAPI
+      def self.initialize_channel_api_instance
+        api_id = ENV.fetch('CHANNEL_API_API_ID', Settings.application_helper.services.driving_licence_channel_api.api_id)
+        vpce_id = ENV.fetch('CHANNEL_API_VPCE_ID', Settings.application_helper.services.aws.vpce_id)
+
+        config = DVLADrivingLicenceChannelApiOpenAPIClient::Configuration.new
+        config.base_path = ENV.fetch('CHANNEL_API_STAGE_NAME', Settings.application_helper.services.driving_licence_channel_api.stage_name)
+        config.scheme = 'https'
+        config.host = "#{api_id}-vpce-#{vpce_id}.execute-api.eu-west-2.amazonaws.com"
+        config.server_index = nil
+        client = DrivingLicenceChannelApiClient.new(config)
+        DVLADrivingLicenceChannelApiOpenAPIClient::DefaultApi.new(client)
+      end
+
+      def self.driving_licence_channel_api_test_headers
+        {
+          dvla_resource: RequestHeaders::DVLA_RESOURCE,
+          dvla_origin_resource: RequestHeaders::DVLA_ORIGIN_RESOURCE,
+          x_correlation_id: RequestHeaders::X_CORRELATION_ID,
+          origin_timestamp: RequestHeaders::ORIGIN_TIMESTAMP,
+          dvla_session_id: RequestHeaders::DVLA_SESSION_ID,
+        }
+      end
+
+      def self.driving_licence_channel_api_test_headers_including_user
+        {
+          dvla_user: RequestHeaders::DVLA_USER,
+          dvla_resource: RequestHeaders::DVLA_RESOURCE,
+          dvla_origin_resource: RequestHeaders::DVLA_ORIGIN_RESOURCE,
+          x_correlation_id: RequestHeaders::X_CORRELATION_ID,
+          origin_timestamp: RequestHeaders::ORIGIN_TIMESTAMP,
+          dvla_session_id: RequestHeaders::DVLA_SESSION_ID,
+        }
+      end
+
+      def self.driving_licence_channel_api_test_headers_disable_payment_processing
+        {
+          dvla_resource: RequestHeaders::DVLA_RESOURCE,
+          dvla_origin_resource: RequestHeaders::DVLA_ORIGIN_RESOURCE,
+          x_correlation_id: RequestHeaders::X_CORRELATION_ID,
+          origin_timestamp: RequestHeaders::ORIGIN_TIMESTAMP,
+          dvla_session_id: RequestHeaders::DVLA_SESSION_ID,
+          disable_payment_processing: RequestHeaders::DISABLE_PAYMENT_PROCESSING,
+        }
+      end
+
+      class DrivingLicenceChannelApiClient < DVLADrivingLicenceChannelApiOpenAPIClient::ApiClient
+        def initialize(config = nil)
+          @signer = AWS.create_signer
+          super
+        end
+
+        def call_api(http_method, path, opts = nil)
+          signed_request = @signer.sign_request(
+            http_method:,
+            url: build_request_url(path),
+            body: opts[:body],
+            )
+          opts[:header_params].merge!(signed_request.headers)
+          super
+        end
+      end
+    end
+  end
+end