def update_variant_main_transcript(request, variant_guid, transcript_id): saved_variant = SavedVariant.objects.get(guid=variant_guid) check_project_permissions(saved_variant.family.project, request.user, can_edit=True) update_model_from_json(saved_variant, {'selected_main_transcript_id': transcript_id}, request.user) return create_json_response({'savedVariantsByGuid': {variant_guid: {'selectedMainTranscriptId': transcript_id}}})
def update_variant_tags_handler(request, variant_guids): request_json = json.loads(request.body) family_guid = request_json.pop('familyGuid') family = Family.objects.get(guid=family_guid) check_project_permissions(family.project, request.user) all_variant_guids = set(variant_guids.split(',')) saved_variants = SavedVariant.objects.filter(guid__in=all_variant_guids) if len(saved_variants) != len(all_variant_guids): error = 'Unable to find the following variant(s): {}'.format( ', '.join([guid for guid in all_variant_guids if guid not in {sv.guid for sv in saved_variants}])) return create_json_response({'error': error}, status=400, reason=error) deleted_tag_guids = _delete_removed_tags(saved_variants, all_variant_guids, request_json.get('tags', []), request.user) created_tags = _create_new_tags(saved_variants, request_json, request.user) tag_updates = {tag['tagGuid']: tag for tag in get_json_for_variant_tags(created_tags)} tag_updates.update({guid: None for guid in deleted_tag_guids}) saved_variants_by_guid = {} for saved_variant in saved_variants: tags = saved_variant.varianttag_set.all() saved_variants_by_guid[saved_variant.guid] = {'tagGuids': [t.guid for t in tags]} if not tags: if not saved_variant.variantnote_set.count() > 0: saved_variant.delete_model(request.user, user_can_delete=True) saved_variants_by_guid[saved_variant.guid] = None return create_json_response({ 'savedVariantsByGuid': saved_variants_by_guid, 'variantTagsByGuid': tag_updates, })
def delete_variant_note_handler(request, variant_guids, note_guid): variant_guids = variant_guids.split(',') note = VariantNote.objects.get(guid=note_guid) projects = { saved_variant.family.project for saved_variant in note.saved_variants.all() } for project in projects: check_project_permissions(project, request.user) note.delete() saved_variants_by_guid = {} for saved_variant in SavedVariant.objects.filter(guid__in=variant_guids): notes = saved_variant.variantnote_set.all() saved_variants_by_guid[saved_variant.guid] = { 'noteGuids': [n.guid for n in notes] } if not notes: if not saved_variant.varianttag_set.count() > 0: saved_variant.delete() saved_variants_by_guid[saved_variant.guid] = None return create_json_response({ 'savedVariantsByGuid': saved_variants_by_guid, 'variantNotesByGuid': { note_guid: None }, })
def create_saved_variant_handler(request): variant_json = json.loads(request.body) family_guid = variant_json['familyGuid'] family = Family.objects.get(guid=family_guid) check_project_permissions(family.project, request.user) variants_json = variant_json['variant'] if not isinstance(variant_json['variant'], list): variants_json = [variants_json] saved_variants = [] for single_variant_json in variants_json: try: parsed_variant_json = _get_parsed_variant_args(single_variant_json, family) except ValueError as e: return create_json_response({'error': str(e)}, status=400) saved_variant, _ = get_or_create_model_from_json( SavedVariant, create_json=parsed_variant_json, update_json={'saved_variant_json': single_variant_json}, user=request.user) saved_variants.append(saved_variant) if variant_json.get('note'): _create_variant_note(saved_variants, variant_json, request.user) elif variant_json.get('tags'): _create_new_tags(saved_variants, variant_json, request.user) return create_json_response(get_json_for_saved_variants_with_tags(saved_variants, add_details=True))
def update_individual_hpo_terms(request, individual_guid): """Updates features fields for the given Individual """ individual = Individual.objects.get(guid=individual_guid) project = individual.family.project check_project_permissions(project, request.user, can_edit=True) request_json = json.loads(request.body) for feature_key in [ 'features', 'absentFeatures', 'nonstandardFeatures', 'absentNonstandardFeatures' ]: orm_key = _to_snake_case(feature_key) value = [get_parsed_feature(feature) for feature in request_json[feature_key]] \ if request_json.get(feature_key) else None setattr(individual, orm_key, value) individual.save() return create_json_response({ individual.guid: _get_json_for_individual(individual, request.user, add_hpo_details=True) })
def update_individual_hpo_terms(request, individual_guid): """Updates features fields for the given Individual """ individual = Individual.objects.get(guid=individual_guid) project = individual.family.project check_project_permissions(project, request.user, can_edit=True) request_json = json.loads(request.body) update_json = { key: [get_parsed_feature(feature) for feature in request_json[key]] if request_json.get(key) else None for key in [ 'features', 'absentFeatures', 'nonstandardFeatures', 'absentNonstandardFeatures' ] } update_model_from_json(individual, update_json, user=request.user) return create_json_response({ individual.guid: _get_json_for_individual(individual, request.user, add_hpo_details=True) })
def update_individual_handler(request, individual_guid): """Updates a single field in an Individual record. Args: request (object): Django HTTP Request object. individual_guid (string): GUID of the Individual. Request: body should be a json dictionary like: { 'value': xxx } Response: json dictionary representing the updated individual like: { <individualGuid> : { individualId: xxx, sex: xxx, affected: xxx, ... } } """ individual = Individual.objects.get(guid=individual_guid) project = individual.family.project check_project_permissions(project, request.user, can_edit=True) request_json = json.loads(request.body) update_individual_from_json(individual, request_json, user=request.user, allow_unknown_keys=True) return create_json_response({ individual.guid: _get_json_for_individual(individual, request.user) })
def create_saved_variant_handler(request): variant_json = json.loads(request.body) family_guid = variant_json['familyGuid'] family = Family.objects.get(guid=family_guid) check_project_permissions(family.project, request.user) if isinstance(variant_json['variant'], list): # are compound hets saved_variants = [] for single_variant_json in variant_json['variant']: saved_variant, created = SavedVariant.objects.get_or_create( **_get_parsed_variant_args(single_variant_json, family)) if created: saved_variant.saved_variant_json = single_variant_json saved_variant.save() saved_variants.append(saved_variant) else: saved_variant = SavedVariant.objects.create( saved_variant_json=variant_json['variant'], **_get_parsed_variant_args(variant_json['variant'], family)) saved_variants = [saved_variant] if variant_json.get('note'): _create_variant_note(saved_variants, variant_json, request.user) elif variant_json.get('tags'): _create_new_tags(saved_variants, variant_json, request.user) return create_json_response( get_json_for_saved_variants_with_tags(saved_variants, add_details=True))
def update_family_pedigree_image(request, family_guid): """Updates the specified field in the Family model. Args: family_guid (string): GUID of the family. """ family = Family.objects.get(guid=family_guid) # check permission check_project_permissions(family.project, request.user, can_edit=True) if len(request.FILES) == 0: pedigree_image = None elif len(request.FILES) > 1: return create_json_response({}, status=400, reason='Received {} files'.format( len(request.FILES))) else: pedigree_image = next(iter((request.FILES.values()))) family.pedigree_image = pedigree_image family.save() return create_json_response( {family.guid: _get_json_for_family(family, request.user)})
def update_family_assigned_analyst(request, family_guid): """Updates the specified field in the Family model. Args: family_guid (string): GUID of the family. """ family = Family.objects.get(guid=family_guid) # assigned_analyst can be edited by anyone with access to the project check_project_permissions(family.project, request.user, can_edit=False) request_json = json.loads(request.body) assigned_analyst_username = request_json.get('assigned_analyst_username') if assigned_analyst_username: try: assigned_analyst = User.objects.get( username=assigned_analyst_username) except Exception: return create_json_response({}, status=400, reason="specified user does not exist") else: assigned_analyst = None family.assigned_analyst = assigned_analyst family.save() return create_json_response( {family.guid: _get_json_for_family(family, request.user)})
def create_variant_note_handler(request, variant_guids): request_json = json.loads(request.body) save_as_gene_note = request_json.get('saveAsGeneNote') family_guid = request_json.pop('familyGuid') family = Family.objects.get(guid=family_guid) check_project_permissions(family.project, request.user) all_variant_guids = variant_guids.split(',') saved_variants = SavedVariant.objects.filter(guid__in=all_variant_guids) if len(saved_variants) != len(all_variant_guids): error = 'Unable to find the following variant(s): {}'.format(', '.join( [ guid for guid in all_variant_guids if guid not in {sv.guid for sv in saved_variants} ])) return create_json_response({'error': error}, status=400, reason=error) # update saved_variants note = _create_variant_note(saved_variants, request_json, request.user) note_json = get_json_for_variant_note(note, add_variant_guids=False) note_json['variantGuids'] = all_variant_guids response = { 'savedVariantsByGuid': { saved_variant.guid: { 'noteGuids': [n.guid for n in saved_variant.variantnote_set.all()] } for saved_variant in saved_variants }, 'variantNotesByGuid': { note.guid: note_json }, } if save_as_gene_note: main_transcript_id = saved_variants[ 0].selected_main_transcript_id or saved_variants[ 0].saved_variant_json['mainTranscriptId'] gene_id = next( (gene_id for gene_id, transcripts in saved_variants[0]. saved_variant_json['transcripts'].items() if any( t['transcriptId'] == main_transcript_id for t in transcripts)), None) if main_transcript_id else None GeneNote.objects.create( note=request_json.get('note'), gene_id=gene_id, created_by=request.user, ) response['genesById'] = { gene_id: { 'notes': get_json_for_gene_notes_by_gene_id([gene_id], request.user)[gene_id], } } return create_json_response(response)
def update_mme_submission(request, submission_guid=None): """ Create or update the submission for the given individual. """ submission_json = json.loads(request.body) phenotypes = submission_json.pop('phenotypes', []) gene_variants = submission_json.pop('geneVariants', []) if not phenotypes and not gene_variants: return create_json_response({}, status=400, reason='Genotypes or phentoypes are required') genomic_features = [] for gene_variant in gene_variants: if not gene_variant.get('geneId'): return create_json_response({}, status=400, reason='Gene id is required for genomic features') feature = {'gene': {'id': gene_variant['geneId']}} if 'numAlt' in gene_variant and gene_variant['numAlt'] > 0: feature['zygosity'] = gene_variant['numAlt'] if gene_variant.get('pos'): genome_version = gene_variant['genomeVersion'] feature['variant'] = { 'referenceName': gene_variant['chrom'], 'start': gene_variant['pos'], 'assembly': GENOME_VERSION_LOOKUP.get(genome_version, genome_version), } if gene_variant.get('alt'): feature['variant'].update({ 'alternateBases': gene_variant['alt'], 'referenceBases': gene_variant['ref'], }) elif gene_variant.get('end'): feature['variant']['end'] = gene_variant['end'] genomic_features.append(feature) submission_json.update({ 'features': phenotypes, 'genomicFeatures': genomic_features, 'deletedDate': None, 'deletedBy': None, }) if submission_guid: submission = MatchmakerSubmission.objects.get(guid=submission_guid) check_mme_permissions(submission, request.user) else: individual_guid = submission_json.get('individualGuid') if not individual_guid: return create_json_response({}, status=400, reason='Individual is required for a new submission') individual = Individual.objects.get(guid=individual_guid) check_project_permissions(individual.family.project, request.user) submission = MatchmakerSubmission.objects.create( individual=individual, submission_id=individual.guid, label=individual.individual_id, ) update_model_from_json(submission, submission_json, allow_unknown_keys=True) # search for new matches return _search_matches(submission, request.user)
def _update_variant_tag_models(request, variant_guids, tag_key, model_cls, get_tag_create_data, get_tags_json, response_guid_key=None, delete_variants_if_empty=False): request_json = json.loads(request.body) family_guid = request_json.pop('familyGuid') family = Family.objects.get(guid=family_guid) check_project_permissions(family.project, request.user) all_variant_guids = set(variant_guids.split(',')) saved_variants = SavedVariant.objects.filter(guid__in=all_variant_guids) if len(saved_variants) != len(all_variant_guids): error = 'Unable to find the following variant(s): {}'.format(', '.join( [ guid for guid in all_variant_guids if guid not in {sv.guid for sv in saved_variants} ])) return create_json_response({'error': error}, status=400, reason=error) tag_type = tag_key.lower().rstrip('s') updated_data = request_json.get(tag_key, []) deleted_guids = _delete_removed_tags(saved_variants, all_variant_guids, updated_data, request.user, tag_type) updated_models = _update_tags(saved_variants, request_json, request.user, tag_key, model_cls, get_tag_create_data) updates = {tag['tagGuid']: tag for tag in get_tags_json(updated_models)} updates.update({guid: None for guid in deleted_guids}) if not response_guid_key: response_guid_key = '{}Guids'.format(tag_key) saved_variants_by_guid = {} for saved_variant in saved_variants: tags = _get_tag_set(saved_variant, tag_type).all() saved_variants_by_guid[saved_variant.guid] = { response_guid_key: [t.guid for t in tags] } if delete_variants_if_empty and not tags: if not saved_variant.variantnote_set.count() > 0: saved_variant.delete_model(request.user, user_can_delete=True) saved_variants_by_guid[saved_variant.guid] = None return create_json_response({ 'savedVariantsByGuid': saved_variants_by_guid, 'variant{}{}ByGuid'.format(tag_key[0].upper(), tag_key[1:]): updates, })
def discovery_sheet(request, project_guid): project = Project.objects.filter(guid=project_guid).prefetch_related( Prefetch('family_set', to_attr='families', queryset=Family.objects.prefetch_related('individual_set')) ).distinct().first() if not project: message = 'Invalid project {}'.format(project_guid) return create_json_response({'error': message}, status = 400, reason = message) check_project_permissions(project, request.user) rows = [] errors = [] loaded_samples_by_family = _get_loaded_samples_by_family(project) saved_variants_by_family = _get_project_saved_discovery_variants_by_family(project) mme_submission_families = _get_has_mme_submission_families(project) if not loaded_samples_by_family: errors.append("No data loaded for project: {}".format(project)) return create_json_response({ 'rows': [], 'errors': errors, }) if "external" in project.name.lower() or "reprocessed" in project.name.lower(): sequencing_approach = "REAN" else: sequencing_approach = next(iter(loaded_samples_by_family.values()))[-1].sample_type initial_row = { "project_guid": project.guid, "collaborator": project.name, "sequencing_approach": sequencing_approach, } initial_row.update(DEFAULT_ROW) now = timezone.now() for family in project.families: samples = loaded_samples_by_family.get(family.guid) if not samples: errors.append("No data loaded for family: %s. Skipping..." % family) continue saved_variants = saved_variants_by_family.get(family.guid) submitted_to_mme = family in mme_submission_families rows += _generate_rows(initial_row, family, samples, saved_variants, submitted_to_mme, errors, now=now) _update_gene_symbols(rows) _update_hpo_categories(rows, errors) _update_initial_omim_numbers(rows) return create_json_response({ 'rows': rows, 'errors': errors, })
def update_individual_igv_sample(request, individual_guid): individual = Individual.objects.get(guid=individual_guid) project = individual.family.project check_project_permissions(project, request.user, can_edit=True) request_json = json.loads(request.body) try: file_path = request_json.get('filePath') if not file_path: raise ValueError('request must contain fields: filePath') suffix = '.'.join(file_path.split('.')[1:]) sample_type = SAMPLE_TYPE_MAP.get(suffix) if not sample_type: raise Exception( 'Invalid file extension for "{}" - valid extensions are {}'. format(file_path, ', '.join(SAMPLE_TYPE_MAP.keys()))) if not does_file_exist(file_path): raise Exception('Error accessing "{}"'.format(file_path)) sample, created = get_or_create_model_from_json( IgvSample, create_json={ 'individual': individual, 'sample_type': sample_type }, update_json={ 'file_path': file_path, 'sample_id': request_json.get('sampleId') }, user=request.user) response = { 'igvSamplesByGuid': { sample.guid: get_json_for_sample(sample, individual_guid=individual_guid, project_guid=project.guid) } } if created: response['individualsByGuid'] = { individual.guid: { 'igvSampleGuids': [s.guid for s in individual.igvsample_set.all()] } } return create_json_response(response) except Exception as e: error = str(e) return create_json_response({'error': error}, status=400, reason=error)
def update_variant_note_handler(request, variant_guids, note_guid): note = VariantNote.objects.get(guid=note_guid) projects = {saved_variant.family.project for saved_variant in note.saved_variants.all()} for project in projects: check_project_permissions(project, request.user) request_json = json.loads(request.body) update_model_from_json(note, request_json, user=request.user, allow_unknown_keys=True) note_json = get_json_for_variant_note(note, add_variant_guids=False) note_json['variantGuids'] = variant_guids.split(',') return create_json_response({ 'variantNotesByGuid': {note.guid: note_json}, })
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_family_analysed_by(request, family_guid): """Updates the specified field in the Family model. Args: family_guid (string): GUID of the family. field_name (string): Family model field name to update """ family = Family.objects.get(guid=family_guid) # analysed_by can be edited by anyone with access to the project check_project_permissions(family.project, request.user, can_edit=False) FamilyAnalysedBy.objects.create(family=family, created_by=request.user) return create_json_response( {family.guid: _get_json_for_family(family, request.user)})
def update_individual_igv_sample(request, individual_guid): individual = Individual.objects.get(guid=individual_guid) project = individual.family.project check_project_permissions(project, request.user, can_edit=True) request_json = json.loads(request.body) try: required_fields = ['filePath'] if any(field not in request_json for field in required_fields): raise ValueError("request must contain fields: {}".format( ', '.join(required_fields))) file_path = request_json['filePath'] if not (file_path.endswith(".bam") or file_path.endswith(".cram")): raise Exception( 'BAM / CRAM file "{}" must have a .bam or .cram extension'. format(file_path)) validate_alignment_dataset_path(file_path) sample, created = IgvSample.objects.get_or_create( individual=individual) sample.file_path = file_path sample.save() response = { 'igvSamplesByGuid': { sample.guid: get_json_for_sample(sample, individual_guid=individual_guid, project_guid=project.guid) } } if created: response['individualsByGuid'] = { individual.guid: { 'igvSampleGuids': [s.guid for s in individual.igvsample_set.all()] } } return create_json_response(response) except Exception as e: error = str(e) return create_json_response({'error': error}, status=400, reason=error)
def update_family_fields_handler(request, family_guid): """Updates the specified field in the Family model. Args: family_guid (string): GUID of the family. """ family = Family.objects.get(guid=family_guid) # check permission - can be edited by anyone with access to the project check_project_permissions(family.project, request.user) request_json = json.loads(request.body) update_family_from_json(family, request_json, user=request.user, allow_unknown_keys=True, immutable_keys=[ 'family_id', 'display_name', ]) return create_json_response({ family.guid: _get_json_for_family(family, request.user) })
def update_family_fields_handler(request, family_guid): """Updates the specified field in the Family model. Args: family_guid (string): GUID of the family. """ family = Family.objects.get(guid=family_guid) # check permission project = family.project check_project_permissions(project, request.user, can_edit=True) request_json = json.loads(request.body) update_family_from_json(family, request_json, user=request.user, allow_unknown_keys=True) return create_json_response({ family.guid: _get_json_for_family(family, request.user) })
def update_variant_functional_data_handler(request, variant_guids): request_json = json.loads(request.body) family_guid = request_json.pop('familyGuid') family = Family.objects.get(guid=family_guid) check_project_permissions(family.project, request.user) all_variant_guids = set(variant_guids.split(',')) saved_variants = SavedVariant.objects.filter(guid__in=all_variant_guids) if len(saved_variants) != len(all_variant_guids): error = 'Unable to find the following variant(s): {}'.format( ', '.join([guid for guid in all_variant_guids if guid not in {sv.guid for sv in saved_variants}])) return create_json_response({'error': error}, status=400, reason=error) updated_functional_data = request_json.get('functionalData', []) deleted_functional_guids = _delete_removed_tags( saved_variants, all_variant_guids, updated_functional_data, request.user, tag_type='functionaldata') updated_functional_models = [] for tag in updated_functional_data: if tag.get('tagGuid'): functional_data = VariantFunctionalData.objects.get(guid=tag.get('tagGuid')) update_model_from_json(functional_data, tag, user=request.user, allow_unknown_keys=True) else: functional_data = create_model_from_json(VariantFunctionalData, { 'functional_data_tag': tag.get('name'), 'metadata': tag.get('metadata'), 'search_hash': request_json.get('searchHash'), }, request.user) functional_data.saved_variants.set(saved_variants) updated_functional_models.append(functional_data) functional_updates = {tag['tagGuid']: tag for tag in get_json_for_variant_functional_data_tags(updated_functional_models)} functional_updates.update({guid: None for guid in deleted_functional_guids}) return create_json_response({ 'savedVariantsByGuid': {saved_variant.guid: { 'functionalDataGuids': [t.guid for t in saved_variant.variantfunctionaldata_set.all()], } for saved_variant in saved_variants}, 'variantFunctionalDataByGuid': functional_updates, })
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_project_permissions(project, request.user, can_edit=True) request_json = json.loads(request.body) update_project_from_json(project, request_json, request.user, allow_unknown_keys=True) return create_json_response({ 'projectsByGuid': { project.guid: _get_json_for_project(project, request.user) }, })
def _get_projects_details(projects, user, project_category_guid=None): for project in projects: check_project_permissions(project, user) prefetch_related_objects(projects, 'can_view_group') project_models_by_guid = {project.guid: project for project in projects} projects_json = get_json_for_projects(projects, user) locus_lists = LocusList.objects.filter( projects__in=projects).prefetch_related('projects') project_guid = projects[0].guid if len(projects) == 1 else None functional_data_tag_types = get_json_for_variant_functional_data_tag_types( ) variant_tag_types_by_guid = { vtt.guid: vtt for vtt in VariantTagType.objects.filter( Q(project__in=projects) | Q(project__isnull=True)).prefetch_related('project') } variant_tag_types = _get_json_for_models( list(variant_tag_types_by_guid.values())) for project_json in projects_json: project = project_models_by_guid[project_json['projectGuid']] project_json.update({ 'locusListGuids': [ locus_list.guid for locus_list in locus_lists if project in locus_list.projects.all() ], 'variantTagTypes': [ vtt for vtt in variant_tag_types if variant_tag_types_by_guid[vtt['variantTagTypeGuid']].project is None or variant_tag_types_by_guid[vtt['variantTagTypeGuid']] .project.guid == project_json['projectGuid'] ], 'variantFunctionalTagTypes': functional_data_tag_types, }) family_models = Family.objects.filter(project__in=projects) families = _get_json_for_families(family_models, user, project_guid=project_guid, skip_nested=True) individual_models = Individual.objects.filter(family__in=family_models) individuals = _get_json_for_individuals(individual_models, user=user, project_guid=project_guid, add_hpo_details=True, skip_nested=True) sample_models = Sample.objects.filter(individual__in=individual_models) samples = get_json_for_samples(sample_models, project_guid=project_guid, skip_nested=True) igv_sample_models = IgvSample.objects.filter( individual__in=individual_models) igv_samples = get_json_for_samples(igv_sample_models, project_guid=project_guid, skip_nested=True) analysis_group_models = AnalysisGroup.objects.filter(project__in=projects) analysis_groups = get_json_for_analysis_groups(analysis_group_models, project_guid=project_guid, skip_nested=True) if not project_guid: project_id_to_guid = {project.id: project.guid for project in projects} family_id_to_guid = { family.id: family.guid for family in family_models } individual_id_to_guid = { individual.id: individual.guid for individual in individual_models } family_guid_to_project_guid = {} individual_guid_to_project_guid = {} for family in families: project_guid = project_id_to_guid[family.pop('projectId')] family['projectGuid'] = project_guid family_guid_to_project_guid[family['familyGuid']] = project_guid for individual in individuals: family_guid = family_id_to_guid[individual.pop('familyId')] project_guid = family_guid_to_project_guid[family_guid] individual['familyGuid'] = family_guid individual['projectGuid'] = project_guid individual_guid_to_project_guid[ individual['individualGuid']] = project_guid for sample in samples: individual_guid = individual_id_to_guid[sample.pop('individualId')] sample['individualGuid'] = individual_guid sample['projectGuid'] = individual_guid_to_project_guid[ individual_guid] for sample in igv_samples: individual_guid = individual_id_to_guid[sample.pop('individualId')] sample['individualGuid'] = individual_guid sample['projectGuid'] = individual_guid_to_project_guid[ individual_guid] for group in analysis_groups: group['projectGuid'] = project_id_to_guid[group.pop('projectId')] individual_guids_by_family = defaultdict(list) for individual in individuals: individual_guids_by_family[individual['familyGuid']].append( individual['individualGuid']) for family in families: family['individualGuids'] = individual_guids_by_family[ family['familyGuid']] sample_guids_by_individual = defaultdict(list) for sample in samples: sample_guids_by_individual[sample['individualGuid']].append( sample['sampleGuid']) igv_sample_guids_by_individual = defaultdict(list) for sample in igv_samples: igv_sample_guids_by_individual[sample['individualGuid']].append( sample['sampleGuid']) for individual in individuals: individual['sampleGuids'] = sample_guids_by_individual[ individual['individualGuid']] individual['igvSampleGuids'] = igv_sample_guids_by_individual[ individual['individualGuid']] response = { 'projectsByGuid': {p['projectGuid']: p for p in projects_json}, 'familiesByGuid': {f['familyGuid']: f for f in families}, 'individualsByGuid': {i['individualGuid']: i for i in individuals}, 'samplesByGuid': {s['sampleGuid']: s for s in samples}, 'igvSamplesByGuid': {s['sampleGuid']: s for s in igv_samples}, 'locusListsByGuid': { ll['locusListGuid']: ll for ll in get_json_for_locus_lists(locus_lists, user) }, 'analysisGroupsByGuid': {ag['analysisGroupGuid']: ag for ag in analysis_groups}, } if project_category_guid: response['projectCategoriesByGuid'] = { project_category_guid: ProjectCategory.objects.get(guid=project_category_guid).json() } return response
def _check_results_permission(results_model, user): families = results_model.families.prefetch_related('project').all() projects = {family.project for family in families} for project in projects: check_project_permissions(project, user)