Added skeleton application stats into results view

Author: wes-otf

hypha/apply/funds/models/submissions.py

@@ -1130,6 +1130,8 @@ class ApplicationSubmissionSkeleton(models.Model):
         on_delete=models.PROTECT,
     )
 
+    objects = ApplicationSubmissionSkeletonQueryset.as_manager()
+
     @classmethod
     def from_dict(
         cls, dict_submission: Dict[str, Any], save_user: bool = False

hypha/apply/funds/tables.py

@@ -16,6 +16,7 @@
 
 from hypha.apply.categories.blocks import CategoryQuestionBlock
 from hypha.apply.categories.models import MetaTerm, Option
+from hypha.apply.funds.models.submissions import ApplicationSubmissionSkeleton
 from hypha.apply.funds.reviewers.services import get_all_reviewers
 from hypha.apply.review.models import Review
 from hypha.core.tables import RelativeTimeColumn
@@ -192,24 +193,33 @@ def render_screening_status(self, value):
 
 
 def get_used_rounds(request):
-    return Round.objects.filter(submissions__isnull=False).distinct()
+    return Round.objects.filter(
+        Q(Q(submissions__isnull=False) | Q(skeleton_submissions__isnull=False))
+    ).distinct()
 
 
 def get_used_funds(request):
     # Use page to pick up on both Labs and Funds
-    return Page.objects.filter(applicationsubmission__isnull=False).distinct()
+    return Page.objects.filter(
+        Q(
+            Q(applicationsubmission__isnull=False)
+            | Q(applicationsubmissionskeleton__isnull=False)
+        )
+    ).distinct()
 
 
 def get_round_leads(request):
     return User.objects.filter(submission_lead__isnull=False).distinct()
 
 
 def get_screening_statuses(request):
-    return ScreeningStatus.objects.filter(
+    sub_filter = Q(
         id__in=ApplicationSubmission.objects.all()
         .values("screening_statuses__id")
         .distinct("screening_statuses__id")
     )
+    skele_filter = Q(skeleton_submissions__isnull=False)
+    return ScreeningStatus.objects.filter(sub_filter | skele_filter)
 
 
 def get_meta_terms(request):
@@ -355,6 +365,37 @@ def filter_archived(self, queryset, name, value):
         return queryset
 
 
+class SubmissionSkeletonFilter(filters.FilterSet):
+    fund = ModelMultipleChoiceFilter(
+        field_name="page", queryset=get_used_funds, label=_("Funds")
+    )
+    round = ModelMultipleChoiceFilter(queryset=get_used_rounds, label=_("Rounds"))
+    screening_statuses = ModelMultipleChoiceFilter(
+        queryset=get_screening_statuses, label=_("Screening"), null_label=_("No Status")
+    )
+
+    class Meta:
+        model = ApplicationSubmissionSkeleton
+        fields = ("fund", "round")
+
+    def __init__(self, *args, exclude=None, limit_statuses=None, **kwargs):
+        if exclude is None:
+            exclude = []
+
+        super().__init__(*args, **kwargs)
+
+        self.filters["status"] = StatusMultipleChoiceFilter(limit_to=limit_statuses)
+        # self.filters["category_options"].extra["choices"] = [
+        #     (option.id, option.value)
+        #     for option in Option.objects.filter(category__filter_on_dashboard=True)
+        # ]
+        self.filters = {
+            field: filter
+            for field, filter in self.filters.items()
+            if field not in exclude
+        }
+
+
 class SubmissionDashboardFilter(filters.FilterSet):
     round = ModelMultipleChoiceFilter(queryset=get_used_rounds, label=_("Rounds"))
     fund = ModelMultipleChoiceFilter(

hypha/apply/funds/views/results.py

@@ -4,9 +4,10 @@
 from django.views.decorators.cache import cache_page
 from django_filters.views import FilterView
 
+from hypha.apply.funds.models.submissions import ApplicationSubmissionSkeleton
 from hypha.apply.users.decorators import staff_required
 
-from ..tables import SubmissionFilterAndSearch
+from ..tables import SubmissionFilterAndSearch, SubmissionSkeletonFilter
 
 User = get_user_model()
 
@@ -34,28 +35,40 @@ def get_queryset(self):
         return self.filterset_class._meta.model.objects.current().exclude_draft()
 
     def get_context_data(self, **kwargs):
-        search_term = self.request.GET.get("query")
+        count_values = 0
+        total_value = 0
+        averages_sum = 0
+        submission_count = 0
 
-        if self.object_list.exists():
-            submission_count = self.object_list.count()
-            submission_values = self.object_list.value()
-            count_values = submission_values.get("value__count")
+        qs_list = [self.object_list]
+
+        # If a filter comes up that is not applicable to skeleton applications, remove them the results (ie. "lead")
+        non_skeleton_fields = set(SubmissionFilterAndSearch.declared_filters) - set(
+            SubmissionSkeletonFilter.declared_filters
+        )
+        if not set(self.request.GET) & set(non_skeleton_fields):
+            skeleton_qs = SubmissionSkeletonFilter(
+                self.request.GET, queryset=ApplicationSubmissionSkeleton.objects.all()
+            ).qs
+            qs_list.append(skeleton_qs)
+
+        populated_qs_list = [qs for qs in qs_list if qs.exists()]
+
+        for qs in populated_qs_list:
+            submission_count += qs.count()
+            submission_values = qs.value()
+            count_values += submission_values.get("value__count")
             if total := submission_values.get("value__sum"):
-                total_value = total
-            else:
-                total_value = 0
+                total_value += total
             if average := submission_values.get("value__avg"):
-                average_value = round(average)
-            else:
-                average_value = 0
+                averages_sum += round(average)
+
+        if qs_list_len := len(populated_qs_list):
+            average_value = averages_sum / qs_list_len
         else:
-            count_values = 0
-            total_value = 0
             average_value = 0
-            submission_count = 0
 
         return super().get_context_data(
-            search_term=search_term,
             filter_action=self.filter_action,
             count_values=count_values,
             total_value=total_value,