Feature/appeals 60433 DRAFT PR

.fasterer.yml

@@ -14,3 +14,7 @@ exclude_paths:
   - "db/seeds.rb"
   - "vendor/**/*.rb"
   - "app/mappers/zip_code_to_lat_lng_mapper.rb"
+
+  # Flagged for using sort instead of using sort_by - however due to complexity of sorting
+  # conditionally makes more sense to use sort
+  - "app/services/auto_assignable_user_finder.rb"

Gemfile

@@ -129,8 +129,8 @@ group :test, :development, :demo, :make_docs do
   gem "rails-erd"
   gem "rb-readline"
   gem "rspec"
-  gem "rspec-rails"
   # For CircleCI test metadata analysis
+  gem "rspec-rails"
   gem "rspec_junit_formatter"
   gem "rswag-specs"
   gem "rubocop", "= 0.83", require: false

Makefile.example

@@ -113,6 +113,10 @@ realclean: clean ## TODO
 	rm -rf client/node_modules
 	rm -f client/package-lock.json
 
+precompile: ## Precompiles assets for testing
+	bundle exec rake assets:precompile
+
+
 facols-bash:  ## Connect to the docker FACOLS instance
 	docker exec --tty -i VACOLS_DB bash
 
@@ -288,6 +292,8 @@ client-build-all client-all: client-test client-demo ## Builds webpack for both
 one-test:  ## run the rspec test passed in
 	bundle exec rspec $(RUN_ARGS)
 
+clean-test: clean precompile one-test ## Cleans and precompiles assets for testing, then runs spec test passed in
+
 one-test-headless: # run the rspec test headless.
 	CI=1 bundle exec rspec $(RUN_ARGS) --format progress
 

app/controllers/appeals_controller.rb

@@ -42,7 +42,7 @@ def show_case_list
       format.html { render template: "queue/index" }
       format.json do
         result = CaseSearchResultsForCaseflowVeteranId.new(
-          caseflow_veteran_ids: params[:veteran_ids]&.split(","), user: current_user
+          caseflow_veteran_ids: appeals_controller_params[:veteran_ids]&.split(","), user: current_user
         ).search_call
 
         render_search_results_as_json(result)
@@ -52,7 +52,7 @@ def show_case_list
 
   # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
   def fetch_notification_list
-    appeals_id = params[:appeals_id]
+    appeals_id = appeals_controller_params[:appeals_id]
     respond_to do |format|
       format.json do
         results = find_notifications_by_appeals_id(appeals_id)
@@ -138,7 +138,7 @@ def show
       format.html { render template: "queue/index" }
       format.json do
         if appeal.accessible?
-          id = params[:appeal_id]
+          id = url_appeal_uuid
           MetricsService.record("Get appeal information for ID #{id}",
                                 service: :queue,
                                 name: "AppealsController.show") do
@@ -162,16 +162,15 @@ def edit
   helper_method :appeal, :url_appeal_uuid
 
   def appeal
-    @appeal ||= Appeal.find_appeal_by_uuid_or_find_or_create_legacy_appeal_by_vacols_id(params[:appeal_id])
+    @appeal ||= Appeal.find_appeal_by_uuid_or_find_or_create_legacy_appeal_by_vacols_id(url_appeal_uuid)
   end
 
   def url_appeal_uuid
-    params[:appeal_id]
+    params.permit(:appeal_id)[:appeal_id]
   end
 
   def update
     if appeal.is_a?(LegacyAppeal) && feature_enabled?(:legacy_mst_pact_identification)
-
       legacy_mst_pact_updates
     elsif request_issues_update.perform!
       set_flash_success_message
@@ -187,8 +186,22 @@ def update
     end
   end
 
+  def active_evidence_submissions
+    appeal = Appeal.find(url_appeal_uuid)
+    render json: appeal.evidence_submission_task
+  end
+
   private
 
+  def appeals_controller_params
+    params.permit(
+      :appeal_id,
+      :any,
+      :appeals_id,
+      :veteran_ids
+    )
+  end
+
   def create_subtasks!
     # if cc appeal, create SendInitialNotificationLetterTask
     if appeal.contested_claim? && feature_enabled?(:cc_appeal_workflow)
@@ -448,7 +461,7 @@ def create_legacy_issue_update_task(before_issue, current_issue)
     # close out any tasks that might be open
     open_issue_task = Task.where(
       assigned_to: SpecialIssueEditTeam.singleton
-    ).where(status: "assigned").where(appeal: appeal)
+    ).where(status: Constants.TASK_STATUSES.assigned).where(appeal: appeal)
     open_issue_task[0].delete unless open_issue_task.empty?
 
     task = IssuesUpdateTask.create!(

app/controllers/application_controller.rb

@@ -9,7 +9,7 @@ class ApplicationController < ApplicationBaseController
   before_action :set_raven_user
   before_action :verify_authentication
   before_action :set_paper_trail_whodunnit
-  before_action :deny_vso_access, except: [:unauthorized, :feedback]
+  before_action :deny_vso_access, except: [:unauthorized, :feedback, :under_construction]
   before_action :set_no_cache_headers
 
   rescue_from StandardError do |e|
@@ -196,7 +196,12 @@ def defult_menu_items
   def manage_teams_menu_items
     current_user.administered_teams.map do |team|
       {
-        title: "#{team.name} team management",
+        title:
+          if team.type == InboundOpsTeam.singleton.type
+            "#{team.name} management"
+          else
+            "#{team.name} team management"
+          end,
         link: team.user_admin_path
       }
     end

app/controllers/concerns/correspondence_controller_concern.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+# :reek:DataClump
+
+# Contains most of the logic inside of CorrespondenceController
+module CorrespondenceControllerConcern
+  private
+
+  # :reek:FeatureEnvy
+  def process_tasks_if_applicable(mail_team_user, task_ids, tab)
+    # candidate for refactor using PATCH request
+    return unless mail_team_user && task_ids.present?
+
+    # Instantiate AutoAssignableUserFinder with current_user
+    permission_checker = AutoAssignableUserFinder.new(mail_team_user)
+
+    # iterate through each task and check if the user can work the correspondence
+    task_ids.each do |id|
+      correspondence = Task.find(id)&.correspondence
+      check_result = permission_checker.can_user_work_this_correspondence?(
+        user: mail_team_user,
+        correspondence: correspondence
+      )
+
+      # assign the task if the user can work the correspondence
+      update_task(mail_team_user, id) if check_result
+    end
+
+    # use permission_checker.unassignable_reasons errors to generate the banner
+    set_banner_params(
+      mail_team_user,
+      permission_checker.unassignable_reasons,
+      task_ids.count,
+      tab
+    )
+  end
+
+  def update_task(mail_team_user, task_id)
+    task = Task.find_by(id: task_id)
+    task.update(
+      assigned_to_id: mail_team_user.id,
+      assigned_to_type: "User",
+      status: Constants.TASK_STATUSES.assigned
+    )
+  end
+
+  # :reek:LongParameterList
+  def set_banner_params(user, errors, task_count, tab)
+    template = message_template(user, errors, task_count, tab)
+    @response_type = errors.empty? ? "success" : "warning"
+    @response_header = template[:header]
+    @response_message = template[:message]
+  end
+
+  # :reek:ControlParameter and :reek:LongParameterList
+  def message_template(user, errors, task_count, tab)
+    case tab
+    when "correspondence_unassigned"
+      if task_count == 1
+        single_assignment_banner_text(user, errors, task_count)
+      else
+        multiple_assignment_banner_text(user, errors, task_count)
+      end
+    when "correspondence_team_assigned"
+      if task_count == 1
+        single_assignment_banner_text(user, errors, task_count, action_prefix: "re")
+      else
+        multiple_assignment_banner_text(user, errors, task_count, action_prefix: "re")
+      end
+    end
+  end
+
+  # :reek:FeatureEnvy
+  def single_assignment_banner_text(*args, action_prefix: "")
+    success_header_unassigned = "You have successfully #{action_prefix}"\
+      "assigned #{args[2]} Correspondence to #{args[0].css_id}."
+    failure_header_unassigned = "Correspondence was not #{action_prefix}assigned to #{args[0].css_id}"
+    success_message = "Please go to your individual queue to see any self-assigned correspondence."
+
+    failure_message = build_single_error_message(action_prefix, error_reason(args[1][0]))
+
+    {
+      header: args[1].empty? ? success_header_unassigned : failure_header_unassigned,
+      message: args[1].empty? ? success_message : failure_message
+    }
+  end
+
+  # :reek:FeatureEnvy
+  def multiple_assignment_banner_text(*args, action_prefix: "")
+    success_header = "You have successfully #{action_prefix}"\
+    "assigned #{args[2]} Correspondences to #{args[0].css_id}."
+    success_message = "Please go to your individual queue to see any self-assigned correspondences."
+    failure_header = "Not all correspondence were #{action_prefix}assigned to #{args[0].css_id}"
+
+    failure_message = build_multi_error_message(args[1], action_prefix)
+
+    # return JSON message
+    {
+      header: args[1].blank? ? success_header : failure_header,
+      message: args[1].blank? ? success_message : failure_message.join(" \n")
+    }
+  end
+
+  # :reek:FeatureEnvy
+  def build_multi_error_message(errors, action_prefix)
+    failure_message = []
+
+    # Get error counts
+    error_counts = {
+      Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.NOD_ERROR => errors.count(
+        Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.NOD_ERROR
+      ),
+      Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.SENSITIVITY_ERROR => errors.count(
+        Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.SENSITIVITY_ERROR
+      ),
+      Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.CAPACITY_ERROR => errors.count(
+        Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.CAPACITY_ERROR
+      )
+    }
+
+    error_counts.each do |error, count|
+      if count.positive?
+        multiple_errors = error_counts.values.count(&:positive?) > 1
+        failure_message << build_error_message(count, action_prefix, error_reason(error), multiple_errors)
+      end
+    end
+
+    failure_message
+  end
+
+  def error_reason(error)
+    return "" unless error.is_a?(String)
+
+    case error
+    when Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.NOD_ERROR then "of NOD permissions settings"
+    when Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.SENSITIVITY_ERROR then "of sensitivity level mismatch"
+    when Constants.CORRESPONDENCE_AUTO_ASSIGN_ERROR.CAPACITY_ERROR then "maximum capacity has been reached for user's
+                                                                        queue"
+    end
+  end
+
+  def build_single_error_message(action_prefix, reason)
+    # Build error message for single correspondence based on error types
+    "Case was not #{action_prefix}assigned to user because #{reason}."
+  end
+
+  def build_error_message(*args)
+    # Build error message for multiple correspondence based on error types
+    message = "#{args[0]} cases were not #{args[1]}assigned to user"
+    message = "• #{message}" if args[3].present?
+    message += " because #{args[2]}." unless args[0].zero?
+    message
+  end
+
+  def set_flash_intake_success_message
+    # intake error message is handled in client/app/queue/correspondence/intake/components/CorrespondenceIntake.jsx
+    vet = veteran_by_correspondence
+    flash[:correspondence_intake_success] = [
+      "You have successfully submitted a correspondence record for #{vet.name}(#{vet.file_number})",
+      "The mail package has been uploaded to the Veteran's eFolder as well."
+    ]
+  end
+
+  # :reek:ControlParameter
+  def intake_cancel_message(action_type)
+    vet = veteran_by_correspondence
+    if action_type == "cancel_intake"
+      @response_header = "You have successfully cancelled the intake form"
+      @response_message = "#{vet.name}'s correspondence (ID: #{correspondence.id}) "\
+       "has been returned to the supervisor's queue for assignment."
+    else
+      @response_header = "You have successfully saved the intake form"
+      @response_message = "You can continue from step three of the intake form for #{vet.name}'s "\
+      "correspondence (ID: #{correspondence.id}) at a later date."
+    end
+    @response_type = "success"
+  end
+
+  def general_information
+    vet = veteran_by_correspondence
+    {
+      notes: correspondence.notes,
+      file_number: vet.file_number,
+      veteran_name: vet.name,
+      correspondence_type_id: correspondence.correspondence_type_id,
+      correspondence_tasks: correspondence.tasks.map do |task|
+        WorkQueue::CorrespondenceTaskSerializer.new(task).serializable_hash[:data][:attributes]
+      end
+    }
+  end
+
+  def correspondence
+    @correspondence = Correspondence.find_by(uuid: params[:correspondence_uuid])
+  end
+
+  def veteran_by_correspondence
+    return nil if correspondence&.veteran_id.blank?
+
+    @veteran_by_correspondence ||= Veteran.find_by(id: correspondence.veteran_id)
+  end
+
+  def veterans_with_correspondences
+    veterans = Veteran.includes(:correspondences).where(correspondences: { id: Correspondence.select(:id) })
+    veterans.map { |veteran| vet_info_serializer(veteran, veteran.correspondences.last) }
+  end
+
+  def auto_texts
+    @auto_texts ||= AutoText.all.pluck(:name)
+  end
+
+  def vet_info_serializer(veteran, correspondence)
+    {
+      firstName: veteran.first_name,
+      lastName: veteran.last_name,
+      fileNumber: veteran.file_number,
+      correspondenceUuid: correspondence.uuid,
+      packageDocumentType: correspondence.correspondence_type_id
+    }
+  end
+
+  def correspondence_intake_processor
+    @correspondence_intake_processor ||= CorrespondenceIntakeProcessor.new
+  end
+
+  def correspondence_documents_efolder_uploader
+    @correspondence_documents_efolder_uploader ||= CorrespondenceDocumentsEfolderUploader.new
+  end
+
+  def upload_documents_to_claim_evidence
+    rpt = ReviewPackageTask.find_by(appeal_id: correspondence.id, type: ReviewPackageTask.name)
+    correspondence_documents_efolder_uploader.upload_documents_to_claim_evidence(correspondence, current_user, rpt)
+  end
+end
+# rubocop:enable Metrics/ModuleLength

app/controllers/concerns/explain_timeline_concern.rb

@@ -9,6 +9,7 @@ module ExplainTimelineConcern
   # :reek:FeatureEnvy
   def timeline_data
     return "(LegacyAppeals are not yet supported)".to_json if legacy_appeal?
+    return "(Correspondences are not yet supported)".to_json if correspondence?
 
     (tasks_timeline_data + intake_timeline_data + hearings_timeline_data).map(&:as_json)
   end