jefftmarks/APPEALS-24999

app/controllers/appeals_controller.rb

@@ -92,6 +92,18 @@ def document_count
     handle_non_critical_error("document_count", error)
   end
 
+  # series_id is lowercase, no curly braces because it comes from url
+  def document_lookup
+    series_id = "{#{params[:series_id]}}".upcase
+    document = Document.find_by(series_id: series_id, file_number: appeal.veteran_file_number)
+
+    unless document
+      document = VBMSService.fetch_document_series_for(appeal).map(&:series_id).include?(series_id)
+    end
+
+    render json: { document_presence: document.present? }
+  end
+
   def power_of_attorney
     render json: power_of_attorney_data
   end
@@ -395,4 +407,3 @@ def get_appeal_object(appeals_id)
     end
   end
 end
-

app/controllers/tasks_controller.rb

@@ -30,6 +30,7 @@ class TasksController < ApplicationController
     EducationDocumentSearchTask: EducationDocumentSearchTask,
     FoiaTask: FoiaTask,
     HearingAdminActionTask: HearingAdminActionTask,
+    HearingPostponementRequestMailTask: HearingPostponementRequestMailTask,
     InformalHearingPresentationTask: InformalHearingPresentationTask,
     JudgeAddressMotionToVacateTask: JudgeAddressMotionToVacateTask,
     JudgeAssignTask: JudgeAssignTask,

app/models/tasks/hearing_mail_tasks/hearing_postponement_request_mail_task.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+##
+# Task to process a hearing postponement request received via the mail
+#
+# When this task is created:
+#   - It's parent task is set as the RootTask of the associated appeal
+#   - The task is assigned to the MailTeam to track where the request originated
+#   - A child task of the same name is created and assigned to the HearingAdmin organization
+##
+class HearingPostponementRequestMailTask < HearingRequestMailTask
+  include RunAsyncable
+
+  class << self
+    def label
+      COPY::HEARING_POSTPONEMENT_REQUEST_MAIL_TASK_LABEL
+    end
+
+    def allow_creation?(*)
+      true
+    end
+  end
+
+  TASK_ACTIONS = [
+    Constants.TASK_ACTIONS.CHANGE_TASK_TYPE.to_h,
+    Constants.TASK_ACTIONS.COMPLETE_AND_POSTPONE.to_h,
+    Constants.TASK_ACTIONS.ASSIGN_TO_TEAM.to_h,
+    Constants.TASK_ACTIONS.ASSIGN_TO_PERSON.to_h,
+    Constants.TASK_ACTIONS.CANCEL_TASK.to_h
+  ].freeze
+
+  def available_actions(user)
+    return [] unless user.in_hearing_admin_team?
+
+    if active_schedule_hearing_task || hearing_scheduled_and_awaiting_disposition?
+      TASK_ACTIONS
+    else
+      [
+        Constants.TASK_ACTIONS.CHANGE_TASK_TYPE.to_h,
+        Constants.TASK_ACTIONS.CANCEL_TASK.to_h
+      ]
+    end
+  end
+
+  def update_from_params(params, user)
+    payload_values = params.delete(:business_payloads)&.dig(:values)
+
+    # If request to postpone hearing is granted
+    if payload_values[:disposition].present?
+      created_tasks = update_hearing_and_create_tasks(payload_values[:after_disposition_update])
+    end
+    update_self_and_parent_mail_task(user: user, params: params, payload_values: payload_values)
+
+    [self] + (created_tasks || [])
+  end
+
+  # Only show HPR mail task assigned to "HearingAdmin" on the Case Timeline
+  def hide_from_case_timeline
+    assigned_to.type == "MailTeam"
+  end
+
+  def recent_hearing
+    @recent_hearing ||= open_assign_hearing_disposition_task&.hearing
+  end
+
+  def hearing_task
+    @hearing_task ||= recent_hearing&.hearing_task || active_schedule_hearing_task&.parent
+  end
+
+  private
+
+  def active_schedule_hearing_task
+    appeal.tasks.where(type: ScheduleHearingTask.name).active.first
+  end
+
+  # ChangeHearingDispositionTask is a subclass of AssignHearingDispositionTask
+  ASSIGN_HEARING_DISPOSITION_TASKS = [
+    AssignHearingDispositionTask.name,
+    ChangeHearingDispositionTask.name
+  ].freeze
+
+  def open_assign_hearing_disposition_task
+    @open_assign_hearing_disposition_task ||= appeal.tasks.where(type: ASSIGN_HEARING_DISPOSITION_TASKS).open.first
+  end
+
+  def hearing_scheduled_and_awaiting_disposition?
+    return false if recent_hearing.nil?
+
+    # Ensure associated hearing is not scheduled for the past
+    !recent_hearing.scheduled_for_past?
+  end
+
+  def update_hearing_and_create_tasks(after_disposition_update)
+    multi_transaction do
+      unless recent_hearing.nil?
+        update_hearing(disposition: Constants.HEARING_DISPOSITION_TYPES.postponed)
+        clean_up_virtual_hearing
+      end
+      reschedule_or_schedule_later(after_disposition_update)
+    end
+  end
+
+  def update_hearing(hearing_hash)
+    if recent_hearing.is_a?(LegacyHearing)
+      recent_hearing.update_caseflow_and_vacols(hearing_hash)
+    else
+      recent_hearing.update(hearing_hash)
+    end
+  end
+
+  def clean_up_virtual_hearing
+    if recent_hearing.virtual?
+      perform_later_or_now(VirtualHearings::DeleteConferencesJob)
+    end
+  end
+
+  def reschedule_or_schedule_later(after_disposition_update)
+    case after_disposition_update[:action]
+    when "reschedule"
+      new_hearing_attrs = after_disposition_update[:new_hearing_attrs]
+      reschedule(
+        hearing_day_id: new_hearing_attrs[:hearing_day_id],
+        scheduled_time_string: new_hearing_attrs[:scheduled_time_string],
+        hearing_location: new_hearing_attrs[:hearing_location],
+        virtual_hearing_attributes: new_hearing_attrs[:virtual_hearing_attributes],
+        notes: new_hearing_attrs[:notes],
+        email_recipients_attributes: new_hearing_attrs[:email_recipients]
+      )
+    when "schedule_later"
+      schedule_later
+    else
+      fail ArgumentError, "unknown disposition action"
+    end
+  end
+
+  # rubocop:disable Metrics/ParameterLists
+  def reschedule(
+    hearing_day_id:,
+    scheduled_time_string:,
+    hearing_location: nil,
+    virtual_hearing_attributes: nil,
+    notes: nil,
+    email_recipients_attributes: nil
+  )
+    multi_transaction do
+      new_hearing_task = hearing_task.cancel_and_recreate
+
+      new_hearing = HearingRepository.slot_new_hearing(hearing_day_id: hearing_day_id,
+                                                       appeal: appeal,
+                                                       hearing_location_attrs: hearing_location&.to_hash,
+                                                       scheduled_time_string: scheduled_time_string,
+                                                       notes: notes)
+      if virtual_hearing_attributes.present?
+        @alerts = VirtualHearings::ConvertToVirtualHearingService
+          .convert_hearing_to_virtual(new_hearing, virtual_hearing_attributes)
+      elsif email_recipients_attributes.present?
+        create_or_update_email_recipients(new_hearing, email_recipients_attributes)
+      end
+
+      disposition_task = AssignHearingDispositionTask
+        .create_assign_hearing_disposition_task!(appeal, new_hearing_task, new_hearing)
+
+      [new_hearing_task, disposition_task]
+    end
+  end
+  # rubocop:enable Metrics/ParameterLists
+
+  def schedule_later
+    new_hearing_task = hearing_task.cancel_and_recreate
+    schedule_task = ScheduleHearingTask.create!(appeal: appeal, parent: new_hearing_task)
+
+    [new_hearing_task, schedule_task].compact
+  end
+
+  def update_self_and_parent_mail_task(user:, params:, payload_values:)
+    updated_instructions = format_instructions_on_completion(
+      admin_context: params[:instructions],
+      granted: payload_values[:disposition].present?,
+      date_of_ruling: payload_values[:date_of_ruling]
+    )
+
+    update!(
+      completed_by: user,
+      status: Constants.TASK_STATUSES.completed,
+      instructions: updated_instructions
+    )
+    update_parent_status
+  end
+
+  def format_instructions_on_completion(admin_context:, granted:, date_of_ruling:)
+    formatted_date = date_of_ruling.to_date.strftime("%m/%d/%Y")
+
+    markdown_to_append = <<~EOS
+
+      ***
+
+      ###### Marked as complete:
+
+      **DECISION**
+      Motion to postpone #{granted ? 'GRANTED' : 'DENIED'}
+
+      **DATE OF RULING**
+      #{formatted_date}
+
+      **DETAILS**
+      #{admin_context}
+    EOS
+
+    [instructions[0] + markdown_to_append]
+  end
+end

app/models/tasks/hearing_mail_tasks/hearing_request_mail_task.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+##
+# Task to serve as interface with shared methods for the following hearings mail tasks:
+#   - HearingPostponementRequestMailTask
+#   - HearingWithdrawalRequestMailTask
+# HearingRequestMailTask is itself not an assignable task type
+##
+class HearingRequestMailTask < MailTask
+  validates :parent, presence: true, on: :create
+
+  before_validation :verify_request_type_designated
+
+  class << self
+    def allow_creation?(*)
+      false
+    end
+
+    # All descendant postponement/withdrawal tasks will initially be assigned to the Hearing Admin org
+    def default_assignee(_task)
+      HearingAdmin.singleton
+    end
+  end
+
+  def available_actions(_user)
+    []
+  end
+
+  def update_from_params(params, current_user)
+    super(params, current_user)
+  end
+
+  private
+
+  # Ensure create is called on a descendant mail task and not directly on the HearingRequestMailTask class
+  def verify_request_type_designated
+    if self.class == HearingRequestMailTask
+      fail Caseflow::Error::InvalidTaskTypeOnTaskCreate, task_type: type
+    end
+  end
+end

app/models/tasks/mail_task.rb

@@ -10,6 +10,8 @@
 #   - withdrawing an appeal
 #   - switching dockets
 #   - add post-decision motions
+#   - postponing a hearing
+#   - withdrawing a hearing
 # Adding a mail task to an appeal is done by mail team members and will create a task assigned to the mail team. It
 # will also automatically create a child task assigned to the team the task should be routed to.
 
@@ -18,15 +20,21 @@ class MailTask < Task
   def verify_org_task_unique; end
   prepend PrivacyActPending
 
+  # This constant is more efficient than iterating through all mail tasks
+  # and filtering out almost all of them since only HPR and HWR are approved for now
+  LEGACY_MAIL_TASKS = [
+    { label: "Hearing postponement request", value: "HearingPostponementRequestMailTask" }
+  ].freeze
+
   class << self
     def blocking?
       # Some open mail tasks should block distribution of an appeal to judges.
-      # Define this method in subclasses for blocking task types.
+      # Define this method in descendants for blocking task types.
       false
     end
 
-    def subclass_routing_options(user: nil, appeal: nil)
-      filtered = MailTask.subclasses.select { |sc| sc.allow_creation?(user: user, appeal: appeal) }
+    def descendant_routing_options(user: nil, appeal: nil)
+      filtered = MailTask.descendants.select { |sc| sc.allow_creation?(user: user, appeal: appeal) }
       sorted = filtered.sort_by(&:label).map { |subclass| { value: subclass.name, label: subclass.label } }
       sorted
     end

app/models/tasks/root_task.rb

@@ -76,8 +76,9 @@ def hide_from_task_snapshot
     true
   end
 
+  # :reek:UtilityFunction
   def available_actions(user)
-    return [Constants.TASK_ACTIONS.CREATE_MAIL_TASK.to_h] if RootTask.user_can_create_mail_task?(user) && ama?
+    return [Constants.TASK_ACTIONS.CREATE_MAIL_TASK.to_h] if RootTask.user_can_create_mail_task?(user)
 
     []
   end