Calvin/appeals 58200

app/jobs/update_appeal_affinity_dates_job.rb

@@ -157,6 +157,8 @@ def process_legacy_appeals_which_need_affinity_updates(receipt_date_hashes_array
 
       legacy_appeals_hash = VACOLS::CaseDocket.update_appeal_affinity_dates_query(receipt_date_hash[:priority],
                                                                                   receipt_date_hash[:receipt_date])
+      legacy_appeals_hash += VACOLS::AojCaseDocket.update_appeal_affinity_dates_query(receipt_date_hash[:priority],
+                                                                                      receipt_date_hash[:receipt_date])
       legacy_appeals_to_update_adjusted_for_affinity = legacy_appeals_with_no_appeal_affinities(legacy_appeals_hash)
       create_or_update_appeal_affinities(legacy_appeals_to_update_adjusted_for_affinity, receipt_date_hash[:priority])
     end

app/models/case_distribution_lever.rb

@@ -27,6 +27,9 @@ class CaseDistributionLever < ApplicationRecord
     #{Constants.DISTRIBUTION.ama_hearing_docket_time_goals}
     #{Constants.DISTRIBUTION.ama_hearing_start_distribution_prior_to_goals}
     #{Constants.DISTRIBUTION.ama_evidence_submission_start_distribution_prior_to_goals}
+    #{Constants.DISTRIBUTION.aoj_affinity_days}
+    #{Constants.DISTRIBUTION.aoj_aod_affinity_days}
+    #{Constants.DISTRIBUTION.aoj_cavc_affinity_days}
   ).freeze
 
   FLOAT_LEVERS = %W(
@@ -185,10 +188,20 @@ def snapshot
       snapshot_hash
     end
 
+    def clear_distribution_lever_cache
+      lever_items = CaseDistributionLever.all.map(&:item)
+
+      # Loop through each lever item and delete the corresponding cache
+      lever_items.each do |item|
+        cache_key = "#{item}_distribution_lever_cache"
+        Rails.cache.delete(cache_key)
+      end
+    end
+
     private
 
     def method_missing_value(name)
-      lever = find_by_item(name).try(:value)
+      lever = check_distribution_lever_cache(name)
       begin
         if INTEGER_LEVERS.include?(name)
           Integer(lever)
@@ -246,5 +259,11 @@ def update_radio_options(lever, options)
 
       lever["options"] = options
     end
+
+    def check_distribution_lever_cache(name)
+      Rails.cache.fetch("#{name}_distribution_lever_cache", expires_in: 2.minutes) do
+        find_by_item(name).try(:value)
+      end
+    end
   end
 end

app/models/concerns/by_docket_date_distribution.rb

@@ -60,6 +60,8 @@ def distribute_nonpriority_appeals_from_all_dockets_by_age_to_limit(limit, style
   # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
   def ama_statistics
     docket_counts = {
+      aoj_legacy_priority_stats: {},
+      aoj_legacy_stats: {},
       direct_review_priority_stats: {},
       direct_review_stats: {},
       evidence_submission_priority_stats: {},

app/models/distribution.rb

@@ -45,6 +45,8 @@ def distribute!(limit = nil)
       update!(status: "completed", completed_at: Time.zone.now, statistics: completed_statistics(ama_stats))
 
       record_distribution_stats(ama_stats)
+
+      CaseDistributionLever.clear_distribution_lever_cache
     end
   rescue StandardError => error
     process_error(error)

app/models/docket.rb

@@ -26,7 +26,7 @@ def appeals(priority: nil, genpop: nil, ready: nil, judge: nil)
     if ready
       scope = scope.ready_for_distribution
       scope = adjust_for_genpop(scope, genpop, judge) if judge.present? && !use_by_docket_date?
-      scope = adjust_for_affinity(scope, judge) if judge.present? && FeatureToggle.enabled?(:acd_exclude_from_affinity)
+      scope = adjust_for_affinity(scope, judge) if FeatureToggle.enabled?(:acd_exclude_from_affinity)
     end
 
     return scoped_for_priority(scope) if priority == true
@@ -203,8 +203,12 @@ def adjust_for_genpop(scope, genpop, judge)
     (genpop == "not_genpop") ? scope.non_genpop_for_judge(judge) : scope.genpop
   end
 
-  def adjust_for_affinity(scope, judge)
-    scope.genpop_with_case_distribution_lever.or(scope.non_genpop_with_case_distribution_lever(judge))
+  def adjust_for_affinity(scope, judge = nil)
+    if judge.present?
+      scope.genpop_with_case_distribution_lever.or(scope.non_genpop_with_case_distribution_lever(judge))
+    else
+      scope.genpop_with_case_distribution_lever
+    end
   end
 
   def scoped_for_priority(scope)

app/models/docket_coordinator.rb

@@ -6,7 +6,8 @@ def dockets
       legacy: LegacyDocket.new,
       direct_review: DirectReviewDocket.new,
       evidence_submission: EvidenceSubmissionDocket.new,
-      hearing: HearingRequestDocket.new
+      hearing: HearingRequestDocket.new,
+      aoj_legacy: AojLegacyDocket.new
     }
 
     @dockets ||= all_dockets

app/models/dockets/aoj_legacy_docket.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+class AojLegacyDocket < LegacyDocket
+  def ready_to_distribute_appeals
+    LegacyAppeal.aoj_appeal_repository.ready_to_distribute_appeals
+  end
+
+  # rubocop:disable Metrics/CyclomaticComplexity
+  def count(priority: nil, ready: nil)
+    counts_by_priority_and_readiness.inject(0) do |sum, row|
+      next sum unless (priority.nil? || (priority ? 1 : 0) == row["priority"]) &&
+                      (ready.nil? || (ready ? 1 : 0) == row["ready"])
+
+      sum + row["n"]
+    end
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+
+  def genpop_priority_count
+    LegacyAppeal.aoj_appeal_repository.genpop_priority_count
+  end
+
+  def not_genpop_priority_count
+    LegacyAppeal.aoj_appeal_repository.not_genpop_priority_count
+  end
+
+  def ready_priority_appeal_ids
+    LegacyAppeal.aoj_appeal_repository.priority_ready_appeal_vacols_ids
+  end
+
+  def oldest_priority_appeal_days_waiting
+    return 0 if age_of_oldest_priority_appeal.nil?
+
+    (Time.zone.now.to_date - age_of_oldest_priority_appeal.to_date).to_i
+  end
+
+  def age_of_oldest_priority_appeal
+    @age_of_oldest_priority_appeal ||=
+      if use_by_docket_date?
+        LegacyAppeal.aoj_appeal_repository.age_of_oldest_priority_appeal_by_docket_date
+      else
+        LegacyAppeal.aoj_appeal_repository.age_of_oldest_priority_appeal
+      end
+  end
+
+  def age_of_n_oldest_priority_appeals_available_to_judge(judge, num)
+    LegacyAppeal.aoj_appeal_repository.age_of_n_oldest_priority_appeals_available_to_judge(judge, num)
+  end
+
+  def age_of_n_oldest_nonpriority_appeals_available_to_judge(judge, num)
+    LegacyAppeal.aoj_appeal_repository.age_of_n_oldest_nonpriority_appeals_available_to_judge(judge, num)
+  end
+
+  def distribute_priority_appeals(distribution, style: "push", genpop: "any", limit: 1)
+    return [] unless should_distribute?(distribution, style: style, genpop: genpop)
+
+    LegacyAppeal.aoj_appeal_repository.distribute_priority_appeals(distribution.judge, genpop, limit).map do |record|
+      next unless existing_distribution_case_may_be_redistributed?(record["bfkey"], distribution)
+
+      dist_case = new_distributed_case(distribution, record, docket_type, genpop, true)
+      save_dist_case(dist_case)
+      dist_case
+    end.compact
+  end
+
+  # rubocop:disable Metrics/ParameterLists
+  def distribute_nonpriority_appeals(distribution,
+                                     style: "push",
+                                     genpop: "any",
+                                     range: nil,
+                                     limit: 1,
+                                     bust_backlog: false)
+    return [] unless should_distribute?(distribution, style: style, genpop: genpop)
+
+    return [] if !range.nil? && range <= 0
+
+    LegacyAppeal.aoj_appeal_repository.distribute_nonpriority_appeals(
+      distribution.judge, genpop, range, limit, bust_backlog
+    ).map do |record|
+      next unless existing_distribution_case_may_be_redistributed?(record["bfkey"], distribution)
+
+      dist_case = new_distributed_case(distribution, record, docket_type, genpop, false)
+      save_dist_case(dist_case)
+      dist_case
+    end.compact
+  end
+  # rubocop:enable Metrics/ParameterLists
+
+  def priority_appeals_affinity_date_count(in_window)
+    LegacyAppeal.aoj_appeal_repository.priority_appeals_affinity_date_count(in_window).size
+  end
+
+  def non_priority_appeals_affinity_date_count(in_window)
+    LegacyAppeal.aoj_appeal_repository.non_priority_appeals_affinity_date_count(in_window).size
+  end
+
+  private
+
+  def counts_by_priority_and_readiness
+    @counts_by_priority_and_readiness ||= LegacyAppeal.aoj_appeal_repository.docket_counts_by_priority_and_readiness
+  end
+end

app/models/dockets/legacy_docket.rb

@@ -137,10 +137,24 @@ def distribute_nonpriority_appeals(distribution,
   end
   # rubocop:enable Metrics/ParameterLists
 
+  def priority_appeals_affinity_date_count(in_window)
+    LegacyAppeal.repository.priority_appeals_affinity_date_count(in_window).size
+  end
+
+  def non_priority_appeals_affinity_date_count(_in_window)
+    "N/A for legacy appeals which are nonpriority and non-AOJ"
+  end
+
   # used for distribution_stats
-  # change parameters to in_window, priority once implemented
-  def affinity_date_count(*)
-    "not implemented"
+  # in_window refers to all cases with an appeal affinity still in their affinity window
+  # Out-of-window (in_window == false) refers to all other cases including cases that are
+  # out of their affinity window, tied_to, or genpop.
+  def affinity_date_count(in_window, priority)
+    if priority
+      priority_appeals_affinity_date_count(in_window)
+    else
+      non_priority_appeals_affinity_date_count(in_window)
+    end
   end
 
   private

app/models/legacy_appeal.rb

@@ -1119,6 +1119,10 @@ def repository
       AppealRepository
     end
 
+    def aoj_appeal_repository
+      AojAppealRepository
+    end
+
     # Wraps the closure of appeals in a transaction
     # add additional code inside the transaction by passing a block
     def close(appeal: nil, appeals: nil, user:, closed_on:, disposition:)