def _get_projects_json(user):
project_guids = get_project_guids_user_can_view(user)
if not project_guids:
return {}
projects = Project.objects.filter(guid__in=project_guids)
projects_with_counts = projects.annotate(
models.Count('family', distinct=True), models.Count('family__individual', distinct=True),
models.Count('family__savedvariant', distinct=True))
projects_by_guid = {p['projectGuid']: p for p in get_json_for_projects(projects, user=user)}
for project in projects_with_counts:
projects_by_guid[project.guid]['numFamilies'] = project.family__count
projects_by_guid[project.guid]['numIndividuals'] = project.family__individual__count
projects_by_guid[project.guid]['numVariantTags'] = project.family__savedvariant__count
analysis_status_counts = Family.objects.filter(project__in=projects).values(
'project__guid', 'analysis_status').annotate(count=models.Count('*'))
for agg in analysis_status_counts:
project_guid = agg['project__guid']
if 'analysisStatusCounts' not in projects_by_guid[project_guid]:
projects_by_guid[project_guid]['analysisStatusCounts'] = {}
projects_by_guid[project_guid]['analysisStatusCounts'][agg['analysis_status']] = agg['count']
sample_type_status_counts = Sample.objects.filter(individual__family__project__in=projects, dataset_type=Sample.DATASET_TYPE_VARIANT_CALLS
).values(
'individual__family__project__guid', 'sample_type',
).annotate(count=models.Count('individual_id', distinct=True))
for agg in sample_type_status_counts:
project_guid = agg['individual__family__project__guid']
if 'sampleTypeCounts' not in projects_by_guid[project_guid]:
projects_by_guid[project_guid]['sampleTypeCounts'] = {}
projects_by_guid[project_guid]['sampleTypeCounts'][agg['sample_type']] = agg['count']
return projects_by_guid
def awesomebar_autocomplete_handler(request):
"""Accepts HTTP GET request with q=.. url arg, and returns suggestions"""
query = request.GET.get('q')
if not query:
return create_json_response({'matches': {}})
categories = request.GET.get('categories').split(',') if request.GET.get(
'categories') else DEFAULT_CATEGORIES
project_guids = get_project_guids_user_can_view(request.user) if any(
category for category in categories
if category in PROJECT_SPECIFIC_CATEGORY_MAP) else None
results = {
category: {
'name': _to_title_case(category),
'results': CATEGORY_MAP[category](query, project_guids)
}
for category in categories
}
return create_json_response(
{'matches': {k: v
for k, v in results.items() if v['results']}})
def mme_details(request):
submissions = MatchmakerSubmission.objects.filter(deleted_date__isnull=True).filter(
individual__family__project__guid__in=get_project_guids_user_can_view(request.user))
hpo_terms_by_id, genes_by_id, gene_symbols_to_ids = get_mme_genes_phenotypes_for_submissions(submissions)
submission_json = get_json_for_matchmaker_submissions(
submissions, additional_model_fields=['label'], all_parent_guids=True)
submissions_by_guid = {s['submissionGuid']: s for s in submission_json}
for submission in submissions:
gene_variants = parse_mme_gene_variants(submission.genomic_features, gene_symbols_to_ids)
submissions_by_guid[submission.guid].update({
'phenotypes': parse_mme_features(submission.features, hpo_terms_by_id),
'geneVariants': gene_variants,
'geneSymbols': ','.join({genes_by_id.get(gv['geneId'], {}).get('geneSymbol') for gv in gene_variants})
})
response = {
'submissions': list(submissions_by_guid.values()),
'genesById': genes_by_id,
}
if user_is_analyst(request.user):
response['metrics'] = get_mme_metrics()
return create_json_response(response)
def _get_or_create_results_model(search_hash, search_context, user):
results_model = VariantSearchResults.objects.filter(search_hash=search_hash).first()
if not results_model:
if not search_context:
raise Exception('Invalid search hash: {}'.format(search_hash))
project_families = search_context.get('projectFamilies')
if project_families:
all_families = set()
for project_family in project_families:
all_families.update(project_family['familyGuids'])
families = Family.objects.filter(guid__in=all_families)
elif _is_all_project_family_search(search_context):
omit_projects = [p.guid for p in ProjectCategory.objects.get(name='Demo').projects.only('guid').all()]
project_guids = [project_guid for project_guid in get_project_guids_user_can_view(user) if project_guid not in omit_projects]
families = Family.objects.filter(project__guid__in=project_guids)
elif search_context.get('projectGuids'):
families = Family.objects.filter(project__guid__in=search_context['projectGuids'])
else:
raise Exception('Invalid search: no projects/ families specified')
search_dict = search_context.get('search', {})
search_model = VariantSearch.objects.filter(search=search_dict).filter(
Q(created_by=user) | Q(name__isnull=False)).first()
if not search_model:
search_model = create_model_from_json(VariantSearch, {'search': search_dict}, user)
# If a search_context request and results request are dispatched at the same time, its possible the other
# request already created the model
results_model, _ = get_or_create_model_from_json(
VariantSearchResults, {'search_hash': search_hash, 'variant_search': search_model},
update_json=None, user=user)
results_model.families.set(families)
return results_model
def saved_variants_page(request, tag):
gene = request.GET.get('gene')
if tag == 'ALL':
saved_variant_models = SavedVariant.objects.exclude(varianttag=None)
else:
tag_type = VariantTagType.objects.get(name=tag, project__isnull=True)
saved_variant_models = SavedVariant.objects.filter(varianttag__variant_tag_type=tag_type)
saved_variant_models = saved_variant_models.filter(family__project__guid__in=get_project_guids_user_can_view(request.user))
if gene:
saved_variant_models = saved_variant_models.filter(saved_variant_json__transcripts__has_key=gene)
elif saved_variant_models.count() > MAX_SAVED_VARIANTS:
return create_json_response({'error': 'Select a gene to filter variants'}, status=400)
prefetch_related_objects(saved_variant_models, 'family__project')
response_json = get_json_for_saved_variants_with_tags(saved_variant_models, add_details=True, include_missing_variants=True)
project_models_by_guid = {variant.family.project.guid: variant.family.project for variant in saved_variant_models}
families = {variant.family for variant in saved_variant_models}
individuals = Individual.objects.filter(family__in=families)
saved_variants = list(response_json['savedVariantsByGuid'].values())
genes = saved_variant_genes(saved_variants)
locus_lists_by_guid = _add_locus_lists(list(project_models_by_guid.values()), genes, include_all_lists=True)
projects_json = get_json_for_projects(list(project_models_by_guid.values()), user=request.user, add_project_category_guids_field=False)
functional_tag_types = get_json_for_variant_functional_data_tag_types()
variant_tag_types = VariantTagType.objects.filter(Q(project__in=project_models_by_guid.values()) | Q(project__isnull=True))
prefetch_related_objects(variant_tag_types, 'project')
variant_tags_json = _get_json_for_models(variant_tag_types)
tag_projects = {vt.guid: vt.project.guid for vt in variant_tag_types if vt.project}
for project_json in projects_json:
project_guid = project_json['projectGuid']
project_variant_tags = [
vt for vt in variant_tags_json if tag_projects.get(vt['variantTagTypeGuid'], project_guid) == project_guid]
project_json.update({
'locusListGuids': list(locus_lists_by_guid.keys()),
'variantTagTypes': sorted(project_variant_tags, key=lambda variant_tag_type: variant_tag_type['order'] or 0),
'variantFunctionalTagTypes': functional_tag_types,
})
families_json = _get_json_for_families(list(families), user=request.user, add_individual_guids_field=True)
individuals_json = _get_json_for_individuals(individuals, add_hpo_details=True, user=request.user)
for locus_list in get_json_for_locus_lists(LocusList.objects.filter(guid__in=locus_lists_by_guid.keys()), request.user):
locus_lists_by_guid[locus_list['locusListGuid']].update(locus_list)
response_json.update({
'genesById': genes,
'projectsByGuid': {project['projectGuid']: project for project in projects_json},
'familiesByGuid': {family['familyGuid']: family for family in families_json},
'individualsByGuid': {indiv['individualGuid']: indiv for indiv in individuals_json},
'locusListsByGuid': locus_lists_by_guid,
})
return create_json_response(response_json)
