dvla-application_helper 5.1.5

data/lib/dvla/application_helper/factories/photo_signature_image.rb

@@ -0,0 +1,158 @@
+require_relative('photo_image.rb')
+
+module DVLA
+  module Application
+    class PhotoSignatureImageFactory < PhotoImageFactory
+      def initialize(unique_images:, no_comparison_image:, home_office_comparison_photo:)
+        @no_comparison_image = no_comparison_image
+        @home_office_comparison_photo = home_office_comparison_photo
+        super(unique_images:)
+      end
+
+      def build(type)
+        case type
+        when :user_signature
+          build_user_signature
+        when :passport_signature
+          build_passport_signature
+        when :passport_signature_moved
+          build_passport_signature_moved
+        when :passport_signature_utility
+          build_passport_active_signature_utility
+        else
+          super
+        end
+      end
+
+    private
+
+      PASSPORT_COMPARISON_IMAGE_ID = '727993a6-04c8-464d-b3e3-6c97c5795ba2'.freeze
+      HOME_OFFICE_COMPARISON_IMAGE_ID = 'ad3e0be1-63be-4e53-98b9-aee57eb74aaa'.freeze
+      USER_SIGNATURE_IMAGE_ID = '3baa5140-ad77-4b57-bac9-397af11cf2a9'.freeze
+      CSUDL_SIGNATURE_IMAGE_ID = '22b0342e-62d5-42e1-8f40-93f08f885938'.freeze
+      PASSPORT_SIGNATURE_IMAGE_ID_IMAGE_SERVICE = 'e0fa10d0-2f23-4faa-b8d7-f21d86b063b9'.freeze
+      PASSPORT_SIGNATURE_IMAGE_ID_IMAGE_UTILITY = '2422cd2a-9973-4573-a063-18fbfcc07eb8'.freeze
+
+      # Overridden from base class
+      def build_comparison
+        if @no_comparison_image
+          nil
+        elsif @home_office_comparison_photo
+          build_home_office_comparison
+        else
+          build_passport_comparison
+        end
+      end
+
+      def build_passport_comparison
+        image_id = @unique_images == false ? PASSPORT_COMPARISON_IMAGE_ID : Random.uuid
+        DVLA::Application::ImageService.put_passport_comparison_image_in_service(image_id:)
+        # This next step ensure image has seeded and D90 transformed image exists
+        DVLA::Application::ImageService.get_base64_image_data(image_id:, image_type: 'Photo', image_origin: 'Passport')
+
+        {
+          imageId: image_id,
+          imageType: 'Photo',
+          imageSource: 'driving-licence-image-service',
+          imageOriginType: 'Passport',
+          imageStatus: 'Active',
+          imagePurpose: 'Comparison',
+          timeCreated: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%L%:z'),
+          reviewHistory: [],
+        }
+      end
+
+      def build_home_office_comparison
+        image_id = @unique_images == false ? HOME_OFFICE_COMPARISON_IMAGE_ID : Random.uuid
+        DVLA::Application::ImageService.put_home_office_comparison_image_in_service(image_id:)
+        # This next step ensure image has seeded and D90 transformed image exists
+        DVLA::Application::ImageService.get_base64_image_data(image_id:, image_type: 'Photo', image_origin: 'Home Office')
+
+        {
+          imageId: image_id,
+          imageType: 'Photo',
+          imageSource: 'driving-licence-image-service',
+          imageOriginType: 'Home Office',
+          imageStatus: 'Active',
+          imagePurpose: 'Comparison',
+          timeCreated: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%L%:z'),
+          reviewHistory: [],
+        }
+      end
+
+      def build_user_signature
+        image_id = @unique_images == false ? USER_SIGNATURE_IMAGE_ID : Random.uuid
+        DVLA::Application::ImageService.put_user_uploaded_image_in_service(image_id:, image_type: 'Signature')
+        # This next step ensure image has seeded and D90 transformed image exists
+        DVLA::Application::ImageService.get_base64_image_data(image_id:, image_type: 'Signature', image_origin: 'User')
+
+        {
+          imageId: image_id,
+          imageType: 'Signature',
+          imageSource: 'driving-licence-image-service',
+          imageOriginType: 'User',
+          imageStatus: 'Active',
+          imagePurpose: 'Application',
+          timeCreated: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%L%:z'),
+          reviewHistory: [],
+        }
+      end
+
+      def build_passport_signature
+        image_id = @unique_images == false ? PASSPORT_SIGNATURE_IMAGE_ID_IMAGE_SERVICE : Random.uuid
+        DVLA::Application::ImageService.put_passport_image_in_service(image_id:, image_type: 'Signature')
+        # This next step ensure image has seeded and D90 transformed image exists
+        DVLA::Application::ImageService.get_base64_image_data(image_id:, image_type: 'Signature', image_origin: 'Passport')
+
+        {
+          imageId: image_id,
+          imageType: 'Signature',
+          imageSource: 'driving-licence-image-service',
+          imageOriginType: 'Passport',
+          imageStatus: 'Active',
+          imagePurpose: 'Application',
+          timeCreated: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%L%:z'),
+          reviewHistory: [],
+        }
+      end
+
+      def build_passport_signature_moved
+        image_id = @unique_images == false ? PASSPORT_SIGNATURE_IMAGE_ID_IMAGE_SERVICE : Random.uuid
+        DVLA::Application::ImageService.put_passport_image_in_service(image_id:, image_type: 'Signature')
+        # This next step ensure image has seeded and D90 transformed image exists
+        DVLA::Application::ImageService.get_base64_image_data(image_id:, image_type: 'Signature', image_origin: 'Passport')
+
+        {
+          imageId: image_id,
+          imageType: 'Signature',
+          imageSource: 'driving-licence-image-service',
+          imageOriginType: 'Passport',
+          imageStatus: 'Moved',
+          imagePurpose: 'Application',
+          timeCreated: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%L%:z'),
+          reviewHistory: [],
+        }
+      end
+
+      def build_passport_active_signature_utility
+        image_id = @unique_images == false ? PASSPORT_SIGNATURE_IMAGE_ID_IMAGE_UTILITY : Random.uuid
+        DVLA::Application::ImageService.put_passport_image_in_service(image_id:, image_type: 'Signature')
+        # This next step ensure image has seeded and D90 transformed image exists
+        DVLA::Application::ImageService.get_base64_image_data(image_id:, image_type: 'Signature', image_origin: 'Passport')
+
+        DVLA::Application::ImageUtility.store_image_in_image_utility(image_id:, image_purpose: 'Application', image_origin: 'Passport', image_type: 'Signature', image_transformation_type: 'UI preview')
+
+        {
+          imageId: image_id,
+          imageType: 'Signature',
+          imageSource: 'image-utility',
+          imageOriginType: 'Passport',
+          imageStatus: 'Active',
+          imagePurpose: 'Application',
+          timeCreated: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%S.%L%:z'),
+          reviewHistory: [],
+        }
+      end
+    end
+  end
+end

data/lib/dvla/application_helper/factories/photo_signature_images.rb

@@ -0,0 +1,64 @@
+require_relative('photo_images.rb')
+
+module DVLA
+  module Application
+    class PhotoSignatureImagesFactory < PhotoImagesFactory
+      def initialize(photo_review_state, signature_review_state, unique_images, use_passport_images:, passport_images_preprocessed:, home_office_comparison_photo:)
+        @use_signature_passport_images = use_passport_images
+        @signature_review_state = signature_review_state
+        no_comparison_image = use_passport_images && !passport_images_preprocessed
+        image_factory = DVLA::Application::PhotoSignatureImageFactory.new(unique_images:, no_comparison_image:, home_office_comparison_photo:)
+        super(photo_review_state, unique_images, use_passport_images:, passport_images_preprocessed:, additional_passport_image_available: false, image_factory:)
+      end
+
+      def build
+        photo_images = super
+
+        signature_images = build_signature_images
+
+        images = photo_images + signature_images
+        images.select { |i| !i.nil? }
+      end
+
+      def build_signature_images
+        if(@use_signature_passport_images)
+          return build_passport_signatures
+        end
+
+        case @signature_review_state
+        when DVLA::Application::SignatureReviewState::CLERK_IN_PROGRESS, nil
+          build_clerk_signature
+        when DVLA::Application::SignatureReviewState::CLERK_REJECTED
+          build_clerk_signature_rejected
+        when DVLA::Application::SignatureReviewState::CLERK_APPROVED
+          build_clerk_signature_approved
+        else
+          raise 'Invalid review state passed to the Images factory'
+        end
+      end
+
+    private
+
+      def build_passport_signatures
+        if @passport_images_preprocessed
+          [@image_factory.build(:passport_signature_moved),
+           @image_factory.build(:passport_signature_utility)]
+        else
+          [@image_factory.build(:passport_signature)]
+        end
+      end
+
+      def build_clerk_signature
+        [@image_factory.build(:user_signature)].flatten
+      end
+
+      def build_clerk_signature_rejected
+        add_review(build_clerk_signature, create_review('Clerk', 'Rejection on standards', ['Signature is not clear']))
+      end
+
+      def build_clerk_signature_approved
+        add_review(build_clerk_signature, create_review('Clerk', 'Success'))
+      end
+    end
+  end
+end

data/lib/dvla/application_helper/processors/application_status.rb

@@ -0,0 +1,45 @@
+module DVLA
+  module Application
+    module ApplicationStatusProcessor
+      def self.process_to(application_id, application_status, update_reason: nil)
+        expected_application_types = [
+          'Started', 'Received', 'Payment settlement requested', 'Preparing', 'Submitted', 'Approved', 'Returned', 'Unapproved',
+          'Rejected', 'Completed', 'Deleted', 'Cancelled'
+        ].freeze
+        application_requiring_submit = %w[Approved Returned Unapproved Rejected Completed].freeze
+        application_requiring_received = application_requiring_submit + ['Submitted', 'Payment settlement requested', 'Preparing']
+
+        unless expected_application_types.include? application_status
+          raise "Invalid application status of, '#{application_status}' passed to the application status processor."
+        end
+
+        if application_requiring_received.include? application_status
+          self.update_application_status(application_id, 'Received')
+        end
+
+        if application_requiring_submit.include? application_status
+          self.update_application_status(application_id, 'Submitted')
+        end
+
+        if application_status == 'Completed'
+          self.update_application_status(application_id, 'Approved')
+        end
+
+        unless application_status == 'Started'
+          self.update_application_status(application_id, application_status, update_reason:)
+        end
+      end
+
+      def self.update_application_status(application_id, status, update_reason: nil)
+        application_state = {
+          'status' => status,
+          'timeUpdated' => Time.now.strftime('%FT%T.%3NZ') }
+
+        # only include when cancelled to avoid validation error regarding required string value
+        application_state['reason'] = update_reason if status == 'Cancelled'
+
+        DVLA::Application::ApplicationDomain.update_application_status(application_id:, application_state: )
+      end
+    end
+  end
+end

data/lib/dvla/application_helper/processors/application_task.rb

@@ -0,0 +1,301 @@
+module DVLA
+  module Application
+    class ApplicationTaskProcessor
+      include BlockRepeater
+
+      class TaskNotFoundError < StandardError; end
+
+      def initialize(application_id:, target: 'Clerk')
+        @application_id = application_id
+        @target = target
+      end
+
+      def self.process_to(application_id, task_state, task_type: 'Photo review')
+        processor = new(application_id: application_id)
+        case task_state
+        when DVLA::Application::ReviewState::CLERK_REJECTED
+          processor.reject_photo
+        when DVLA::Application::ReviewState::CLERK_REJECT_COMPARISON_PHOTO
+          processor.reject_comparison_photo
+        when DVLA::Application::ReviewState::FRAUD_REJECT_COMPARISON_PHOTO
+          processor.refer_task_standards(task_type)
+          processor.refer_task_compare(task_type)
+          processor.reject_comparison_photo
+        when DVLA::Application::ReviewState::SUPERVISOR_REJECT_COMPARISON_PHOTO
+          processor.refer_task_standards(task_type)
+          processor.reject_comparison_photo
+        when DVLA::Application::SignatureReviewState::CLERK_REJECTED
+          processor.reject_signature
+        when DVLA::Application::ReviewState::CLERK_REFER_TO_SUPERVISOR_STANDARDS
+          processor.refer_task_standards(task_type)
+        when DVLA::Application::ReviewState::CLERK_REFER_TO_SUPERVISOR_COMPARE
+          processor.refer_task_compare(task_type)
+        when DVLA::Application::ReviewState::CLERK_APPROVED, DVLA::Application::SignatureReviewState::CLERK_APPROVED
+          processor.approve_task(task_type)
+        when DVLA::Application::ReviewState::SUPERVISOR_REJECTED
+          processor.refer_task_standards(task_type)
+          processor.reject_photo
+        when DVLA::Application::ReviewState::SUPERVISOR_REFER_TO_FRAUD
+          processor.refer_task_compare(task_type)
+          processor.refer_task_compare(task_type)
+        when DVLA::Application::ReviewState::SUPERVISOR_APPROVED
+          processor.refer_task_standards(task_type)
+          processor.approve_task(task_type)
+        when DVLA::Application::ReviewState::FRAUD_BEGIN_INVESTIGATION
+          processor.refer_task_compare(task_type)
+          processor.refer_task_compare(task_type)
+          processor.fraud_begin_investigation(task_type)
+        when DVLA::Application::ReviewState::FRAUD_APPROVED
+          processor.refer_task_standards(task_type)
+          processor.refer_task_compare(task_type)
+          processor.approve_task(task_type)
+        when DVLA::Application::ReviewState::FRAUD_REJECTED
+          processor.refer_task_standards(task_type)
+          processor.refer_task_compare(task_type)
+          processor.reject_photo
+        when DVLA::Application::ReviewState::FRAUD_REVIEW_REJECTION_WITH_REFUND
+          processor.refer_task_compare(task_type)
+          processor.refer_task_compare(task_type)
+          processor.fraud_begin_investigation(task_type)
+          processor.fraud_cancel_with_refund(task_type)
+        when DVLA::Application::ReviewState::FRAUD_REVIEW_REJECTION_WITHOUT_REFUND
+          processor.refer_task_compare(task_type)
+          processor.refer_task_compare(task_type)
+          processor.fraud_begin_investigation(task_type)
+          processor.fraud_cancel_without_refund(task_type)
+        when DVLA::Application::ReviewState::FRAUD_REVIEW_APPROVED
+          processor.refer_task_compare(task_type)
+          processor.refer_task_compare(task_type)
+          processor.fraud_begin_investigation(task_type)
+          processor.approve_task(task_type)
+        else
+          raise 'Invalid task state passed to the task processor'
+        end
+      end
+
+      def approve_task(task_type)
+        DVLA::Application.logger.info("Approving #{task_type} as #{@target}")
+        retrieve_and_submit_task(
+          {
+            outcome: 'Success',
+            taskTarget: @target,
+            taskType: task_type,
+          },
+        )
+      end
+
+      def reject_photo
+        DVLA::Application.logger.info("Rejecting photo as #{@target}")
+        retrieve_and_submit_task(
+          {
+            outcome: 'Rejection on standards',
+            rejectionReasons: [
+              'Background is not light in colour',
+              'Background is not plain',
+              'Background is not clear',
+            ],
+            taskTarget: @target,
+            taskType: 'Photo review',
+          },
+        )
+      end
+
+      def reject_comparison_photo
+        DVLA::Application.logger.info("Rejecting photo comparison as #{@target}")
+        retrieve_and_submit_task({
+          outcome: 'Reject comparison photo',
+          taskTarget: @target,
+          taskType: 'Photo review',
+      })
+      end
+
+      def reject_signature
+        DVLA::Application.logger.info("Rejecting signature as #{@target}")
+        retrieve_and_submit_task(
+          {
+            outcome: 'Rejection on standards',
+            rejectionReasons: [
+              'Signature is not clear',
+            ],
+            taskTarget: @target,
+            taskType: 'Signature review',
+          },
+        )
+      end
+
+      def refer_task_standards(task_type)
+        DVLA::Application.logger.info("Referring #{task_type} on standards as #{@target}")
+        retrieve_and_submit_task(
+          {
+            outcome: 'Referral at standards',
+            taskType: task_type,
+            taskTarget: @target,
+          },
+        )
+        DVLA::Application.logger.info("Referred #{task_type} on standards as #{@target}")
+        escalate_target
+      end
+
+      def refer_task_compare(task_type)
+        DVLA::Application.logger.info("Referring #{task_type} on compare as #{@target}")
+        retrieve_and_submit_task(
+          {
+            outcome: 'Referral at compare',
+            taskType: task_type,
+            taskTarget: @target,
+          },
+        )
+        escalate_target
+      end
+
+      def fraud_begin_investigation(task_type)
+        DVLA::Application.logger.info('Starting fraud investigation')
+        retrieve_and_submit_task(
+          {
+            caseNumber: DVLA::Application.generate_case_number,
+            outcome: 'Begin investigation',
+            taskType: task_type,
+            taskTarget: @target,
+          },
+        )
+        escalate_target
+      end
+
+      def fraud_cancel_with_refund(task_type)
+        DVLA::Application.logger.info('Fraud cancelling with refund')
+        retrieve_and_submit_task(
+          {
+            outcome: 'Rejection with refund',
+            taskType: task_type,
+            taskTarget: @target,
+          },
+        )
+      end
+
+      def fraud_cancel_without_refund(task_type)
+        DVLA::Application.logger.info('Fraud cancelling without refund')
+        retrieve_and_submit_task(
+          {
+            outcome: 'Rejection no refund',
+            taskType: task_type,
+            taskTarget: @target,
+          },
+        )
+      end
+
+      def casework_cancellation
+        DVLA::Application.logger.info('Casework cancellation')
+        retrieve_and_submit_task(
+          {
+            outcome: 'Cancellation',
+            taskTarget: 'Drivers caseworker',
+            taskType: 'CASP casework',
+            withNotification: true,
+          },
+          )
+      end
+
+      def casework_completion
+        DVLA::Application.logger.info('Casework completion')
+        retrieve_and_submit_task(
+          {
+            outcome: 'Completion',
+            taskTarget: 'Drivers caseworker',
+            taskType: 'CASP casework',
+          },
+          )
+      end
+
+      def switch_to_passport_image
+        DVLA::Application.logger.info('Switch to passport image')
+        retrieve_and_submit_task(
+          {
+            outcome: 'Switch to passport photo',
+            taskTarget: 'External',
+            taskType: 'Photo review',
+          },
+          )
+      end
+
+      # @param outcome [String] defaults to 'New photo uploaded', can also use 'New signature uploaded'
+      def user_upload_new_image(image_id:, task_type:, outcome: 'New photo uploaded')
+        DVLA::Application.logger.info("User upload new #{task_type} image")
+        retrieve_and_submit_task(
+          {
+            outcome: outcome,
+            taskTarget: 'External',
+            taskType: task_type,
+            imageId: image_id,
+            imageSource: 'driving-licence-image-service',
+          },
+          )
+      end
+
+      def user_upload_passport_photo(image_id:)
+        DVLA::Application.logger.info('User upload passport photo')
+        retrieve_and_submit_task(
+          {
+            outcome: 'Passport photo uploaded',
+            taskTarget: 'External',
+            taskType: 'Photo review',
+            imageId: image_id,
+            imageSource: 'driving-licence-image-service',
+          },
+          )
+      end
+
+    private
+
+      def escalate_target
+        @target = if @target == 'Clerk'
+                    'Supervisor'
+                  elsif @target == 'Supervisor'
+                    'Fraud'
+                  else
+                    'Fraud review'
+                  end
+      end
+
+      def retrieve_and_submit_task(task_outcome)
+        channel_api_client = DVLA::Application::ChannelAPI.initialize_channel_api_instance
+
+        retrieve_tasks_request = DVLADrivingLicenceChannelApiOpenAPIClient::RetrieveTasksByApplicationIdRequest.new(
+          {
+            application_id: @application_id,
+          },
+        )
+
+        task = repeat(times: 30, delay: 3) do
+          tasks =
+            channel_api_client.get_tasks_by_application_id(
+              RequestHeaders::DVLA_RESOURCE,
+              RequestHeaders::DVLA_ORIGIN_RESOURCE,
+              retrieve_tasks_request,
+              DVLA::Application::ChannelAPI.driving_licence_channel_api_test_headers,
+            ).tasks
+
+          # Looking for the task for the expected review level and task type
+          tasks.find { |t| t.task_status == 'Active' && t.task_target == @target && t.task_type == task_outcome[:taskType] }
+        end.until(&:present?)
+
+        raise TaskNotFoundError, "Request: '#{retrieve_tasks_request}' found no tasks" unless task.present?
+
+        submit_task_outcome_request = DVLADrivingLicenceChannelApiOpenAPIClient::SubmitTaskOutcomeRequest.new(
+          {
+            application_id: @application_id,
+            task_id: task.task_id,
+            task_outcome:,
+            version: 1,
+          },
+        )
+
+        channel_api_client.submit_task_outcome_with_http_info(
+          RequestHeaders::DVLA_RESOURCE,
+          RequestHeaders::DVLA_ORIGIN_RESOURCE,
+          submit_task_outcome_request,
+          DVLA::Application::ChannelAPI.driving_licence_channel_api_test_headers_including_user,
+        )
+      end
+    end
+  end
+end