Create Vacated Decision Issues from Request Issues

app/controllers/post_decision_motions_controller.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class PostDecisionMotionsController < ApplicationController
-  before_action :verify_task_access
+  before_action :verify_task_access, only: [:create, :return_to_lit_support]
 
   def create
     motion_updater = PostDecisionMotionUpdater.new(task, motion_params)
@@ -25,6 +25,17 @@ def return_to_lit_support
     render json: { tasks: ::WorkQueue::TaskSerializer.new(appeal_tasks, is_collection: true) }
   end
 
+  def create_issues
+    new_request_issues = post_decision_motion.create_request_issues_for_vacatur
+
+    new_decision_issues = post_decision_motion.create_vacated_decision_issues
+
+    render json: {
+      request_issues: Intake::RequestIssueSerializer.new(new_request_issues, is_collection: true),
+      decision_issues: Intake::DecisionIssueSerializer.new(new_decision_issues, is_collection: true)
+    }
+  end
+
   private
 
   def verify_task_access
@@ -40,4 +51,16 @@ def task
   def motion_params
     params.permit(:disposition, :task_id, :vacate_type, :instructions, :assigned_to_id, vacated_decision_issue_ids: [])
   end
+
+  def create_issues_params
+    params.permit(:id)
+  end
+
+  def motion_id
+    create_issues_params[:id]
+  end
+
+  def post_decision_motion
+    PostDecisionMotion.find(motion_id)
+  end
 end

app/models/decision_issue.rb

@@ -160,7 +160,7 @@ def associated_request_issue
   end
 
   def create_contesting_request_issue!
-    RequestIssue.create!(
+    RequestIssue.find_or_create_by!(
       decision_review: decision_review,
       decision_review_type: decision_review_type,
       contested_decision_issue_id: id,

app/models/post_decision_motion.rb

@@ -21,14 +21,26 @@ class PostDecisionMotion < ApplicationRecord
     vacate_and_de_novo: "vacate_and_de_novo"
   }
 
-  def vacated_issues
+  def decision_issues_for_vacatur
     return [] unless vacated_decision_issue_ids
 
     DecisionIssue.find(vacated_decision_issue_ids)
   end
 
-  def create_request_issues_for_vacature
-    vacated_issues.map(&:create_contesting_request_issue!)
+  def request_issues_for_vacatur
+    @request_issues_for_vacatur ||= RequestIssue.where(contested_decision_issue_id: vacated_decision_issue_ids)
+  end
+
+  def create_request_issues_for_vacatur
+    decision_issues_for_vacatur.map(&:create_contesting_request_issue!)
+  end
+
+  def vacated_decision_issues
+    @vacated_decision_issues ||= request_issues_for_vacatur.map { |ri| ri.decision_issues.first }
+  end
+
+  def create_vacated_decision_issues
+    request_issues_for_vacatur.map(&:create_vacated_decision_issue!)
   end
 
   private

app/models/request_issue.rb

@@ -472,6 +472,18 @@ def create_decision_issue_from_params(decision_issue_param)
     )
   end
 
+  def create_vacated_decision_issue!
+    decision_issues.find_or_create_by!(
+      decision_review: decision_review,
+      decision_review_type: decision_review_type,
+      disposition: "vacated",
+      description: "The decision: #{description} has been vacated.",
+      caseflow_decision_date: Time.zone.today,
+      benefit_type: benefit_type,
+      participant_id: decision_review.veteran.participant_id
+    )
+  end
+
   def requires_record_request_task?
     eligible? && !is_unidentified && !benefit_type_requires_payee_code?
   end

config/routes.rb

@@ -302,6 +302,7 @@
   end
 
   post "post_decision_motions/return", to: "post_decision_motions#return_to_lit_support"
+  post "post_decision_motions/:id/create_issues", to: "post_decision_motions#create_issues"
   post "post_decision_motions", to: "post_decision_motions#create"
 
   # :nocov:

spec/controllers/post_decision_motions_controller_spec.rb

@@ -5,6 +5,8 @@
   let(:judge) { create(:user) }
   let(:judge_team) { JudgeTeam.create_for_judge(judge) }
 
+  let(:post_decision_motion) { create(:post_decision_motion) }
+
   before do
     User.authenticate!(roles: ["System Admin"])
     User.stub = judge
@@ -73,6 +75,51 @@
     end
   end
 
+  describe "#create_issues" do
+    context "with a valid PostDecisionMotion id" do
+      it "returns a 200 response and creates issues" do
+        allow(controller).to receive(:verify_authentication).and_return(true)
+
+        create_task_without_unnecessary_models
+        judge_team.add_user(user)
+
+        appeal = post_decision_motion.task.appeal.reload
+
+        expect(appeal.decision_issues.size).to eq(3)
+
+        post :create_issues, params: { id: post_decision_motion.id }
+
+        appeal.reload
+
+        expect(response).to be_success
+        expect(appeal.request_issues.size).to eq(3)
+        expect(appeal.decision_issues.size).to eq(6)
+      end
+    end
+
+    context "with an invalid PostDecisionMotion id" do
+      it "returns a 404 response and doesn't create issues" do
+        allow(controller).to receive(:verify_authentication).and_return(true)
+
+        create_task_without_unnecessary_models
+        judge_team.add_user(user)
+
+        appeal = post_decision_motion.task.appeal.reload
+
+        expect(appeal.decision_issues.size).to eq(3)
+        expect(appeal.request_issues.size).to eq(3)
+
+        post :create_issues, params: { id: 9999 }
+
+        appeal.reload
+
+        expect(response.status).to eq 404
+        expect(appeal.request_issues.size).to eq(3)
+        expect(appeal.decision_issues.size).to eq(3)
+      end
+    end
+  end
+
   def create_task_without_unnecessary_models
     appeal = create(:appeal)
     assigned_by = create(:user)

spec/factories/post_decision_motions.rb

@@ -2,7 +2,24 @@
 
 FactoryBot.define do
   factory :post_decision_motion do
-    disposition { "MyString" }
-    task { nil }
+    task { create(:judge_address_motion_to_vacate_task) }
+    disposition { "granted" }
+    vacate_type { "straight_vacate" }
+
+    before(:create) do |post_decision_motion|
+      appeal = post_decision_motion.task.appeal
+      return unless appeal.reload.decision_issues.empty?
+
+      3.times do |idx|
+        create(
+          :decision_issue,
+          :rating,
+          decision_review: appeal,
+          disposition: "denied",
+          description: "Decision issue description #{idx}",
+          decision_text: "decision issue"
+        )
+      end
+    end
   end
 end

spec/feature/queue/motion_to_vacate_spec.rb

@@ -317,7 +317,7 @@
       motion = PostDecisionMotion.find_by(task: judge_address_motion_to_vacate_task)
       expect(motion).to_not be_nil
       expect(motion.disposition).to eq("partially_granted")
-      expect(motion.vacated_issues.length).to eq(issues_to_select.length)
+      expect(motion.decision_issues_for_vacatur.length).to eq(issues_to_select.length)
 
       # Verify new task creation
       instructions = format_judge_instructions(

spec/models/post_decision_motion_spec.rb

@@ -10,11 +10,13 @@
   let(:motions_atty) { create(:user, full_name: "Motions attorney") }
   let(:appeal) { create(:appeal) }
   let(:orig_decision_issues) do
-    Array.new(3) do
+    Array.new(3) do |index|
       create(
         :decision_issue,
         decision_review: appeal,
-        disposition: "denied"
+        disposition: "denied",
+        description: "issue #{index}",
+        participant_id: appeal.veteran.participant_id
       )
     end
   end
@@ -41,15 +43,30 @@
     lit_support_team.add_user(motions_atty)
   end
 
-  context "handles creation of request issues" do
+  context "#create_request_issues_for_vacatur" do
     let(:disposition) { "granted" }
     let(:vacate_type) { "vacate_and_readjudication" }
+    subject { post_decision_motion.create_request_issues_for_vacatur }
 
     it "creates a request issue for every selected decision issue" do
-      expect(appeal.request_issues.length).to eq 0
-      post_decision_motion.create_request_issues_for_vacature
+      expect(appeal.request_issues.size).to eq 0
+      subject
       appeal.reload
-      expect(appeal.request_issues.length).to eq 3
+      expect(appeal.request_issues.size).to eq 3
+    end
+  end
+
+  context "#create_vacated_decision_issues" do
+    let(:disposition) { "granted" }
+    let(:vacate_type) { "vacate_and_readjudication" }
+    subject { post_decision_motion.create_vacated_decision_issues }
+
+    it "creates a vacated decision issue for every selected decision issue" do
+      expect(post_decision_motion.decision_issues_for_vacatur.size).to eq 3
+      post_decision_motion.create_request_issues_for_vacatur
+      subject
+      appeal.reload
+      expect(appeal.decision_issues.size).to eq 6
     end
   end
 end