Calvin/appeals 43853

app/models/vacols/case_docket.rb

@@ -122,23 +122,26 @@ class DocketNumberCentennialLoop < StandardError; end
   "
 
   SELECT_PRIORITY_APPEALS = "
-    select BFKEY, BFDLOOUT, VLJ
+    select BFKEY, BFDLOOUT, BFAC, AOD, VLJ, PREV_TYPE_ACTION, PREV_DECIDING_JUDGE
       from (
-        select BFKEY, BFDLOOUT,
-          case when BFHINES is null or BFHINES <> 'GP' then VLJ_HEARINGS.VLJ end VLJ
+        select BFKEY, BFDLOOUT, BFAC, AOD,
+          case when BFHINES is null or BFHINES <> 'GP' then VLJ_HEARINGS.VLJ end VLJ,
+          PREV_APPEAL.PREV_TYPE_ACTION PREV_TYPE_ACTION,
+          PREV_APPEAL.PREV_DECIDING_JUDGE PREV_DECIDING_JUDGE
         from (
           #{SELECT_READY_APPEALS}
             and (BFAC = '7' or AOD = '1')
           order by BFDLOOUT
         ) BRIEFF
         #{JOIN_ASSOCIATED_VLJS_BY_HEARINGS}
+        #{JOIN_PREVIOUS_APPEALS}
       )
     "
 
   SELECT_PRIORITY_APPEALS_ORDER_BY_BFD19 = "
-    select BFKEY, BFD19, BFDLOOUT, VLJ, PREV_TYPE_ACTION, PREV_DECIDING_JUDGE
+    select BFKEY, BFD19, BFDLOOUT, BFAC, AOD, VLJ, PREV_TYPE_ACTION, PREV_DECIDING_JUDGE
       from (
-        select BFKEY, BFD19, BFDLOOUT,
+        select BFKEY, BFD19, BFDLOOUT, BFAC, AOD,
           case when BFHINES is null or BFHINES <> 'GP' then VLJ_HEARINGS.VLJ end VLJ,
           PREV_APPEAL.PREV_TYPE_ACTION PREV_TYPE_ACTION,
           PREV_APPEAL.PREV_DECIDING_JUDGE PREV_DECIDING_JUDGE
@@ -206,7 +209,6 @@ class DocketNumberCentennialLoop < StandardError; end
     left join STAFF on APPEALS.VLJ = STAFF.STAFKEY
     order by BFD19
   "
-
   # rubocop:disable Metrics/MethodLength
   def self.counts_by_priority_and_readiness
     query = <<-SQL
@@ -341,27 +343,34 @@ def self.age_of_n_oldest_genpop_priority_appeals(num)
     appeals.map { |appeal| appeal["bfdloout"] }
   end
 
-  # {UPDATE}
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
   def self.age_of_n_oldest_priority_appeals_available_to_judge(judge, num)
+    priority_cdl_aod_query = generate_priority_case_distribution_lever_aod_query
     conn = connection
 
     query = <<-SQL
       #{SELECT_PRIORITY_APPEALS_ORDER_BY_BFD19}
-      where (VLJ = ? or #{ineligible_judges_sattyid_cache} or VLJ is null)
-      and rownum <= ?
+      where (VLJ = ? or #{ineligible_judges_sattyid_cache} or VLJ is null or #{priority_cdl_aod_query})
     SQL
 
     fmtd_query = sanitize_sql_array([
                                       query,
                                       judge.vacols_attorney_id,
-                                      num
+                                      judge.vacols_attorney_id
                                     ])
 
     appeals = conn.exec_query(fmtd_query).to_a
+
+    cavc_aod_affinity_filter(appeals, judge)
+
+    appeals.sort_by { |appeal| appeal[:bfd19] } if use_by_docket_date?
+
+    appeals = appeals.first(num) unless num.nil? # {Reestablishes the limit}
+
     appeals.map { |appeal| appeal["bfd19"] }
   end
+  # rubocop:enable
 
-  # {UPDATE}
   def self.age_of_n_oldest_nonpriority_appeals_available_to_judge(judge, num)
     conn = connection
 
@@ -451,8 +460,7 @@ def self.ready_to_distribute_appeals
     connection.exec_query(fmtd_query).to_a
   end
 
-  # {UPDATE}
-  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/ParameterLists, Metrics/MethodLength
+  # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
   def self.distribute_nonpriority_appeals(judge, genpop, range, limit, bust_backlog, dry_run = false)
     fail(DocketNumberCentennialLoop, COPY::MAX_LEGACY_DOCKET_NUMBER_ERROR_MESSAGE) if Time.zone.now.year >= 2030
 
@@ -461,7 +469,6 @@ def self.distribute_nonpriority_appeals(judge, genpop, range, limit, bust_backlo
         #{SELECT_NONPRIORITY_APPEALS_ORDER_BY_BFD19}
         where (((VLJ = ? or #{ineligible_judges_sattyid_cache}) and 1 = ?) or (VLJ is null and 1 = ?))
         and (DOCKET_INDEX <= ? or 1 = ?)
-        and rownum <= ?
       SQL
     else
       # Docket numbers begin with the two digit year. The Board of Veterans Appeals was created in 1930.
@@ -481,7 +488,6 @@ def self.distribute_nonpriority_appeals(judge, genpop, range, limit, bust_backlo
         #{SELECT_NONPRIORITY_APPEALS}
         where (((VLJ = ? or #{ineligible_judges_sattyid_cache}) and 1 = ?) or (VLJ is null and 1 = ?))
         and (DOCKET_INDEX <= ? or 1 = ?)
-        and rownum <= ?
       SQL
     end
 
@@ -491,27 +497,23 @@ def self.distribute_nonpriority_appeals(judge, genpop, range, limit, bust_backlo
                                       (genpop == "any" || genpop == "not_genpop") ? 1 : 0,
                                       (genpop == "any" || genpop == "only_genpop") ? 1 : 0,
                                       range,
-                                      range.nil? ? 1 : 0,
-                                      limit
+                                      range.nil? ? 1 : 0
                                     ])
 
-    distribute_appeals(fmtd_query, judge, dry_run)
+    distribute_appeals(fmtd_query, judge, limit, dry_run)
   end
-  # rubocop:enable Metrics/ParameterLists, Metrics/MethodLength
 
-  # {UPDATE}
   def self.distribute_priority_appeals(judge, genpop, limit, dry_run = false)
+    priority_cdl_aod_query = generate_priority_case_distribution_lever_aod_query
     query = if use_by_docket_date?
               <<-SQL
                 #{SELECT_PRIORITY_APPEALS_ORDER_BY_BFD19}
-                where (((VLJ = ? or #{ineligible_judges_sattyid_cache}) and 1 = ?) or (VLJ is null and 1 = ?))
-                and (rownum <= ? or 1 = ?)
+                where (((VLJ = ? or #{ineligible_judges_sattyid_cache}) and 1 = ?) or (VLJ is null and 1 = ?) or #{priority_cdl_aod_query})
               SQL
             else
               <<-SQL
                 #{SELECT_PRIORITY_APPEALS}
-                where (((VLJ = ? or #{ineligible_judges_sattyid_cache}) and 1 = ?) or (VLJ is null and 1 = ?))
-                and (rownum <= ? or 1 = ?)
+                where (((VLJ = ? or #{ineligible_judges_sattyid_cache}) and 1 = ?) or (VLJ is null and 1 = ?) or #{priority_cdl_aod_query})
               SQL
             end
 
@@ -520,27 +522,36 @@ def self.distribute_priority_appeals(judge, genpop, limit, dry_run = false)
                                       judge.vacols_attorney_id,
                                       (genpop == "any" || genpop == "not_genpop") ? 1 : 0,
                                       (genpop == "any" || genpop == "only_genpop") ? 1 : 0,
-                                      limit,
-                                      limit.nil? ? 1 : 0
+                                      judge.vacols_attorney_id
                                     ])
 
-    distribute_appeals(fmtd_query, judge, dry_run)
+    distribute_appeals(fmtd_query, judge, limit, dry_run)
   end
-  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-  # :nocov:
 
-  def self.distribute_appeals(query, judge, dry_run)
+  # :nocov:
+  # rubocop:disable Metrics/AbcSize
+  def self.distribute_appeals(query, judge, limit, dry_run)
     conn = connection
 
     conn.transaction do
       if dry_run
-        conn.exec_query(query).to_a
+        dry_appeals = conn.exec_query(query).to_a
+
+        cavc_aod_affinity_filter(dry_appeals, judge)
+
+        dry_appeals
       else
         conn.execute(LOCK_READY_APPEALS) unless FeatureToggle.enabled?(:acd_disable_legacy_lock_ready_appeals)
 
         appeals = conn.exec_query(query).to_a
         return appeals if appeals.empty?
 
+        cavc_aod_affinity_filter(appeals, judge)
+
+        appeals.sort_by { |appeal| appeal[:bfd19] } if use_by_docket_date?
+
+        appeals = appeals.first(limit) unless limit.nil? # {Reestablishes the limit}
+
         vacols_ids = appeals.map { |appeal| appeal["bfkey"] }
         location = if FeatureToggle.enabled?(:legacy_das_deprecation, user: RequestStore.store[:current_user])
                      LegacyAppeal::LOCATION_CODES[:caseflow]
@@ -553,15 +564,99 @@ def self.distribute_appeals(query, judge, dry_run)
     end
   end
 
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/ParameterLists
+
+  def self.generate_priority_case_distribution_lever_aod_query
+    if case_affinity_days_lever_value_is_selected?(CaseDistributionLever.cavc_aod_affinity_days) ||
+       CaseDistributionLever.cavc_aod_affinity_days == Constants.ACD_LEVERS.omit
+      "((PREV_DECIDING_JUDGE = ? or PREV_DECIDING_JUDGE is null or PREV_DECIDING_JUDGE is not null)
+      and AOD = '1' and BFAC = '7' )"
+    elsif CaseDistributionLever.cavc_aod_affinity_days == Constants.ACD_LEVERS.infinite
+      "((PREV_DECIDING_JUDGE = ? or #{ineligible_judges_sattyid_cache(true)} or
+      #{vacols_judges_with_exclude_appeals_from_affinity}) and AOD = '1' and BFAC = '7' )"
+    else
+      "VLJ = ?"
+    end
+  end
+
   def self.use_by_docket_date?
     FeatureToggle.enabled?(:acd_distribute_by_docket_date, user: RequestStore.store[:current_user])
   end
 
-  # rubocop:disable Metrics/MethodLength
-  def self.ineligible_judges_sattyid_cache
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def self.cavc_aod_affinity_filter(appeals, judge)
+    appeals.reject! do |appeal|
+      # {will skip if not CAVC AOD || if CAVC AOD being distributed to tied_to judge || if not tied to any judge}
+      next if tied_to_or_not_cavc_aod?(appeal, judge)
+
+      if not_distributing_to_tied_judge?(appeal, judge)
+        next if ineligible_judges_sattyids&.include?(appeal["vlj"])
+
+        next (appeal["vlj"] != judge.vacols_attorney_id)
+      end
+
+      next if ineligible_or_excluded_deciding_judge?(appeal)
+
+      if case_affinity_days_lever_value_is_selected?(CaseDistributionLever.cavc_aod_affinity_days)
+        next if appeal["prev_deciding_judge"] == judge.vacols_attorney_id
+
+        reject_due_to_affinity?(appeal)
+      elsif CaseDistributionLever.cavc_aod_affinity_days == Constants.ACD_LEVERS.infinite
+        next if ineligible_judges_sattyids&.include?(appeal["vlj"])
+
+        appeal["prev_deciding_judge"] != judge.vacols_attorney_id
+      elsif CaseDistributionLever.cavc_aod_affinity_days == Constants.ACD_LEVERS.omit
+        appeal["prev_deciding_judge"] == appeal["vlj"]
+      end
+    end
+  end
+
+  def self.tied_to_or_not_cavc_aod?(appeal, judge)
+    (appeal["bfac"] != "7" || appeal["aod"] != 1) ||
+      (appeal["bfac"] == "7" && appeal["aod"] == 1 &&
+        !appeal["vlj"].blank? &&
+        (appeal["vlj"] == appeal["prev_deciding_judge"] || appeal["prev_deciding_judge"].nil?) &&
+        appeal["vlj"] == judge.vacols_attorney_id) ||
+      (appeal["vlj"].nil? && appeal["prev_deciding_judge"].nil?)
+  end
+
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+  def self.not_distributing_to_tied_judge?(appeal, judge)
+    !appeal["vlj"].blank? &&
+      (appeal["vlj"] == appeal["prev_deciding_judge"]) &&
+      (appeal["vlj"] != judge.vacols_attorney_id)
+  end
+
+  def self.ineligible_or_excluded_deciding_judge?(appeal)
+    # {if deciding_judge is ineligible or excluded, we will skip, unless excluded deciding_judge = VLJ}
+    ineligible_judges_sattyids&.include?(appeal["prev_deciding_judge"]) ||
+      (appeal["vlj"] != appeal["prev_deciding_judge"] &&
+        excluded_judges_sattyids&.include?(appeal["prev_deciding_judge"]))
+  end
+
+  def self.reject_due_to_affinity?(appeal)
+    VACOLS::Case.find_by(bfkey: appeal["bfkey"])&.appeal_affinity&.affinity_start_date.nil? ||
+      (VACOLS::Case.find_by(bfkey: appeal["bfkey"])
+        .appeal_affinity
+        .affinity_start_date > CaseDistributionLever.cavc_aod_affinity_days.to_i.days.ago)
+  end
+
+  def self.ineligible_judges_sattyids
+    Rails.cache.fetch("case_distribution_ineligible_judges")&.pluck(:sattyid)&.reject(&:blank?) || []
+  end
+
+  def self.excluded_judges_sattyids
+    VACOLS::Staff.where(sdomainid: JudgeTeam.active
+        .where(exclude_appeals_from_affinity: true)
+        .flat_map(&:judge).compact.pluck(:css_id))&.pluck(:sattyid)
+  end
+
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+  def self.ineligible_judges_sattyid_cache(prev_deciding_judge = false)
     if FeatureToggle.enabled?(:acd_cases_tied_to_judges_no_longer_with_board) &&
-       !Rails.cache.fetch("case_distribution_ineligible_judges")&.pluck(:sattyid)&.reject(&:blank?).blank?
-      list = Rails.cache.fetch("case_distribution_ineligible_judges")&.pluck(:sattyid)&.reject(&:blank?)
+       !ineligible_judges_sattyids.blank?
+      list = ineligible_judges_sattyids
       split_lists = {}
       num_of_lists = (list.size.to_f / 999).ceil
 
@@ -575,15 +670,45 @@ def self.ineligible_judges_sattyid_cache
 
       vljs_strings = split_lists.flat_map do |k, v|
         base = "(#{v.join(', ')})"
-        base += " or VLJ in " unless k == split_lists.keys.last
+        if prev_deciding_judge
+          base += " or PREV_DECIDING_JUDGE in " unless k == split_lists.keys.last
+        else
+          base += " or VLJ in " unless k == split_lists.keys.last
+        end
         base
       end
 
-      "VLJ in #{vljs_strings.join}"
+      if prev_deciding_judge
+        "PREV_DECIDING_JUDGE in #{vljs_strings.join}"
+      else
+        "VLJ in #{vljs_strings.join}"
+      end
+
+    elsif prev_deciding_judge
+      "PREV_DECIDING_JUDGE = 'false'"
     else
       "VLJ = 'false'"
     end
   end
-  # rubocop:enable Metrics/MethodLength
+
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+
+  def self.vacols_judges_with_exclude_appeals_from_affinity
+    return "PREV_DECIDING_JUDGE = 'false'" unless FeatureToggle.enabled?(:acd_exclude_from_affinity)
+
+    satty_ids = excluded_judges_sattyids
+
+    if satty_ids.blank?
+      "PREV_DECIDING_JUDGE = 'false'"
+    else
+      "PREV_DECIDING_JUDGE in (#{satty_ids.join(', ')})"
+    end
+  end
+
+  def self.case_affinity_days_lever_value_is_selected?(lever_value)
+    return false if lever_value == "omit" || lever_value == "infinite"
+
+    true
+  end
 end
-# rubocop:enable Metrics/ClassLength
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize

spec/factories/user.rb

@@ -56,6 +56,11 @@
       roles { ["Hearing Prep"] }
     end
 
+    trait :judge_with_appeals_excluded_from_affinity do
+      with_appeals_excluded_from_affinity_judge_team
+      roles { ["Hearing Prep"] }
+    end
+
     trait :ama_only_judge do
       after(:create) do |judge|
         JudgeTeam.for_judge(judge)&.update(ama_only_push: true, ama_only_request: true) ||
@@ -95,6 +100,13 @@
       end
     end
 
+    trait :with_appeals_excluded_from_affinity_judge_team do
+      after(:create) do |judge|
+        judge_team = JudgeTeam.for_judge(judge) || JudgeTeam.create_for_judge(judge)
+        judge_team.update!(exclude_appeals_from_affinity: true)
+      end
+    end
+
     trait :with_vacols_attorney_record do
       after(:create) do |user|
         create(:staff, :attorney_role, user: user)