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 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_phenotype(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 = 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 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 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 cohort_gene_search(request):
project, cohort = get_project_and_cohort_for_user(request.user, request.GET)
sys.stderr.write("cohort_gene_search %s %s: starting ... \n" % (project.project_id, cohort.cohort_id))
form = api_forms.CohortGeneSearchForm(request.GET)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.cohort_id = cohort.cohort_id
sys.stderr.write("cohort_gene_search %s %s: search spec: %s \n" % (project.project_id, cohort.cohort_id, str(search_spec.toJSON())))
genes = api_utils.calculate_cohort_gene_search(cohort, search_spec)
sys.stderr.write("cohort_gene_search %s %s: get %s genes \n" % (project.project_id, cohort.cohort_id, len(genes)))
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)
sys.stderr.write("cohort_gene_search %s %s: done adding extra info \n" % (project.project_id, cohort.cohort_id))
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 cohort_gene_search(request):
project, cohort = get_project_and_cohort_for_user(request.user, request.GET)
sys.stderr.write("cohort_gene_search %s %s: starting ... \n" % (project.project_id, cohort.cohort_id))
form = api_forms.CohortGeneSearchForm(request.GET)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.cohort_id = cohort.cohort_id
sys.stderr.write("cohort_gene_search %s %s: search spec: %s \n" % (project.project_id, cohort.cohort_id, str(search_spec.toJSON())))
genes = api_utils.calculate_cohort_gene_search(cohort, search_spec)
sys.stderr.write("cohort_gene_search %s %s: get %s genes \n" % (project.project_id, cohort.cohort_id, len(genes)))
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)
sys.stderr.write("cohort_gene_search %s %s: done adding extra info \n" % (project.project_id, cohort.cohort_id))
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):
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_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)
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_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():
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_or_edit_tag.html', {
'project': project,
'form': form,
'error': error,
})
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):
"""
"""
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():
tag = 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_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 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(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_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 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 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 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 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 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 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 edit_family_cause(request, project_id, family_id):
error = None
project = get_object_or_404(Project, project_id=project_id)
family = get_object_or_404(Family, project=project, family_id=family_id)
if not project.can_admin(request.user):
raise PermissionDenied
causal_variants = list(CausalVariant.objects.filter(family=family))
if request.GET.get('variant'):
xpos, ref, alt = request.GET['variant'].split('|')
c = CausalVariant.objects.get_or_create(
family=family,
xpos=int(xpos),
ref=ref,
alt=alt,
)[0]
causal_variants = list(CausalVariant.objects.filter(family=family))
if request.method == 'POST':
form = EditFamilyCauseForm(family, request.POST)
if form.is_valid():
CausalVariant.objects.filter(family=family).delete()
for v_str in request.POST.getlist('variants'):
xpos, ref, alt = v_str.split('|')
CausalVariant.objects.create(
family=family,
xpos=int(xpos),
ref=ref,
alt=alt,
)
update_xbrowse_model(family,
analysis_status='S',
causal_inheritance_mode=form.
cleaned_data['inheritance_mode'])
return redirect('family_home',
project_id=project.project_id,
family_id=family.family_id)
else:
error = server_utils.form_error_string(form)
else:
form = EditFamilyForm(family)
variants = []
for c in causal_variants:
variants.append(
get_datastore(project).get_single_variant(project_id, family_id,
c.xpos, c.ref, c.alt))
return render(
request, 'family/edit_cause.html', {
'project': project,
'family': family,
'error': error,
'form': form,
'variants': [v.toJSON() for v in variants],
})
def edit_family_cause(request, project_id, family_id):
error = None
project = get_object_or_404(Project, project_id=project_id)
family = get_object_or_404(Family, project=project, family_id=family_id)
if not project.can_admin(request.user):
raise PermissionDenied
causal_variants = list(CausalVariant.objects.filter(family=family))
if request.GET.get('variant'):
xpos, ref, alt = request.GET['variant'].split('|')
c = CausalVariant.objects.get_or_create(
family=family,
xpos=int(xpos),
ref=ref,
alt=alt,
)[0]
causal_variants = list(CausalVariant.objects.filter(family=family))
if request.method == 'POST':
form = EditFamilyCauseForm(family, request.POST)
if form.is_valid():
CausalVariant.objects.filter(family=family).delete()
for v_str in request.POST.getlist('variants'):
xpos, ref, alt = v_str.split('|')
CausalVariant.objects.create(
family=family,
xpos=int(xpos),
ref=ref,
alt=alt,
)
update_xbrowse_model(
family,
analysis_status = 'S',
causal_inheritance_mode = form.cleaned_data['inheritance_mode'])
return redirect('family_home', project_id=project.project_id, family_id=family.family_id)
else:
error = server_utils.form_error_string(form)
else:
form = EditFamilyForm(family)
variants = []
for c in causal_variants:
variants.append(get_datastore(project).get_single_variant(project_id, family_id, c.xpos, c.ref, c.alt))
return render(request, 'family/edit_cause.html', {
'project': project,
'family': family,
'error': error,
'form': form,
'variants': [v.toJSON() for v in variants],
})
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
request_dict = request.GET or request.POST
project, family = get_project_and_family_for_user(request.user,
request_dict)
form = api_forms.MendelianVariantSearchForm(request_dict)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.family_id = family.family_id
try:
variants = api_utils.calculate_mendelian_variant_search(
search_spec, family.xfamily())
except Exception as e:
return JSONResponse({
'is_error': True,
'error': str(e.args[0]) if e.args else str(e)
})
sys.stderr.write("done fetching %s variants. Adding extra info..\n" %
len(variants))
hashable_search_params = search_spec.toJSON()
hashable_search_params['family_id'] = family.family_id
search_hash = cache_utils.save_results_for_spec(
project.project_id, hashable_search_params,
[v.toJSON() for v in variants])
add_extra_info_to_variants_family(get_reference(), family, variants)
sys.stderr.write(
"done adding extra info to %s variants. Sending response..\n" %
len(variants))
return_type = request_dict.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 cohort_gene_search_variants(request):
# TODO: this view not like the others - refactor to forms
error = None
project, cohort = get_project_and_cohort_for_user(request.user, request.GET)
if not project.can_view(request.user):
return PermissionDenied
form = api_forms.CohortGeneSearchVariantsForm(request.GET)
if form.is_valid():
gene_id = form.cleaned_data['gene_id']
inheritance_mode = form.cleaned_data['inheritance_mode']
variant_filter = form.cleaned_data['variant_filter']
quality_filter = form.cleaned_data['quality_filter']
else:
error = server_utils.form_error_string(form)
if not error:
indivs_with_inheritance, gene_variation = cohort_search.get_individuals_with_inheritance_in_gene(
get_datastore(project.project_id),
get_reference(),
cohort.xcohort(),
inheritance_mode,
gene_id,
variant_filter=variant_filter,
quality_filter=quality_filter
)
relevant_variants = gene_variation.get_relevant_variants_for_indiv_ids(cohort.indiv_id_list())
api_utils.add_extra_info_to_variants_family(get_reference(), cohort, relevant_variants)
ret = {
'is_error': False,
'variants': [v.toJSON() for v in relevant_variants],
'gene_info': get_reference().get_gene(gene_id),
}
return JSONResponse(ret)
else:
ret = {
'is_error': True,
'error': error
}
return JSONResponse(ret)
def edit_tag(request, project_id, tag_name, tag_title):
"""For HTTP GET requests, this view generates the html page for editing a tag.
For HTTP POST, it saves the submitted changes.
Args:
request: Django HTTP request object
project_id: seqr project ID string
tag_name: name of the tag to edit
tag_title: title of the tag to edit
"""
tag_name = urllib.unquote(tag_name)
tag_title = urllib.unquote(tag_title)
project = get_object_or_404(Project, project_id=project_id)
if not project.can_admin(request.user):
raise PermissionDenied
try:
tag = ProjectTag.objects.get(project=project,
tag=tag_name,
title=tag_title)
except ObjectDoesNotExist as e:
return HttpResponse("Error: tag not found: %s - %s" %
(tag_name, tag_title))
if request.method == 'POST':
form = AddTagForm(project, request.POST)
if form.is_valid():
update_xbrowse_model(tag,
tag=form.cleaned_data['tag'],
title=form.cleaned_data['title'])
return redirect('project_home', project_id=project_id)
error = server_utils.form_error_string(form)
else:
error = None
form = AddTagForm(project)
return render(
request, 'project/add_or_edit_tag.html', {
'project': project,
'tag_name': tag.tag,
'tag_title': tag.title,
'form': form,
'error': error,
})
def cohort_gene_search_variants(request):
# TODO: this view not like the others - refactor to forms
error = None
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.CohortGeneSearchVariantsForm(request.GET)
if form.is_valid():
gene_id = form.cleaned_data['gene_id']
inheritance_mode = form.cleaned_data['inheritance_mode']
variant_filter = form.cleaned_data['variant_filter']
quality_filter = form.cleaned_data['quality_filter']
else:
error = server_utils.form_error_string(form)
if not error:
indivs_with_inheritance, gene_variation = cohort_search.get_individuals_with_inheritance_in_gene(
get_datastore(project.project_id),
get_reference(),
cohort.xcohort(),
inheritance_mode,
gene_id,
variant_filter=variant_filter,
quality_filter=quality_filter)
relevant_variants = gene_variation.get_relevant_variants_for_indiv_ids(
cohort.indiv_id_list())
api_utils.add_extra_info_to_variants_family(get_reference(), cohort,
relevant_variants)
ret = {
'is_error': False,
'variants': [v.toJSON() for v in relevant_variants],
'gene_info': get_reference().get_gene(gene_id),
}
return JSONResponse(ret)
else:
ret = {'is_error': True, 'error': error}
return JSONResponse(ret)
def add_variant_note(request):
"""
"""
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(
request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantNoteForm(project, request.GET)
if form.is_valid():
note = VariantNote.objects.create(
user=request.user,
date_saved=datetime.datetime.now(),
project=project,
note=form.cleaned_data['note_text'],
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
if family:
note.family = family
note.save()
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
add_extra_info_to_variants_family(get_reference(), family, [
variant,
])
ret = {
'is_error': False,
'variant': variant.toJSON(),
}
else:
ret = {'is_error': True, 'error': server_utils.form_error_string(form)}
return JSONResponse(ret)
def add_variant_note(request):
"""
"""
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantNoteForm(project, request.GET)
if form.is_valid():
note = VariantNote.objects.create(
user=request.user,
date_saved=datetime.datetime.now(),
project=project,
note=form.cleaned_data['note_text'],
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
if family:
note.family = family
note.save()
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
add_extra_info_to_variants_family(get_reference(), family, [variant,])
ret = {
'is_error': False,
'variant': variant.toJSON(),
}
else:
ret = {
'is_error': True,
'error': server_utils.form_error_string(form)
}
return JSONResponse(ret)
def edit_tag(request, project_id, tag_name, tag_title):
"""For HTTP GET requests, this view generates the html page for editing a tag.
For HTTP POST, it saves the submitted changes.
Args:
request: Django HTTP request object
project_id: seqr project ID string
tag_name: name of the tag to edit
tag_title: title of the tag to edit
"""
tag_name = urllib.unquote(tag_name)
tag_title = urllib.unquote(tag_title)
project = get_object_or_404(Project, project_id=project_id)
if not project.can_admin(request.user):
raise PermissionDenied
try:
tag = ProjectTag.objects.get(project=project, tag=tag_name, title=tag_title)
except ObjectDoesNotExist as e:
return HttpResponse("Error: tag not found: %s - %s" % (tag_name, tag_title))
if request.method == 'POST':
form = AddTagForm(project, request.POST)
if form.is_valid():
update_xbrowse_model(tag, tag=form.cleaned_data['tag'], title=form.cleaned_data['title'])
return redirect('project_home', project_id=project_id)
error = server_utils.form_error_string(form)
else:
error = None
form = AddTagForm(project)
return render(request, 'project/add_or_edit_tag.html', {
'project': project,
'tag_name': tag.tag,
'tag_title': tag.title,
'form': form,
'error': error,
})
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():
tag = 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 edit_variant_tags(request):
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(
request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantTagsForm(project, request.GET)
if form.is_valid():
VariantTag.objects.filter(family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt']).delete()
for project_tag in form.cleaned_data['project_tags']:
VariantTag.objects.create(
project_tag=project_tag,
family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
add_extra_info_to_variants_family(get_reference(), family, [
variant,
])
ret = {
'is_error': False,
'variant': variant.toJSON(),
}
else:
ret = {'is_error': True, 'error': server_utils.form_error_string(form)}
return JSONResponse(ret)
def edit_variant_tags(request):
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantTagsForm(project, request.GET)
if form.is_valid():
VariantTag.objects.filter(family=family, xpos=form.cleaned_data['xpos'], ref=form.cleaned_data['ref'], alt=form.cleaned_data['alt']).delete()
for project_tag in form.cleaned_data['project_tags']:
VariantTag.objects.create(
user=request.user,
date_saved=datetime.datetime.now(),
project_tag=project_tag,
family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
add_extra_info_to_variants_family(get_reference(), family, [variant,])
ret = {
'is_error': False,
'variant': variant.toJSON(),
}
else:
ret = {
'is_error': True,
'error': server_utils.form_error_string(form)
}
return JSONResponse(ret)
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_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 cohort_gene_search(request):
project, cohort = get_project_and_cohort_for_user(request.user, request.GET)
form = api_forms.CohortGeneSearchForm(request.GET)
if form.is_valid():
search_spec = form.cleaned_data['search_spec']
search_spec.cohort_id = cohort.cohort_id
genes = api_utils.calculate_cohort_gene_search(cohort, 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_or_edit_variant_note(request):
"""Add a variant note"""
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantNoteForm(project, request.GET)
if not form.is_valid():
return JSONResponse({
'is_error': True,
'error': server_utils.form_error_string(form)
})
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
if not variant:
variant = Variant.fromJSON({
'xpos' : form.cleaned_data['xpos'], 'ref': form.cleaned_data['ref'], 'alt': form.cleaned_data['alt'],
'genotypes': {}, 'extras': {},
})
if 'note_id' in form.cleaned_data and form.cleaned_data['note_id']:
event_type = "edit_variant_note"
notes = VariantNote.objects.filter(
id=form.cleaned_data['note_id'],
project=project,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
if not notes:
return JSONResponse({
'is_error': True,
'error': 'note id %s not found' % form.cleaned_data['note_id']
})
note = notes[0]
note.user = request.user
note.note = form.cleaned_data['note_text']
note.date_saved = timezone.now()
if family:
note.family = family
note.save()
else:
event_type = "add_variant_note"
VariantNote.objects.create(
user=request.user,
project=project,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
note=form.cleaned_data['note_text'],
date_saved=timezone.now(),
family=family,
)
add_extra_info_to_variants_family(get_reference(), family, [variant,])
try:
settings.EVENTS_COLLECTION.insert({
'event_type': event_type,
'date': timezone.now(),
'project_id': ''.join(project.project_id),
'family_id': family.family_id,
'note': form.cleaned_data['note_text'],
'xpos':form.cleaned_data['xpos'],
'pos':variant.pos,
'chrom': variant.chr,
'ref':form.cleaned_data['ref'],
'alt':form.cleaned_data['alt'],
'gene_names': ", ".join(variant.extras['gene_names'].values()),
'username': request.user.username,
'email': request.user.email,
})
except Exception as e:
logging.error("Error while logging %s event: %s" % (event_type, e))
return JSONResponse({
'is_error': False,
'variant': variant.toJSON(),
})
def add_or_edit_variant_tags(request):
family = None
if 'family_id' in request.GET:
project, family = get_project_and_family_for_user(request.user, request.GET)
else:
project = utils.get_project_for_user(request.user, request.GET)
form = api_forms.VariantTagsForm(project, request.GET)
if not form.is_valid():
ret = {
'is_error': True,
'error': server_utils.form_error_string(form)
}
return JSONResponse(ret)
variant = get_datastore(project.project_id).get_single_variant(
project.project_id,
family.family_id,
form.cleaned_data['xpos'],
form.cleaned_data['ref'],
form.cleaned_data['alt'],
)
if not variant:
variant = Variant(form.cleaned_data['xpos'], form.cleaned_data['ref'], form.cleaned_data['alt'])
variant_tags_to_delete = {
variant_tag.id: variant_tag for variant_tag in VariantTag.objects.filter(
family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'])
}
project_tag_events = {}
for project_tag in form.cleaned_data['project_tags']:
# retrieve tags
tag, created = VariantTag.objects.get_or_create(
project_tag=project_tag,
family=family,
xpos=form.cleaned_data['xpos'],
ref=form.cleaned_data['ref'],
alt=form.cleaned_data['alt'],
)
if not created:
# this tag already exists so just keep it (eg. remove it from the set of tags that will be deleted)
del variant_tags_to_delete[tag.id]
continue
# this a new tag, so update who saved it and when
project_tag_events[project_tag] = "add_variant_tag"
tag.user = request.user
tag.date_saved = timezone.now()
tag.search_url = form.cleaned_data['search_url']
tag.save()
# delete the tags that are no longer checked.
for variant_tag in variant_tags_to_delete.values():
project_tag_events[variant_tag.project_tag] = "delete_variant_tag"
variant_tag.delete()
# add the extra info after updating the tag info in the database, so that the new tag info is added to the variant JSON
add_extra_info_to_variants_family(get_reference(), family, [variant,])
# log tag creation
for project_tag, event_type in project_tag_events.items():
try:
settings.EVENTS_COLLECTION.insert({
'event_type': event_type,
'date': timezone.now(),
'project_id': ''.join(project.project_id),
'family_id': family.family_id,
'tag': project_tag.tag,
'title': project_tag.title,
'xpos':form.cleaned_data['xpos'],
'pos':variant.pos,
'chrom': variant.chr,
'ref':form.cleaned_data['ref'],
'alt':form.cleaned_data['alt'],
'gene_names': ", ".join(variant.extras['gene_names'].values()),
'username': request.user.username,
'email': request.user.email,
'search_url': form.cleaned_data.get('search_url'),
})
except Exception as e:
logging.error("Error while logging add_variant_tag event: %s" % e)
return JSONResponse({
'is_error': False,
'variant': variant.toJSON(),
})
