Create PrivacyActTask subclass of GenericTask

[lowellrex]

Currently, when VLJ support staff assign tasks the Privacy team we create GenericTasks assigned to that team. However, we've recently run into some issues with this approach when the Privacy team attempts to re-assign the task back to VLJ support instead of marking the task complete which results in tasks bouncing back and forth between the two teams (pictured below) because tasks are not being properly closed.

             |
     +-------+-------+
     |               |
     | ColocatedTask |
     |               |
     +-------+-------+
             |
             |
             |
+------------+------------+
|                         |
|       GenericTask       |
| assigned to PrivacyTeam |
|                         |
+------------+------------+
             |
             |
             |
+------------+------------+
|                         |
|       GenericTask       |
| assigned to VLJ support |
|                         |
+------------+------------+
             |
             |
             v

   Return to PrivacyTeam
           fails

Most other teams have specifically-designed tasks for their team, the Privacy team is the only team that is making use of GenericTasks like this. In order to reduce confusion we could limit the actions available on tasks assigned to the Privacy team.

Acceptance criteria

• Determine what actions the privacy will need to take on tasks assigned to them.
• Create a subclass of GenericTask with a limited set of available action.
• Fix existing tasks that are in a bad state

[lowellrex]

We should also fix the existing tasks that are in a bad state to return the task tree to a state where they can be worked on in the Caseflow application.

[lowellrex]

MEDIUM.

[lowellrex]

Noting here that #10304 is likely a result of the existing tasks being in a bad state, so we should check to see if that ticket is resolved by the cleanup in this ticket.

[lowellrex]

Example of a task where we've gotten into a bad state with Privacy assigning to VLJ support staff instead of marking the task complete:

rails c> org = PrivacyTeam.singleton
rails c> GenericTask.where(assigned_to: org).count
# 377
rails c> GenericTask.where(assigned_to: org).pluck(:type).uniq
# ["GenericTask", "FoiaRequestMailTask"]
rails c> GenericTask.where(assigned_to: org).select { |t| t.children.any? }.count
# 129
rails c> privacy_team_tasks = GenericTask.where(assigned_to: org).select { |t| t.children.any? }
rails c> example_task = privacy_team_tasks.first
rails c> example_task.appeal.tasks.order(:created_at).pluck(:parent_id, :id, :type, :assigned_to_type, :assigned_to_id)
# [nil, 9663, "RootTask", "Organization", 2],
[nil, 9664, "ColocatedTask", "Organization", 23],
    [9664, 9665, "ColocatedTask", "User", 2141],
[nil, 165228, "ColocatedTask", "Organization", 23],
    [165228, 165229, "ColocatedTask", "User", 803],
[nil, 165230, "ColocatedTask", "Organization", 23],
    [165230, 165231, "ColocatedTask", "User", 803],
        [165231, 169114, "GenericTask", "Organization", 202],
            [169114, 176826, "GenericTask", "User", 2173],
        [165231, 181974, "GenericTask", "Organization", 202]

# Let's limit it to only the situation where we have assigned to Colocated instead of
# returned to Colocated.
rails c> colocated_tasks_with_generic_parents = GenericTask.where(assigned_to: Colocated.singleton).where.not(parent_id: nil).select { |t| t.parent.is_a?(GenericTask) }
rails c> colocated_tasks_with_generic_parents.count
# 66
rails c> colocated_tasks_with_privacy_parents =  colocated_tasks_with_generic_parents.select { |t| PrivacyTeam.singleton == t.parent.assigned_to }
rails c> colocated_tasks_with_privacy_parents.count
# 27
rails c> example_task = colocated_tasks_with_privacy_parents.first
rails c> example_task.appeal.tasks.order(:created_at).pluck(:parent_id, :id, :type, :assigned_to_type, :assigned_to_id, :status)
[nil, 372, "RootTask", "Organization", 2, "completed"],
    [372, 542, "JudgeDecisionReviewTask", "User", 1060, "completed"],
        [542, 795, "AttorneyTask", "User", 957, "completed"],
            [795, 1566, "ColocatedTask", "Organization", 23, "completed"],
                [1566, 838, "ColocatedTask", "User", 1967, "completed"],
                    [838, 31194, "GenericTask", "Organization", 202, "on_hold"], # <- Privacy Team
                        [31194, 32036, "GenericTask", "Organization", 23, "on_hold"], # <- VLJ support staff
                            [32036, 32037, "GenericTask", "User", 1829, "in_progress"],
    [372, 178576, "BvaDispatchTask", "Organization", 19, "completed"],
        [178576, 178577, "BvaDispatchTask", "User", 2008, "completed"]

[lowellrex]

Has anybody used the "Assign to team" option to assign GenericTasks to teams other than PrivacyTeam?

# GenericTasks assigned to any team.
rails c> Task.where(assigned_to_type: Organization.name, type: GenericTask.name).where.not(parent_id: nil).count
# 420

# GenericTasks assigned to non-PrivacyTeam teams.
rails c> Task.where(assigned_to_type: Organization.name, type: GenericTask.name).where.not(parent_id: nil).where.not(assigned_to: PrivacyTeam.singleton).count
# 0

Let's just get rid of the "Assign to team" option from GenericTask.available_actions because it doesn't look like anybody is using it.

[kevmo]

Re "tasks that are in a bad state" - #10304

[lowellrex]

Started the process to clean up the tasks in a bad state. Went from 21 to 20. More work left to do, but this is a solid pattern we can follow:

# Let's look for GenericTasks assigned to Colocated org that are incomplete.
rails c> tasks_to_fix = Task.active.where(type: GenericTask.name, assigned_to: Colocated.singleton)
rails c> tasks_to_fix.count
# 21

# Let's look at an example and decide if we need to fix it.
rails c> pp tasks_to_fix.first.appeal.tasks.order(:created_at).pluck(:id, :parent_id, :type, :status, :assigned_to_type, :assigned_to_id)
# [[8147, nil, "RootTask", "assigned", "Organization", 2],
   [12925, nil, "ColocatedTask", "completed", "Organization", 23], <- VLJ Support
       [12926, 12925, "ColocatedTask", "completed", "User", 2012],
           [15789, 12926, "GenericTask", "on_hold", "Organization", 202], <- Privacy team
                [16566, 15789, "GenericTask", "on_hold", "Organization", 23],
                    [16567, 16566, "GenericTask", "cancelled", "User", 1379],
                    [201983, 16566, "GenericTask", "assigned", "User", 1585]]
# The child task (201983) should be completed. Privacy team should be active
# and different type.
rails c> privacy_act_task = Task.find(15789)
rails c> privacy_act_task.update!(type: PrivacyActTask.name)
# Let's complete the VLJ support staff GenericTask and put the ball in Privacy team's
# court by updating statuses if we need to afterwards.
rails c> colocated_user_generic_task = Task.find(201983)
rails c> colocated_user_generic_task.update!(status: Constants.TASK_STATUSES.completed)
# Let's see how the statuses are looking!
rails c> pp colocated_user_generic_task.appeal.reload.tasks.order(:created_at).pluck(:id, :parent_id, :type, :status, :assigned_to_type, :assigned_to_id)
# [[8147, nil, "RootTask", "assigned", "Organization", 2],
   [12925, nil, "ColocatedTask", "completed", "Organization", 23],
       [12926, 12925, "ColocatedTask", "completed", "User", 2012],
           [15789, 12926, "PrivacyActTask", "completed", "Organization", 202],
               [16566, 15789, "GenericTask", "completed", "Organization", 23],
                   [16567, 16566, "GenericTask", "cancelled", "User", 1379],
                   [201983, 16566, "GenericTask", "completed", "User", 1585]]
# I think we've updated the VACOLS location here. So let's take a look.
rails c> appeal = colocated_user_generic_task.appeal
rails c> appeal.location_code
# 50
# What is 50?
# Would expect it to be this:
rails c> Task.find(12925).assigned_by.vacols_uniq_id
# "TALAMT"
# Let's re-open the task, it should be routed correctly when it is closed again.
rails c> AppealRepository.update_location!(appeal, LegacyAppeal::LOCATION_CODES[:caseflow])
# We want re-open all the way back to Privacy team.
rails c> Task.find(12925).update!(status: Constants.TASK_STATUSES.on_hold)
rails c> Task.find(12926).update!(status: Constants.TASK_STATUSES.on_hold)
rails c> Task.find(15789).update!(status: Constants.TASK_STATUSES.assigned)
# Let's take a look to see if the task tree looks how we expect.
rails c> pp Task.find(8147).appeal.tasks.order(:created_at).pluck(:id, :parent_id, :type, :status, :assigned_to_type, :assigned_to_id)
# [[8147, nil, "RootTask", "assigned", "Organization", 2],
 [12925, nil, "ColocatedTask", "on_hold", "Organization", 23],
 [12926, 12925, "ColocatedTask", "on_hold", "User", 2012],
 [15789, 12926, "PrivacyActTask", "assigned", "Organization", 202],
 [16566, 15789, "GenericTask", "completed", "Organization", 23],
 [16567, 16566, "GenericTask", "cancelled", "User", 1379],
 [201983, 16566, "GenericTask", "completed", "User", 1585]]
# That looks exactly how we want it to.
# What is the location code?
rails c> Task.find(8147).appeal.location_code
# "CASEFLOW"
# Perfect.

# How many tasks to fix do we have now?
rails c> tasks_to_fix = Task.active.where(type: GenericTask.name, assigned_to: Colocated.singleton)
rails c> tasks_to_fix.count
# 20

[lowellrex]

More progress! Only 17 remaining:

# Let's look for GenericTasks assigned to Colocated org that are incomplete.
rails c> tasks_to_fix = Task.active.where(type: GenericTask.name, assigned_to: Colocated.singleton)
rails c> tasks_to_fix.count
# 19

# Let's look at the task tree for this first one
rails c> pp tasks_to_fix.first.appeal.tasks.order(:created_at).pluck(:id, :parent_id, :type, :status, :assigned_to_type, :assigned_to_id)
# [[372, nil, "RootTask", "completed", "Organization", 2],
       [542, 372, "JudgeDecisionReviewTask", "completed", "User", 1060],
           [795, 542, "AttorneyTask", "completed", "User", 957],
               [1566, 795, "ColocatedTask", "completed", "Organization", 23],
                   [838, 1566, "ColocatedTask", "completed", "User", 1967],
                       [31194, 838, "GenericTask", "on_hold", "Organization", 202], # <- Privacy team
                           [32036, 31194, "GenericTask", "on_hold", "Organization", 23], # <- Colocated
                               [32037, 32036, "GenericTask", "in_progress", "User", 1829],
       [178576, 372, "BvaDispatchTask", "completed", "Organization", 19],
           [178577, 178576, "BvaDispatchTask", "completed", "User", 2008]]
# This appeal has already been dispatched. Let's complete the one open task.
# We expect the task tree not to change outside of the 2 on hold tasks and 1 in progress.
rails c> Task.find(32037).update!(status: Constants.TASK_STATUSES.completed)
rails c> pp tasks_to_fix.first.appeal.tasks.order(:created_at).pluck(:id, :parent_id, :type, :status, :assigned_to_type, :assigned_to_id)
# Looks the same. This is an AMA appeal so nothing would have changed in VACOLS
# because it does not exist in VACOLS.

# Next VICTIM:
rails c> tasks_to_fix = Task.active.where(type: GenericTask.name, assigned_to: Colocated.singleton)
rails c> tasks_to_fix.count
# 18

rails c> pp tasks_to_fix.first.appeal.tasks.order(:created_at).pluck(:id, :parent_id, :type, :status, :assigned_to_type, :assigned_to_id)
# [[1878, nil, "ColocatedTask", "on_hold", "Organization", 23],
       [1879, 1878, "ColocatedTask", "cancelled", "User", 1885],
       [152087, 1878, "ColocatedTask", "on_hold", "User", 2141]]
           [30615, 152087, "GenericTask", "on_hold", "Organization", 202],
               [32059, 30615, "GenericTask", "on_hold", "Organization", 23],
                   [32060, 32059, "GenericTask", "assigned", "User", 1885],
   [30610, nil, "RootTask", "assigned", "Organization", 2],
# What is the current location of this LegacyAppeal?
rails c> tasks_to_fix.first.appeal.location_code
# "CASEFLOW"
# Caseflow still has responsibility, the appeal has not been dispatched. Let's get it
# unstuck!
rails c> tasks_to_fix.first.appeal.status
# "Active"
# Definitely still active at the Board.
# Which tasks do we need to fix up? What is going on with each of these tasks?
rails c> pp Task.where(id: [30615, 32059, 32060]).order(:created_at).pluck(:instructions)
# This Privacy act task should have just gone back to VLJ support staff directly.
rails c> true_parent_task = Task.find(152087)
rails c> child_privacy_task = Task.find(30615)
rails c> incorrect_colocated_generic_org_task = child_privacy_task.children.first
# Let's move the instructions to the correct parent ColocatedTask.
rails c> true_parent_task.instructions = true_parent_task.instructions.push(incorrect_colocated_generic_org_task.instructions).flatten
rails c> true_parent_task.save!
# Let's cancel the GenericTasks assigned to VLJ and complete the one assigned to Privacy
rails c> childmost_task = Task.find(32060)
# We expect the parent (generic task, assigned to colocated org) to be completed
# its parent (generic assigned to privacy org) to also be completed
# and the ColocatedTask currently on hold assigned to a person to have status "assigned"
rails c> childmost_task.update!(status: Constants.TASK_STATUSES.cancelled)
# [[1878, nil, "ColocatedTask", "on_hold", "Organization", 23],
       [1879, 1878, "ColocatedTask", "cancelled", "User", 1885],
       [152087, 1878, "ColocatedTask", "assigned", "User", 2141]]
           [30615, 152087, "GenericTask", "completed", "Organization", 202],
               [32059, 30615, "GenericTask", "completed", "Organization", 23],
                   [32060, 32059, "GenericTask", "cancelled", "User", 1885],
   [30610, nil, "RootTask", "assigned", "Organization", 2],
# Looks good here!

# How do our numbers look now?
rails c> tasks_to_fix = Task.active.where(type: GenericTask.name, assigned_to: Colocated.singleton)
rails c> tasks_to_fix.count
# 17

[kevmo]

rails c> tasks_to_fix = Task.active.where(type: GenericTask.name, assigned_to: Colocated.singleton)
rails c> tasks_to_fix.count

# 11 left!

rails c> pp tasks_to_fix.first.appeal.tasks.order(:created_at).pluck(:id, :parent_id, :type, :status, :assigned_to_type, :assigned_to_id)



[1916, nil, "ColocatedTask", "on_hold", "Organization", 23],
 	[1917, 1916, "ColocatedTask", "on_hold", "User", 1967],
		[13478, 1917, "GenericTask", "completed", "Organization", 202],
 		[31204, 1917, "GenericTask", "on_hold", "Organization", 202],
			[32243, 31204, "GenericTask", "on_hold", "User", 1515],
				 [32423, 32243, "GenericTask", "on_hold", "Organization", 23],
					 [32424, 32423, "GenericTask", "assigned", "User", 2077]

[13477, nil, "RootTask", "assigned", "Organization", 2],
 
 

 
Curious.  Looks like we need to collect all open tasks & reach out to VLJ support staff 
and ask “What do you wanna do with this?”

rails c>  Task.find_by(id: 32424)

rails > User.find_by(id: 2077) 

Tina 

rails c> Task.find(32424).update!(status: Constants.TASK_STATUSES.completed)

rails c> Task,find(32243).update!(status: Constants.TASK_STATUSES.completed)

rails c> tasks_to_fix = Task.active.where(type: GenericTask.name, assigned_to: Colocated.singleton)

rails c> tasks_to_fix.first.appeal.tasks.order(:created_at).pluck(:id, :parent_id, :type, :status, :assigned_to_type, :assigned_to_id)



[11017, nil, "RootTask", "assigned", "Organization", 2], 
[11043, nil, "ColocatedTask", "completed", "Organization", 23], 
	[11044, 11043, "ColocatedTask", "completed", "User", 1967], 
		[12253, 11044, "GenericTask", "completed", "Organization", 202], 
			[14342, 12253, "GenericTask", "completed", "User", 1515], 
		[74926, 11044, "GenericTask", "on_hold", "Organization", 202], 
			[77290, 74926, "GenericTask", "on_hold", "Organization", 23], 
				[219234, 77290, "GenericTask", "assigned", "User", 1967]
				[77291, 77290, "GenericTask", "cancelled", "User", 1379], 

[143761, nil, "ColocatedTask", "completed", "Organization", 23], 
	[143762, 143761, "ColocatedTask", "completed", "User", 2141], 

rails c> Task.find(219234).update!(status: Constants.TASK_STATUS.completed)

[103516, nil, "RootTask", "assigned", "Organization", 2],
 [103553, nil, "ColocatedTask", "on_hold", "Organization", 23],
 	[103557, 103553, "ColocatedTask", "on_hold", "User", 2141],
 		[131454, 103557, "GenericTask", "on_hold", "Organization", 202],
 			[131587, 131454, "GenericTask", "on_hold", "Organization", 23],
 				[131588, 131587, "GenericTask", "assigned", "User", 1379]


rails c> Task.find(131588).update!(status: Constants.TASK_STATUSES.completed)


[169972, nil, "RootTask", "assigned", "Organization", 2],
 [176357, nil, "ColocatedTask", "completed", "Organization", 23],
 	[176358, 176357, "ColocatedTask", "completed", "User", 803],
 		[177941, 176358, "GenericTask", "completed", "Organization", 202],
 		[181957, 176358, "GenericTask", "completed", "Organization", 202],
 		[183477, 176358, "GenericTask", "on_hold", "Organization", 202],
 			[190374, 183477, "GenericTask", "on_hold", "User", 2173],
 				[190711, 190374, "GenericTask", "on_hold", "Organization", 23],
					 [190712, 190711, "GenericTask", "assigned", "User", 1379],
 [208994, nil, "ColocatedTask", "on_hold", "Organization", 23],
 	[208995, 208994, "ColocatedTask", "on_hold", "User", 1379]

rails c> Task.find(190712).update!(status: Constants.TASK_STATUSES.completed)



[58328, nil, "RootTask", "assigned", "Organization", 2],
 [58642, nil, "ColocatedTask", "completed", "Organization", 23],
 	[58643, 58642, "ColocatedTask", "cancelled", "User", 1379],
 	[152204, 58642, "ColocatedTask", "completed", "User", 1379],
 		[178398, 152204, "GenericTask", "on_hold", "Organization", 202],
 			[190563, 178398, "GenericTask", "on_hold", "User", 2173],
				 [190754, 190563, "GenericTask", "on_hold", "Organization", 23],
					 [190755, 190754, "GenericTask", "cancelled", "User", 2141],
 					 [190868, 190754, "GenericTask", "in_progress", "User", 1379]]


rails c>  tasks_to_fix = Task.active.where(type: GenericTask.name, assigned_to: Colocated.singleton)
rails c> tasks_to_fix.count

6 left, whew