dvla-application_helper 5.1.5

data/lib/dvla/application_helper/builders/V1/csudl_application_builder.rb

@@ -0,0 +1,329 @@
+require_relative('../photo_signature_builder_mixin.rb')
+
+module DVLA
+  module Application
+    class CSUDLApplicationBuilder
+      # Including all properties and methods needed to support photos and signatures
+      include DVLA::Application::PhotoSignatureBuilderMixin
+
+      def initialize
+        @processable = false
+        @unique_images = false
+        @applicant = nil
+        @application_id = SecureRandom::uuid
+        @application_status = 'Preparing'
+        @customer_id = :default
+        @update_reason = nil
+        @product_type = 'Driving Licence'
+        @update_address = false # Optional field
+        @unable_to_prove_licence_possession_reason = nil # Optional field
+        @organ_donor = nil
+        @photo_compliance_checks = false # Optional fields within
+        @investigation_required = false # Optional field
+        @reminder_barcode_contents = nil # Optional field
+        @licence_data = nil # Optional fields within
+        @counter_service_metadata = nil
+        init_photo_signature_properties
+      end
+
+      # Some builder methods are automatically included from PhotoSignatureBuilderMixin
+
+      # Marks the application as processable, doing this will ensure that real services are used to create the
+      # application. For example, the channel api will process the tasks rather than stub data being provided.
+      # Whilst this results in a more complete application, this option is more expensive.
+      # Avoid excessive use in QA tests.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def processable
+        @processable = true
+        self
+      end
+
+      # Marks the application as non-processable. This will result in the application being created using the test application endpoint.
+      # These applications cannot be actioned via the task service.
+      # This is typically the default option to be used.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def non_processable
+        @processable = false
+        self
+      end
+
+      # APE uses very specific generated uuid to test with, the inspectable hooks filter the last 12 integers to return specific responses
+      # @param application_id [UUID]
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_application_id(application_id)
+        @application_id = application_id
+        self
+      end
+
+      # The application will be made for the given customer
+      # @param customer_id [String] The customer ID to use
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_customer_id(customer_id)
+        @customer_id = customer_id
+        self
+      end
+
+      # The application will contain the provided applicant data.
+      # @param applicant [ApplicantObject] Application data.
+      # @return [Builder]
+      def with_applicant(applicant)
+        @applicant = applicant
+        self
+      end
+
+      def is_welsh_language
+        @welsh_language = true
+        self
+      end
+
+      # The application will contain a phone number.
+      # @return [Builder]
+      def has_phone_number
+        @phone_number = true
+        self
+      end
+
+      def with_low_confidence_level
+        @identity_confidence_level = 'LOW'
+        self
+      end
+
+      # The application will contain a specific application status.
+      # How this state is reached will depend on if the application has been marked as processable or not.
+      # If processable is used here, we will also contain all actions.
+      # @param application_status [String] The application status the application should be in.
+      # @param update_reason [String] The reason for the change in status.
+      # @return [DVLA::Application::CSUDLApplicationBuilder].
+      def with_application_status(application_status, update_reason = nil)
+        @application_status = application_status
+        @update_reason = update_reason
+        self
+      end
+
+      # Sets the organ donor status of the application.
+      # By default, no organ donation is made
+      # Passing true will cause all_organs to be selected.
+      # Passing false will ensure no organs are selected.
+      # @param donor [boolean] Organ donor status.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def is_organ_donor(donor)
+        @organ_donor = donor
+        self
+      end
+
+      # Adds the customer provided reason for not being able to prove licence possession to the application
+      # @param reason [DVLA::Application::UnableToProveLicencePossessionReasons] the reason for not being able to prove licence possession
+      # @return [BuilderUsingMixin]
+      def with_unable_to_prove_licence_possession_reason(reason)
+        @unable_to_prove_licence_possession_reason = reason
+        self
+      end
+
+      # The application will contain unique imageIds
+      # Allows images to be interacted with during test, e.g. deleted
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def unique_images
+        @unique_images = true
+        self
+      end
+
+      # The application will have a new address to be updated.
+      # If an address isn't passed in, it will generate a random address.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_update_address(new_address = 'Random')
+        @update_address = new_address
+        self
+      end
+
+      # The application wil have Photo Compliance Checks Present
+      # @param photo_compliance_checks [Hash] The photo compliance checks to be used in the application.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_photo_compliance_checks(photo_compliance_checks = nil)
+        @photo_compliance_checks = photo_compliance_checks || {
+          photoOverride: false,
+          icaoCompliant: true,
+          eyesOpen: true,
+          exposure: true,
+          frontalView: true,
+          greyscaleDensity: true,
+          uniformLighting: true,
+          headWidth: true,
+          headLength: true,
+          widthHeightRatio: true,
+          resolution: true,
+          verticalPosition: true,
+          horizontallyCentered: true,
+        }
+        self
+      end
+
+      # Flags the application as requiring an investigation by a counter service clerk.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_investigation_required
+        @investigation_required = true
+        self
+      end
+
+      # At the moment, this will not function, as the happy path expects an applicant to be present.
+      # Driver reminder service may not bew able to find a customer, which could cause this case
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_no_applicant
+        @applicant = false
+        self
+      end
+
+      # Sets the contents of the scanned bartcode from the reminder letter sent to the applicant.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_reminder_barcode_contents(barcode_contents)
+        @reminder_barcode_contents = barcode_contents
+        self
+      end
+
+      # Sets the data captured from the driver's licence. if licence_data is not provided, it will default to a set of values.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_licence_data(licence_data = nil)
+        @licence_data = licence_data || {
+          photocard_surrendered: true,
+          photoCardIssueNumber: '2',
+        }
+        self
+      end
+
+      # Sets the counter service metadata for the application. Optional as there is already default metadata set in the application factory.
+      # @return [DVLA::Application::CSUDLApplicationBuilder]
+      def with_counter_service_metadata(counter_service_metadata)
+        @counter_service_metadata = counter_service_metadata
+        self
+      end
+
+      def check_application_validity
+        # Allows validation of the application before building it
+      end
+
+      # Creating the images that the BaseUODLV2ApplicationBuilder will include in the app
+      def application_images
+        generate_csudl_photo_signature_images(@processable, @unique_images)
+      end
+
+      # Advance and submits the tasks based on the phot and signature review state specified | DL-14939
+      # def process_application_tasks(app)
+      #   process_photo_signature_tasks(app) if @processable
+      # end
+      #
+      def set_application_specific_fields!(app)
+        unless @unable_to_prove_licence_possession_reason.nil?
+          app.data.unable_to_prove_licence_possession_reason = @unable_to_prove_licence_possession_reason
+        end
+
+        if @update_address
+          app.data.update_address = if @update_address === 'Random'
+                                      { newAddress: { unstructuredAddress: FM[:application_unstructured_address].build } }
+                                    else
+                                      @update_address
+                                    end
+        end
+
+        if @photo_compliance_checks
+          app.data.photo_compliance_checks = @photo_compliance_checks
+        end
+
+        if @investigation_required
+          app.data.investigation_required = true
+        end
+
+        if @reminder_barcode_contents
+          app.data.reminder_barcode_contents = @reminder_barcode_contents
+        end
+
+        if @licence_data
+          app.data.licence_data = @licence_data
+        end
+
+        if @counter_service_metadata
+          app.data.counter_service_metadata = @counter_service_metadata
+        end
+      end
+
+      def build
+        # Sense check to ensure AWS credentials are present.
+        DVLA::Application.check_aws_credentials
+
+        check_application_validity
+
+        factory = if @processable
+                    # FM[:csudl_processable_application]
+                    # DL-14939
+                    # Processable CSUDL not available yet, throw an error
+                    raise 'Processable CSUDL application is not available yet.'
+                  else
+                    FM[:csudl_application]
+                  end
+
+        app = factory.build do |b|
+          update_main_properties!(b)
+
+          update_applicant!(b)
+          update_organ_donor!(b)
+
+          b.images = application_images
+
+          set_application_specific_fields!(b)
+        end
+
+        # DL-14939 - Process tasks
+        # process_application_tasks(app)
+        process_application(app)
+
+        DVLA::Application::ApplicationDomain.retrieve_application_by_app_id(application_id: app.application_id)
+      end
+
+    private
+
+      # -- Methods allowing specific actions that occur during the application build process --
+      def update_main_properties!(app)
+        app.application_id = @application_id
+        app.customer_id = @customer_id unless @customer_id == :default
+        unless @processable
+          app.data_schema = 'https://osl-data-dictionary-schemas.engineering.dvla.gov.uk/driving-licence-application/applications/v1/counter-service-update-driving-licence-application.json'
+          app.product_type = @product_type
+        end
+      end
+
+      def update_applicant!(app)
+        if @applicant == false
+          app.data.applicant = nil
+        else
+          app.data.applicant = @applicant if @applicant
+          app.data.applicant[:phoneNumber] = Faker::PhoneNumber.phone_number if @phone_number
+          app.data.applicant[:languagePreference] = 'Welsh' if @welsh_language
+          app.data.applicant[:identityTokenData][:confidenceLevel] = @identity_confidence_level
+        end
+      end
+
+      def update_organ_donor!(app)
+        app.data.organ_donor = if @organ_donor
+                                 set_any_organs(any_organs_bool: @organ_donor)
+                               elsif @application_status == 'Rejected'
+                                 FM[:organ_donor_d90_response].build(attributes: { kidneys: true })
+                               elsif @application_status == 'Returned'
+                                 FM[:organ_donor_d90_response].build(attributes: { cornea: true })
+                               elsif @application_status == 'Unapproved'
+                                 FM[:organ_donor_d90_response].build(attributes: { heart: true })
+                               else
+                                 {}
+                               end
+      end
+
+      def process_application(app)
+        unless @processable
+
+          if @application_status == 'Cancelled' && @update_reason.nil?
+            @update_reason = 'Timed out'
+          end
+
+          DVLA::Application::ApplicationStatusProcessor.process_to(app.application_id, @application_status, update_reason: @update_reason)
+        end
+      end
+    end
+  end
+end

data/lib/dvla/application_helper/builders/V2/base_uodl_v2_application_builder.rb

@@ -0,0 +1,357 @@
+module DVLA
+  module Application
+    class BaseUODLV2ApplicationBuilder
+      def initialize
+        @applicant = nil
+        @application_id = SecureRandom::uuid
+        @application_status = 'Preparing'
+        @bfpo_address = false
+        @change_of_address = false
+        @customer_id = nil
+        @driver_id = nil
+        @driving_licence_actions = nil
+        @extend_application_deadline = false
+        @free_key_address = false
+        @identity_confidence_level = 'MEDIUM'
+        @organ_donor = nil
+        @payments = nil
+        @product_type = 'Driving Licence'
+        @processable = false
+        @phone_number = false
+        @transaction_outcome = nil
+        @unique_images = false
+        @update_reason = nil
+        @welsh_language = false
+      end
+
+      # Marks the application as processable, doing this will ensure that real services are used to create the
+      # application. For example, the channel api will process the tasks rather than stub data being provided.
+      # Whilst this results in a more complete application, this option is more expensive.
+      # Avoid excessive use in QA tests.
+      # @return [Builder]
+      def processable
+        @processable = true
+        self
+      end
+
+      # Marks the application as non-processable. This will result in the application being created using the test application endpoint.
+      # These applications cannot be actioned via the task service.
+      # This is typically the default option to be used.
+      # @return [Builder]
+      def non_processable
+        @processable = false
+        self
+      end
+
+      # APE uses very specific generated uuid to test with, the inspectable hooks filter the last 12 integers to return specific responses
+      # @param application_id [UUID]
+      def with_application_id(application_id)
+        @application_id = application_id
+        self
+      end
+
+      # The application will be made for the given customer
+      # @param customer_id [String] The customer ID to use
+      # @return [Builder]
+      def with_customer_id(customer_id)
+        @customer_id = customer_id
+        self
+      end
+
+      # The application will be made for the given driver
+      # @param driver_id [String] The driver ID to use
+      # @return [Builder]
+      def with_driver_id(driver_id)
+        @driver_id = driver_id
+        self
+      end
+
+      # The application will contain a specific application status.
+      # How this state is reached will depend on if the application has been marked as processable or not.
+      # If processable is used here, we will also contain all actions.
+      # @param application_status [String] The application status the application should be in.
+      # @param update_reason [String] The reason for the change in status.
+      # @return [Builder].
+      def with_application_status(application_status, update_reason = nil)
+        @application_status = application_status
+        @update_reason = update_reason
+        self
+      end
+
+      # The application will be updated with a call to action field which is used to extend an application
+      def extend_application_deadline
+        @extend_application_deadline = true
+        self
+      end
+
+      # The application will contain the provided payments.
+      # @param payments [PaymentObject] Payment status.
+      # @return [Builder]
+      def with_payments(payments)
+        @payments = payments
+        self
+      end
+
+      def with_driving_licence_actions(action)
+        @driving_licence_actions = action
+        self
+      end
+
+      # The application will contain the provided applicant data.
+      # @param applicant [ApplicantObject] Application data.
+      # @return [Builder]
+      def with_applicant(applicant)
+        @applicant = applicant
+        self
+      end
+
+      # The application will contain a bfpo address.
+      # @return [Builder]
+      def with_bfpo_address
+        @bfpo_address = true
+        self
+      end
+
+      # The application will contain a free key address.
+      # @return [Builder]
+      def with_free_key_address
+        @free_key_address = true
+        self
+      end
+
+      # The application will contain a change of address.
+      # @return [Builder]
+      def with_change_of_address
+        @change_of_address = true
+        self
+      end
+
+      # Sets the organ donor status of the application.
+      # By default, no organ donation is made
+      # Passing true will cause all_organs to be selected.
+      # Passing false will ensure no organs are selected.
+      # @param donor [boolean] Organ donor status.
+      # @return [Builder]
+      def is_organ_donor(donor)
+        @organ_donor = donor
+        self
+      end
+
+      def is_welsh_language
+        @welsh_language = true
+        self
+      end
+
+      # The application will contain a phone number.
+      # @return [Builder]
+      def has_phone_number
+        @phone_number = true
+        self
+      end
+
+      def with_low_confidence_level
+        @identity_confidence_level = 'LOW'
+        self
+      end
+
+      # Allows specific product type to be passed in
+      # Used during APE testing for inspectable hooks
+      # @param product [Enum] one of: [Vehicles,Driving Licence,Test]
+      # @return [Builder]
+      def with_product_type(product)
+        if !Settings.test.product_type.include?(product)
+          raise "Unknown Product_type: #{product}, must be one of: #{Settings.test.product_type}"
+        end
+        @product_type = product
+        self
+      end
+
+      # The application will contain unique imageIds
+      # Allows images to be interacted with during test, e.g. deleted
+      def unique_images
+        @unique_images = true
+        self
+      end
+
+      def with_transaction_outcome(outcome)
+        @transaction_outcome = outcome
+        self
+      end
+
+      def build
+        # Sense check to ensure AWS credentials are present.
+        DVLA::Application.check_aws_credentials
+
+        check_application_validity
+
+        factory = if @processable
+                    FM[:uodl_v2_processable_application]
+                  else
+                    non_processable_application_factory
+                  end
+
+        # pass in uodl_v2 FM factory to build data attribute
+        app = factory.build(attributes: { data: FM[:uodl_v2_application_data].build }) do |b|
+          @driver_id = default_application_driver_id if @driver_id.nil?
+          update_driver_id!(b)
+
+          update_main_properties!(b)
+
+          update_driving_licence_actions!(b, application_driving_licence_actions)
+
+          b.data.customer_context = application_customer_context
+          update_customer_context!(b)
+
+          update_applicant!(b)
+          update_organ_donor!(b)
+
+          update_payments!(b)
+
+          update_no_fee!(b) unless @no_fee_application.nil?
+
+          b.images = application_images
+
+          calculate_default_update_reason
+
+          set_application_specific_fields!(b)
+        end
+
+        process_application_tasks(app)
+        process_application(app)
+
+        extend_deadline(app) if @extend_application_deadline
+
+        DVLA::Application::ApplicationDomain.retrieve_application_by_app_id(application_id: app.application_id)
+      end
+
+      # -- Overridable methods used by sub-types --
+
+      def check_application_validity
+        # Allows a sub-type to optionally run checks on the flags of the application before building any resourcses
+      end
+
+      def non_processable_application_factory
+        raise 'The specific application type builder should override this method and return the factory specific to the application type'
+      end
+
+      def default_application_driver_id
+        raise 'The specific application type builder should override this method and return the driver id specific for the application type, this usually is hardcoded in channel-api-stub'
+      end
+
+      # Allows a sub-type to specify any driving licence action specific to that application
+      def application_driving_licence_actions
+        {}
+      end
+
+      def application_images
+        raise 'The specific application type builder should override this method and return the images needed for the specific application type'
+      end
+
+      def application_customer_context
+        raise 'The specific application type builder should override this method and return the customer context of the specific application type'
+      end
+
+      def set_application_specific_fields!(app)
+        # Allows a sub-type to populate or override specific fields of an application
+      end
+
+      def process_application_tasks(app)
+        # Allows a sub-type to advance any tasks specific of the application type
+      end
+
+    private
+      # -- Methods allowing specific actions that occur during the application build process --
+      def update_main_properties!(app)
+        app.application_id = @application_id
+        app.customer_id = @customer_id if @customer_id
+        unless @processable
+          app.data_schema = Settings.application.v2_schema
+          app.product_type = @product_type
+        end
+      end
+
+      def update_driver_id!(app)
+        if @processable && @driver_id
+          app.driver_id = @driver_id
+        elsif @driver_id
+          app.product_id = @driver_id
+          app.product_key = @driver_id
+        end
+      end
+
+      def update_driving_licence_actions!(app, application_actions)
+        new_address = if @change_of_address || @free_key_address
+                        { unstructuredAddress: FM[:application_unstructured_address].build }
+                      elsif @bfpo_address
+                        { bfpoAddress: FM[:bfpo_address].build }
+                      end
+        unless new_address.nil?
+          app.data.driving_licence_actions[:updateAddress] = { newAddress: new_address }
+        end
+
+        app.data.driving_licence_actions.merge!(application_actions)
+
+        unless @driving_licence_actions.nil?
+          app.data.driving_licence_actions.merge!(@driving_licence_actions)
+        end
+      end
+
+      def update_customer_context!(app)
+        if !@processable && !@transaction_outcome.nil?
+          app.data.customer_context[:transactionOutcome] = @transaction_outcome
+          app.data.customer_context[:customerIntent] = @transaction_outcome
+        end
+      end
+
+      def update_applicant!(app)
+        app.data.applicant = @applicant if @applicant
+        app.data.applicant[:phoneNumber] = Faker::PhoneNumber.phone_number if @phone_number
+        app.data.applicant[:languagePreference] = 'Welsh' if @welsh_language
+        app.data.applicant[:identityTokenData][:confidenceLevel] = @identity_confidence_level
+      end
+
+      def update_organ_donor!(app)
+        app.data.organ_donor = if @organ_donor
+                                 set_any_organs(any_organs_bool: @organ_donor)
+                               elsif @application_status == 'Rejected'
+                                 FM[:organ_donor_d90_response].build(attributes: { kidneys: true })
+                               elsif @application_status == 'Returned'
+                                 FM[:organ_donor_d90_response].build(attributes: { cornea: true })
+                               elsif @application_status == 'Unapproved'
+                                 FM[:organ_donor_d90_response].build(attributes: { heart: true })
+                               else
+                                 {}
+                               end
+      end
+
+      def update_payments!(app)
+        if !@processable && !@payments.nil?
+          app.payments = @payments
+        end
+      end
+
+      def update_no_fee!(app)
+        app.no_fee_application = true if @no_fee_application
+      end
+
+      def calculate_default_update_reason
+        if !@processable && !@application_status.nil? && @application_status == 'Cancelled'
+          @update_reason = @update_reason || 'Timed out'
+        end
+      end
+
+      def process_application(app)
+        if !@processable
+          DVLA::Application::ApplicationStatusProcessor.process_to(app.application_id, @application_status, update_reason: @update_reason)
+        end
+      end
+
+      # updates call to action date on domain
+      def extend_deadline(app)
+        extend_date = Time.now + 21.days
+        DVLA::Application.logger.info("Updating application call to action deadline date to: #{extend_date}".blue)
+        DVLA::Application::ApplicationDomain.update_call_to_action_deadline_date(application_id: app.application_id, call_to_action_deadline_date: extend_date.utc.iso8601)
+      end
+    end
+  end
+end