code climate spec fix (#22211)

* code climate spec fix

* up argument count

* created a parser helper for reusable methods

* reset codeclimate back to original and added issue parser

* modified methods to take in a hash instead of multiple params

* reduced create params down to 3 params

* added space inside

* swapped to safe navigator for intake check

* fixed spec

* fixed linting issue

* fixed failing spec

* fixed merge conflicts with code changes for helper

---------

Co-authored-by: TuckerRose <tuckerrose@tuckerroses-mbp.lan>
Co-authored-by: TuckerRose <tuckerrose@TuckerRoses-MacBook-Pro.local>
Co-authored-by: Nader Kutub <nader.kutub@va.gov>

app/controllers/api/events/v1/decision_review_created_controller.rb

@@ -25,7 +25,8 @@ def decision_review_created
 
     claim_id = drc_params[:claim_id]
     headers = request.headers
-    ::Events::DecisionReviewCreated.create!(consumer_event_id, claim_id, headers, drc_params)
+    consumer_and_claim_ids = { consumer_event_id: consumer_event_id, reference_id: claim_id }
+    ::Events::DecisionReviewCreated.create!(consumer_and_claim_ids, headers, drc_params)
     render json: { message: "DecisionReviewCreatedEvent successfully processed and backfilled" }, status: :created
   rescue Caseflow::Error::RedisLockFailed => error
     render json: { message: error.message }, status: :conflict

app/helpers/parser_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ParserHelper
+  # Checking for nonrating_issue_category is "Disposition" and processing such issues.
+  def process_nonrating_issue_category(payload_json)
+    payload_json[:request_issues].each do |issue|
+      next unless issue[:nonrating_issue_category] == "Disposition"
+
+      issue[:nonrating_issue_category] = "Unknown Issue Category"
+    end
+  end
+
+  # Generic/universal methods
+  # rubocop:disable Rails/TimeZone
+  def convert_milliseconds_to_datetime(milliseconds)
+    milliseconds.nil? ? nil : Time.at(milliseconds.to_i / 1000).to_datetime
+  end
+  # rubocop:enable Rails/TimeZone
+
+  # convert logical date int to date
+  def logical_date_converter(logical_date_int)
+    return nil if logical_date_int.nil? || logical_date_int.to_i.days == 0
+
+    base_date = Date.new(1970, 1, 1)
+    converted_date = base_date + logical_date_int.to_i.days
+    converted_date
+  end
+end

app/models/claim_review.rb

@@ -310,7 +310,7 @@ def cleared_nonrating_ep?
 
   def from_decision_review_created_event?
     # refer back to the associated Intake to see if both objects came from DRCE
-    intake ? intake.from_decision_review_created_event? : false
+    intake&.from_decision_review_created_event? || false
   end
 
   def sct_appeal?

app/services/decision_review_created_issue_parser.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+class DecisionReviewCreatedIssueParser
+  include ParserHelper
+  attr_reader :issue
+
+  def initialize(issue)
+    @issue = issue
+  end
+
+  def ri_benefit_type
+    @issue.dig(:benefit_type)
+  end
+
+  def ri_contested_issue_description
+    @issue.dig(:contested_issue_description)
+  end
+
+  def ri_contention_reference_id
+    @issue.dig(:contention_reference_id)
+  end
+
+  def ri_contested_rating_decision_reference_id
+    @issue.dig(:contested_rating_decision_reference_id)
+  end
+
+  def ri_contested_rating_issue_profile_date
+    @issue.dig(:contested_rating_issue_profile_date)
+  end
+
+  def ri_contested_rating_issue_reference_id
+    @issue.dig(:contested_rating_issue_reference_id)
+  end
+
+  def ri_contested_decision_issue_id
+    @issue.dig(:contested_decision_issue_id)
+  end
+
+  def ri_decision_date
+    decision_date_int = @issue.dig(:decision_date)
+    logical_date_converter(decision_date_int)
+  end
+
+  def ri_ineligible_due_to_id
+    @issue.dig(:ineligible_due_to_id)
+  end
+
+  def ri_ineligible_reason
+    @issue.dig(:ineligible_reason)
+  end
+
+  def ri_is_unidentified
+    @issue.dig(:is_unidentified)
+  end
+
+  def ri_unidentified_issue_text
+    @issue.dig(:unidentified_issue_text)
+  end
+
+  def ri_nonrating_issue_category
+    @issue.dig(:nonrating_issue_category)
+  end
+
+  def ri_nonrating_issue_description
+    @issue.dig(:nonrating_issue_description)
+  end
+
+  def ri_untimely_exemption
+    @issue.dig(:untimely_exemption)
+  end
+
+  def ri_untimely_exemption_notes
+    @issue.dig(:untimely_exemption_notes)
+  end
+
+  def ri_vacols_id
+    @issue.dig(:vacols_id)
+  end
+
+  def ri_vacols_sequence_id
+    @issue.dig(:vacols_sequence_id)
+  end
+
+  def ri_closed_at
+    @issue.dig(:closed_at)
+  end
+
+  def ri_closed_status
+    @issue.dig(:closed_status)
+  end
+
+  def ri_contested_rating_issue_diagnostic_code
+    @issue.dig(:contested_rating_issue_diagnostic_code)
+  end
+
+  def ri_ramp_claim_id
+    @issue.dig(:ramp_claim_id)
+  end
+
+  def ri_rating_issue_associated_at
+    ri_rating_issue_associated_at_in_ms = @issue.dig(:rating_issue_associated_at)
+    convert_milliseconds_to_datetime(ri_rating_issue_associated_at_in_ms)
+  end
+
+  def ri_nonrating_issue_bgs_id
+    @issue.dig(:nonrating_issue_bgs_id)
+  end
+
+  def ri_nonrating_issue_bgs_source
+    @issue.dig(:nonrating_issue_bgs_source)
+  end
+end

app/services/events/decision_review_created.rb

@@ -13,7 +13,9 @@ class Events::DecisionReviewCreated
 
   class << self
     # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Lint/UselessAssignment
-    def create!(consumer_event_id, reference_id, headers, payload)
+    def create!(params, headers, payload)
+      consumer_event_id = params[:consumer_event_id]
+      reference_id = params[:reference_id]
       return if Event.exists_and_is_completed?(consumer_event_id)
 
       redis = Redis.new(url: Rails.application.secrets.redis_url_cache)
@@ -48,8 +50,10 @@ def create!(consumer_event_id, reference_id, headers, payload)
                                                  decision_review: decision_review)
 
           # NOTE: event, user, and veteran need to be before this call.
-          Events::DecisionReviewCreated::CreateIntake.process!(event: event, user: user, veteran: vet, parser: parser,
-                                                               decision_review: decision_review)
+          Events::DecisionReviewCreated::CreateIntake.process!(
+            { event: event, user: user, veteran: vet,
+              parser: parser, decision_review: decision_review }
+          )
 
           # NOTE: end_product_establishment & station_id is coming from the payload
           # claim_review can either be a higher_level_revew or supplemental_claim
@@ -58,8 +62,10 @@ def create!(consumer_event_id, reference_id, headers, payload)
                                                                               user: user)
 
           # NOTE: 'epe' arg is the obj created as a result of the CreateEpEstablishment service class
-          Events::DecisionReviewCreated::CreateRequestIssues.process!(event: event, parser: parser, epe: epe,
-                                                                      decision_review: decision_review)
+          Events::DecisionReviewCreated::CreateRequestIssues.process!(
+            { event: event, parser: parser, epe: epe,
+              decision_review: decision_review }
+          )
 
           # NOTE: decision_review arg can either be a HLR or SC object. process! will only run if
           # decision_review.legacy_opt_in_approved is true

app/services/events/decision_review_created/create_intake.rb

@@ -7,7 +7,12 @@ class Events::DecisionReviewCreated::CreateIntake
   # that was created in the DecisionReviewCreated Service.
 
   class << self
-    def process!(event:, user:, veteran:, parser:, decision_review:)
+    def process!(params)
+      event = params[:event]
+      user = params[:user]
+      veteran = params[:veteran]
+      parser = params[:parser]
+      decision_review = params[:decision_review]
       # create Intake
       intake = Intake.create!(veteran_file_number: veteran.file_number,
                               user: user,

app/services/events/decision_review_created/create_request_issues.rb

@@ -4,8 +4,8 @@
 # when an Event is received using the data sent from VBMS
 class Events::DecisionReviewCreated::CreateRequestIssues
   class << self
-    def process!(event:, parser:, epe:, decision_review:)
-      create_request_issue_backfill(event, parser, epe, decision_review)
+    def process!(params)
+      create_request_issue_backfill(params)
     rescue StandardError => error
       raise Caseflow::Error::DecisionReviewCreatedRequestIssuesError, error.message
     end
@@ -14,38 +14,43 @@ def process!(event:, parser:, epe:, decision_review:)
 
     # iterate through the array of issues and create backfill object from each one
     # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-    def create_request_issue_backfill(event, parser, epe, decision_review)
+    def create_request_issue_backfill(params)
+      event = params[:event]
+      epe = params[:epe]
+      parser = params[:parser]
+      decision_review = params[:decision_review]
       request_issues = parser.request_issues
       newly_created_issues = []
 
       request_issues&.each do |issue|
         # create backfill RI object using extracted values
+        parser_issues = DecisionReviewCreatedIssueParser.new(issue)
         ri = RequestIssue.create!(
-          benefit_type: parser.ri_benefit_type(issue),
-          contested_issue_description: parser.ri_contested_issue_description(issue),
-          contention_reference_id: parser.ri_contention_reference_id(issue),
-          contested_rating_decision_reference_id: parser.ri_contested_rating_decision_reference_id(issue),
-          contested_rating_issue_profile_date: parser.ri_contested_rating_issue_profile_date(issue),
-          contested_rating_issue_reference_id: parser.ri_contested_rating_issue_reference_id(issue),
-          contested_decision_issue_id: parser.ri_contested_decision_issue_id(issue),
-          decision_date: parser.ri_decision_date(issue),
-          ineligible_due_to_id: parser.ri_ineligible_due_to_id(issue),
-          ineligible_reason: parser.ri_ineligible_reason(issue),
-          is_unidentified: parser.ri_is_unidentified(issue),
-          unidentified_issue_text: parser.ri_unidentified_issue_text(issue),
-          nonrating_issue_category: parser.ri_nonrating_issue_category(issue),
-          nonrating_issue_description: parser.ri_nonrating_issue_description(issue),
-          untimely_exemption: parser.ri_untimely_exemption(issue),
-          untimely_exemption_notes: parser.ri_untimely_exemption_notes(issue),
-          vacols_id: parser.ri_vacols_id(issue),
-          vacols_sequence_id: parser.ri_vacols_sequence_id(issue),
-          closed_at: parser.ri_closed_at(issue),
-          closed_status: parser.ri_closed_status(issue),
-          contested_rating_issue_diagnostic_code: parser.ri_contested_rating_issue_diagnostic_code(issue),
-          ramp_claim_id: parser.ri_ramp_claim_id(issue),
-          rating_issue_associated_at: parser.ri_rating_issue_associated_at(issue),
-          nonrating_issue_bgs_id: parser.ri_nonrating_issue_bgs_id(issue),
-          nonrating_issue_bgs_source: parser.ri_nonrating_issue_bgs_source(issue),
+          benefit_type: parser_issues.ri_benefit_type,
+          contested_issue_description: parser_issues.ri_contested_issue_description,
+          contention_reference_id: parser_issues.ri_contention_reference_id,
+          contested_rating_decision_reference_id: parser_issues.ri_contested_rating_decision_reference_id,
+          contested_rating_issue_profile_date: parser_issues.ri_contested_rating_issue_profile_date,
+          contested_rating_issue_reference_id: parser_issues.ri_contested_rating_issue_reference_id,
+          contested_decision_issue_id: parser_issues.ri_contested_decision_issue_id,
+          decision_date: parser_issues.ri_decision_date,
+          ineligible_due_to_id: parser_issues.ri_ineligible_due_to_id,
+          ineligible_reason: parser_issues.ri_ineligible_reason,
+          is_unidentified: parser_issues.ri_is_unidentified,
+          unidentified_issue_text: parser_issues.ri_unidentified_issue_text,
+          nonrating_issue_category: parser_issues.ri_nonrating_issue_category,
+          nonrating_issue_description: parser_issues.ri_nonrating_issue_description,
+          untimely_exemption: parser_issues.ri_untimely_exemption,
+          untimely_exemption_notes: parser_issues.ri_untimely_exemption_notes,
+          vacols_id: parser_issues.ri_vacols_id,
+          vacols_sequence_id: parser_issues.ri_vacols_sequence_id,
+          closed_at: parser_issues.ri_closed_at,
+          closed_status: parser_issues.ri_closed_status,
+          contested_rating_issue_diagnostic_code: parser_issues.ri_contested_rating_issue_diagnostic_code,
+          ramp_claim_id: parser_issues.ri_ramp_claim_id,
+          rating_issue_associated_at: parser_issues.ri_rating_issue_associated_at,
+          nonrating_issue_bgs_id: parser_issues.ri_nonrating_issue_bgs_id,
+          nonrating_issue_bgs_source: parser_issues.ri_nonrating_issue_bgs_source,
           end_product_establishment_id: epe.id,
           veteran_participant_id: parser.veteran_participant_id,
           decision_review: decision_review