Merge branch 'feature/icat-limit-skip-filters-#139' into feature/icat…

…-distinct-filter-#141

common/filter_order_handler.py

@@ -25,6 +25,7 @@ def sort_filters(self):
     def apply_filters(self, query):
         """
         Given a query apply the filters the handler has in the correct order.
+
         :param query: The query to have filters applied to
         """
         self.sort_filters()

common/icat/filters.py

@@ -99,22 +99,24 @@ def apply_filter(self, query):
 
 
 class PythonICATOrderFilter(OrderFilter):
+    # Used to append the order tuples across all filters in a single request
+    result_order = []
+
     def __init__(self, field, direction):
         # Python ICAT doesn't automatically uppercase the direction, errors otherwise
         super().__init__(field, direction.upper())
 
     def apply_filter(self, query):
-        result_order = [(self.field, self.direction)]
-        log.debug("Result Order: %s", result_order)
+        PythonICATOrderFilter.result_order.append((self.field, self.direction))
+        log.debug("Result Order: %s", PythonICATOrderFilter.result_order)
 
         try:
             log.info("Adding order filter")
             query.setOrder(PythonICATOrderFilter.result_order)
-        except ValueError:
-            raise FilterError(
-                "Order Filter Error: Either an invalid attribute(s) or attribute(s)"
-                " contains 1-many relationship"
-            )
+        except ValueError as e:
+            # Typically either invalid attribute(s) or attribute(s) contains 1-many
+            # relationship
+            raise FilterError(e)
 
 
 class PythonICATSkipFilter(SkipFilter):

common/icat/helpers.py

@@ -16,6 +16,7 @@
     PythonICATLimitFilter,
     PythonICATWhereFilter,
     PythonICATSkipFilter,
+    PythonICATOrderFilter,
 )
 
 
@@ -411,12 +412,26 @@ def update_entity_by_id(client, table_name, id_, new_data):
 
 
 def get_entity_with_filters(client, table_name, filters):
+    """
+    Gets all the records of a given entity, based on the filters provided in the request
+
+    :param client: ICAT client containing an authenticated user
+    :type client: :class:`icat.client.Client`
+    :param table_name: Table name to extract which entity to use
+    :type table_name: :class:`str`
+    :param filters: The list of filters to be applied to the request
+    :type filters: List of specific implementations :class:`QueryFilter`
+    :return: The list of records of the given entity, using the filters to restrict the
+        result of the query
+    """
+
     selected_entity_name = get_python_icat_entity_name(client, table_name)
     query = icat_query(client, selected_entity_name)
 
     filter_handler = FilterOrderHandler()
     filter_handler.add_filters(filters)
     merge_limit_skip_filters(filter_handler)
+    clear_order_filters(filter_handler.filters)
     filter_handler.apply_filters(query.query)
 
     data = query.execute_query(client, True)
@@ -456,3 +471,19 @@ def merge_limit_skip_filters(filter_handler):
             log.info("Removing skip filter from list of filters")
             filter_handler.remove_filter(skip_filter)
             log.debug("Filters: %s", filter_handler.filters)
+
+
+def clear_order_filters(filters):
+    """
+    Checks if any order filters have been added to the request and resets the variable
+    used to manage which attribute(s) to use for sorting results.
+    
+    A reset is required because Python ICAT overwrites (as opposed to appending to it)
+    the query's order list every time one is added to the query.
+
+    :param filters: The list of filters to be applied to the request
+    :type filters: List of specific implementations :class:`QueryFilter`
+    """
+
+    if any(isinstance(filter, PythonICATOrderFilter) for filter in filters):
+        PythonICATOrderFilter.result_order = []