def project_page_data(request, project_guid):
"""Returns a JSON object containing information used by the project page:
::
json_response = {
'project': {..},
'familiesByGuid': {..},
'individualsByGuid': {..},
'samplesByGuid': {..},
}
Args:
project_guid (string): GUID of the Project to retrieve data for.
"""
project = get_project_and_check_permissions(project_guid, request.user)
update_project_from_json(project, {'last_accessed_date': timezone.now()})
response = _get_project_child_entities(project, request.user)
project_json = _get_json_for_project(project, request.user)
project_json['collaborators'] = get_json_for_project_collaborator_list(project)
project_json['locusListGuids'] = response['locusListsByGuid'].keys()
project_json['detailsLoaded'] = True
project_json.update(_get_json_for_variant_tag_types(project))
gene_ids = set()
for tag in project_json['discoveryTags']:
gene_ids.update(tag.get('transcripts', {}).keys())
response.update({
'projectsByGuid': {project_guid: project_json},
'genesById': get_genes(gene_ids),
})
return create_json_response(response)
def _get_project_details(project, user):
check_permissions(project, user)
project_json = _get_json_for_project(project, user)
families_by_guid, individuals_by_guid, samples_by_guid, analysis_groups_by_guid, locus_lists_by_guid = get_project_child_entities(
project, user)
project_json.update({
'hasGeneSearch':
True,
'locusListGuids':
locus_lists_by_guid.keys(),
'variantTagTypes':
get_project_variant_tag_types(project),
'variantFunctionalTagTypes':
get_json_for_variant_functional_data_tag_types(),
})
return {
'projectsByGuid': {
project.guid: project_json
},
'familiesByGuid': families_by_guid,
'individualsByGuid': individuals_by_guid,
'samplesByGuid': samples_by_guid,
'locusListsByGuid': locus_lists_by_guid,
'analysisGroupsByGuid': analysis_groups_by_guid,
}
def variant_search_page_data(request, project_guid):
"""Returns a JSON object containing information needed to display the variant search page
::
json_response = {
'user': {..},
'variants': [..],
}
Args:
project_guid (string): GUID of the Project under case review.
"""
project = Project.objects.get(guid=project_guid)
# check permissions
if not request.user.has_perm(CAN_VIEW,
project) and not request.user.is_staff:
raise PermissionDenied
json_response = {
'user': _get_json_for_user(request.user),
'project': _get_json_for_project(project, request.user),
'variants': {},
}
return create_json_response(json_response)
def create_project_handler(request):
"""Create a new project.
HTTP POST
Request body - should contain json params:
name: Project name
description: Project description
Response body - will be json with the following structure, representing the ,created project:
{
'projectsByGuid': { <projectGuid1> : { ... <project key-value pairs> ... } }
}
"""
request_json = json.loads(request.body)
name = request_json.get('name')
if not name:
return create_json_response({}, status=400, reason="'Name' cannot be blank")
description = request_json.get('description', '')
genome_version = request_json.get('genomeVersion')
#if not created:
# return create_json_response({}, status=400, reason="A project named '%(name)s' already exists" % locals())
project = create_project(name, description=description, genome_version=genome_version, user=request.user)
return create_json_response({
'projectsByGuid': {
project.guid: _get_json_for_project(project, request.user)
},
})
def create_project_handler(request):
"""Create a new project.
HTTP POST
Request body - should contain json params:
name: Project name
description: Project description
Response body - will be json with the following structure, representing the ,created project:
{
'projectsByGuid': { <projectGuid1> : { ... <project key-value pairs> ... } }
}
"""
request_json = json.loads(request.body)
name = request_json.get('name')
if not name:
return create_json_response({}, status=400, reason="'Name' cannot be blank")
description = request_json.get('description', '')
genome_version = request_json.get('genomeVersion')
project = _create_project(name, description=description, genome_version=genome_version, user=request.user)
return create_json_response({
'projectsByGuid': {
project.guid: _get_json_for_project(project, request.user)
},
})
def update_project_categories_handler(request, project_guid):
"""Update ProjectCategories for the given project.
Args:
project_guid (string): GUID of the project that should be updated
HTTP POST
Request body - should contain the following json structure:
{
'form' : {
'categories': a list of category GUIDs for the categories assigned to the given project
}
}
Response body - will contain the following structure, representing the updated project,
as well all categories in seqr:
{
'projectsByGuid': {
<projectGuid1> : { ... <project key-value pairs> ... }
}
'projectCategoriesByGuid': {
<projectCategoryGuid1> : { ... <category key-value pairs> ... }
<projectCategoryGuid2> : { ... <category key-value pairs> ... }
}
}
"""
project = Project.objects.get(guid=project_guid)
# check permissions
if not request.user.has_perm(CAN_EDIT,
project) and not request.user.is_staff:
raise PermissionDenied
request_json = json.loads(request.body)
if 'form' not in request_json:
return create_json_response(
{},
status=400,
reason="Invalid request: 'form' not in request_json")
form_data = request_json['form']
# project categories according to the UI
current_category_guids = set(form_data['categories'])
project_categories_by_guid = _update_project_categories(
project, request.user, current_category_guids)
projects_by_guid = {
project.guid: _get_json_for_project(project, request.user)
}
return create_json_response({
'projectsByGuid':
projects_by_guid,
'projectCategoriesByGuid':
project_categories_by_guid,
})
def discovery_sheet(request, project_guid=None):
projects = Project.objects.filter(
projectcategory__name__iexact='cmg').distinct()
projects_json = [
_get_json_for_project(project,
request.user,
add_project_category_guids_field=False)
for project in projects
]
projects_json.sort(key=lambda project: project["name"])
rows = []
errors = []
# export table for all cmg projects
if "download" in request.GET and project_guid is None:
logger.info("exporting xls table for all projects")
for project in projects:
if any([
proj_id.lower() == exclude_id.lower() for exclude_id in
PROJECT_IDS_TO_EXCLUDE_FROM_DISCOVERY_SHEET_DOWNLOAD for
proj_id in [project.guid, project.deprecated_project_id]
]):
continue
rows.extend(generate_rows(project, errors))
return export_table("discovery_sheet", HEADER, rows, file_format="xls")
# generate table for 1 project
try:
project = Project.objects.get(guid=project_guid)
except ObjectDoesNotExist:
return render(request, "staff/discovery_sheet.html", {
'projects': projects_json,
'rows': rows,
'errors': errors,
})
rows = generate_rows(project, errors)
logger.info("request.get: " + str(request.GET))
if "download" in request.GET:
logger.info("exporting xls table")
return export_table("discovery_sheet", HEADER, rows, file_format="xls")
return render(
request, "staff/discovery_sheet.html", {
'project': project,
'projects': projects_json,
'header': HEADER.values(),
'rows': rows,
'errors': errors,
})
def update_project(request, project_guid):
"""Update project metadata - including one or more of these fields: name, description
Args:
project_guid (string): GUID of the project that should be updated
HTTP POST
Request body - should contain the following json structure:
{
'form' : {
'name': <project name>,
'description': <project description>,
}
}
Response body - will contain the following structure, representing the updated project:
{
'projectsByGuid': {
<projectGuid1> : { ... <project key-value pairs> ... }
}
}
"""
project = Project.objects.get(guid=project_guid)
# check permissions
if not request.user.has_perm(CAN_EDIT,
project) and not request.user.is_staff:
raise PermissionDenied
request_json = json.loads(request.body)
if 'form' not in request_json:
return create_json_response(
{},
status=400,
reason="Invalid request: 'form' not in request_json")
form_data = request_json['form']
if 'name' in form_data:
project.name = form_data.get('name')
project.save()
if 'description' in form_data:
project.description = form_data.get('description')
project.save()
# keep new seqr.Project model in sync with existing xbrowse_server.base.models - TODO remove this code after transition to new schema is finished
_deprecated_update_original_project(project)
return create_json_response({
'projectsByGuid': {
project.guid: _get_json_for_project(project, request.user)
},
})
def test_json_for_project(self):
project = Project.objects.first()
user = User.objects.first()
json = _get_json_for_project(project, user)
self.assertSetEqual(
set(json.keys()),
{'projectGuid', 'projectCategoryGuids', 'canEdit', 'name', 'description', 'createdDate', 'lastModifiedDate',
'isPhenotipsEnabled', 'phenotipsUserId', 'deprecatedProjectId', 'lastAccessedDate', 'hasNewSearch',
'isMmeEnabled', 'mmePrimaryDataOwner', 'mmeContactInstitution', 'mmeContactUrl', 'genomeVersion'}
)
def create_project(request):
"""Create a new project.
HTTP POST
Request body - should contain json params:
name: Project name
description: Project description
Response body - will be json with the following structure, representing the created project:
{
'projectsByGuid': { <projectGuid1> : { ... <project key-value pairs> ... } }
}
"""
request_json = json.loads(request.body)
if 'form' not in request_json:
return create_json_response(
{},
status=400,
reason="Invalid request: 'form' not in request_json")
form_data = request_json['form']
name = form_data.get('name')
if not name:
return create_json_response({},
status=400,
reason="'Name' cannot be blank")
description = form_data.get('description')
project, created = Project.objects.get_or_create(created_by=request.user,
name=name,
description=description)
if not created:
return create_json_response(
{},
status=400,
reason="A project named '%(name)s' already exists" % locals())
base_project = _deprecated_create_original_project(project)
project.deprecated_project_id = base_project.project_id
project.save()
_enable_phenotips_for_project(project)
_add_default_variant_tag_types(project)
# TODO: add custom populations
return create_json_response({
'projectsByGuid': {
project.guid: _get_json_for_project(project, request.user)
},
})
def test_json_for_project(self):
project = Project.objects.first()
user = User.objects.first()
json = _get_json_for_project(project, user)
self.assertSetEqual(
set(json.keys()),
{'projectGuid', 'projectCategoryGuids', 'canEdit', 'name', 'description', 'createdDate', 'lastModifiedDate',
'isPhenotipsEnabled', 'phenotipsUserId', 'deprecatedProjectId', 'lastAccessedDate', 'hasNewSearch',
'isMmeEnabled', 'mmePrimaryDataOwner', 'mmeContactInstitution', 'mmeContactUrl', 'genomeVersion'}
)
def project_page_data(request, project_guid):
"""Returns a JSON object containing information used by the project page:
::
json_response = {
'user': {..},
'familiesByGuid': {..},
'individualsByGuid': {..},
'samplesByGuid': {..},
'datasetsByGuid': {..},
}
Args:
project_guid (string): GUID of the Project to retrieve data for.
"""
project = get_project_and_check_permissions(project_guid, request.user)
cursor = connection.cursor()
families_by_guid, individuals_by_guid = _retrieve_families_and_individuals(
cursor, project.guid)
samples_by_guid, datasets_by_guid = _retrieve_samples(
cursor, project.guid, individuals_by_guid)
cursor.close()
project_json = _get_json_for_project(project, request.user)
project_json['collaborators'] = _get_json_for_collaborator_list(project)
project_json['locusLists'] = _get_json_for_locus_lists(project)
project_json['variantTagTypes'] = _get_json_for_variant_tag_types(project)
#project_json['referencePopulations'] = _get_json_for_reference_populations(project)
# gene search will be deprecated once the new database is online.
project_json['hasGeneSearch'] = _has_gene_search(project)
user_json = _get_json_for_user(request.user)
user_json[
'hasEditPermissions'] = request.user.is_staff or request.user.has_perm(
CAN_EDIT, project)
user_json['hasViewPermissions'] = user_json[
'hasEditPermissions'] or request.user.has_perm(CAN_VIEW, project)
json_response = {
'user': user_json,
'project': project_json,
'familiesByGuid': families_by_guid,
'individualsByGuid': individuals_by_guid,
'samplesByGuid': samples_by_guid,
'datasetsByGuid': datasets_by_guid,
}
return create_json_response(json_response)
def project_page_data(request, project_guid):
"""Returns a JSON object containing information used by the project page:
::
json_response = {
'project': {..},
'familiesByGuid': {..},
'individualsByGuid': {..},
'samplesByGuid': {..},
}
Args:
project_guid (string): GUID of the Project to retrieve data for.
"""
project = get_project_and_check_permissions(project_guid, request.user)
families_by_guid, individuals_by_guid, samples_by_guid, analysis_groups_by_guid, locus_lists_by_guid = get_project_child_entities(
project, request.user)
project_json = _get_json_for_project(project, request.user)
project_json['collaborators'] = _get_json_for_collaborator_list(project)
project_json.update(
_get_json_for_variant_tag_types(project, request.user,
individuals_by_guid))
project_json['locusListGuids'] = locus_lists_by_guid.keys()
# gene search will be deprecated once the new database is online.
project_json['hasGeneSearch'] = _has_gene_search(project)
# TODO once all project data is reloaded get rid of this
sorted_es_samples = sorted([
sample
for sample in samples_by_guid.values() if sample['elasticsearchIndex']
],
key=lambda sample: sample['loadedDate'],
reverse=True)
project_json[
'hasNewSearch'] = sorted_es_samples and is_nested_genotype_index(
sorted_es_samples[0]['elasticsearchIndex'])
project_json['detailsLoaded'] = True
return create_json_response({
'projectsByGuid': {
project_guid: project_json
},
'familiesByGuid': families_by_guid,
'individualsByGuid': individuals_by_guid,
'samplesByGuid': samples_by_guid,
'locusListsByGuid': locus_lists_by_guid,
'analysisGroupsByGuid': analysis_groups_by_guid,
'matchmakerSubmissions': {
project.guid: _project_matchmaker_submissions(project)
},
})
def project_page_data(request, project_guid):
"""Returns a JSON object containing information used by the project page:
::
json_response = {
'project': {..},
'familiesByGuid': {..},
'individualsByGuid': {..},
'samplesByGuid': {..},
}
Args:
project_guid (string): GUID of the Project to retrieve data for.
"""
project = get_project_and_check_permissions(project_guid, request.user)
cursor = connection.cursor()
families_by_guid = _retrieve_families(cursor, project.guid, request.user)
individuals_by_guid = _retrieve_individuals(project.guid, request.user)
for individual_guid, individual in individuals_by_guid.items():
families_by_guid[individual['familyGuid']]['individualGuids'].add(
individual_guid)
samples_by_guid = _retrieve_samples(cursor, project.guid,
individuals_by_guid)
cursor.close()
project_json = _get_json_for_project(project, request.user)
project_json['collaborators'] = _get_json_for_collaborator_list(project)
project_json.update(_get_json_for_variant_tag_types(project))
locus_lists = get_sorted_project_locus_lists(project, request.user)
project_json['locusListGuids'] = [
locus_list['locusListGuid'] for locus_list in locus_lists
]
# gene search will be deprecated once the new database is online.
project_json['hasGeneSearch'] = _has_gene_search(project)
project_json['detailsLoaded'] = True
json_response = {
'project': project_json,
'familiesByGuid': families_by_guid,
'individualsByGuid': individuals_by_guid,
'samplesByGuid': samples_by_guid,
'locusListsByGuid': {
locus_list['locusListGuid']: locus_list
for locus_list in locus_lists
}
}
return create_json_response(json_response)
def update_project_categories_handler(request, project_guid):
"""Update ProjectCategories for the given project.
Args:
project_guid (string): GUID of the project that should be updated
HTTP POST
Request body - should contain the following json structure:
{
'form' : {
'categories': a list of category GUIDs for the categories assigned to the given project
}
}
Response body - will contain the following structure, representing the updated project,
as well all categories in seqr:
{
'projectsByGuid': {
<projectGuid1> : { ... <project key-value pairs> ... }
}
'projectCategoriesByGuid': {
<projectCategoryGuid1> : { ... <category key-value pairs> ... }
<projectCategoryGuid2> : { ... <category key-value pairs> ... }
}
}
"""
project = Project.objects.get(guid=project_guid)
# check permissions
check_project_permissions(project, request.user, can_edit=True)
request_json = json.loads(request.body)
# project categories according to the UI
current_category_guids = set(request_json['categories'])
project_categories_by_guid = _update_project_categories(
project, request.user, current_category_guids)
projects_by_guid = {
project.guid: _get_json_for_project(project, request.user)
}
return create_json_response({
'projectsByGuid':
projects_by_guid,
'projectCategoriesByGuid':
project_categories_by_guid,
})
def update_project_categories_handler(request, project_guid):
"""Update ProjectCategories for the given project.
Args:
project_guid (string): GUID of the project that should be updated
HTTP POST
Request body - should contain the following json structure:
{
'form' : {
'categories': a list of category GUIDs for the categories assigned to the given project
}
}
Response body - will contain the following structure, representing the updated project,
as well all categories in seqr:
{
'projectsByGuid': {
<projectGuid1> : { ... <project key-value pairs> ... }
}
'projectCategoriesByGuid': {
<projectCategoryGuid1> : { ... <category key-value pairs> ... }
<projectCategoryGuid2> : { ... <category key-value pairs> ... }
}
}
"""
project = Project.objects.get(guid=project_guid)
# check permissions
check_permissions(project, request.user, CAN_EDIT)
request_json = json.loads(request.body)
# project categories according to the UI
current_category_guids = set(request_json['categories'])
project_categories_by_guid = _update_project_categories(project, request.user, current_category_guids)
projects_by_guid = {
project.guid: _get_json_for_project(project, request.user)
}
return create_json_response({
'projectsByGuid': projects_by_guid,
'projectCategoriesByGuid': project_categories_by_guid,
})
def case_review_page_data(request, project_guid):
"""Returns a JSON object containing information used by the case review page:
::
json_response = {
'user': {..},
'project': {..},
'familiesByGuid': {..},
'individualsByGuid': {..},
}
Args:
project_guid (string): GUID of the project being case-reviewed.
"""
# get all families in this project
project = get_project_and_check_permissions(project_guid, request.user)
json_response = {
'user': _get_json_for_user(request.user),
'project': _get_json_for_project(project, request.user),
'familiesByGuid': {},
'individualsByGuid': {},
}
for i in Individual.objects.select_related('family').filter(
family__project=project):
# filter out individuals that were never in case review
if not i.case_review_status:
continue
# process family record if it hasn't been added already
family = i.family
if family.guid not in json_response['familiesByGuid']:
json_response['familiesByGuid'][
family.guid] = _get_json_for_family(family, request.user)
json_response['familiesByGuid'][
family.guid]['individualGuids'] = []
json_response['individualsByGuid'][i.guid] = _get_json_for_individual(
i, request.user)
json_response['familiesByGuid'][family.guid]['individualGuids'].append(
i.guid)
return create_json_response(json_response)
def project_page_data(request, project_guid):
"""Returns a JSON object containing information used by the project page:
::
json_response = {
'project': {..},
'familiesByGuid': {..},
'individualsByGuid': {..},
'samplesByGuid': {..},
}
Args:
project_guid (string): GUID of the Project to retrieve data for.
"""
project = get_project_and_check_permissions(project_guid, request.user)
update_project_from_json(project, {'last_accessed_date': timezone.now()})
families_by_guid, individuals_by_guid, samples_by_guid, analysis_groups_by_guid, locus_lists_by_guid = _get_project_child_entities(
project, request.user)
project_json = _get_json_for_project(project, request.user)
project_json['collaborators'] = get_json_for_project_collaborator_list(
project)
project_json.update(
_get_json_for_variant_tag_types(project, request.user,
individuals_by_guid))
project_json['locusListGuids'] = locus_lists_by_guid.keys()
project_json['detailsLoaded'] = True
return create_json_response({
'projectsByGuid': {
project_guid: project_json
},
'familiesByGuid':
families_by_guid,
'individualsByGuid':
individuals_by_guid,
'samplesByGuid':
samples_by_guid,
'locusListsByGuid':
locus_lists_by_guid,
'analysisGroupsByGuid':
analysis_groups_by_guid,
})
def create_project_handler(request):
"""Create a new project.
HTTP POST
Request body - should contain json params:
name: Project name
description: Project description
Response body - will be json with the following structure, representing the ,created project:
{
'projectsByGuid': { <projectGuid1> : { ... <project key-value pairs> ... } }
}
"""
request_json = json.loads(request.body)
if 'form' not in request_json:
return create_json_response(
{},
status=400,
reason="Invalid request: 'form' not in request_json")
form_data = request_json['form']
name = form_data.get('name')
if not name:
return create_json_response({},
status=400,
reason="'Name' cannot be blank")
description = form_data.get('description')
#if not created:
# return create_json_response({}, status=400, reason="A project named '%(name)s' already exists" % locals())
project = create_project(name,
genome_version="37",
description=description,
user=request.user)
return create_json_response({
'projectsByGuid': {
project.guid: _get_json_for_project(project, request.user)
},
})
def update_project_handler(request, project_guid):
"""Update project metadata - including one or more of these fields: name, description
Args:
project_guid (string): GUID of the project that should be updated
HTTP POST
Request body - should contain the following json structure:
{
'form' : {
'name': <project name>,
'description': <project description>,
}
}
Response body - will contain the following structure, representing the updated project:
{
'projectsByGuid': {
<projectGuid1> : { ... <project key-value pairs> ... }
}
}
"""
project = Project.objects.get(guid=project_guid)
check_permissions(project, request.user, CAN_EDIT)
request_json = json.loads(request.body)
if 'name' in request_json:
update_seqr_model(project, name=request_json.get('name'))
if 'description' in request_json:
update_seqr_model(project, description=request_json.get('description'))
return create_json_response({
'projectsByGuid': {
project.guid: _get_json_for_project(project, request.user)
},
})
def create_project_handler(request):
"""Create a new project.
HTTP POST
Request body - should contain json params:
name: Project name
description: Project description
Response body - will be json with the following structure, representing the ,created project:
{
'projectsByGuid': { <projectGuid1> : { ... <project key-value pairs> ... } }
}
"""
request_json = json.loads(request.body)
missing_fields = [
field for field in ['name', 'genomeVersion']
if not request_json.get(field)
]
if missing_fields:
error = 'Field(s) "{}" are required'.format(', '.join(missing_fields))
return create_json_response({'error': error}, status=400, reason=error)
project_args = {
'name': request_json['name'],
'genome_version': request_json['genomeVersion'],
'description': request_json.get('description', ''),
}
project = create_model_from_json(Project, project_args, user=request.user)
if ANALYST_PROJECT_CATEGORY:
ProjectCategory.objects.get(
name=ANALYST_PROJECT_CATEGORY).projects.add(project)
return create_json_response({
'projectsByGuid': {
project.guid: _get_json_for_project(project, request.user)
},
})
def _get_project_details(project, user):
check_permissions(project, user)
project_json = _get_json_for_project(project, user)
families_by_guid, individuals_by_guid, samples_by_guid, analysis_groups_by_guid, locus_lists_by_guid = get_project_child_entities(project, user)
project_json.update({
'hasGeneSearch': True,
'locusListGuids': locus_lists_by_guid.keys(),
'variantTagTypes': get_project_variant_tag_types(project),
'variantFunctionalTagTypes': get_json_for_variant_functional_data_tag_types(),
})
return {
'projectsByGuid': {project.guid: project_json},
'familiesByGuid': families_by_guid,
'individualsByGuid': individuals_by_guid,
'samplesByGuid': samples_by_guid,
'locusListsByGuid': locus_lists_by_guid,
'analysisGroupsByGuid': analysis_groups_by_guid,
}
def update_project_handler(request, project_guid):
"""Update project metadata - including one or more of these fields: name, description
Args:
project_guid (string): GUID of the project that should be updated
HTTP POST
Request body - should contain the following json structure:
{
'form' : {
'name': <project name>,
'description': <project description>,
}
}
Response body - will contain the following structure, representing the updated project:
{
'projectsByGuid': {
<projectGuid1> : { ... <project key-value pairs> ... }
}
}
"""
project = Project.objects.get(guid=project_guid)
check_permissions(project, request.user, CAN_EDIT)
request_json = json.loads(request.body)
update_project_from_json(project, request_json, allow_unknown_keys=True)
return create_json_response({
'projectsByGuid': {
project.guid: _get_json_for_project(project, request.user)
},
})
def variant_search_page_data(request, project_guid, family_guid):
"""Returns a JSON object containing information needed to display the variant search page
::
json_response = {
'user': {..},
'variants': [..],
}
Args:
project_guid (string): GUID of the Project under case review.
"""
logger.info("project_guid: %s" % (project_guid,))
logger.info("family_guid: %s" % (family_guid,))
if family_guid is not None:
# single-family search mode
family = Family.objects.get(guid=family_guid)
# TODO handle family-not-found
project = family.project
check_permissions(project, request.user, CAN_VIEW)
project_guids = [project.guid]
family_guids = [family_guid]
else:
# all-families-in-a-project search mode
family = None
family_guids = None
if project_guid is not None:
project = Project.objects.get(guid=project_guid)
# TODO handle project-not-found
# check permissions
check_permissions(project, request.user, CAN_VIEW)
project_guids = [project.guid]
else:
# all projects search mode permissions to access
project = None
project_guids = [p.guid for p in get_projects_user_can_view(request.user)]
# get all datasets
dataset_info = _retrieve_datasets(
project_guids=project_guids,
family_guids=family_guids,
individual_guids=None,
sample_types=None,
analysis_types=None,
only_loaded_datasets=True
)
# retrieve search params from hash or use default values
search_params_hash = request.GET.get("h")
if search_params_hash is not None:
search_params = {} # TODO retrieve search params for hash
raise ValueError("Not implemented")
else:
search_params = {
'dataset_guids': [],
'project_guids': project_guids,
'family_guids': [],
}
# TODO adjust search params that are no-longer valid
json_response = {
'user': _get_json_for_user(request.user),
'project': _get_json_for_project(project, request.user) if project is not None else {},
'family': _get_json_for_family(family, request.user) if family is not None else {},
'variants': {},
'datasets': dataset_info,
}
return create_json_response(json_response)
def discovery_sheet(request, project_guid=None):
projects = Project.objects.filter(
projectcategory__name__iexact='cmg').prefetch_related(
Prefetch('family_set',
to_attr='families',
queryset=Family.objects.prefetch_related(
'individual_set'))).distinct()
projects_json = [
_get_json_for_project(project,
request.user,
add_project_category_guids_field=False)
for project in projects
]
projects_json.sort(key=lambda project: project["name"])
rows = []
errors = []
# export table for all cmg projects
if "download" in request.GET and project_guid is None:
logger.info("exporting xls table for all projects")
loaded_samples_by_project_family = get_loaded_samples_by_project_family(
projects)
saved_variants_by_project_family = get_saved_variants_by_project_family(
projects)
for project in projects:
rows.extend(
generate_rows(
project,
loaded_samples_by_project_family,
saved_variants_by_project_family,
errors,
update_omim_and_gene_symbols=False,
))
_update_gene_symbols(rows)
_update_initial_omim_numbers(rows)
temp_file = tempfile.NamedTemporaryFile()
wb_out = xl.Workbook()
ws_out = wb_out.active
ws_out.append(map(_to_title_case, HEADER))
for row in rows:
ws_out.append([row[column_key] for column_key in HEADER])
wb_out.save(temp_file.name)
temp_file.seek(0)
email_message = EmailMultiAlternatives(
subject="Discovery Sheet",
body="Attached is the discovery sheet for all seqr projects",
to=[request.user.email],
attachments=[
("discovery_sheet.xlsx", temp_file.read(), "application/xls"),
],
)
email_message.send()
logger.info("emailing discovery sheet to {}".format(
request.user.email))
return create_json_response({'errors': errors})
# generate table for 1 project
project = next(
(project for project in projects if project.guid == project_guid),
None)
if not project:
return render(request, "staff/discovery_sheet.html", {
'projects': projects_json,
'rows': rows,
'errors': errors,
})
loaded_samples_by_project_family = get_loaded_samples_by_project_family(
[project])
saved_variants_by_project_family = get_saved_variants_by_project_family(
[project])
rows = generate_rows(project, loaded_samples_by_project_family,
saved_variants_by_project_family, errors)
logger.info("request.get: " + str(request.GET))
if "download" in request.GET:
logger.info("exporting xls table")
return export_table("discovery_sheet", HEADER, rows, file_format="xls")
return render(
request, "staff/discovery_sheet.html", {
'project': project,
'projects': projects_json,
'header': HEADER.values(),
'rows': rows,
'errors': errors,
})
def test_json_for_project(self):
project = Project.objects.first()
user = User.objects.first()
json = _get_json_for_project(project, user)
self.assertSetEqual(set(json.keys()), PROJECT_FIELDS)
