OSB-36: Make the errors unique

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

@@ -953,10 +953,10 @@ class ControllerStationComponentElementErrors(ValidableReadOnlyView):
                                        end_datetime__lt=self.to_date,
                                        station__name=self.station_name).\
             exclude(errors_summary__rcu__in=list(rcus_per_polarization.keys())).\
-            order_by('-start_datetime').values('pk',
-                                                'observation_id',
-                                                'start_datetime',
-                                                'end_datetime')
+            values('pk',
+                    'observation_id',
+                    'start_datetime',
+                    'end_datetime').distinct('pk')
         result = []
         for observation in good_observation_list:
             entry = dict(test_id=observation['observation_id'],
@@ -1020,29 +1020,27 @@ class ControllerStationComponentElementErrors(ValidableReadOnlyView):
                                                        component_errors=dict())
             rcu = item['rcu']
             polarization = rcus_per_polarization[rcu]
-            if polarization not in errors[observation_pk]:
-                errors[observation_pk]['component_errors'][polarization] = dict(
-                    rcu=rcu,
-                    errors = dict()
-                )
+
             error_type = item['error_type']
             percentage = item['percentage']
             count = item['count']
             mode = item['mode']
             samples = item['observation__samples']
 
+            if error_type not in errors[observation_pk]['component_errors']:
+                errors[observation_pk]['component_errors'][error_type] = dict()
+
             url_to_plot = reverse('rtsm-summary-plot-detail', (item['pk'],), request=self.request)
-            errors[observation_pk]['component_errors'][polarization]['errors'][error_type] = dict(samples=samples,
+            errors[observation_pk]['component_errors'][error_type][polarization] = dict(samples=samples,
                                                                               percentage=percentage,
                                                                               count=count,
                                                                               mode=mode,
+                                                                              rcu=rcu,
                                                                               url=url_to_plot)
         return list(errors.values())
 
     def compute_station_tests_error_list(self):
         errors = dict()
-        rcus_per_polarization = self.rcus_from_antenna_and_type(self.antenna_id,
-                                                                self.component_type)
         component_errors = ComponentError.objects.filter(
             station_test__start_datetime__gt=self.from_date,
             station_test__end_datetime__lt=self.to_date,
@@ -1058,20 +1056,15 @@ class ControllerStationComponentElementErrors(ValidableReadOnlyView):
                                                end_date=component_error.station_test.end_datetime,
                                                test_type='S',
                                                component_errors=dict())
-                for rcu_id, polarization in rcus_per_polarization.items():
-                    if polarization not in errors[station_test_pk]:
-                        errors[station_test_pk]['component_errors'][polarization] = dict(
-                            rcu=rcu_id,
-                            errors=dict())
-                    error_type = component_error.type
-                    details = component_error.details
-                    errors_per_error_polarization = errors[station_test_pk]['component_errors'][polarization]['errors']
-                    errors_per_error_polarization[error_type] = dict(details=details, element_errors=dict())
+            error_type = component_error.type
+            details = component_error.details
+            errors[station_test_pk]['component_errors'][error_type] = dict(details=details, element_errors = dict())
 
+            error_per_error_type = errors[station_test_pk]['component_errors'][error_type]
 
-                    for element in component_error.failing_elements.values('element__element_id', 'details'):
-                        element_id = element['element__element_id']
-                        errors_per_error_polarization[error_type]['element_errors'][element_id] = element['details']
+            for element in component_error.failing_elements.values('element__element_id', 'details'):
+                element_id = element['element__element_id']
+                error_per_error_type["element_errors"][element_id] = element['details']
 
         return list(errors.values())