Ejemplo n.º 1
0
def query_export_custom(request):
    """
    Create and serve the CSV file.
    """

    try:
        content_type = Query.get_content_type(request.GET.get("entity"))
    except ContentType.DoesNotExist:
        raise InvalidContentTypeError(
            "Wrong table name in entity param. Please refer to query docs.")

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        raise InvalidContentTypeError(
            "Wrong table name in entity param. Please refer to query docs.")

    conditions = Query.parse_conditions(content_type,
                                        request.GET.get("conditions"))

    filename = "query_%s_export" % (content_type)

    try:
        results = Query.get_queryset(content_type,
                                     conditions).visible_by_user(request.user)
    except FieldError:
        raise InvalidConditionsError("Conditions URL incorrect: Field does "
                                     "not exist. Please refer to query docs.")

    return _export_query(results, content_type, filename)
Ejemplo n.º 2
0
def notification_criteria(job_id, criteria, state, health, old_health):
    if "dependency_query" in criteria:
        # Makes sure that all the jobs from dependency list also satisfy the
        # criteria for sending notification.
        dependency_jobs = Query.get_queryset(
            ContentType.objects.get_for_model(TestJob),
            Query.parse_conditions(TestJob._meta.model_name,
                                   criteria["dependency_query"]),
        ).exclude(pk=job_id)
        if criteria["status"] == "finished":
            if dependency_jobs.filter(~Q(
                    state=TestJob.STATE_FINISHED)).count():
                return False

        if criteria["status"] == "running":
            if dependency_jobs.filter(~Q(state=TestJob.STATE_RUNNING)).count():
                return False

        if criteria["status"] == "complete":
            if dependency_jobs.filter(~Q(
                    health=TestJob.HEALTH_COMPLETE)).count():
                return False
        elif criteria["status"] == "incomplete":
            if dependency_jobs.filter(~Q(
                    health=TestJob.HEALTH_INCOMPLETE)).count():
                return False
        elif criteria["status"] == "canceled":
            if dependency_jobs.filter(~Q(
                    health=TestJob.HEALTH_CANCELED)).count():
                return False

    # support special status of finished, otherwise skip to normal
    if criteria["status"] == "finished":
        return state == TestJob.STATE_FINISHED

    if criteria["status"] == "running":
        return state == TestJob.STATE_RUNNING

    if criteria["status"] == "complete":
        const = TestJob.HEALTH_COMPLETE
    elif criteria["status"] == "incomplete":
        const = TestJob.HEALTH_INCOMPLETE
    else:
        const = TestJob.HEALTH_CANCELED

    # use normal notification support
    if health == const:
        if "type" in criteria:
            if criteria["type"] == "regression":
                if (old_health == TestJob.HEALTH_COMPLETE
                        and health == TestJob.HEALTH_INCOMPLETE):
                    return True
            if criteria["type"] == "progression":
                if (old_health == TestJob.HEALTH_INCOMPLETE
                        and health == TestJob.HEALTH_COMPLETE):
                    return True
        else:
            return True

    return False
Ejemplo n.º 3
0
def query_export_custom(request):
    """
    Create and serve the CSV file.
    """

    try:
        content_type = Query.get_content_type(request.GET.get("entity"))
    except ContentType.DoesNotExist:
        raise InvalidContentTypeError(
            "Wrong table name in entity param. Please refer to query docs.")

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        raise InvalidContentTypeError(
            "Wrong table name in entity param. Please refer to query docs.")

    conditions = Query.parse_conditions(
        content_type, request.GET.get("conditions"))

    filename = "query_%s_export" % (content_type)

    try:
        results = Query.get_queryset(content_type, conditions).visible_by_user(
            request.user)
    except FieldError:
        raise InvalidConditionsError("Conditions URL incorrect: Field does "
                                     "not exist. Please refer to query docs.")

    return _export_query(results, content_type, filename)
Ejemplo n.º 4
0
def query_export_custom(request):
    """
    Create and serve the CSV file.
    """

    try:
        content_type = Query.get_content_type(request.GET.get("entity"))
    except InvalidContentTypeError as e:
        messages.error(request, e)
        raise Http404()

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        messages.error(
            request,
            "Wrong table name in entity param. Please refer to query docs.")
        raise Http404()

    try:
        conditions = Query.parse_conditions(content_type,
                                            request.GET.get("conditions"))
    except InvalidConditionsError as e:
        messages.error(request, e)
        raise Http404()

    filename = "query_%s_export" % (content_type)

    try:
        results = Query.get_queryset(content_type,
                                     conditions).visible_by_user(request.user)
    except (FieldDoesNotExist, FieldError) as e:
        messages.error(request, e)
        raise Http404()

    return _export_query(results, content_type, filename)
Ejemplo n.º 5
0
def query_export_custom(request):
    """
    Create and serve the CSV file.
    """

    try:
        content_type = Query.get_content_type(request.GET.get("entity"))
    except InvalidContentTypeError as e:
        messages.error(request, e)
        raise Http404()

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        messages.error(
            request,
            "Wrong table name in entity param. Please refer to query docs.")
        raise Http404()

    try:
        conditions = Query.parse_conditions(
            content_type, request.GET.get("conditions"))
    except InvalidConditionsError as e:
        messages.error(request, e)
        raise Http404()

    filename = "query_%s_export" % (content_type)

    try:
        results = Query.get_queryset(content_type, conditions).visible_by_user(
            request.user)
    except (FieldDoesNotExist, FieldError) as e:
        messages.error(request, e)
        raise Http404()

    return _export_query(results, content_type, filename)
Ejemplo n.º 6
0
def validate_yaml(yaml_data):
    if "notify" in yaml_data:
        if "recipients" in yaml_data["notify"]:
            for recipient in yaml_data["notify"]["recipients"]:
                if recipient["to"][
                        "method"] == NotificationRecipient.EMAIL_STR:
                    if "email" not in recipient[
                            "to"] and "user" not in recipient["to"]:
                        raise SubmissionException(
                            "No valid user or email address specified.")
                else:
                    if ("handle" not in recipient["to"]
                            and "user" not in recipient["to"]):
                        raise SubmissionException(
                            "No valid user or IRC handle specified.")
                if "user" in recipient["to"]:
                    try:
                        User.objects.get(username=recipient["to"]["user"])
                    except User.DoesNotExist:
                        raise SubmissionException(
                            "%r is not an existing user in LAVA." %
                            recipient["to"]["user"])
                elif "email" in recipient["to"]:
                    try:
                        validate_email(recipient["to"]["email"])
                    except ValidationError:
                        raise SubmissionException(
                            "%r is not a valid email address." %
                            recipient["to"]["email"])

        if ("compare" in yaml_data["notify"]
                and "query" in yaml_data["notify"]["compare"]):
            query_yaml_data = yaml_data["notify"]["compare"]["query"]
            if "username" in query_yaml_data:
                try:
                    query = Query.objects.get(
                        owner__username=query_yaml_data["username"],
                        name=query_yaml_data["name"],
                    )
                    if query.content_type.model_class() != TestJob:
                        raise SubmissionException(
                            "Only TestJob queries allowed.")
                except Query.DoesNotExist:
                    raise SubmissionException(
                        "Query ~%s/%s does not exist" %
                        (query_yaml_data["username"], query_yaml_data["name"]))
            else:  # Custom query.
                if query_yaml_data["entity"] != "testjob":
                    raise SubmissionException("Only TestJob queries allowed.")
                try:
                    conditions = None
                    if "conditions" in query_yaml_data:
                        conditions = query_yaml_data["conditions"]
                    Query.validate_custom_query(query_yaml_data["entity"],
                                                conditions)
                except Exception as e:
                    raise SubmissionException(e)
Ejemplo n.º 7
0
Archivo: views.py Proyecto: slawr/lava
def query_add(request):

    query = Query()
    query.owner = request.user

    if request.GET.get("entity"):
        query.content_type = Query.get_content_type(request.GET.get("entity"))

    return query_form(request, BreadCrumbTrail.leading_to(query_add), instance=query)
Ejemplo n.º 8
0
def query_custom(request):

    try:
        content_type = Query.get_content_type(request.GET.get("entity"))
    except InvalidContentTypeError as e:
        messages.error(request, e)
        raise Http404()

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        messages.error(
            request,
            "Wrong table name in entity param. Please refer to query docs.")
        raise Http404()

    try:
        conditions = Query.parse_conditions(content_type,
                                            request.GET.get("conditions"))
    except InvalidConditionsError as e:
        messages.error(request, e)
        raise Http404()

    view = QueryCustomResultView(
        content_type=content_type,
        conditions=conditions,
        request=request,
        model=content_type.model_class(),
        table_class=QUERY_CONTENT_TYPE_TABLE[content_type.model_class()]
    )

    try:
        table = QUERY_CONTENT_TYPE_TABLE[content_type.model_class()](
            None,
            request.user,
            view.get_table_data()
        )
    except (FieldDoesNotExist, FieldError) as e:
        messages.error(request, e)
        raise Http404()

    config = RequestConfig(request, paginate={"per_page": table.length})
    config.configure(table)
    template = loader.get_template('lava_results_app/query_custom.html')
    return HttpResponse(template.render(
        {
            'query_table': table,
            'conditions': conditions,
            'terms_data': table.prepare_terms_data(view),
            'search_data': table.prepare_search_data(view),
            'discrete_data': table.prepare_discrete_data(view),

            'bread_crumb_trail': BreadCrumbTrail.leading_to(query_custom),
            'context_help': ['lava-queries-charts'],
        }, request=request)
    )
Ejemplo n.º 9
0
def query_custom(request):

    try:
        content_type = Query.get_content_type(request.GET.get("entity"))
    except InvalidContentTypeError as e:
        messages.error(request, e)
        raise Http404()

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        messages.error(
            request,
            "Wrong table name in entity param. Please refer to query docs.")
        raise Http404()

    try:
        conditions = Query.parse_conditions(content_type,
                                            request.GET.get("conditions"))
    except InvalidConditionsError as e:
        messages.error(request, e)
        raise Http404()

    view = QueryCustomResultView(
        content_type=content_type,
        conditions=conditions,
        request=request,
        model=content_type.model_class(),
        table_class=QUERY_CONTENT_TYPE_TABLE[content_type.model_class()]
    )

    try:
        table = QUERY_CONTENT_TYPE_TABLE[content_type.model_class()](
            None,
            request.user,
            view.get_table_data()
        )
    except (FieldDoesNotExist, FieldError) as e:
        messages.error(request, e)
        raise Http404()

    config = RequestConfig(request, paginate={"per_page": table.length})
    config.configure(table)
    template = loader.get_template('lava_results_app/query_custom.html')
    return HttpResponse(template.render(
        {
            'query_table': table,
            'conditions': conditions,
            'terms_data': table.prepare_terms_data(view),
            'search_data': table.prepare_search_data(view),
            'discrete_data': table.prepare_discrete_data(view),

            'bread_crumb_trail': BreadCrumbTrail.leading_to(query_custom),
            'context_help': ['lava-queries-charts'],
        }, request=request)
    )
Ejemplo n.º 10
0
def query_add(request):

    query = Query()
    query.owner = request.user

    if request.GET.get("entity"):
        query.content_type = Query.get_content_type(request.GET.get("entity"))

    return query_form(
        request,
        BreadCrumbTrail.leading_to(query_add),
        instance=query)
Ejemplo n.º 11
0
def get_query_results(notification):
    if notification.query_name:
        query = Query.objects.get(name=notification.query_name,
                                  owner=notification.query_owner)
        # We use query_owner as user here since we show only status.
        return query.get_results(
            notification.query_owner)[:notification.QUERY_LIMIT]
    else:
        return Query.get_queryset(
            notification.entity,
            Query.parse_conditions(notification.entity,
                                   notification.conditions),
            notification.QUERY_LIMIT)
Ejemplo n.º 12
0
def query_add(request):

    query = Query()
    query.owner = request.user

    if request.GET.get("entity"):
        query.content_type = ContentType.objects.get(
            model=request.GET.get("entity"),
            app_label=_get_app_label_for_model(request.GET.get("entity"))
        )

    return query_form(
        request,
        BreadCrumbTrail.leading_to(query_add),
        instance=query)
Ejemplo n.º 13
0
def chart_custom(request):

    content_type = Query.get_content_type(request.GET.get("entity"))

    chart_type = request.GET.get("type")
    chart_type_choices = ChartQuery._meta.get_field("chart_type").choices
    if not chart_type:
        chart_type = ChartQuery._meta.get_field("chart_type").default
    else:
        found = False
        for choice in chart_type_choices:
            if chart_type in choice:
                found = True
        if not found:
            raise InvalidChartTypeError(
                "Wrong chart type param. Please refer to chart docs."
            )

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        raise InvalidContentTypeError(
            "Wrong table name in entity param. Please refer to chart docs."
        )

    if content_type.model_class() == TestCase and chart_type == "pass/fail":
        raise TestCasePassFailChartError(
            "Chart of TestCase entity cannot be of pass/fail chart type."
        )

    conditions = Query.parse_conditions(content_type, request.GET.get("conditions"))

    chart = Chart(name="Custom")
    chart_query = ChartQuery(id=0)
    chart_query.chart = chart
    chart_query.chart_type = chart_type
    chart_data = {}
    chart_data[0] = chart_query.get_data(request.user, content_type, conditions)
    template = loader.get_template("lava_results_app/chart_display.html")
    return HttpResponse(
        template.render(
            {
                "chart": chart,
                "chart_data": simplejson.dumps(chart_data),
                "bread_crumb_trail": BreadCrumbTrail.leading_to(chart_custom),
                "can_admin": False,
            },
            request=request,
        )
    )
Ejemplo n.º 14
0
def query_detail(request, username, name):

    query = get_object_or_404(Query, owner__username=username, name=name)
    query_conditions = Query.serialize_conditions(
        query.querycondition_set.all())
    template = loader.get_template("lava_results_app/query_detail.html")
    return HttpResponse(
        template.render(
            {
                "query":
                query,
                "query_conditions":
                query_conditions,
                "bread_crumb_trail":
                BreadCrumbTrail.leading_to(
                    query_detail, username=username, name=name),
                "context_help": ["lava-queries-charts"],
                "condition_form":
                QueryConditionForm(instance=None,
                                   initial={
                                       "query": query,
                                       "table": query.content_type
                                   }),
            },
            request=request,
        ))
Ejemplo n.º 15
0
def query_form(request, bread_crumb_trail, instance=None, is_copy=False):

    if request.method == 'POST':

        form = QueryForm(request.user, request.POST,
                         instance=instance, is_copy=is_copy)
        if form.is_valid():
            query = form.save()
            if request.GET.get("conditions"):
                conditions = Query.parse_conditions(
                    query.content_type, request.GET.get("conditions"))
                for condition in conditions:
                    condition.query = query
                    condition.save()

            return HttpResponseRedirect(query.get_absolute_url() + "/+detail")

    else:
        form = QueryForm(request.user, instance=instance, is_copy=is_copy)
        form.fields['owner'].initial = request.user

    query_name = None
    if is_copy:
        query_name = instance.name
        instance.name = None

    return render_to_response(
        'lava_results_app/query_form.html', {
            'bread_crumb_trail': bread_crumb_trail,
            'is_copy': is_copy,
            'query_name': query_name,
            'form': form,
        }, RequestContext(request))
Ejemplo n.º 16
0
def query_form(request, bread_crumb_trail, instance=None, is_copy=False):

    if request.method == 'POST':

        form = QueryForm(request.user, request.POST,
                         instance=instance, is_copy=is_copy)
        if form.is_valid():
            query = form.save()
            if request.GET.get("conditions"):
                conditions = Query.parse_conditions(
                    query.content_type, request.GET.get("conditions"))
                for condition in conditions:
                    condition.query = query
                    condition.save()

            return HttpResponseRedirect(query.get_absolute_url() + "/+detail")

    else:
        form = QueryForm(request.user, instance=instance, is_copy=is_copy)
        form.fields['owner'].initial = request.user

    query_name = None
    if is_copy:
        query_name = instance.name
        instance.name = None
    template = loader.get_template('lava_results_app/query_form.html')
    return HttpResponse(template.render(
        {
            'bread_crumb_trail': bread_crumb_trail,
            'is_copy': is_copy,
            'query_name': query_name,
            'form': form,
            'context_help': ['lava-queries-charts'],
        }, request=request))
Ejemplo n.º 17
0
def query_detail(request, username, name):

    query = get_object_or_404(Query, owner__username=username, name=name)
    query_conditions = Query.serialize_conditions(
        query.querycondition_set.all())
    template = loader.get_template('lava_results_app/query_detail.html')
    return HttpResponse(
        template.render(
            {
                'query':
                query,
                'query_conditions':
                query_conditions,
                'bread_crumb_trail':
                BreadCrumbTrail.leading_to(
                    query_detail, username=username, name=name),
                'context_help': ['lava-queries-charts'],
                'condition_form':
                QueryConditionForm(instance=None,
                                   initial={
                                       'query': query,
                                       'table': query.content_type
                                   }),
            },
            request=request))
Ejemplo n.º 18
0
def chart_custom(request):

    content_type = Query.get_content_type(request.GET.get("entity"))

    chart_type = request.GET.get("type")
    chart_type_choices = ChartQuery._meta.get_field_by_name(
        'chart_type')[0].choices
    if not chart_type:
        chart_type = ChartQuery._meta.get_field_by_name(
            'chart_type')[0].default
    else:
        found = False
        for choice in chart_type_choices:
            if chart_type in choice:
                found = True
        if not found:
            raise InvalidChartTypeError(
                "Wrong chart type param. Please refer to chart docs.")

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        raise InvalidContentTypeError(
            "Wrong table name in entity param. Please refer to chart docs.")

    if content_type.model_class() == TestCase and chart_type == "pass/fail":
        raise TestCasePassFailChartError(
            "Chart of TestCase entity cannot be of pass/fail chart type.")

    conditions = Query.parse_conditions(
        content_type, request.GET.get("conditions"))

    chart = Chart(name="Custom")
    chart_query = ChartQuery(id=0)
    chart_query.chart = chart
    chart_query.chart_type = chart_type
    chart_data = {}
    chart_data[0] = chart_query.get_data(request.user, content_type,
                                         conditions)
    template = loader.get_template('lava_results_app/chart_display.html')
    return HttpResponse(template.render(
        {
            'chart': chart,
            'chart_data': simplejson.dumps(chart_data),
            'bread_crumb_trail': BreadCrumbTrail.leading_to(
                chart_custom),
            'can_admin': False,
        }, request=request)
    )
Ejemplo n.º 19
0
def query_display(request, username, name):

    query = get_object_or_404(Query, owner__username=username, name=name)

    if not request.user.is_superuser:
        if not query.is_published and query.owner != request.user:
            raise PermissionDenied

    view = QueryResultView(
        query=query,
        request=request,
        model=query.content_type.model_class(),
        table_class=QUERY_CONTENT_TYPE_TABLE[query.content_type.model_class()],
    )

    table = QUERY_CONTENT_TYPE_TABLE[query.content_type.model_class()](
        query, request.user, view.get_table_data())

    try:
        config = RequestConfig(request, paginate={"per_page": table.length})
        config.configure(table)
    except ProgrammingError:
        raise QueryViewDoesNotExistError(
            "Query view does not exist. Please contact query owner or system "
            "administrator.")

    omitted = [
        result.content_object
        for result in QueryOmitResult.objects.filter(query=query)
    ]
    template = loader.get_template("lava_results_app/query_display.html")
    return HttpResponse(
        template.render(
            {
                "query":
                query,
                "entity":
                query.content_type.model,
                "conditions":
                Query.serialize_conditions(query.querycondition_set.all()),
                "omitted":
                omitted,
                "query_table":
                table,
                "terms_data":
                table.prepare_terms_data(view),
                "search_data":
                table.prepare_search_data(view),
                "discrete_data":
                table.prepare_discrete_data(view),
                "bread_crumb_trail":
                BreadCrumbTrail.leading_to(
                    query_display, username=username, name=name),
                "context_help": ["lava-queries-charts"],
            },
            request=request,
        ))
Ejemplo n.º 20
0
def query_custom(request):

    content_type = Query.get_content_type(request.GET.get("entity"))

    if content_type.model_class() not in QueryCondition.RELATION_MAP:
        raise InvalidContentTypeError(
            "Wrong table name in entity param. Please refer to query docs.")

    view = QueryCustomResultView(
        content_type=content_type,
        conditions=Query.parse_conditions(content_type,
                                          request.GET.get("conditions")),
        request=request,
        model=content_type.model_class(),
        table_class=QUERY_CONTENT_TYPE_TABLE[content_type.model_class()]
    )

    try:
        table = QUERY_CONTENT_TYPE_TABLE[content_type.model_class()](
            view.get_table_data()
        )
    except FieldError:
        raise InvalidConditionsError("Conditions URL incorrect: Field does "
                                     "not exist. Please refer to query docs.")

    config = RequestConfig(request, paginate={"per_page": table.length})
    config.configure(table)

    return render_to_response(
        'lava_results_app/query_custom.html', {
            'query_table': table,

            'terms_data': table.prepare_terms_data(view),
            'search_data': table.prepare_search_data(view),
            'discrete_data': table.prepare_discrete_data(view),

            'bread_crumb_trail': BreadCrumbTrail.leading_to(query_custom),
            'context_help': BreadCrumbTrail.leading_to(query_list),
        }, RequestContext(request)
    )
Ejemplo n.º 21
0
def query_display(request, username, name):

    query = get_object_or_404(Query, owner__username=username, name=name)

    if not request.user.is_superuser:
        if not query.is_published and query.owner != request.user:
            raise PermissionDenied

    view = QueryResultView(
        query=query,
        request=request,
        model=query.content_type.model_class(),
        table_class=QUERY_CONTENT_TYPE_TABLE[query.content_type.model_class()]
    )

    table = QUERY_CONTENT_TYPE_TABLE[query.content_type.model_class()](
        query,
        request.user,
        view.get_table_data()
    )

    try:
        config = RequestConfig(request, paginate={"per_page": table.length})
        config.configure(table)
    except ProgrammingError:
        raise QueryViewDoesNotExistError(
            "Query view does not exist. Please contact query owner or system "
            "administrator.")

    omitted = [result.content_object for result in QueryOmitResult.objects.filter(query=query)]
    template = loader.get_template('lava_results_app/query_display.html')
    return HttpResponse(template.render(
        {
            'query': query,
            'entity': query.content_type.model,
            'conditions': Query.serialize_conditions(
                query.querycondition_set.all()),
            'omitted': omitted,
            'query_table': table,
            'terms_data': table.prepare_terms_data(view),
            'search_data': table.prepare_search_data(view),
            'discrete_data': table.prepare_discrete_data(view),
            'bread_crumb_trail': BreadCrumbTrail.leading_to(
                query_display, username=username, name=name),
            'context_help': ['lava-queries-charts'],
        }, request=request)
    )
Ejemplo n.º 22
0
def query_detail(request, username, name):

    query = get_object_or_404(Query, owner__username=username, name=name)
    query_conditions = Query.serialize_conditions(
        query.querycondition_set.all())
    template = loader.get_template('lava_results_app/query_detail.html')
    return HttpResponse(template.render(
        {
            'query': query,
            'query_conditions': query_conditions,
            'bread_crumb_trail': BreadCrumbTrail.leading_to(
                query_detail, username=username, name=name),
            'context_help': ['lava-queries-charts'],
            'condition_form': QueryConditionForm(
                instance=None,
                initial={'query': query, 'table': query.content_type}),
        }, request=request)
    )
Ejemplo n.º 23
0
def query_form(request, bread_crumb_trail, instance=None, is_copy=False):

    if request.method == "POST":

        form = QueryForm(request.user,
                         request.POST,
                         instance=instance,
                         is_copy=is_copy)
        if form.is_valid():
            query = form.save()
            if request.GET.get("conditions"):
                conditions = Query.parse_conditions(
                    query.content_type, request.GET.get("conditions"))
                for condition in conditions:
                    condition.query = query
                    condition.save()

            return HttpResponseRedirect(query.get_absolute_url() + "/+detail")

    else:
        form = QueryForm(request.user, instance=instance, is_copy=is_copy)
        form.fields["owner"].initial = request.user

    query_name = None
    if is_copy:
        query_name = instance.name
        instance.name = None
    template = loader.get_template("lava_results_app/query_form.html")
    return HttpResponse(
        template.render(
            {
                "bread_crumb_trail": bread_crumb_trail,
                "is_copy": is_copy,
                "query_name": query_name,
                "form": form,
                "context_help": ["lava-queries-charts"],
            },
            request=request,
        ))
Ejemplo n.º 24
0
def create_notification(job, data):
    # Create notification object.
    notification = Notification()

    if "verbosity" in data:
        notification.verbosity = Notification.VERBOSITY_MAP[data["verbosity"]]

    if "type" in data["criteria"]:
        notification.type = Notification.TYPE_MAP[data["criteria"]["type"]]

    if "compare" in data:
        if "blacklist" in data["compare"]:
            notification.blacklist = data["compare"]["blacklist"]
        if "query" in data["compare"]:
            query_data = data["compare"]["query"]
            if "username" in query_data:
                # DoesNotExist scenario already verified in validate
                username = query_data["username"]
                notification.query_owner = User.objects.get(username=username)
                notification.query_name = query_data["name"]
            else:  # Custom query.
                notification.entity = Query.get_content_type(
                    query_data["entity"])
                if "conditions" in query_data:
                    # Save conditions as a string.
                    conditions = [
                        "%s%s%s" % (key, Query.CONDITION_DIVIDER, value)
                        for (key, value) in query_data["conditions"].items()
                    ]
                    notification.conditions = Query.CONDITIONS_SEPARATOR.join(
                        conditions)

    notification.test_job = job
    notification.template = Notification.DEFAULT_TEMPLATE
    notification.save()

    if "recipients" in data:
        for recipient in data["recipients"]:
            notification_recipient = NotificationRecipient(
                notification=notification)
            notification_recipient.method = NotificationRecipient.METHOD_MAP[
                recipient["to"]["method"]]
            if "user" in recipient["to"]:
                user = User.objects.get(username=recipient["to"]["user"])
                notification_recipient.user = user
            if "email" in recipient["to"]:
                notification_recipient.email = recipient["to"]["email"]
            if "handle" in recipient["to"]:
                notification_recipient.irc_handle = recipient["to"]["handle"]
            if "server" in recipient["to"]:
                notification_recipient.irc_server = recipient["to"]["server"]

            # Ignore unique constraint violation.
            with contextlib.suppress(IntegrityError):
                notification_recipient.save()

    else:
        # You can do "callbacks only" without having recipients, in that
        # case, no notification will be sent.
        if "callbacks" not in data and "callback" not in data:
            # But if there's no callback and no recipients then we add a
            # submitter as a default recipient.
            # Ignore unique constraint violation.
            with contextlib.suppress(IntegrityError):
                notification_recipient = NotificationRecipient.objects.create(
                    user=job.submitter, notification=notification)

    # Add callbacks.
    if "callbacks" in data:
        for callback in data["callbacks"]:
            create_callback(job, callback, notification)
    if "callback" in data:
        create_callback(job, data["callback"], notification)
Ejemplo n.º 25
0
    def make_custom_query(self, entity, conditions, limit=200):
        """
        Name
        ----
        `make_custom_query` (`entity`, `conditions`, `limit`)

        Description
        -----------
        Construct and run a custom query and return the results.

        Arguments
        ---------
        `entity`: string
            The entity you want to query
        `conditions`: string
            The conditions of the query
        `limit`: integer
            Add a limit to the number of results returned.
            Defaults to 200.

        Return value
        ------------
        A list of dictionaries containing the query results.

        The user should be authenticated with a username and token.

        Example
        -------

        # Get all test jobs submitted by the user 'kernel-ci', and which ended
        # as 'Incomplete':
        server.results.make_custom_query("testjob",
            "testjob__submitter__exact__kernel-ci,"
            "testjob__health__exact__Incomplete")
        [{ jobXX }, { jobXY }, ...]

        # Get all test cases in a test suite named 'custom-tests', that failed,
        # and for whom the job ended after '2017-04-26 00:00:00'.
        server.results.make_custom_query("testcase",
            "testsuite__name__exact__1_custom-tests,"
            "testcase__result__exact__Test failed,"
            "testjob__end_time__gt__2017-04-26 00:00:00")
        [{ testcaseXX }, { testcaseXY }, ...]

        """
        self._authenticate()
        try:
            content_type = Query.get_content_type(entity)
        except InvalidContentTypeError:
            raise xmlrpclib.Fault(
                400, "Wrong table name in entity parameter. "
                "Please refer to query docs.")

        if content_type.model_class() not in QueryCondition.RELATION_MAP:
            raise xmlrpclib.Fault(
                400, "Wrong table name in entity parameter. "
                "Please refer to query docs.")

        conditions = Query.parse_conditions(content_type, conditions)

        try:
            results = Query.get_queryset(content_type,
                                         conditions).visible_by_user(self.user)
        except FieldDoesNotExist:
            raise xmlrpclib.Fault(400,
                                  "Conditions URL incorrect: Field does not exist. "
                                  "Please refer to query docs.")
        return list(results[:limit])
Ejemplo n.º 26
0
 def get_queryset(self):
     return Query.get_queryset(self.content_type,
                               self.conditions).visible_by_user(
                                   self.request.user)
Ejemplo n.º 27
0
 def get_queryset(self):
     return Query.get_queryset(
         self.content_type,
         self.conditions).visible_by_user(
             self.request.user)
Ejemplo n.º 28
0
    def make_custom_query(self, entity, conditions, limit=200):
        """
        Name
        ----
        `make_custom_query` (`entity`, `conditions`, `limit`)

        Description
        -----------
        Construct and run a custom query and return the results.

        Arguments
        ---------
        `entity`: string
            The entity you want to query
        `conditions`: string
            The conditions of the query
        `limit`: integer
            Add a limit to the number of results returned.
            Defaults to 200.

        Return value
        ------------
        A list of dictionaries containing the query results.

        The user should be authenticated with a username and token.

        Example
        -------

        # Get all test jobs submitted by the user 'kernel-ci', and which ended
        # as 'Incomplete':
        server.results.make_custom_query("testjob",
            "testjob__submitter__exact__kernel-ci,"
            "testjob__health__exact__Incomplete")
        [{ jobXX }, { jobXY }, ...]

        # Get all test cases in a test suite named 'custom-tests', that failed,
        # and for whom the job ended after '2017-04-26 00:00:00'.
        server.results.make_custom_query("testcase",
            "testsuite__name__exact__1_custom-tests,"
            "testcase__result__exact__Test failed,"
            "testjob__end_time__gt__2017-04-26 00:00:00")
        [{ testcaseXX }, { testcaseXY }, ...]

        """
        self._authenticate()
        try:
            content_type = Query.get_content_type(entity)
        except InvalidContentTypeError:
            raise xmlrpc.client.Fault(
                400, "Wrong table name in entity parameter. "
                "Please refer to query docs.")

        if content_type.model_class() not in QueryCondition.RELATION_MAP:
            raise xmlrpc.client.Fault(
                400, "Wrong table name in entity parameter. "
                "Please refer to query docs.")

        conditions = Query.parse_conditions(content_type, conditions)

        try:
            results = Query.get_queryset(content_type,
                                         conditions).visible_by_user(self.user)
        except FieldDoesNotExist:
            raise xmlrpc.client.Fault(
                400, "Conditions URL incorrect: Field does not exist. "
                "Please refer to query docs.")
        return list(results[:limit])
Ejemplo n.º 29
0
 def get_queryset(self):
     return Query.get_results(self.content_type, self.conditions)