Python server_utils.form_error_string函数代码示例

def cohort_variant_search(request):

    project, cohort = get_project_and_cohort_for_user(request.user, request.GET)
    if not project.can_view(request.user):
        return HttpResponse('unauthorized')

    form = api_forms.CohortVariantSearchForm(request.GET)
    if form.is_valid():
        search_spec = form.cleaned_data['search_spec']
        search_spec.family_id = cohort.cohort_id

        variants = api_utils.calculate_mendelian_variant_search(search_spec, cohort.xfamily())
        search_hash = cache_utils.save_results_for_spec(project.project_id, search_spec.toJSON(), [v.toJSON() for v in variants])
        api_utils.add_extra_info_to_variants_cohort(get_reference(), cohort, variants)

        return JSONResponse({
            'is_error': False,
            'variants': [v.toJSON() for v in variants],
            'search_hash': search_hash,
        })

    else:
        return JSONResponse({
            'is_error': True,
            'error': server_utils.form_error_string(form)
        })

def add_family_group(request, project_id):

    error = None

    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        raise PermissionDenied

    form = AddFamilyGroupForm(project, request.POST)
    if form.is_valid():
        # todo: move to sample_anagement
        family_group = FamilyGroup.objects.create(
            project=project,
            slug=form.cleaned_data['family_group_slug'],
            name=form.cleaned_data['name'],
            description=form.cleaned_data['description'],
        )
        for family in form.cleaned_data['families']:
            family_group.families.add(family)
    else:
        error = server_utils.form_error_string(form)

    if error:
        return server_utils.JSONResponse({'is_error': True, 'error': error})
    else:
        return redirect('family_group_home', project.project_id, family_group.slug )

def add_family_group_submit(request, project_id):
    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        return HttpResponse('unauthorized')

    error = None

    form = AddFamilyGroupForm(project, request.POST)
    if form.is_valid():
        # todo: move to sample_anagement
        family_group = FamilyGroup.objects.create(
            project=project,
            slug=form.cleaned_data['family_group_slug'],
            name=form.cleaned_data['name'],
            description=form.cleaned_data['description'],
        )
        for family in form.cleaned_data['families']:
            family_group.families.add(family)
    else:
        error = server_utils.form_error_string(form)

    if error:
        return server_utils.JSONResponse({'is_error': True, 'error': error})
    else:
        return server_utils.JSONResponse({'is_error': False, 'new_url': reverse('family_group_home', args=(project.project_id, family_group.slug))})

def cohort_variant_search(request):

    project, cohort = get_project_and_cohort_for_user(request.user, request.GET)
    if not project.can_view(request.user):
        return PermissionDenied

    form = api_forms.CohortVariantSearchForm(request.GET)
    if form.is_valid():
        search_spec = form.cleaned_data['search_spec']
        search_spec.family_id = cohort.cohort_id

        sys.stderr.write("cohort_variant_search - starting: %s  %s\n" % (json.dumps(search_spec.toJSON()), cohort.xfamily().family_id))
        variants = api_utils.calculate_mendelian_variant_search(search_spec, cohort.xfamily())

        list_of_variants = [v.toJSON() for v in variants]
        sys.stderr.write("cohort_variant_search - done calculate_mendelian_variant_search: %s  %s %s\n" % (json.dumps(search_spec.toJSON()), cohort.xfamily().family_id, len(list_of_variants)))
        search_hash = cache_utils.save_results_for_spec(project.project_id, search_spec.toJSON(), list_of_variants)

        sys.stderr.write("cohort_variant_search - done save_results_for_spec: %s  %s\n" % (json.dumps(search_spec.toJSON()), cohort.xfamily().family_id))
        api_utils.add_extra_info_to_variants_cohort(get_reference(), cohort, variants)

        sys.stderr.write("cohort_variant_search - done add_extra_info_to_variants_cohort: %s  %s\n" % (json.dumps(search_spec.toJSON()), cohort.xfamily().family_id))
        return JSONResponse({
            'is_error': False,
            'variants': [v.toJSON() for v in variants],
            'search_hash': search_hash,
        })

    else:
        return JSONResponse({
            'is_error': True,
            'error': server_utils.form_error_string(form)
        })

def add_phenotype(request, project_id):

    error = None

    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        return HttpResponse("unauthorized")

    form = AddPhenotypeForm(project, request.POST)
    if form.is_valid():
        phenotype = ProjectPhenotype(
            project=project,
            slug=form.cleaned_data["slug"],
            name=form.cleaned_data["name"],
            category=form.cleaned_data["category"],
            datatype=form.cleaned_data["datatype"],
        )
        phenotype.save()
        return redirect("edit_individuals", project.project_id)
    else:
        error = server_utils.form_error_string(form)

    if error:
        return server_utils.JSONResponse({"is_error": True, "error": error})
    else:
        return redirect("edit_individuals", project.project_id)

def add_tag(request, project_id):
    """
    """
    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        return HttpResponse('Unauthorized')

    error = None
    if request.method == 'POST':
        form = AddTagForm(project, request.POST)
        if form.is_valid():
            ProjectTag.objects.create(
                project=project,
                tag=form.cleaned_data['tag'],
                title=form.cleaned_data['title'],
            )
            return redirect('project_home', project_id=project_id)
        else:
            error = server_utils.form_error_string(form)
    else:
        form = AddTagForm(project)

    return render(request, 'project/add_tag.html', {
        'project': project,
        'form': form,
        'error': error,
    })

def combine_mendelian_families(request):

    project, family_group = utils.get_project_and_family_group_for_user(request.user, request.GET)
    if not project.can_view(request.user):
        return PermissionDenied

    form = api_forms.CombineMendelianFamiliesForm(request.GET)
    if form.is_valid():

        search_spec = form.cleaned_data['search_spec']
        search_spec.family_group_id = family_group.slug

        genes = api_utils.calculate_combine_mendelian_families(family_group, search_spec)
        search_hash = cache_utils.save_results_for_spec(project.project_id, search_spec.toJSON(), genes)
        api_utils.add_extra_info_to_genes(project, get_reference(), genes)

        return JSONResponse({
            'is_error': False,
            'genes': genes,
            'search_hash': search_hash,
        })

    else:
        return JSONResponse({
            'is_error': True,
            'error': server_utils.form_error_string(form)
        })

def add_family_group_submit(request, project_id):
    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        raise PermissionDenied

    error = None

    form = AddFamilyGroupForm(project, request.POST)
    if form.is_valid():
        # todo: move to sample_anagement
        family_group, created = get_or_create_xbrowse_model(
            FamilyGroup,
            project=project,
            slug=form.cleaned_data['family_group_slug'],
        )
        update_xbrowse_model(family_group, name=form.cleaned_data['name'], description=form.cleaned_data['description'])

        seqr_analysis_group = find_matching_seqr_model(family_group)
        for family in form.cleaned_data['families']:
            family_group.families.add(family)
            seqr_analysis_group.families.add(find_matching_seqr_model(family))
    else:
        error = server_utils.form_error_string(form)

    if error:
        return server_utils.JSONResponse({'is_error': True, 'error': error})
    else:
        return server_utils.JSONResponse({'is_error': False, 'new_url': reverse('family_group_home', args=(project.project_id, family_group.slug))})

def add(request, project_id):

    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        raise PermissionDenied

    if request.method == 'POST':
        form = base_forms.AddCohortForm(project, request.POST)
        if form.is_valid():
            cohort = Cohort.objects.create(
                project=project,
                cohort_id=form.cleaned_data['cohort_id'],
                display_name=form.cleaned_data['name'],
                short_description=form.cleaned_data['description'],
            )
            for indiv in form.cleaned_data['individuals']:
                cohort.individuals.add(indiv)
            cohort.save()

            # TODO figure out a way to launch variant loading in the background
            #xbrowse_controls.load_variants_for_cohort_list(project, [cohort])

            return JSONResponse({'is_error': False, 'next_page': reverse('cohort_home', args=(project.project_id, cohort.cohort_id))})
        else:
            return JSONResponse({'is_error': True, 'error': server_utils.form_error_string(form)})

    individuals_json = json_displays.individual_list(project.get_individuals())

    return render(request, 'cohort/add.html', {
        'project': project,
        'individuals_json': json.dumps(individuals_json),
    })

def add_tag(request, project_id):
    """For HTTP GET requests, this view generates the html page for creating a tag.
    For HTTP POST, it saves the submitted changes.

    Args:
        request: Django HTTP request object
        project_id: seqr project ID string
    """
    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        raise PermissionDenied

    error = None
    if request.method == 'POST':
        form = AddTagForm(project, request.POST)
        if form.is_valid():
            create_xbrowse_model(
                ProjectTag,
                project=project,
                tag=form.cleaned_data['tag'],
                title=form.cleaned_data['title'])
            return redirect('project_home', project_id=project_id)
        else:
            error = server_utils.form_error_string(form)
    else:
        form = AddTagForm(project)

    return render(request, 'project/add_or_edit_tag.html', {
        'project': project,
        'form': form,
        'error': error,
    })

def mendelian_variant_search(request):

    # TODO: how about we move project getter into the form, and just test for authX here?
    # esp because error should be described in json, not just 404
    project, family = get_project_and_family_for_user(request.user, request.GET)

    form = api_forms.MendelianVariantSearchForm(request.GET)
    if form.is_valid():

        search_spec = form.cleaned_data['search_spec']
        search_spec.family_id = family.family_id

        variants = api_utils.calculate_mendelian_variant_search(search_spec, family.xfamily())
        search_hash = cache_utils.save_results_for_spec(project.project_id, search_spec.toJSON(), [v.toJSON() for v in variants])
        add_extra_info_to_variants_family(get_reference(), family, variants)

        return_type = request.GET.get('return_type', 'json')
        if return_type == 'json':
            return JSONResponse({
                'is_error': False,
                'variants': [v.toJSON() for v in variants],
                'search_hash': search_hash,
            })
        elif return_type == 'csv':
            return ''
        else:
            return HttpResponse("Return type not implemented")

    else:
        return JSONResponse({
            'is_error': True,
            'error': server_utils.form_error_string(form)
        })

def add(request, project_id):

    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        return HttpResponse('unauthorized')

    if request.method == 'POST':
        form = base_forms.AddCohortForm(project, request.POST)
        if form.is_valid():
            cohort = Cohort.objects.create(
                project=project,
                cohort_id=form.cleaned_data['cohort_id'],
                display_name=form.cleaned_data['name'],
                short_description=form.cleaned_data['description'],
            )
            for indiv in form.cleaned_data['individuals']:
                cohort.individuals.add(indiv)
            tasks.reload_cohort_variants.delay(project_id, cohort.cohort_id)
            return JSONResponse({'is_error': False, 'next_page': reverse('cohort_home', args=(project.project_id, cohort.cohort_id))})
        else:
            return JSONResponse({'is_error': True, 'error': server_utils.form_error_string(form)})

    individuals_json = json_displays.individual_list(project.get_individuals())

    return render(request, 'cohort/add.html', {
        'project': project,
        'individuals_json': json.dumps(individuals_json),
    })

def combine_mendelian_families_variants(request):

    project, family_group = utils.get_project_and_family_group_for_user(request.user, request.GET)

    form = api_forms.CombineMendelianFamiliesVariantsForm(request.GET)
    if form.is_valid():
        variants_grouped = get_variants_by_family_for_gene(
            get_mall(project.project_id),
            [f.xfamily() for f in form.cleaned_data['families']],
            form.cleaned_data['inheritance_mode'],
            form.cleaned_data['gene_id'],
            variant_filter=form.cleaned_data['variant_filter'],
            quality_filter=form.cleaned_data['quality_filter']
        )
        variants_by_family = []
        for family in form.cleaned_data['families']:
            variants = variants_grouped[(family.project.project_id, family.family_id)]
            add_extra_info_to_variants_family(get_reference(), family, variants)
            variants_by_family.append({
                'project_id': family.project.project_id,
                'family_id': family.family_id,
                'family_name': str(family),
                'variants': [v.toJSON() for v in variants],
            })
        return JSONResponse({
            'is_error': False,
            'variants_by_family': variants_by_family,
        })

    else:
        return JSONResponse({
            'is_error': True,
            'error': server_utils.form_error_string(form)
        })

def diagnostic_search(request):

    project, family = utils.get_project_and_family_for_user(request.user, request.GET)
    if not project.can_view(request.user):
        raise PermissionDenied

    form = api_forms.DiagnosticSearchForm(family, request.GET)
    if form.is_valid():

        search_spec = form.cleaned_data['search_spec']
        search_spec.family_id = family.family_id

        gene_list = form.cleaned_data['gene_list']
        diagnostic_info_list = []
        for gene_id in gene_list.gene_id_list():
            diagnostic_info = get_gene_diangostic_info(family, gene_id, search_spec.variant_filter)
            add_extra_info_to_variants_family(get_reference(), family, diagnostic_info._variants)
            diagnostic_info_list.append(diagnostic_info)



        return JSONResponse({
            'is_error': False,
            'gene_diagnostic_info_list': [d.toJSON() for d in diagnostic_info_list],
            'gene_list_info': gene_list.toJSON(details=True),
            'data_summary': family.get_data_summary(),
        })

    else:
        return JSONResponse({
            'is_error': True,
            'error': server_utils.form_error_string(form)
        })

def add_family_group(request, project_id):

    error = None

    project = get_object_or_404(Project, project_id=project_id)
    if not project.can_admin(request.user):
        return HttpResponse("unauthorized")

    form = AddFamilyGroupForm(project, request.POST)
    if form.is_valid():
        # todo: move to sample_anagement
        family_group = FamilyGroup.objects.create(
            project=project,
            slug=form.cleaned_data["family_group_slug"],
            name=form.cleaned_data["name"],
            description=form.cleaned_data["description"],
        )
        for family in form.cleaned_data["families"]:
            family_group.families.add(family)
    else:
        error = server_utils.form_error_string(form)

    if error:
        return server_utils.JSONResponse({"is_error": True, "error": error})
    else:
        return redirect("family_group_home", project.project_id, family_group.slug)