dvla-application_helper 5.1.5

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

@@ -0,0 +1,116 @@
+module DVLA
+  module Application
+    module ImageService
+      def self.image_service_headers
+        {
+          'x-correlation-id': RequestHeaders::X_CORRELATION_ID,
+          'dvla-resource': RequestHeaders::DVLA_RESOURCE,
+          'dvla-origin-resource': RequestHeaders::DVLA_ORIGIN_RESOURCE,
+          'dvla-user': RequestHeaders::DVLA_USER,
+        }
+      end
+
+      def self.get_image_url_body(image_id:, image_origin:, image_type:)
+        {
+          imageId: image_id,
+          imageOriginType: image_origin,
+          imageType: image_type,
+        }
+      end
+
+      def self.image_base64_body(image_id:, image_type:, image_transformation_type:, image_origin: 'User')
+        {
+          imageId: image_id,
+          imageOriginType: image_origin,
+          imageType: image_type,
+          imageTransformationType: image_transformation_type,
+        }
+      end
+
+      def self.image_retention_body(retention, image_id, origin_type = 'User')
+        {
+          imageId: image_id,
+          imageOriginType: origin_type,
+          imageType: 'Photo',
+          retainForApplication: retention,
+        }
+      end
+
+      def self.put_user_uploaded_image_in_service(image_id:, image_type: 'Photo')
+        image_folder_name = image_type.downcase
+        put_local_image_in_service(image_id:, image_origin: 'User', image_path: "../fixtures/#{image_folder_name}/user_uploaded_image.jpg", log_description: "User #{image_type}", image_type:)
+      end
+
+      def self.put_comparison_image_in_service(image_id:, image_type: 'Photo')
+        image_folder_name = image_type.downcase
+        put_local_image_in_service(image_id:, image_origin: 'User', image_path: "../fixtures/#{image_folder_name}/comparison_image.jpeg", log_description: "Comparison #{image_type}", image_type:)
+      end
+
+      def self.put_passport_image_in_service(image_id:, image_type: 'Photo')
+        image_folder_name = image_type.downcase
+        put_local_image_in_service(image_id:, image_origin: 'Passport', image_path: "../fixtures/#{image_folder_name}/passport_image.jpg", log_description: "Passport #{image_type}", image_type:)
+      end
+
+      def self.put_passport_comparison_image_in_service(image_id:, image_type: 'Photo')
+        image_folder_name = image_type.downcase
+        put_local_image_in_service(image_id:, image_origin: 'Passport', image_path: "../fixtures/#{image_folder_name}/comparison_image.jpeg", log_description: "Passport Comparison #{image_type}", image_type:)
+      end
+
+      def self.put_home_office_comparison_image_in_service(image_id:, image_type: 'Photo')
+        image_folder_name = image_type.downcase
+        put_local_image_in_service(image_id:, image_origin: 'HomeOffice', image_path: "../fixtures/#{image_folder_name}/comparison_image.jpeg", log_description: "Home Office Comparison #{image_type}", image_type:)
+      end
+
+      def self.put_local_image_in_service(image_id:, image_origin:, image_path:, log_description:, image_type: 'Photo')
+        if image_exists?(image_id:, image_origin:, image_type:)
+          DVLA::Application.logger.info("#{log_description} image already exists in image service, no need to create. imageID = #{image_id.green}")
+        else
+          image_upload_url = JSON.parse(image_service_http_post(endpoint: 'get-image-upload-url', body: get_image_url_body(image_id:, image_origin:, image_type:)))['url']
+          image_file = File.open(File.expand_path(image_path, File.dirname(__FILE__)))
+
+          DVLA::Application.logger.info("Uploading #{log_description} photo to image service. imageID = #{image_id.green}")
+          HTTPX.put(image_upload_url, body: File.open(image_file))
+        end
+      end
+
+      def self.image_service_http_post(endpoint:, body:)
+        image_service_url = "#{Settings.application_helper.services.image_service.base_url}v1/#{endpoint}"
+        headers = image_service_headers.merge(AWS.sign_the_request(image_service_url, body))
+        HTTPX.post(image_service_url, json: body, headers:)
+      end
+
+      def self.image_exists?(image_id:, image_origin:, image_type:)
+        images_service_does_image_exist_url = "#{Settings.application_helper.services.image_service.base_url}v1/get-image-exists"
+        headers = image_service_headers.merge(AWS.sign_the_request(images_service_does_image_exist_url, get_image_exists_body(image_id:, image_origin:, image_type:)))
+        response = HTTPX.post(images_service_does_image_exist_url, json: get_image_exists_body(image_id:, image_origin:, image_type:), headers:)
+        JSON.parse(response.body).to_h['imageExists']
+      end
+
+      def self.image_service_get_base64(image_id:, image_type:, image_transformation_type:, image_origin: 'User')
+        image_service_base64_url = "#{Settings.application_helper.services.image_service.base_url}v1/get-image-as-base64"
+        request_body = image_base64_body(image_id:, image_origin:, image_type:, image_transformation_type:)
+        headers = image_service_headers.merge(AWS.sign_the_request(image_service_base64_url, request_body))
+        HTTPX.post(image_service_base64_url, json: request_body, headers:)
+      end
+
+      def self.get_base64_image_data(image_id:, image_origin:, image_type: 'Photo', image_transformation_type: 'D90')
+        BlockRepeater::Repeater.new do
+          DVLA::Application.logger.info("Checking that imageID = #{image_id.green} has seeded successfully")
+          @response = JSON.parse(image_service_get_base64(image_id:, image_origin:, image_type:, image_transformation_type:))['base64String']
+        end.until do
+          @response != nil
+        end.repeat(times: 10, delay: 3)
+
+        if @response == false
+          raise StandardError "ImageId: #{image_id.green} not found in image service S3 bucket"
+        end
+
+        @response
+      end
+
+      def self.get_image_exists_body(image_id:, image_origin:, image_type:)
+        get_image_url_body(image_id:, image_origin:, image_type:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module DVLA
+  module Application
+    module ImageUtility
+      def self.image_utility_headers(x_image_use: RequestHeaders::X_IMAGE_USE)
+        {
+          'content-type': RequestHeaders::CONTENT_TYPE,
+          'dvla-resource': RequestHeaders::DVLA_RESOURCE,
+          'dvla-origin-resource': RequestHeaders::DVLA_ORIGIN_RESOURCE,
+          'x-image-use': x_image_use,
+        }
+      end
+
+      def self.generate_x_image_use(image_purpose: 'Comparison', image_type: 'Photo')
+        if image_type == 'Signature'
+          RequestHeaders::X_IMAGE_USE_APP_SIGNATURE
+        elsif image_purpose == 'Application'
+          RequestHeaders::X_IMAGE_USE_APP_PHOTO
+        elsif image_purpose == 'Comparison'
+          RequestHeaders::X_IMAGE_USE_DRIVER_PHOTO
+        elsif image_purpose == 'Photocard front'
+          RequestHeaders::X_IMAGE_USE_PHOTOCARD_FRONT
+        elsif image_purpose == 'Photocard back'
+          RequestHeaders::X_IMAGE_USE_PHOTOCARD_BACK
+        else
+          raise StandardError, 'The image_purpose and image_type are not valid'
+        end
+      end
+
+      def self.store_image_in_image_utility(image_id:, image_purpose: 'Comparison', image_origin: 'User', image_type: 'Photo', image_transformation_type: 'D90')
+        x_image_use = generate_x_image_use(image_purpose:, image_type:)
+
+        if image_exists_in_utility?(image_id:, x_image_use:)
+          DVLA::Application.logger.info("Image already exists in image utility, no need to create. imageID = #{image_id.green}")
+        else
+          base64_image_data = DVLA::Application::ImageService.get_base64_image_data(image_id:, image_origin:, image_type:, image_transformation_type:)
+          body = {
+            type: 'image/jpeg',
+            data: base64_image_data,
+            imageId: image_id,
+          }
+
+          DVLA::Application.logger.info("Uploading #{image_origin} #{image_purpose} image to image utility")
+          image_utility_http_post(endpoint: 'image/store', body:, x_image_use:)
+        end
+      end
+
+      def self.store_local_image_in_image_utility(image_id:, image_path:, image_purpose: 'Comparison', image_origin: 'User', image_type: 'Photo', image_file_type: 'image/jpeg')
+        x_image_use = generate_x_image_use(image_purpose:, image_type:)
+
+        if image_exists_in_utility?(image_id:, x_image_use:)
+          DVLA::Application.logger.info("#{image_origin.blue} #{image_type.blue} | #{image_purpose.blue} Image already exists in image utility, no need to create. imageID = #{image_id.green}")
+        else
+          image_file = File.open(File.expand_path(image_path, File.dirname(__FILE__)))
+          base64_image_data = Base64.strict_encode64(image_file.read)
+          image_file.close
+          body = {
+            type: image_file_type,
+            data: base64_image_data,
+            imageId: image_id,
+          }
+
+          DVLA::Application.logger.info("Uploading #{image_origin.blue} #{image_type.blue} | #{image_purpose.blue} local image to image utility")
+          response = image_utility_http_post(endpoint: 'image/store', body:, x_image_use:)
+
+          raise StandardError, "Failed to store image in image utility, status: #{response.status}" unless response.status == 201
+
+          DVLA::Application.logger.info("Image stored in image utility, imageID = #{image_id.green}") if response.status == 201
+        end
+      end
+
+      def self.image_exists_in_utility?(image_id:, x_image_use:)
+        image_utility_http_post(endpoint: 'image/exist', body: { imageId: image_id }, x_image_use:).status == 204
+      end
+
+      def self.image_utility_http_post(endpoint:, body:, x_image_use: RequestHeaders::X_IMAGE_USE_DRIVER_PHOTO)
+        image_utility_url = "#{Settings.application_helper.services.image_utility.base_url}v1/#{endpoint}"
+        headers = image_utility_headers(x_image_use:).merge(AWS.sign_the_request(image_utility_url, body))
+        HTTPX.post(image_utility_url, json: body.as_json, headers:)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+module DVLA
+  module Application
+    require 'aws-sdk-states'
+    require 'block_repeater/repeater'
+
+    class StateMachine
+      attr_accessor :stage, :account_id, :state_machine_arn, :state_machine_name
+
+      # @param *account_id [String] AWS AccountId, optional, will default to dev if not set in env
+      # @param *state_machine_name [String] eg 'application-process-engine-fulfilment', required
+      # @param *stage [String] deployed stage name eg 'dev', optional, will default to dev if not set in env
+      def initialize(state_machine_name:, stage: nil, account_id: nil)
+        @stage = stage || ENV.fetch('DRIVERS_APPLICATION_PROCESS_ENGINE_STAGE_NAME', Settings.application_helper.services.state_machine.stage)
+        @account_id = account_id || ENV.fetch('STATE_MACHINE_ACCOUNT_ID', Settings.application_helper.services.state_machine.account_id)
+        @state_machine_name = state_machine_name
+        @state_machine_arn = %(arn:aws:states:eu-west-2:#{@account_id}:stateMachine:#{@stage}-#{@state_machine_name})
+        @client = Aws::States::Client.new
+      end
+
+      def list_activities
+        @client.list_activities(state_machine_arn: @state_machine_arn)
+      end
+
+      def list_executions
+        @client.list_executions(state_machine_arn: @state_machine_arn).to_hash[:executions]
+      end
+
+      def assert_execution_exists(execution_arn:)
+        begin
+          @client.describe_execution(execution_arn: execution_arn)
+          true
+        rescue Aws::States::Errors::ExecutionDoesNotExist
+          false
+        end
+      end
+
+      def start_execution(execution_name:, input:)
+        @client.start_execution(state_machine_arn: @state_machine_arn, name: execution_name, input: input.to_json)
+      end
+
+      # @param *application_id [String](UUID), required
+      # @param *correlation_id [String](UUID), optional
+      # @param *session_id [String](UUID), optional
+      # @return *input data [Hash], will include additional_input if passed in
+      def generate_start_execution_input_data(application_id:, additional_input: nil, correlation_id: SecureRandom.uuid, session_id: SecureRandom.uuid)
+        base_input = { applicationId: application_id,
+                       correlationId: correlation_id,
+                       sessionId: session_id }
+
+        additional_input.nil? ? base_input : base_input.merge(additional_input)
+      end
+    end
+
+    class StateMachineExecution
+      attr_accessor :account_id, :calling_service, :execution_arn, :execution_uuid, :iteration, :stage, :state_machine_name
+
+      # @param *execution_arn [String], optional, can be calculated and set using method calculate_execution_arn
+      def initialize(execution_arn: nil)
+        @account_id = ENV.fetch('STATE_MACHINE_ACCOUNT_ID', Settings.application_helper.services.state_machine.account_id)
+        @calling_service = nil
+        @client = Aws::States::Client.new
+        @execution_arn = execution_arn
+        @execution_uuid = nil
+        @iteration = nil
+        @stage = ENV.fetch('STATE_MACHINE_STAGE_NAME', Settings.application_helper.services.state_machine.stage)
+        @state_machine_name = nil
+      end
+
+      def describe_execution
+        DVLA::Application.logger.info("Calling Describe Execution for execution: #{@execution_arn}".blue)
+        make_state_machine_call(client_method: 'describe_execution')
+      end
+
+      def get_history
+        DVLA::Application.logger.info("Calling Get History for execution: #{@execution_arn}".blue)
+        make_state_machine_call(client_method: 'get_execution_history')
+      end
+
+      def stop_execution
+        DVLA::Application.logger.info("Calling Stop Execution on execution: #{@execution_arn}".blue)
+        make_state_machine_call(client_method: 'stop_execution')
+      end
+
+      # @param *step_name [String], relates to AWS step function step name
+      # @param *event_type_name [String], relates to AWS step event type
+      # returns found object or nil
+      def find_event_details(step_name:, event_type_name:)
+        DVLA::Application.logger.info("Attempting to find: #{event_type_name}, for step: #{step_name}".blue)
+        #  iterate through each event first
+        get_history.data.events.each do |event|
+          target_event = event.as_json[event_type_name]
+          unless target_event.nil?
+            if target_event['name'] == step_name
+              DVLA::Application.logger.info('Event Found'.green)
+              return target_event
+            end
+          end
+        end
+        DVLA::Application.logger.info("No event found for: #{event_type_name}, for step: #{step_name}".blue)
+        nil
+      end
+
+      def wait_for_execution_completion(repeat_times: 30, repeat_delay: 2, status: 'RUNNING')
+        BlockRepeater::Repeater.new do
+          begin
+            @client.describe_execution(execution_arn: @execution_arn).to_hash
+          rescue Aws::States::Errors::ServiceError => e
+            DVLA::Application.logger.info "AWS Service error #{e.message}"
+          end
+        end.until do |result|
+          result[:status] != status
+        end.repeat(times: repeat_times, delay: repeat_delay)
+      end
+
+      # @param *execution_arn [String], will be set once this method is called
+      # @param *execution_uuid [String](UUID), required, typically the application_id or a generated uuid
+      # @param *state_machine_name [String], required, eg 'application-process-engine-fulfilment'
+      # @param *calling_service [String], optional, eg 'application-process-engine'
+      # @param *iteration [Integer], optional, defaults to 1
+      def generate_execution_arn(execution_uuid:, state_machine_name:, calling_service: nil, iteration: 1)
+        @calling_service = calling_service
+        @execution_uuid = execution_uuid
+        @state_machine_name = state_machine_name
+        @iteration = iteration
+        @execution_arn = if @calling_service.nil?
+                           %(arn:aws:states:eu-west-2:#{@account_id}:execution:#{@stage}-#{@state_machine_name}:#{@execution_uuid})
+                         else
+                           %(arn:aws:states:eu-west-2:#{@account_id}:execution:#{@stage}-#{@state_machine_name}:#{@calling_service}-#{@execution_uuid}-#{@iteration})
+                         end
+        self
+      end
+
+      def make_state_machine_call(client_method:)
+        DVLA::Application.logger.info("Invoking state machine method: #{client_method}")
+        DVLA::Application.logger.info("AWS execution_arn: #{@execution_arn}")
+        begin
+          @client.method(client_method).call(execution_arn: @execution_arn)
+        rescue Aws::States::Errors::ServiceError => e
+          e
+        end
+      end
+    end
+  end
+end
+
+

data/lib/dvla/application_helper/version.rb

@@ -0,0 +1,5 @@
+module DVLA
+  module Application
+    VERSION = '5.1.5'.freeze
+  end
+end

data/lib/dvla/application_helper.rb

@@ -0,0 +1,92 @@
+require 'block_repeater'
+require 'config'
+require 'dvla-application-diary-openapi-client'
+require 'dvla-application-domain-openapi-client'
+require 'dvla-application-process-engine-openapi-client'
+require 'dvla/application_helper/configuration'
+require 'rspec/expectations'
+require 'dvla/herodotus'
+require 'dvla/aws'
+require 'dvla-driving-licence-channel-api-openapi-client'
+require 'dvla/poirot'
+require 'faker'
+require 'faker_maker'
+require 'httpx'
+
+Faker::Config.locale = 'en-GB'
+
+module DVLA
+  module Application
+    path = File.expand_path(__dir__)
+    Dir.glob("#{path}/application_helper/**/*.rb").each { |f| require_relative f }
+
+    CONFIG = "#{Gem::Specification.find_by_name('dvla-application_helper').gem_dir.freeze}/config".freeze
+
+    # Returns the configuration object, initializing it if necessary.
+    #
+    # @return [Configuration] the configuration object.
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configures the gem environment.
+    #
+    # @yieldparam [Configuration] config the configuration object yielded to the block.
+    def self.config
+      yield configuration
+    end
+
+    # Retrieve the logger object.
+    #
+    # @return [Logger] logger instance.
+    def self.logger
+      configuration.logger
+    end
+  end
+end
+
+module Dvla
+  def self.build_mirror(source, destination)
+    inners = source
+               .constants(false)
+               .filter { |constant| source.const_get(constant, false).is_a?(Module) }
+               .map { |constant| source.const_get(constant) }
+
+
+    inners.each do |inner|
+      inner_name = inner.name.split('::').last
+      mirror = if destination.constants(false).include?(inner_name)
+                 mirror.const_get(inner_name, false)
+               else
+                 inner.is_a?(Class) ? Class.new : Module.new
+               end
+
+      destination.const_set(inner_name, mirror)
+
+      mirror.define_singleton_method(:method_missing) do |method_name, *vargs, **kwargs, &block|
+        warn("Access via deprecated module name of Dvla; use DVLA instead. Method #{method_name} called")
+        inner.send(method_name, *vargs, **kwargs, &block)
+      end
+
+      mirror.define_singleton_method(:const_missing) do |const_name|
+        warn("Access via deprecated module name of Dvla; use DVLA instead. Constant #{const_name} called")
+        inner.const_get(const_name)
+      end
+
+      if inner.is_a?(Class)
+        mirror.define_method(:initialize) do |*vargs, **kwargs, &block|
+          warn("Access via deprecated module name of Dvla; use DVLA instead. Class #{inner.name} instantiated")
+          mirror.instance_variable_set(:@mirror, inner.new(*vargs, **kwargs, &block))
+        end
+
+        mirror.define_method(:method_missing) do |method_name, *vargs, **kwargs, &block|
+          mirror.instance_variable_get(:@mirror).send(method_name, *vargs, **kwargs, &block)
+        end
+      end
+
+      build_mirror(inner, mirror)
+    end
+  end
+
+  build_mirror(DVLA, self)
+end

data/renovate.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": ["local>AP/renovate-config"]
+}

data/scripts/application-login.sh

@@ -0,0 +1,56 @@
+#!/bin/zsh
+
+profile="dev"
+account_id=129805137803
+
+if [ $# -gt 0 ] && [ $1 != ${profile} ]
+then
+  if [ $1 = "nonprod" ]
+  then
+    profile="nonprod"
+    account_id=736948357641
+  else
+    printf "Unrecognised account, provide 'dev' or 'nonprod'\n"
+    return
+  fi
+fi
+
+export AWS_PROFILE=application-${profile}
+export ACCOUNT_ID=${account_id}
+export AWS_SDK_LOAD_CONFIG=true
+export AWS_REGION=eu-west-2
+
+aws sso login
+
+setopt no_nomatch
+rm -f ~/.aws/sso/cache/botocore*.json
+setopt nomatch
+
+SSO_CREDS="$(jq -s add ~/.aws/sso/cache/*.json)"
+
+ACCESS_TOKEN=$(echo $SSO_CREDS | jq -r .accessToken)
+
+TEMP_ROLE="$(aws sso get-role-credentials --account-id $ACCOUNT_ID --role-name Developer --access-token $ACCESS_TOKEN --region $AWS_REGION)"
+
+secret_key=$(echo $TEMP_ROLE | jq -r .roleCredentials.secretAccessKey)
+access_key=$(echo $TEMP_ROLE | jq -r .roleCredentials.accessKeyId)
+token=$(echo $TEMP_ROLE | jq -r .roleCredentials.sessionToken)
+expiration=$(echo $TEMP_ROLE | jq -r .roleCredentials.expiration)
+
+aws configure set aws_secret_access_key $secret_key
+aws configure set aws_access_key_id $access_key
+aws configure set aws_session_token $token
+printf "Account #%s | cloudplatform+Application%s\n" ${account_id} ${(C)profile}
+
+export AWS_SECRET_ACCESS_KEY=$secret_key
+export AWS_ACCESS_KEY_ID=$access_key
+export AWS_SESSION_TOKEN=$token
+export AWS_TOKEN_EXPIRY=$expiration
+
+# Update .env file values
+sed -i "" "s|\(AWS_SECRET_ACCESS_KEY=\).*|\1$secret_key|" .env
+sed -i "" "s|\(AWS_ACCESS_KEY_ID=\).*|\1$access_key|" .env
+sed -i "" "s|\(AWS_SESSION_TOKEN=\).*|\1$token|" .env
+printf ".env file AWS values updated\n"
+
+source ./.env

data/scripts/drone-aws-login.sh

@@ -0,0 +1,18 @@
+ACCOUNT_ID="129805137803"
+if [ "$ENVIRONMENT" = "drone-link" ]; then
+  ACCOUNT_ID="736948357641"
+fi
+
+echo "Attempting to get AWS credentials..."
+TEMP_ROLE="$(aws sts assume-role --role-arn arn:aws:iam::${ACCOUNT_ID}:role/platform/drone-serverless-test-role --role-session-name drone-serverless-sts)"
+secret_key=$(echo $TEMP_ROLE | jq -r .Credentials.SecretAccessKey)
+access_key=$(echo $TEMP_ROLE | jq -r .Credentials.AccessKeyId)
+token=$(echo $TEMP_ROLE | jq -r .Credentials.SessionToken)
+aws configure set aws_secret_access_key $secret_key --profile drone-serverless-sts
+aws configure set aws_access_key_id $access_key --profile drone-serverless-sts
+aws configure set aws_session_token $token --profile drone-serverless-sts
+export AWS_SECRET_ACCESS_KEY=$secret_key
+export AWS_ACCESS_KEY_ID=$access_key
+export AWS_SESSION_TOKEN=$token
+export AWS_TOKEN_EXPIRY=$expiration
+export AWS_REGION=eu-west-2