def family_group_edit(request, project_id, family_group_slug):
project = get_object_or_404(Project, project_id=project_id)
family_group = get_object_or_404(FamilyGroup, project=project, slug=family_group_slug)
if not project.can_admin(request.user):
raise PermissionDenied
if request.method == 'POST':
form = base_forms.EditFamilyGroupForm(project, request.POST)
if form.is_valid():
update_xbrowse_model(
family_group,
name=form.cleaned_data['name'],
description=form.cleaned_data['description'],
slug=form.cleaned_data['slug']
)
return redirect('family_group_home', project.project_id, family_group.slug)
else:
form = base_forms.EditFamilyGroupForm(project, initial={
'name': family_group.name,
'description': family_group.description,
})
return render(request, 'family_group/family_group_edit.html', {
'project': project,
'family_group': family_group,
'form': form,
'new_page_url': '/project/{}/analysis_group/{}'.format(project.seqr_project.guid, family_group.seqr_analysis_group.guid) if project.seqr_project and family_group.seqr_analysis_group else None,
})
def __process_sync_request_helper(patient_id, xbrowse_user, project_name, url_parameters, curr_session):
"""
Sync data of this user between xbrowse and phenotips. Persists the update in a
database for later searching and edit audits.
"""
try:
# first get the newest data via API call
url = os.path.join(settings.PHENOPTIPS_BASE_URL, 'bin/get/PhenoTips/ExportPatient?id=' + patient_id)
response = curr_session.get(url)
updated_patient_record = response.json()
settings.PHENOTIPS_EDIT_AUDIT.insert({
'xbrowse_username': xbrowse_user.username,
'xbrowse_user_email': xbrowse_user.email,
'updated_patient_record': updated_patient_record,
'project_name': project_name,
'patient_id': patient_id,
'url_parameters': parameters,
'time': datetime.datetime.now()
})
except Exception as e:
sys.stderr.write('phenotips.views:' + str(e))
try:
external_id = updated_patient_record['external_id']
individual = Individual.objects.get(phenotips_id = external_id)
update_xbrowse_model(individual,
phenotips_data = json.dumps(updated_patient_record))
except Exception as e:
sys.stderr.write('error while saving to db:' + str(e))
def edit_basic_info(request, project_id):
"""
Form for a manager to add a new collaborator
"""
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.EditBasicInfoForm(request.POST)
if form.is_valid():
update_xbrowse_model(
project,
project_name=form.cleaned_data['name'],
description=form.cleaned_data['description'])
return redirect('project_settings', project_id)
else:
form = base_forms.EditBasicInfoForm({'name': project.project_name, 'description': project.description})
return render(request, 'project/edit_basic_info.html', {
'project': project,
'form': form,
'new_page_url': '/project/{}/project_page'.format(project.seqr_project.guid) if project.seqr_project else None,
})
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 project_tags(request, project_id):
"""
Form for a manager to add a new collaborator
"""
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.EditBasicInfoForm(request.POST)
if form.is_valid():
update_xbrowse_model(project,
project_name=form.cleaned_data['name'],
description=form.cleaned_data['description'])
return redirect('project_settings', project_id)
else:
form = base_forms.EditBasicInfoForm({
'name': project.project_name,
'description': project.description
})
return render(request, 'project/edit_basic_info.html', {
'project': project,
'form': 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 insert_individual_into_phenotips(request, eid, project_id):
"""
Insert these phenotypes of this individual into PhenoTips
Args:
eid is an external id to PhenoTips. (A sample ID in seqr)
project_id the project this individual belongs to
Returns:
A JSON response with insertion status
"""
project = get_object_or_404(Project, project_id=project_id)
if not project.can_edit(request.user):
raise PermissionDenied
#this is the phenotypes that were uploaded and needs to be inserted in
uploaded_phenotype_data = json.loads(
request.POST.get("phenotypes", "no data found in POST"))
#finding phenotips ID via sample ID, which is in phenotype_data['external_id'], and fetching existing
#phenotips data with that
indiv = Individual.objects.get(
project=project, indiv_id=uploaded_phenotype_data['external_id'])
phenotips_id = indiv.phenotips_id
existing_phenotypes = get_phenotypes_entered_for_individual(
project_id, phenotips_id)
#using the external ID, and ID from existing record in PhenoTips
external_id = phenotips_id
#merge uploaded data into what'a already there
merged_phenotypes = merge_phenotype_data(uploaded_phenotype_data,
existing_phenotypes)
username, passwd = (settings.PHENOTIPS_ADMIN_UNAME,
settings.PHENOTIPS_ADMIN_PWD)
url = settings.PHENOTIPS_UPLOAD_EXTERNAL_PHENOTYPE_URL + '/' + external_id
response = requests.put(url,
data=json.dumps(merged_phenotypes),
auth=(username, passwd))
#do some validation to find out what went in (some values tend to drop in upload process
VALID_UPLOAD = 204
validation = ""
if response.status_code == VALID_UPLOAD:
phenotypes_now_avalable = get_phenotypes_entered_for_individual(
project_id, external_id)
validation = validate_phenotips_upload(phenotypes_now_avalable,
merged_phenotypes)
update_xbrowse_model(
indiv, phenotips_data=json.dumps(phenotypes_now_avalable))
if response.status_code != VALID_UPLOAD:
logger.error("ERROR: %s %s" % (response.status_code, response.reason))
return JSONResponse({
'response': response.text,
'status_code': response.status_code,
'validation': validation
})
def delete_family(project_id, family_id):
"""
Delete a project and perform any cleanup (ie. deleting from datastore and removing temp files)
"""
family = Family.objects.get(project__project_id=project_id, family_id=family_id)
for individual in family.get_individuals():
update_xbrowse_model(individual, family=None)
get_mall(project_id).variant_store.delete_family(project_id, family_id)
delete_xbrowse_model(family)
def delete_family(project_id, family_id):
"""
Delete a project and perform any cleanup (ie. deleting from datastore and removing temp files)
"""
family = Family.objects.get(project__project_id=project_id, family_id=family_id)
for individual in family.get_individuals():
update_xbrowse_model(individual, family=None)
get_mall(project_id).variant_store.delete_family(project_id, family_id)
delete_xbrowse_model(family)
def get_or_create_project_tag(project,
order,
category,
tag_name,
description,
color='#1f78b4',
original_names=None):
"""
Updates or creates a particular ProjectTag in a given project.
Args:
project (object): The project that contains this tag
category (string):
tag_name (string): The name of the new tag (can contain spaces) (eg. "Causal Variant")
description (string): Longer description of the tag
color (string): hex color (eg. "#123456")
original_names (list): if the tag appeaered under one or more different names, remap these to the new tag_name
Returns:
new ProjectTag model object (or an existing one if a match was found)
"""
project_tag = None
if original_names:
for original_name in original_names:
tags = ProjectTag.objects.filter(project=project,
tag__icontains=original_name,
order__isnull=True)
if tags:
project_tag = tags[0]
if project_tag is None:
tags = ProjectTag.objects.filter(project=project, tag__iexact=tag_name)
if tags:
project_tag = tags[0]
if project_tag is None:
tags = ProjectTag.objects.filter(project=project,
tag__icontains=tag_name)
if tags:
project_tag = tags[0]
if project_tag is None:
project_tag, created = get_or_create_xbrowse_model(ProjectTag,
project=project,
tag=tag_name)
if created:
print("Created new tag: %s : %s" % (project, tag_name))
update_xbrowse_model(project_tag,
order=order,
category=category,
tag=tag_name,
title=description,
color=color)
def set_family_id_for_individual(individual, family_id):
"""
Sets family for an individual (creating if necessary)
Saves both to db
"""
project = individual.project
if family_id:
family = get_or_create_xbrowse_model(Family, family_id=family_id, project=project)[0]
else:
family = None
update_xbrowse_model(individual, family=family)
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 save_individual_from_json_dict(project, indiv_dict):
individual = get_or_create_xbrowse_model(Individual, indiv_id=indiv_dict['indiv_id'], project=project)[0]
update_xbrowse_model(
individual,
gender = indiv_dict.get('gender'),
affected = indiv_dict.get('affected'),
nickname = indiv_dict.get('nickname', ''),
paternal_id = indiv_dict.get('paternal_id', ''),
maternal_id = indiv_dict.get('maternal_id', ''))
sample_management.set_family_id_for_individual(individual, indiv_dict.get('family_id', ''))
sample_management.set_individual_phenotypes_from_dict(individual, indiv_dict.get('phenotypes', {}))
def save_individual_from_json_dict(project, indiv_dict):
individual = get_or_create_xbrowse_model(Individual, indiv_id=indiv_dict['indiv_id'], project=project)[0]
update_xbrowse_model(
individual,
gender = indiv_dict.get('gender'),
affected = indiv_dict.get('affected'),
nickname = indiv_dict.get('nickname', ''),
paternal_id = indiv_dict.get('paternal_id', ''),
maternal_id = indiv_dict.get('maternal_id', ''))
sample_management.set_family_id_for_individual(individual, indiv_dict.get('family_id', ''))
sample_management.set_individual_phenotypes_from_dict(individual, indiv_dict.get('phenotypes', {}))
def set_parents_for_individual(individual):
"""
Sets family for an individual (creating if necessary)
Saves both to db
"""
project = individual.project
if individual.paternal_id and individual.paternal_id != '.':
father = get_or_create_xbrowse_model(Individual, project=project, indiv_id=individual.paternal_id)[0]
update_xbrowse_model(father, family=individual.family)
if individual.maternal_id and individual.maternal_id != '.':
mother = get_or_create_xbrowse_model(Individual, project=project, indiv_id=individual.maternal_id)[0]
update_xbrowse_model(mother, family=individual.family)
def set_parents_for_individual(individual):
"""
Sets family for an individual (creating if necessary)
Saves both to db
"""
project = individual.project
if individual.paternal_id and individual.paternal_id != '.':
father = get_or_create_xbrowse_model(Individual, project=project, indiv_id=individual.paternal_id)[0]
update_xbrowse_model(father, family=individual.family)
if individual.maternal_id and individual.maternal_id != '.':
mother = get_or_create_xbrowse_model(Individual, project=project, indiv_id=individual.maternal_id)[0]
update_xbrowse_model(mother, family=individual.family)
def pedigree_image_delete(request, project_id, family_id):
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
if request.method == 'POST':
if request.POST.get('confirm') == 'yes':
update_xbrowse_model(family, pedigree_image = None)
return redirect('family_home', project.project_id, family.family_id)
return render(request, 'family/pedigree_image_delete.html', {
'project': project,
'family': family,
})
def pedigree_image_delete(request, project_id, family_id):
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
if request.method == 'POST':
if request.POST.get('confirm') == 'yes':
update_xbrowse_model(family, pedigree_image = None)
return redirect('family_home', project.project_id, family.family_id)
return render(request, 'family/pedigree_image_delete.html', {
'project': project,
'family': family,
})
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 insert_individual_into_phenotips(request, eid,project_id):
"""
Insert these phenotypes of this individual into PhenoTips
Args:
eid is an external id to PhenoTips. (A sample ID in seqr)
project_id the project this individual belongs to
Returns:
A JSON response with insertion status
"""
project = get_object_or_404(Project, project_id=project_id)
if not project.can_edit(request.user):
raise PermissionDenied
#this is the phenotypes that were uploaded and needs to be inserted in
uploaded_phenotype_data = json.loads(request.POST.get("phenotypes","no data found in POST"))
#finding phenotips ID via sample ID, which is in phenotype_data['external_id'], and fetching existing
#phenotips data with that
indiv = Individual.objects.get(project=project, indiv_id=uploaded_phenotype_data['external_id'])
phenotips_id = indiv.phenotips_id
existing_phenotypes = get_phenotypes_entered_for_individual(project_id, phenotips_id)
#using the external ID, and ID from existing record in PhenoTips
external_id = phenotips_id
#merge uploaded data into what'a already there
merged_phenotypes = merge_phenotype_data(uploaded_phenotype_data,existing_phenotypes)
username, passwd = (settings.PHENOTIPS_ADMIN_UNAME, settings.PHENOTIPS_ADMIN_PWD)
url=settings.PHENOTIPS_UPLOAD_EXTERNAL_PHENOTYPE_URL+'/'+ external_id
response=requests.put(url, data=json.dumps(merged_phenotypes), auth=(username, passwd))
#do some validation to find out what went in (some values tend to drop in upload process
VALID_UPLOAD=204
validation=""
if response.status_code == VALID_UPLOAD:
phenotypes_now_avalable = get_phenotypes_entered_for_individual(project_id, external_id)
validation = validate_phenotips_upload(phenotypes_now_avalable,merged_phenotypes)
update_xbrowse_model(
indiv,
phenotips_data=json.dumps(phenotypes_now_avalable))
if response.status_code != VALID_UPLOAD:
logger.error("ERROR: %s %s" % (response.status_code, response.reason))
return JSONResponse({'response':response.text,
'status_code':response.status_code,
'validation':validation})
def load_project(project_id,
force_load_annotations=False,
force_load_variants=False,
vcf_files=None,
mark_as_loaded=True,
start_from_chrom=None,
end_with_chrom=None):
"""
Reload a whole project
"""
if not settings.DEBUG:
settings.EVENTS_COLLECTION.insert({
'event_type': 'load_project_started',
'date': timezone.now(),
'project_id': project_id
})
if vcf_files is None:
load_project_variants(project_id,
force_load_annotations=force_load_annotations,
force_load_variants=force_load_variants,
start_from_chrom=start_from_chrom,
end_with_chrom=end_with_chrom)
else:
load_project_variants_from_vcf(project_id,
vcf_files=vcf_files,
mark_as_loaded=mark_as_loaded,
start_from_chrom=start_from_chrom,
end_with_chrom=end_with_chrom)
load_project_breakpoints(project_id)
# update the analysis status from 'Waiting for data' to 'Analysis in Progress'
for f in Family.objects.filter(project__project_id=project_id):
if f.analysis_status == 'Q':
update_xbrowse_model(f, analysis_status='I')
if not settings.DEBUG:
settings.EVENTS_COLLECTION.insert({
'event_type': 'load_project_finished',
'date': timezone.now(),
'project_id': project_id
})
def family_group_edit(request, project_id, family_group_slug):
project = get_object_or_404(Project, project_id=project_id)
family_group = get_object_or_404(FamilyGroup,
project=project,
slug=family_group_slug)
if not project.can_admin(request.user):
raise PermissionDenied
if request.method == 'POST':
form = base_forms.EditFamilyGroupForm(project, request.POST)
if form.is_valid():
update_xbrowse_model(family_group,
name=form.cleaned_data['name'],
description=form.cleaned_data['description'],
slug=form.cleaned_data['slug'])
return redirect('family_group_home', project.project_id,
family_group.slug)
else:
form = base_forms.EditFamilyGroupForm(project,
initial={
'name':
family_group.name,
'description':
family_group.description,
})
return render(
request, 'family_group/family_group_edit.html', {
'project':
project,
'family_group':
family_group,
'form':
form,
'new_page_url':
'/project/{}/analysis_group/{}'.format(
project.seqr_project.guid,
family_group.seqr_analysis_group.guid) if project.seqr_project
and family_group.seqr_analysis_group else None,
})
def edit(request, slug):
gene_list = get_object_or_404(GeneList, slug=slug)
authorized = False
if gene_list.owner == request.user:
authorized = True
if not authorized:
raise PermissionDenied
if request.method == 'POST':
form = GeneListForm(request.POST)
if form.is_valid():
update_xbrowse_model(gene_list,
slug=form.cleaned_data['slug'],
name=form.cleaned_data['name'],
description=form.cleaned_data['description'],
is_public=form.cleaned_data['is_public'],
last_updated=datetime.datetime.now())
for gene_list_item in GeneListItem.objects.filter(
gene_list=gene_list):
delete_xbrowse_model(gene_list_item)
for gene_id in form.cleaned_data['gene_ids']:
create_xbrowse_model(GeneListItem,
gene_list=gene_list,
gene_id=gene_id)
return redirect('gene_list', slug=gene_list.slug)
else:
form = GeneListForm(
initial={
'name': gene_list.name,
'description': gene_list.description,
'is_public': gene_list.is_public,
'genes': '\n'.join(
[g['symbol'] for g in gene_list.get_genes()]),
})
return render(request, 'gene_lists/edit.html', {
'form': form,
'gene_list': gene_list,
})
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 __process_sync_request_helper(patient_id, xbrowse_user, project_name,
url_parameters, curr_session):
"""
Sync data of this user between xbrowse and phenotips. Persists the update in a
database for later searching and edit audits.
"""
try:
# first get the newest data via API call
url = os.path.join(settings.PHENOPTIPS_BASE_URL,
'bin/get/PhenoTips/ExportPatient?id=' + patient_id)
response = curr_session.get(url)
updated_patient_record = response.json()
settings.PHENOTIPS_EDIT_AUDIT.insert({
'xbrowse_username':
xbrowse_user.username,
'xbrowse_user_email':
xbrowse_user.email,
'updated_patient_record':
updated_patient_record,
'project_name':
project_name,
'patient_id':
patient_id,
'url_parameters':
parameters,
'time':
datetime.datetime.now()
})
except Exception as e:
sys.stderr.write('phenotips.views:' + str(e))
try:
external_id = updated_patient_record['external_id']
individual = Individual.objects.get(phenotips_id=external_id)
update_xbrowse_model(individual,
phenotips_data=json.dumps(updated_patient_record))
except Exception as e:
sys.stderr.write('error while saving to db:' + str(e))
def update_project_from_fam(project, fam_file, in_case_review=False):
"""
Update project with the individuals in fam_file
Create individuals and families if necessary and return a list of
JSON obejcts representing the individual details
"""
xindividuals = fam_stuff.get_individuals_from_fam_file(fam_file)
individual_details=[]
for ind in xindividuals:
individual_details.append(ind.toJSON())
individuals = update_project_from_individuals(project, xindividuals)
if in_case_review:
for ind in individuals:
ind.in_case_review = True
if not ind.case_review_status:
update_xbrowse_model(ind, case_review_status='I')
else:
print("ERROR: case review status already set to" + ind.case_review_status)
return individual_details
def update_project_from_fam(project, fam_file, in_case_review=False):
"""
Update project with the individuals in fam_file
Create individuals and families if necessary and return a list of
JSON obejcts representing the individual details
"""
xindividuals = fam_stuff.get_individuals_from_fam_file(fam_file)
individual_details=[]
for ind in xindividuals:
individual_details.append(ind.toJSON())
individuals = update_project_from_individuals(project, xindividuals)
if in_case_review:
for ind in individuals:
ind.in_case_review = True
if not ind.case_review_status:
update_xbrowse_model(ind, case_review_status='I')
else:
print("ERROR: case review status already set to" + ind.case_review_status)
return individual_details
def edit(request, slug):
gene_list = get_object_or_404(GeneList, slug=slug)
authorized = False
if gene_list.owner == request.user:
authorized = True
if not authorized:
raise PermissionDenied
if request.method == 'POST':
form = GeneListForm(request.POST)
if form.is_valid():
update_xbrowse_model(gene_list,
slug=form.cleaned_data['slug'],
name=form.cleaned_data['name'],
description=form.cleaned_data['description'],
is_public=form.cleaned_data['is_public'],
last_updated = datetime.datetime.now())
for gene_list_item in GeneListItem.objects.filter(gene_list=gene_list):
delete_xbrowse_model(gene_list_item)
for gene_id in form.cleaned_data['gene_ids']:
create_xbrowse_model(GeneListItem, gene_list=gene_list, gene_id=gene_id)
return redirect('gene_list', slug=gene_list.slug)
else:
form = GeneListForm(initial={
'name': gene_list.name,
'description': gene_list.description,
'is_public': gene_list.is_public,
'genes': '\n'.join([g['symbol'] for g in gene_list.get_genes()]),
})
return render(request, 'gene_lists/edit.html', {
'form': form,
'gene_list': gene_list,
'new_page_url': '/gene_lists/{}'.format(gene_list.seqr_locus_list.guid) if gene_list.seqr_locus_list else None,
})
def edit_family(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
if request.method == 'POST':
form = EditFamilyForm(request.POST, request.FILES)
if form.is_valid():
update_xbrowse_model(
family,
coded_phenotype=form.cleaned_data['coded_phenotype'],
short_description=form.cleaned_data['short_description'],
about_family_content=form.cleaned_data['about_family_content'],
analysis_summary_content=form.cleaned_data['analysis_summary_content'],
post_discovery_omim_number=form.cleaned_data['post_discovery_omim_number'])
if family.analysis_status != form.cleaned_data['analysis_status']:
if family.analysis_status not in ('Q', 'I'):
if not settings.DEBUG: settings.EVENTS_COLLECTION.insert({
'event_type': 'family_analysis_status_changed', 'project_id': project_id, 'family_id': family_id, 'date': timezone.now(),
'username': request.user.username, 'email': request.user.email,
'from': family.analysis_status, 'to': form.cleaned_data['analysis_status'] })
update_xbrowse_model(
family,
analysis_status=form.cleaned_data['analysis_status'],
analysis_status_date_saved=timezone.now(),
analysis_status_saved_by=request.user)
if 'pedigree_image' in request.FILES:
update_xbrowse_model(
family,
pedigree_image = request.FILES['pedigree_image'])
return redirect('family_home', project_id=project.project_id, family_id=family.family_id)
else:
form = EditFamilyForm(initial={
'coded_phenotype': family.coded_phenotype,
'short_description': family.short_description,
'about_family_content': family.about_family_content,
'analysis_summary_content': family.analysis_summary_content,
'post_discovery_omim_number': family.post_discovery_omim_number,
})
return render(request, 'family_edit.html', {
'user': request.user,
'project': project,
'family': family,
'error': error,
'form': form,
'analysis_statuses': ANALYSIS_STATUS_CHOICES,
'new_page_url': '/project/{0}/family_page/{1}'.format(
family.seqr_family.project.guid, family.seqr_family.guid) if family.seqr_family else None,
})
def edit_family(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
if request.method == 'POST':
form = EditFamilyForm(request.POST, request.FILES)
if form.is_valid():
update_xbrowse_model(
family,
coded_phenotype=form.cleaned_data['coded_phenotype'],
short_description=form.cleaned_data['short_description'],
about_family_content=form.cleaned_data['about_family_content'],
analysis_summary_content=form.cleaned_data['analysis_summary_content'],
post_discovery_omim_number=form.cleaned_data['post_discovery_omim_number'])
if family.analysis_status != form.cleaned_data['analysis_status']:
if family.analysis_status not in ('Q', 'I'):
if not settings.DEBUG: settings.EVENTS_COLLECTION.insert({
'event_type': 'family_analysis_status_changed', 'project_id': project_id, 'family_id': family_id, 'date': timezone.now(),
'username': request.user.username, 'email': request.user.email,
'from': family.analysis_status, 'to': form.cleaned_data['analysis_status'] })
update_xbrowse_model(
family,
analysis_status=form.cleaned_data['analysis_status'],
analysis_status_date_saved=timezone.now(),
analysis_status_saved_by=request.user)
if 'pedigree_image' in request.FILES:
update_xbrowse_model(
family,
pedigree_image = request.FILES['pedigree_image'])
return redirect('family_home', project_id=project.project_id, family_id=family.family_id)
else:
form = EditFamilyForm(initial={
'coded_phenotype': family.coded_phenotype,
'short_description': family.short_description,
'about_family_content': family.about_family_content,
'analysis_summary_content': family.analysis_summary_content,
'post_discovery_omim_number': family.post_discovery_omim_number,
})
return render(request, 'family_edit.html', {
'user': request.user,
'project': project,
'family': family,
'error': error,
'form': form,
'analysis_statuses': ANALYSIS_STATUS_CHOICES,
'new_page_url': '/project/{0}/family_page/{1}'.format(
family.seqr_family.project.guid, family.seqr_family.guid) if family.seqr_family else None,
})
def load_project(project_id, force_load_annotations=False, force_load_variants=False, vcf_files=None, mark_as_loaded=True, start_from_chrom=None, end_with_chrom=None):
"""
Reload a whole project
"""
if not settings.DEBUG: settings.EVENTS_COLLECTION.insert({
'event_type': 'load_project_started',
'date': timezone.now(),
'project_id': project_id
})
if vcf_files is None:
load_project_variants(
project_id,
force_load_annotations=force_load_annotations,
force_load_variants=force_load_variants,
start_from_chrom=start_from_chrom,
end_with_chrom=end_with_chrom)
else:
load_project_variants_from_vcf(
project_id,
vcf_files=vcf_files,
mark_as_loaded=mark_as_loaded,
start_from_chrom=start_from_chrom,
end_with_chrom=end_with_chrom)
load_project_breakpoints(project_id)
# update the analysis status from 'Waiting for data' to 'Analysis in Progress'
for f in Family.objects.filter(project__project_id=project_id):
if f.analysis_status == 'Q':
update_xbrowse_model(f, analysis_status='I')
if not settings.DEBUG: settings.EVENTS_COLLECTION.insert({
'event_type': 'load_project_finished',
'date': timezone.now(),
'project_id': project_id
})
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 handle(self, *args, **options):
from_project = BaseProject.objects.get(project_id=options['from_project'])
to_project = BaseProject.objects.get(project_id=options['to_project'])
to_seqr_project = find_matching_seqr_model(to_project)
family_ids = options['family_ids']
families = BaseFamily.objects.filter(project=from_project, family_id__in=family_ids)
print('Found {} out of {} families. No match for: {}.'.format(len(families), len(set(family_ids)), set(family_ids) - set([f.family_id for f in families])))
for f in families:
print("==> Moving {}".format(f))
for individual in f.individual_set.all():
individual.project = to_project
individual.save()
# Update individuals in phenotips
if _phenotips_patient_exists(individual.seqr_individual):
# make sure phenotips_patient_id is up to date
seqr_individual = individual.seqr_individual
data_json = _get_patient_data(
from_project.seqr_project,
seqr_individual,
)
seqr_individual.phenotips_patient_id = data_json["id"]
seqr_individual.save()
# update permissions
phenotips_readonly_username, _ = _get_phenotips_uname_and_pwd_for_project(to_project.seqr_project.phenotips_user_id, read_only=True)
_add_user_to_patient(phenotips_readonly_username, seqr_individual.phenotips_patient_id, allow_edit=False)
phenotips_readwrite_username, _ = _get_phenotips_uname_and_pwd_for_project(to_project.seqr_project.phenotips_user_id, read_only=False)
_add_user_to_patient(phenotips_readwrite_username, seqr_individual.phenotips_patient_id, allow_edit=True)
# Update individuals samples/ VCFs
for from_vcf_file in individual.vcf_files.all():
to_vcf_file, _ = VCFFile.objects.get_or_create(
project=to_project,
elasticsearch_index=from_vcf_file.elasticsearch_index,
file_path=from_vcf_file.file_path,
dataset_type=from_vcf_file.dataset_type,
sample_type=from_vcf_file.sample_type,
loaded_date=from_vcf_file.loaded_date,
)
individual.vcf_files.add(to_vcf_file)
individual.vcf_files.remove(from_vcf_file)
# Update variant tags/ notes
saved_variants = set()
for note in BaseVariantNote.objects.filter(family=f):
seqr_note = find_matching_seqr_model(note)
if seqr_note:
saved_variants.add(seqr_note.saved_variant)
note.project = to_project
note.save()
for variant_tag in BaseVariantTag.objects.filter(family=f):
to_project_tag, created = get_or_create_xbrowse_model(
ProjectTag, project=to_project, tag=variant_tag.project_tag.tag
)
if created:
update_xbrowse_model(
to_project_tag,
category=variant_tag.project_tag.category,
title=variant_tag.project_tag.title,
color=variant_tag.project_tag.color,
order=variant_tag.project_tag.order,
)
update_xbrowse_model(variant_tag, project_tag=to_project_tag)
seqr_variant_tag = find_matching_seqr_model(variant_tag)
if seqr_variant_tag:
saved_variants.add(seqr_variant_tag.saved_variant)
for saved_variant in saved_variants:
saved_variant.project = to_seqr_project
saved_variant.save()
# Update families
update_xbrowse_model(f, project=to_project)
print("Done.")
def handle(self, *args, **options):
to_project = BaseProject.objects.get(project_id=options['to_project'])
from_project = BaseProject.objects.get(
project_id=options['from_project'])
to_families = BaseFamily.objects.filter(project=to_project).only(
'family_id').prefetch_related('individual_set')
from_families_map = {
f.family_id: {
'family': f,
'individuals': f.individual_set.all()
}
for f in BaseFamily.objects.filter(
project=from_project,
family_id__in=[f.family_id for f in to_families]).only(
'family_id').prefetch_related('individual_set')
}
print('Transferring individuals from {} to {}:'.format(
from_project.project_name, to_project.project_name))
missing_family_individual_counts = defaultdict(int)
missing_individual_sample_counts = {}
created_vcf_count = 0
for family in to_families:
for from_individual in from_families_map[
family.family_id]['individuals']:
to_individual, individual_created = get_or_create_xbrowse_model(
BaseIndividual,
project=to_project,
family=family,
indiv_id=from_individual.indiv_id,
)
if individual_created:
update_xbrowse_model(
to_individual, **{
field: getattr(from_individual, field)
for field in INDIVIDUAL_FIELDS
})
_update_model(
to_individual, **{
field: getattr(from_individual, field)
for field in INDIVIDUAL_DATA_FIELDS
})
missing_family_individual_counts[family] += (
1 if individual_created else 0)
for from_vcf_file in from_individual.vcf_files.all():
to_vcf_file, vcf_created = VCFFile.objects.get_or_create(
project=to_project,
**{
field: getattr(from_vcf_file, field)
for field in VCF_FILE_FIELDS
})
if vcf_created:
created_vcf_count += 1
to_individual.vcf_files.add(to_vcf_file)
counters = {'samples_created': 0}
create_sample_records(to_individual, None,
to_individual.seqr_individual, counters)
missing_individual_sample_counts[to_individual] = counters[
'samples_created']
missing_individual_counts = defaultdict(int)
updated_families = set()
for family, individual_count in missing_family_individual_counts.items(
):
missing_individual_counts[individual_count] += 1
if individual_count > 0:
updated_families.add(family)
missing_sample_counts = defaultdict(int)
for individual, sample_count in missing_individual_sample_counts.items(
):
missing_sample_counts[sample_count] += 1
if sample_count > 0:
updated_families.add(individual.family)
for family in updated_families:
update_xbrowse_model(
family,
pedigree_image=from_families_map[
family.family_id]['family'].pedigree_image)
print("Done.")
print("----------------------------------------------")
for num_individuals, num_families in missing_individual_counts.items():
print('Added {} individuals to {} families'.format(
num_individuals, num_families))
print("----------------------------------------------")
print('Added {} VCF files'.format(created_vcf_count))
print("----------------------------------------------")
for num_samples, num_individuals in missing_sample_counts.items():
print('Added {} samples to {} individuals'.format(
num_samples, num_individuals))
def handle(self, *args, **options):
to_project = BaseProject.objects.get(project_id=options['to_project'])
from_project = BaseProject.objects.get(project_id=options['from_project'])
to_families = BaseFamily.objects.filter(project=to_project).only('family_id').prefetch_related('individual_set')
from_families_map = {
f.family_id: {'family': f, 'individuals': f.individual_set.all()}
for f in BaseFamily.objects.filter(
project=from_project, family_id__in=[f.family_id for f in to_families]
).only('family_id').prefetch_related('individual_set')
}
print('Transferring individuals from {} to {}:'.format(from_project.project_name, to_project.project_name))
missing_family_individual_counts = defaultdict(int)
missing_individual_sample_counts = {}
created_vcf_count = 0
for family in to_families:
for from_individual in from_families_map[family.family_id]['individuals']:
to_individual, individual_created = get_or_create_xbrowse_model(
BaseIndividual,
project=to_project,
family=family,
indiv_id=from_individual.indiv_id,
)
if individual_created:
update_xbrowse_model(
to_individual,
**{field: getattr(from_individual, field) for field in INDIVIDUAL_FIELDS}
)
_update_model(
to_individual,
**{field: getattr(from_individual, field) for field in INDIVIDUAL_DATA_FIELDS}
)
missing_family_individual_counts[family] += (1 if individual_created else 0)
for from_vcf_file in from_individual.vcf_files.all():
to_vcf_file, vcf_created = VCFFile.objects.get_or_create(
project=to_project,
**{field: getattr(from_vcf_file, field) for field in VCF_FILE_FIELDS}
)
if vcf_created:
created_vcf_count += 1
to_individual.vcf_files.add(to_vcf_file)
counters = {'samples_created': 0}
create_sample_records(to_individual, None, to_individual.seqr_individual, counters)
missing_individual_sample_counts[to_individual] = counters['samples_created']
missing_individual_counts = defaultdict(int)
updated_families = set()
for family, individual_count in missing_family_individual_counts.items():
missing_individual_counts[individual_count] += 1
if individual_count > 0:
updated_families.add(family)
missing_sample_counts = defaultdict(int)
for individual, sample_count in missing_individual_sample_counts.items():
missing_sample_counts[sample_count] += 1
if sample_count > 0:
updated_families.add(individual.family)
for family in updated_families:
update_xbrowse_model(family, pedigree_image=from_families_map[family.family_id]['family'].pedigree_image)
print("Done.")
print("----------------------------------------------")
for num_individuals, num_families in missing_individual_counts.items():
print('Added {} individuals to {} families'.format(num_individuals, num_families))
print("----------------------------------------------")
print('Added {} VCF files'.format(created_vcf_count))
print("----------------------------------------------")
for num_samples, num_individuals in missing_sample_counts.items():
print('Added {} samples to {} individuals'.format(num_samples, num_individuals))
