fix for pagination UI

Author: IdirLISN

src/apps/api/pagination.py

@@ -27,7 +27,7 @@ def get_paginated_response(self, data):
 class DynamicChoicePagination(PageNumberPagination):
     """
     Dynamic pagination :
-    - défaut : 50 objects.
+    - default : 50 objects.
     - predetermined values : 50, 100, 500, all
     - if page_size=all => fetch all objects, capped by lax_page_size
     """
@@ -43,37 +43,33 @@ def get_page_size(self, request):
 
         raw_lower = str(raw).lower()
         if raw_lower == 'all':
-            return None
+            return self.max_page_size
 
         try:
             val = int(raw)
         except (TypeError, ValueError):
             return self.page_size
-
+    
         if val in (50, 100, 500):
-            return val
+            return min(val, self.max_page_size)
         return self.page_size
 
     def paginate_queryset(self, queryset, request, view=None):
         raw = request.query_params.get(self.page_size_query_param)
-        self.requested_page_size = raw if raw is not None else str(self.page_size)
+        self.requested_page_size = str(raw).lower() if raw is not None else str(self.page_size)
 
-        if raw is not None and str(raw).lower() == 'all':
-            try:
-                total = queryset.count()
-            except Exception:
-                total = self.max_page_size
-            self.page_size = total if (isinstance(total, int) and total > 0) else 1
+        page_size = self.get_page_size(request)
+        if isinstance(page_size, int) and page_size > 0:
+            self.page_size = min(page_size, self.max_page_size)
         else:
-            page_size = self.get_page_size(request)
-            if page_size is None:
-                page_size = self.page_size
-            self.page_size = page_size
+            self.page_size = self.page_size
 
         return super().paginate_queryset(queryset, request, view)
 
     def get_paginated_response(self, data):
-        page_size_value = self.requested_page_size if getattr(self, 'requested_page_size', None) is not None else self.page_size
+        page_size_value = getattr(self, 'requested_page_size', None)
+        if page_size_value is None:
+            page_size_value = self.page_size
 
         return Response({
             'next': self.get_next_link(),

src/static/riot/competitions/detail/submission_manager.tag

@@ -323,7 +323,11 @@
             }
 
             filters.page = self.page
-            filters.page_size = self.page_size
+            if (String(self.page_size).toLowerCase() === 'all') {
+                filters.page_size = 'all'
+            } else {
+                filters.page_size = self.page_size
+            }
 
             CODALAB.api.get_submissions(filters)
                 .done(function (response) {
@@ -334,21 +338,60 @@
                         self.next = response.next || null
                         self.previous = response.previous || null
                         self.total_count = response.count || 0
+
+                        var effectivePageSize = 1
+                        var serverPageSize = undefined
+                        var totalCount = (typeof response.count === 'number') ? response.count : self.total_count
+                        var isLastPage = (response.next === null)
+
                         if (response && typeof response.page_size !== 'undefined') {
-                            const rsp = String(response.page_size).toLowerCase()
-                            if (rsp === 'all') {
+                            serverPageSize = response.page_size
+                        }
+
+                        if (typeof serverPageSize !== 'undefined') {
+                            if (String(serverPageSize).toLowerCase() === 'all') {
                                 self.page_size = 'all'
                             } else {
-                                const n = Number(response.page_size)
-                                self.page_size = isNaN(n) ? self.page_size : n
+                                var parsedServerPS = Number(serverPageSize)
+                                if (!isNaN(parsedServerPS) && parsedServerPS > 0) {
+                                    self.page_size = parsedServerPS
+                                }
                             }
                         }
 
                         if (String(self.page_size).toLowerCase() === 'all') {
+                            if (typeof response.page_size_numeric === 'number' && response.page_size_numeric > 0) {
+                                effectivePageSize = response.page_size_numeric
+                            } else if (typeof response.effective_page_size === 'number' && response.effective_page_size > 0) {
+                                effectivePageSize = response.effective_page_size
+                            } else {
+                                if (!isLastPage && Array.isArray(results) && results.length > 0) {
+                                    effectivePageSize = results.length
+                                } else if (isLastPage && self.page > 1 && typeof totalCount === 'number' && totalCount > 0) {
+                                    var itemsOnLastPage = Array.isArray(results) ? results.length : 0
+                                    var pagesBefore = self.page - 1
+                                    var calc = Math.floor((totalCount - itemsOnLastPage) / pagesBefore)
+                                    if (calc > 0) {
+                                        effectivePageSize = calc
+                                    } else {
+                                        effectivePageSize = 50
+                                    }
+                                } else if (Array.isArray(results) && results.length > 0) {
+                                    effectivePageSize = results.length
+                                } else {
+                                    effectivePageSize = 50
+                                }
+                            }
+                        } else if (typeof self.page_size === 'number' && self.page_size > 0) {
+                            effectivePageSize = self.page_size
+                        } else {
+                            effectivePageSize = 50
+                        }
+
+                        if (typeof totalCount !== 'number' || totalCount < 0) {
                             self.total_pages = 1
                         } else {
-                            const ps = Number(self.page_size) || 1
-                            self.total_pages = Math.max(1, Math.ceil(self.total_count / ps))
+                            self.total_pages = Math.max(1, Math.ceil(totalCount / effectivePageSize))
                         }
                     } else {
                         results = response || []
@@ -640,16 +683,11 @@
             // Set checkboxes to be equal to Select_All checkbox
             check_boxes.prop('checked', check_boxes.first().is(':checked'))
 
-
             let inputs = $(self.refs.submission_table).find('input')
             let checked_boxes = inputs.not(':first').filter('input:checked')
             self.checked_submissions = checked_boxes.serializeArray().map((x) => { return x.name })
         }
 
-
-
-
-
         self.submission_clicked = function (submission) {
             // stupid workaround to not modify the original submission object
             submission = _.defaultsDeep({}, submission)