Story OSB-11: major fixes

LCU/Maintenance/DBInterface/monitoringdb/pagination.py

 from rest_framework.pagination import PageNumberPagination
 
+from rest_framework.response import Response
 
 class DefaultPaginationSettings(PageNumberPagination):
     page_size = 10
     page_size_query_param = 'page_size'
     max_page_size = 100
+
+    def get_paginated_response(self, data):
+        return Response({
+            'links': {
+               'next': self.get_next_link(),
+               'previous': self.get_previous_link()
+            },
+            'count': self.page.paginator.count,
+            'total_pages': self.page.paginator.num_pages,
+            'results': data
+        })
\ No newline at end of file

LCU/Maintenance/DBInterface/monitoringdb/station_test_raw_parser.py

@@ -156,6 +156,7 @@ def collect_error_details(content):
             error_name = error_name.lower()
             error_details[error_name] = error_value
     error_details.update(element_errors=element_errors)
+
     return error_details
 
 
@@ -292,7 +293,6 @@ def dicts_from_element_error(contents):
     results = defaultdict(dict)
     key_pattern = "([^xy0-9]{0,3})([x,y]{0,1})([0-9]{1,3})"
     component_type, component_id, error_type = contents[1:4]
-
     for tile_error in contents[4:]:
         key, args = tile_error.popitem()
 
@@ -302,26 +302,25 @@ def dicts_from_element_error(contents):
                          component_id=int(component_id))
         component_error = dict(component=component,
                                type=component_error_type)
-        element = dict(element_id=element_id)
+        element = dict(element_id=int(element_id))
         element_error = dict(component_error=component_error,
                              element=element,
                              type=component_error_type)
-
         element_error_details = dict()
-        if element_error_type in ['HN', 'LN']:
+        if element_error_type in ['hn', 'ln']:
             value, diff = map(float, args.strip().split(' '))
             element_error_details[polarization+'val'] = value
             element_error_details[polarization+'diff'] = diff
-
-        elif 'J' in error_type:
+        elif 'j' in element_error_type:
             element_error_details[polarization+'diff'] = float(args.strip())
-        elif error_type == '':
+        elif element_error_type == '':
             element_error_details.update(parse_rffail_string(polarization, args))
-
+        elif element_error_type in ['o', 'sp']:
+            element_error_details[polarization] = True
         element_error['details'] = element_error_details
-        element_error_key = (component_id, element_id, error_type)
+        element_error_key = (component_id, element_id, element_error_type)
         if element_error_key in results:
             results[element_error_key]['details'].update(element_error_details)
         else:
-            results[element_error_key] = element_error
-    return results.values()
+            results[element_error_key] = dict(element_error)
+    return list(results.values())

LCU/Maintenance/DBInterface/monitoringdb/views/station_test_views.py

@@ -55,16 +55,14 @@ class ComponentErrorFilterSet(filters.FilterSet):
 class ElementErrorFilterSet(filters.FilterSet):
     component_id = filters.NumberFilter(field_name='component_error__component', lookup_expr='component_id')
     element_id = filters.NumberFilter(field_name='element', lookup_expr='element_id')
-
-    station_test_id = filters.CharFilter(field_name='station_test__id',
-                                      lookup_expr='eq')
-    station_name = filters.CharFilter(field_name='station_test__station',
-                                      lookup_expr='name__contains')
-    station_type = filters.CharFilter(field_name='station_test__station',
+    station_name = filters.CharFilter(field_name='component_error__station_test__station',
                                       lookup_expr='name__contains')
+    station_type = filters.CharFilter(field_name='component_error__station_test__station',
+                                      lookup_expr='type__contains')
+
+    from_date = filters.DateFilter(field_name='component_error__station_test', lookup_expr='start_datetime__gt')
+    to_date = filters.DateFilter(field_name='component_error__station_test', lookup_expr='end_datetime__lt')
 
-    from_date = filters.DateFilter(field_name='station_test', lookup_expr='start_datetime__gt')
-    to_date = filters.DateFilter(field_name='station_test', lookup_expr='end_datetime__lt')
     type = filters.CharFilter(field_name='type',
                               lookup_expr='contains')
 
@@ -74,7 +72,7 @@ class ComponentErrorViewSet(ReadOnlyModelViewSet):
     queryset = ComponentError.objects.all().order_by('-station_test__start_datetime',
                                                      'type',
                                                      'component__component_id',
-                                                     'station__name')
+                                                     'component__station__name')
     filter_fields = '__all__'
     filterset_class = ComponentErrorFilterSet
 
@@ -100,11 +98,12 @@ class ErrorDetailsViewSet(ReadOnlyModelViewSet):
 
 class ElementErrorViewSet(ReadOnlyModelViewSet):
     serializer_class = ElementErrorSerializer
-    queryset = ElementError.objects.all().order_by('-station_test__start_datetime',
-                                                   'type',
-                                                   'component__component_id',
-                                                   'station__name')
+    queryset = ElementError.objects.all().order_by('-component_error__station_test__start_datetime',
+                                                   'component_error__station_test__station__name',
+                                                   'component_error__component__component_id',
+                                                   'element__element_id')
     filter_fields = '__all__'
+    filterset_class = ElementErrorFilterSet
 
 
 class ElementViewSet(ReadOnlyModelViewSet):
@@ -186,7 +185,6 @@ def insert_element_error(station_test_entry,
 
     element_error_entry = ElementError.objects.filter(element=element_entry,
                                                       component_error=component_error_entry,
-                                                      station_test=station_test_entry,
                                                       **element_error).first()
     if element_error_entry is None:
         element_error_details_entry = ErrorDetails(**element_error_details)
@@ -196,7 +194,6 @@ def insert_element_error(station_test_entry,
         element_error_entry = ElementError(element=element_entry,
                                            details=element_error_details_entry,
                                            component_error=component_error_entry,
-                                           station_test=station_test_entry,
                                            **element_error)
 
         element_error_entry.save()
@@ -217,7 +214,6 @@ def insert_station_test(station_test):
     station = station_test.pop('station')
     component_errors = station_test.pop('component_errors')
     element_errors = station_test.pop('element_errors')
-
     station_entry = Station.objects.filter(**station).first()
 
     if station_entry is None: