controllers.py

import datetime
import logging
from collections import OrderedDict
from math import ceil
from django.conf import settings
import coreapi
import coreschema
from django.db.models import Count
from lofar.maintenance.monitoringdb.models.component_error import ComponentError
from lofar.maintenance.monitoringdb.models.rtsm import RTSMErrorSummary, MODE_TO_COMPONENT
from lofar.maintenance.monitoringdb.models.rtsm import RTSMObservation
from lofar.maintenance.monitoringdb.models.station import Station
from lofar.maintenance.monitoringdb.models.station_test import StationTest
from rest_framework import status
from rest_framework.response import Response
from rest_framework.schemas import ManualSchema
from rest_framework.views import APIView
import pytz

logger = logging.getLogger(__name__)


def parse_date(date):
    expected_format = '%Y-%m-%d'
    try:
        parsed_date = datetime.datetime.strptime(date, expected_format)
        return pytz.utc.localize(parsed_date)
    except Exception as e:
        raise ValueError('cannot parse %s with format %s - %s' % (date, expected_format, e))


def parse_bool(boolean_value_str):
    boolean_value_str = boolean_value_str.lower()
    if boolean_value_str in ['t', 'true', '1']:
        return True
    elif boolean_value_str in ['f', 'false', '0']:
        return False
    else:
        raise ValueError('%s is neither true or false' % boolean_value_str)


def parse_array(array_str):
    parsed_array = list(array_str.strip().lstrip('[').rstrip(']').split(','))
    if len(parsed_array) == 1 and parsed_array[0] == '':
        return []
    else:
        return parsed_array


def _get_unique_error_types():
    """
    List the unique error types found in the database
    :return: the list containing the unique error types
    :rtype: list
    """
    return [item['type'] for item in ComponentError.objects.values('type').distinct()]


class ValidableReadOnlyView(APIView):
    """
    Convenience APIView class to have the validation of the query parameters on a get http request
    """

    # Override this to make the schema validation work
    fields = []
    description = ''
    def compute_response(self):
        raise NotImplementedError()

    @property
    def schema(self):
        return ManualSchema(fields=self.fields, description=self.description)

    def validate_query_parameters(self, request):
        """
        Validated the request parameters and stores them as fields
        :param request: the http request to the api call
        :type request: rest_framework.request.Request
        :raises ValueError: if the parameter is not valid
        :raises KeyError: if the requested parameter is missing
        """
        for field in self.fields:
            if field.required and field.name not in request.query_params:
                raise KeyError('%s parameter is missing' % field.name)
            elif field.name not in request.query_params:
                continue
            else:
                value = self.request.query_params.get(field.name)
                if field.type:
                    self.__setattr__(field.name, field.type(value))
                else:
                    self.__setattr__(field.name, value)
                errors = field.schema.validate(self.__getattribute__(field.name))
                for error in errors:
                    raise ValueError(error.text)

    def get(self, request):
        try:
            self.validate_query_parameters(request)
        except ValueError as e:
            return Response(status=status.HTTP_406_NOT_ACCEPTABLE,
                            data='Please specify the correct parameters: %s' % (e,))
        except KeyError as e:
            return Response(status=status.HTTP_406_NOT_ACCEPTABLE,
                            data='Please specify all the required parameters: %s' % (e,))

        try:
            response = self.compute_response()

        except ValueError as e:
            return Response(status=status.HTTP_406_NOT_ACCEPTABLE,
                            data='Please specify the correct parameters: %s' % (e,))
        except Exception as e:
            logger.exception(e)
            return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR,
                            data='exception occurred: %s' % e)
        return response


class ControllerStationOverview(ValidableReadOnlyView):
    description = "Overview of the latest tests performed on the stations"

    station_group = 'A'
    errors_only = 'true'
    n_station_tests = 4
    n_rtsm = 4
    error_types = []

    fields = [
        coreapi.Field(
            "station_group",
            required=False,
            location='query',
            schema=coreschema.Enum(['C', 'R', 'I', 'A'], description=
            'Station group to select for choices are [C|R|I|ALL]',
                                   )
        ),
        coreapi.Field(
            "n_station_tests",
            required=False,
            location='query',
            type=int,
            schema=coreschema.Integer(description='number of station tests to select',
                                      minimum=1)
        ),
        coreapi.Field(
            "n_rtsm",
            required=False,
            location='query',
            type=int,
            schema=coreschema.Integer(description='number of station tests to select',
                                      minimum=1)
        ),
        coreapi.Field(
            "errors_only",
            required=False,
            location='query',
            type=parse_bool,
            schema=coreschema.Boolean(
                description='displays or not only the station with more than one error')
        ),
        coreapi.Field(
            "error_types",
            required=False,
            location='query',
            type=parse_array,
            schema=coreschema.Array(description='select the error types to filter for',
                                    items=coreschema.Enum(_get_unique_error_types()),
                                    unique_items=True)
        )
    ]

    def compute_response(self):
        station_entities = Station.objects.all()
        for group in self.station_group:
            if group is not 'A':
                station_entities = station_entities.filter(type=group)

        # Since django preferes a ordered dict over a dict we make it happy... for now
        response_payload = list()
        for station_entity in station_entities:
            station_payload = OrderedDict()

            station_payload['station_name'] = station_entity.name

            station_test_list = StationTest.objects.filter(
                station__name=station_entity.name).order_by('-end_datetime')[:self.n_station_tests]
            rtsm_list = RTSMObservation.objects.filter(
                station__name=station_entity.name).order_by('-end_datetime')[:self.n_rtsm]

            station_payload['station_tests'] = list()
            for station_test in station_test_list:
                station_test_payload = OrderedDict()
                component_errors = station_test.component_errors
                selected_component_errors = component_errors
                if(self.error_types):
                    selected_component_errors = component_errors.filter(type__in=self.error_types)
                station_test_payload[
                    'total_component_errors'] = selected_component_errors.count()
                station_test_payload['start_datetime'] = station_test.start_datetime
                station_test_payload['end_datetime'] = station_test.end_datetime
                station_test_payload['checks'] = station_test.checks

                component_errors_summary = selected_component_errors. \
                    values('component__type', 'type').annotate(
                    total=Count('type')).order_by('-total')
                component_errors_summary_dict = OrderedDict()
                for item in component_errors_summary:
                    item_component_type = item['component__type']
                    item_error_type = item['type']
                    item_error_total = item['total']

                    if item_component_type not in component_errors_summary_dict:
                        component_errors_summary_dict[item_component_type] = OrderedDict()

                    component_errors_summary_dict[item_component_type][item_error_type] = \
                        item_error_total
                station_test_payload['component_error_summary'] = component_errors_summary_dict

                station_payload['station_tests'].append(station_test_payload)

            station_payload['rtsm'] = list()
            for rtsm in rtsm_list:
                rtsm_payload = OrderedDict()
                rtsm_payload['observation_id'] = rtsm.observation_id
                rtsm_payload['start_datetime'] = rtsm.start_datetime
                rtsm_payload['end_datetime'] = rtsm.end_datetime

                unique_modes = [item['mode'] for item in
                                rtsm.errors_summary.values('mode').distinct()]
                rtsm_payload['mode'] = unique_modes

                selected_rtsm_errors = rtsm.errors_summary
                if(self.error_types):
                    selected_rtsm_errors = rtsm.errors_summary.filter(error_type__in=self.error_types)

                rtsm_payload['total_component_errors'] = selected_rtsm_errors.count()

                errors_summary = OrderedDict()

                errors_summary_query = selected_rtsm_errors.values('error_type').annotate(
                    total=Count('error_type'))

                for error_summary in errors_summary_query:
                    errors_summary[error_summary['error_type']] = error_summary['total']

                rtsm_payload['error_summary'] = errors_summary
                station_payload['rtsm'].append(rtsm_payload)

            response_payload.append(station_payload)
        if self.errors_only:
            response_payload = filter(
                lambda station_entry:
                len(station_entry['station_tests']) + len(station_entry['rtsm']) > 0,
                response_payload)
        response_payload = sorted(response_payload, key=lambda item: item['station_name'])
        return Response(status=status.HTTP_200_OK, data=response_payload)


class ControllerStationTestsSummary(ValidableReadOnlyView):
    description = "Overview of the latest station tests performed on" \
                  " the stations a [loopback_time] days ago from now"
    station_group = 'A'
    errors_only = 'true'
    lookback_time = 7
    error_types = []

    fields = [
        coreapi.Field(
            "station_group",
            required=False,
            location='query',
            schema=coreschema.Enum(['C', 'R', 'I', 'A'],
                                   description='Station group to select for choices are [C|R|I|ALL]')
        ),
        coreapi.Field(
            "errors_only",
            required=False,
            location='query',
            type=parse_bool,
            schema=coreschema.Boolean(
                description='displays or not only the station with more than one error')
        ),
        coreapi.Field(
            "lookback_time",
            required=False,
            type=int,
            location='query',
            schema=coreschema.Integer(description='number of days from now (default 7)',
                                      minimum=1)
        ),
        coreapi.Field(
            "error_types",
            required=False,
            location='query',
            type=parse_array,
            schema=coreschema.Array(description='select the error types to filter for',
                                    items=coreschema.Enum(_get_unique_error_types()),
                                    unique_items=True)
        )
    ]

    def compute_response(self):
        self.lookback_time = datetime.timedelta(days=self.lookback_time)

        station_test_list = StationTest.objects \
            .filter(start_datetime__gte=datetime.date.today() - self.lookback_time) \
            .order_by('-start_datetime', 'station__name')
        for group in self.station_group:
            if group is not 'A':
                station_test_list = station_test_list.filter(station__type=group)

        # Since django preferes a ordered dict over a dict we make it happy... for now
        response_payload = list()

        for station_test in station_test_list:

            station_test_payload = OrderedDict()
            station_test_payload['station_name'] = station_test.station.name
            selected_component_errors = station_test.component_errors
            if(self.error_types):
                selected_component_errors = selected_component_errors.filter(type__in=self.error_types)


            station_test_payload[
                'total_component_errors'] = selected_component_errors.count()
            station_test_payload['date'] = station_test.start_datetime.strftime('%Y-%m-%d')
            station_test_payload['start_datetime'] = station_test.start_datetime
            station_test_payload['end_datetime'] = station_test.end_datetime
            station_test_payload['checks'] = station_test.checks
            component_errors_summary = selected_component_errors. \
                values('component__type', 'type').annotate(
                total=Count('type')).order_by('-total')
            component_errors_summary_dict = OrderedDict()
            for item in component_errors_summary:
                item_component_type = item['component__type']
                item_error_type = item['type']
                item_error_total = item['total']

                if item_component_type not in component_errors_summary_dict:
                    component_errors_summary_dict[item_component_type] = OrderedDict()

                component_errors_summary_dict[item_component_type][item_error_type] = \
                    item_error_total
            station_test_payload['component_error_summary'] = component_errors_summary_dict

            response_payload.append(station_test_payload)

        if self.errors_only:
            response_payload = filter(
                lambda station_test_entry:
                station_test_entry['total_component_errors'] > 0,
                response_payload)

        return Response(status=status.HTTP_200_OK, data=response_payload)


class ControllerLatestObservations(ValidableReadOnlyView):
    description = "Overview of the latest observations performed on the stations"

    station_group = 'A'
    errors_only = 'true'
    error_types = []

    fields = [
        coreapi.Field(
            "station_group",
            required=False,
            location='query',
            schema=coreschema.Enum(['C', 'R', 'I', 'A'], description=
            'Station group to select for choices are [C|R|I|A]',
                                   )
        ),
        coreapi.Field(
            "errors_only",
            required=False,
            location='query',
            type=parse_bool,
            schema=coreschema.Boolean(
                description='displays or not only the station with more than one error')
        ),
        coreapi.Field(
            "from_date",
            required=True,
            location='query',
            schema=coreschema.String(
                description='select rtsm from date (ex. YYYY-MM-DD)')
        ),
        coreapi.Field(
            "error_types",
            required=False,
            location='query',
            type=parse_array,
            schema=coreschema.Array(description='select the error types to filter for',
                                    items=coreschema.Enum(_get_unique_error_types()),
                                    unique_items=True)
        )
    ]

    def compute_response(self):
        self.from_date = parse_date(self.from_date)

        filtered_entities = RTSMObservation.objects \
            .filter(start_datetime__gte=self.from_date)
        if self.station_group != 'A':
            filtered_entities = filtered_entities \
                .filter(station__type=self.station_group)
        if self.errors_only:
            filtered_entities = filtered_entities.exclude(errors_summary__isnull=True)

        errors_summary = filtered_entities \
            .values('observation_id',
                    'station__name',
                    'start_datetime',
                    'end_datetime',
                    'errors_summary__error_type',
                    'errors_summary__mode') \
            .annotate(total=Count('errors_summary__error_type')) \
            .order_by('observation_id', 'station__name')

        if self.error_types:
            errors_summary = errors_summary.filter(errors_summary__error_type__in=self.error_types)
        response = dict()

        for error_summary in errors_summary:
            observation_id = error_summary['observation_id']
            station_name = error_summary['station__name']
            start_datetime = error_summary['start_datetime']
            end_datetime = error_summary['end_datetime']
            mode = error_summary['errors_summary__mode']
            error_type = error_summary['errors_summary__error_type']
            total = error_summary['total']

            if observation_id not in response:
                response[observation_id] = OrderedDict()
                response[observation_id]['observation_id'] = observation_id
                response[observation_id]['start_datetime'] = start_datetime
                response[observation_id]['end_datetime'] = end_datetime

                response[observation_id]['total_component_errors'] = 0
                response[observation_id]['mode'] = list()
                response[observation_id]['station_involved'] = dict()

            if total == 0:
                continue

            response[observation_id]['total_component_errors'] += total
            station_involved_summary = response[observation_id]['station_involved']
            response[observation_id]['mode'] += [mode] \
                if mode not in response[observation_id]['mode'] else []
            if station_name not in station_involved_summary:
                station_involved_summary[station_name] = OrderedDict()
                station_involved_summary[station_name]['station_name'] = station_name
                station_involved_summary[station_name]['n_errors'] = 0
                station_involved_summary[station_name]['component_error_summary'] = OrderedDict()

            station_involved_summary[station_name]['n_errors'] += total
            station_involved_summary[station_name]['component_error_summary'][error_type] = total

        response_payload = sorted(response.values(),
                                  key=lambda item: item['start_datetime'],
                                  reverse=True)

        return Response(status=status.HTTP_200_OK, data=response_payload)


class ControllerStationTestStatistics(ValidableReadOnlyView):
    description = "Statistical summary of both or either the station test and RTSM"
    station_group = 'A'
    test_type = 'B'
    error_types = []

    fields = [
        coreapi.Field(
            "test_type",
            required=False,
            location='query',
            schema=coreschema.Enum(['R', 'S', 'B'],
                                   description='select the type of test possible values are (R, RTSM),'
                                               ' (S, Station test), (B, both)[DEFAULT=B]',
                                   )
        ),
        coreapi.Field(
            "station_group",
            required=False,
            location='query',
            schema=coreschema.Enum(['C', 'R', 'I', 'A'], description=
            'Station group to select for choices are [C|R|I|ALL]',
                                   )
        ),
        coreapi.Field(
            "from_date",
            required=True,
            location='query',
            schema=coreschema.String(
                description='select tests from date (ex. YYYY-MM-DD)')
        ),
        coreapi.Field(
            "to_date",
            required=True,
            location='query',
            schema=coreschema.String(
                description='select tests to date (ex. YYYY-MM-DD)')
        ),
        coreapi.Field(
            "averaging_interval",
            required=True,
            location='query',
            type=int,
            schema=coreschema.Integer(
                description='averaging interval in days')
        ),
        coreapi.Field(
            "error_types",
            required=False,
            location='query',
            type=parse_array,
            schema=coreschema.Array(description='select the error types to filter for',
                                    items=coreschema.Enum(_get_unique_error_types()),
                                    unique_items=True)
        )
    ]

    def compute_errors_per_station(self, from_date, to_date, central_time, station_group,
                                   test_type):

        component_errors = ComponentError.objects.all()
        rtsm_summary_errors = RTSMErrorSummary.objects.all()

        if station_group:
            component_errors = component_errors.filter(station_test__station__type=station_group)
            rtsm_summary_errors = rtsm_summary_errors.filter(
                observation__station__type=station_group)
        if self.error_types:
            component_errors = component_errors.filter(type__in=self.error_types)
            rtsm_summary_errors = rtsm_summary_errors.filter(error_type__in=self.error_types)

        station_test_results = []
        rtsm_results = []
        if test_type in ['S', 'B']:
            station_test_results = component_errors. \
                filter(station_test__start_datetime__gt=from_date,
                       station_test__start_datetime__lt=to_date). \
                values('station_test__station__name'). \
                annotate(n_errors=Count('station_test__station__name'))
        if test_type in ['R', 'B']:
            rtsm_results = rtsm_summary_errors. \
                filter(observation__start_datetime__gt=from_date,
                       observation__start_datetime__lt=to_date). \
                values('observation__station__name'). \
                annotate(n_errors=Count('observation__station__name'))

        errors_per_station_in_bin = dict()
        central_time_str = central_time.strftime('%Y-%m-%d')
        if test_type in ['S', 'B']:
            for result in station_test_results:
                station_name = result['station_test__station__name']
                errors_per_station_in_bin[station_name] = dict(station_name=station_name,
                                                               n_errors=result['n_errors'],
                                                               time=central_time_str)

        if test_type in ['R', 'B']:
            for result in rtsm_results:
                station_name = result['observation__station__name']
                if station_name not in errors_per_station_in_bin:
                    errors_per_station_in_bin[station_name] = dict(station_name=station_name,
                                                                   n_errors=result['n_errors'],
                                                                   time=central_time_str)
                else:
                    errors_per_station_in_bin[station_name]['n_errors'] += result['n_errors']

        return errors_per_station_in_bin.values()

    def compute_errors_per_type(self, from_date, to_date, central_time, station_group, test_type):

        component_errors = ComponentError.objects.all()
        rtsm_summary_errors = RTSMErrorSummary.objects.all()

        station_test_results = []
        rtsm_results = []

        central_time_str = central_time.strftime('%Y-%m-%d')
        if station_group:
            component_errors = component_errors.filter(station_test__station__type=station_group)
            rtsm_summary_errors = rtsm_summary_errors.filter(
                observation__station__type=station_group)

        if self.error_types:
            component_errors = component_errors.filter(type__in=self.error_types)
            rtsm_summary_errors = rtsm_summary_errors.filter(error_type__in=self.error_types)

        if test_type in ['S', 'B']:
            station_test_results = component_errors. \
                filter(station_test__start_datetime__gt=from_date,
                       station_test__start_datetime__lt=to_date). \
                values('type'). \
                annotate(n_errors=Count('type'))
        if test_type in ['R', 'B']:
            rtsm_results = rtsm_summary_errors. \
                filter(observation__start_datetime__gt=from_date,
                       observation__start_datetime__lt=to_date). \
                values('error_type'). \
                annotate(n_errors=Count('error_type'))

        errors_per_error_type_in_bin = dict()

        if test_type in ['S', 'B']:
            for result in station_test_results:
                error_type = result['type']
                errors_per_error_type_in_bin[error_type] = dict(error_type=error_type,
                                                                n_errors=result['n_errors'],
                                                                time=central_time_str)
        if test_type in ['R', 'B']:
            for result in rtsm_results:
                error_type = result['error_type']
                if error_type not in errors_per_error_type_in_bin:
                    errors_per_error_type_in_bin[error_type] = dict(error_type=error_type,
                                                                    n_errors=result['n_errors'],
                                                                    time=central_time_str)
                else:
                    errors_per_error_type_in_bin[error_type]['n_errors'] += result['n_errors']

        return errors_per_error_type_in_bin.values()

    def compute_response(self):
        from_date = parse_date(self.from_date)
        to_date = parse_date(self.to_date)
        averaging_interval = datetime.timedelta(days=self.averaging_interval)
        response_payload = OrderedDict()

        response_payload['start_date'] = from_date
        response_payload['end_date'] = to_date
        response_payload['averaging_interval'] = averaging_interval

        errors_per_station = []
        errors_per_type = []
        n_bins = int(ceil((to_date - from_date) / averaging_interval))

        for i in range(n_bins):
            if self.station_group is 'A':
                station_group = None
            else:
                station_group = self.station_group
            errors_per_station += self.compute_errors_per_station(
                from_date=from_date + i * averaging_interval,
                to_date=from_date + (i + 1) * averaging_interval,
                central_time=from_date + (i + .5) * averaging_interval,
                station_group=station_group,
                test_type=self.test_type)

            errors_per_type += self.compute_errors_per_type(
                from_date=from_date + i * averaging_interval,
                to_date=from_date + (i + 1) * averaging_interval,
                central_time=from_date + (i + .5) * averaging_interval,
                station_group=station_group,
                test_type=self.test_type)

        response_payload['errors_per_station'] = errors_per_station
        response_payload['errors_per_type'] = errors_per_type

        return Response(status=status.HTTP_200_OK, data=response_payload)


class ControllerAllComponentErrorTypes(ValidableReadOnlyView):
    description = "Lists all the presents component error types"

    def compute_response(self):
        data = [item['type'] for item in ComponentError.objects.values('type').distinct()]
        return Response(status=status.HTTP_200_OK, data=data)


class ControllerStationComponentErrors(ValidableReadOnlyView):
    description = "Provides a summary per station of the component errors"
    # required parameters
    station_name = None
    from_date = None
    to_date = None
    # optional parameters
    test_type = 'B'
    error_types = []

    fields = [
        coreapi.Field(
            'station_name',
            required=True,
            location='query',
            schema=coreschema.String(description='name of the station to select')
        ),
        coreapi.Field(
            'from_date',
            required=True,
            location='query',
            schema=coreschema.String(description='select tests from date (ex. YYYY-MM-DD)')
        ),
        coreapi.Field(
            'to_date',
            required=True,
            location='query',
            schema=coreschema.String(description='select tests from date (ex. YYYY-MM-DD)')
        ),
        coreapi.Field(
            'test_type',
            required=False,
            location='query',
            schema=coreschema.Enum(
                ['R', 'S', 'B'],
                description='select the type of test possible values are (R, RTSM),'
                            ' (S, Station test), (B, both)[DEFAULT=B]',
            )
        ),
        coreapi.Field(
            "error_types",
            required=False,
            location='query',
            type=parse_array,
            schema=coreschema.Array(description='select the error types to filter for',
                                    items=coreschema.Enum(_get_unique_error_types()),
                                    unique_items=True)
        )
    ]

    def collect_station_test_errors(self):
        station_entry = Station.objects.filter(name=self.station_name).first()

        response_payload = OrderedDict()

        station_tests = station_entry.stationtest_set \
            .filter(start_datetime__gte=self.from_date,
                    end_datetime__lte=self.to_date)

        failing_component_types = station_tests.distinct('component_errors__component__type').exclude(component_errors__component__type__isnull=True).values_list('component_errors__component__type')

        for failing_component_type in failing_component_types:
            failing_component_type = failing_component_type[0]
            component_type_errors_list = list()

            response_payload[failing_component_type] = component_type_errors_list

            for station_test in station_tests.order_by('-start_datetime'):
                test_summary = OrderedDict()
                test_summary['test_type'] = 'S'
                test_summary['start_date'] = station_test.start_datetime
                test_summary['end_date'] = station_test.end_datetime
                component_errors_dict = OrderedDict()
                test_summary['component_errors'] = component_errors_dict
                component_errors = station_test.component_errors\
                    .filter(component__type=failing_component_type)
                if self.error_types:
                    component_errors = component_errors.filter(type__in=self.error_types)

                for component_error in component_errors:
                    component_id = component_error.component.component_id
                    error_type = component_error.type
                    details = component_error.details
                    if component_id not in component_errors:
                        component_errors_dict[str(component_id)] = list()
                    component_errors_dict[str(component_id)] += [dict(error_type=error_type,
                                                                     details=details)]

                component_type_errors_list.append(test_summary)

        return response_payload

    def compose_image_storage_url(self,station_name, observation_id, start_date, rcu, component_type, error_type, both_polarization):
        """
        WARNING -----------------------------------------------------------
        This is an ugly function that has to be removed as soon as possible
        and it is meant to provide a url to the RTSM plots to have it displayed
        in the webview. A way to proper implement this part is still missing
        hence this function.
        DONT BLAME THE PLAYER BLAME THE GAME!
        -------------------------------------------------------------------
        :param observation_id: id of the observation (SASID)
        :param start_date: start date of the observation
        :param rcu: rcu number
        :param error_type: type of error
        :return:
        """
        # the sample link address looks like
        # https://proxy.lofar.eu/rtsm/obs_plots/20181108_1542_683264/683264_SE607C_rcu175_sn.png
        baseURL = settings.URL_TO_RTSM_PLOTS

        TO_SHORT_ERROR_TYPE = dict(SUMMATOR_NOISE='sn',
                                   HIGH_NOISE='hn',
                                   LOW_NOISE='ln',
                                   FLAT='flat',
                                   SHORT='short',
                                   OSCILLATION='osc',
                                   DOWN='down'
                                   )

        if component_type in ['LBL', 'LBH'] and both_polarization:
            TO_SHORT_ERROR_TYPE.pop('FLAT')
            type = 'ant'
            component_id = rcu // 2
            if component_type == 'LBL':
                component_id += 48
        else:
            type = 'rcu'
            component_id = rcu

        # If the error is not in the dict above there is not such plot on disk.
        # Hence,  returns 'url not present'
        try:
            short_error_type = TO_SHORT_ERROR_TYPE[error_type]
        except KeyError:
            return 'url not present'

        imageURL = '%(baseURL)s/%(start_date)s_%(observation_id)s/%(observation_id)s_%(station_name)s_%(type)s%(component_id)s_%(error_type)s.png' % dict(
            baseURL=baseURL,
            observation_id=observation_id,
            start_date=start_date.strftime('%Y%m%d_%H%M'),
            station_name=station_name,
            component_id=component_id,
            type=type,
            error_type=short_error_type
        )
        return imageURL

    def find_other_polarization_given_rcu_number(self, rcu_number):
        # if it is even
        if rcu_number % 2 == 0:
            return rcu_number + 1
        else:
            return rcu_number - 1

    def collect_rtsm_errors(self):
        station_entry = Station.objects.filter(name=self.station_name).first()
        response_payload = OrderedDict()
        rtsm_observations = station_entry.rtsmobservation_set \
            .filter(start_datetime__gte=self.from_date,
                    end_datetime__lte=self.to_date)

        failing_component_modes = rtsm_observations.exclude(errors_summary__isnull=True).distinct(
            'errors_summary__mode').values_list('errors_summary__mode')
        for observing_mode in failing_component_modes:

            observing_mode = observing_mode[0]

            rtsm_errors_per_component_type = list()

            response_payload[MODE_TO_COMPONENT[observing_mode]] = rtsm_errors_per_component_type

            for rtsm_observation in rtsm_observations.order_by('-start_datetime'):
                rtsm_summary = OrderedDict()
                rtsm_errors_per_component_type.append(rtsm_summary)

                rtsm_summary['test_type'] = 'R'
                rtsm_summary['start_date'] = rtsm_observation.start_datetime
                rtsm_summary['end_date'] = rtsm_observation.end_datetime
                component_errors_dict = OrderedDict()
                rtsm_summary['component_errors'] = component_errors_dict

                component_errors = rtsm_observation.errors_summary\
                    .filter(mode=observing_mode)\
                    .values('error_type', 'start_frequency',
                            'stop_frequency', 'percentage',
                            'error_type', 'count', 'rcu')

                if self.error_types:
                    component_errors = component_errors.filter(error_type__in=self.error_types)
                for component_error in component_errors:
                    component_id = component_error['rcu']
                    details = dict(percentage = component_error['percentage'],
                                   start_frequency = component_error['start_frequency'],
                                   stop_frequency = component_error['stop_frequency'],
                                   count = component_error['count'])
                    error_type = component_error['error_type']
                    # CHECKS IF THE ERROR IS PRESENT IN BOTH RCUS (hence, both polarizations of the antenna)
                    both_polarization = len(component_errors.filter(rcu=self.find_other_polarization_given_rcu_number(component_id),
                                                                    error_type=error_type)) == 1

                    details['url'] = self.compose_image_storage_url(self.station_name,
                                                                    rtsm_observation.observation_id,
                                                                    rtsm_observation.start_datetime,
                                                                    component_id,
                                                                    MODE_TO_COMPONENT[observing_mode],
                                                                    error_type,
                                                                    both_polarization)
                    if component_id not in component_errors:
                        component_errors_dict[str(component_id)] = list()
                    component_errors_dict[str(component_id)] += [dict(error_type=error_type, details=details)]

                #self.decorate_component_errors_with_url(component_errors_dict, rtsm_observation.observation_id, rtsm_observation.start_datetime, MODE_TO_COMPONENT[observing_mode])
        return response_payload

    def compute_response(self):

        self.from_date = parse_date(self.from_date)
        self.to_date = parse_date(self.to_date)
        station_test_errors = {}
        rtsm_errors = {}

        if self.test_type in ['S', 'B']:
            station_test_errors = self.collect_station_test_errors()

        if self.test_type in ['R', 'B']:
            rtsm_errors = self.collect_rtsm_errors()

        payload = OrderedDict()
        for component_type in set(rtsm_errors.keys() | station_test_errors.keys()):
            station_test_errors_per_type = station_test_errors.get(component_type, [])
            rtsm_errors_per_type = rtsm_errors.get(component_type, [])

            payload[component_type] = sorted(station_test_errors_per_type + rtsm_errors_per_type, key=lambda item: item['start_date'], reverse=True)

        return Response(status=status.HTTP_200_OK, data=payload)

from ..tasks import greetings, check_observation_plots

class ControllerTestCeleryQueue(ValidableReadOnlyView):
    observation_database_id = None
    fields = [
        coreapi.Field(
            'observation_database_id',
            required=True,
            type=int,
            location='query',

            schema=coreschema.Integer(description='observation_id')
        )]
    def compute_response(self):
        from celery.result import AsyncResult
        task_id = 'print_last_observation_%s' % self.observation_database_id

        stuff = check_observation_plots.apply_async((self.observation_database_id,))
        stuff = check_observation_plots.apply_async((self.observation_database_id,))

        #print(aresult.get(timeout=10))

        return Response(status=status.HTTP_200_OK, data='command sent: %s' % stuff)