def no_login_main_app(request, *args, **kwargs):
"""Loads the react single page app for non-logged in views."""
initial_json = {}
user_token = kwargs.get('user_token')
if user_token:
initial_json['newUser'] = _get_json_for_user(
User.objects.get(password=user_token))
elif not request.user.is_anonymous():
initial_json['user'] = _get_json_for_user(request.user)
return _render_app_html(request, initial_json)
def get_all_staff(request):
staff_analysts = {
staff.username: _get_json_for_user(staff)
for staff in User.objects.filter(is_staff=True)
}
return create_json_response(staff_analysts)
def get_all_users(request):
users = [
_get_json_for_user(user, is_anvil=False)
for user in User.objects.exclude(email='')
]
return create_json_response({'users': users})
def render_app_html(request,
additional_json=None,
include_user=True,
status=200):
html = loader.render_to_string('app.html')
ui_version = re.search('static/app-(.*)\.js', html).group(1)
initial_json = {
'meta': {
'version': '{}-{}'.format(SEQR_VERSION, ui_version),
'hijakEnabled': DEBUG or False,
'googleLoginEnabled': google_auth_enabled(),
}
}
if include_user:
initial_json['user'] = _get_json_for_user(request.user)
if additional_json:
initial_json.update(additional_json)
html = html.replace(
"window.initialJSON=null", "window.initialJSON=" +
json.dumps(initial_json, default=DjangoJSONEncoder().default))
if request.get_host() == 'localhost:3000':
html = re.sub(r'static/app(-.*)js', 'app.js', html)
html = re.sub(r'<link\s+href="/static/app.*css"[^>]*>', '', html)
return HttpResponse(html, content_type="text/html", status=status)
def no_login_main_app(request, *args, **kwargs):
"""Loads the react single page app for non-logged in views."""
initial_json = {}
user_token = kwargs.get('user_token')
if user_token:
initial_json['newUser'] = _get_json_for_user(User.objects.get(password=user_token))
return _render_app_html(request, initial_json)
def get_all_analyst_options(request):
analysts = {
user.username: _get_json_for_user(user, fields=USER_OPTION_FIELDS)
for user in _get_all_analysts()
}
return create_json_response(analysts)
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 _get_collaborator_json(collaborator, include_permissions, can_edit):
collaborator_json = _get_json_for_user(collaborator)
if include_permissions:
collaborator_json.update({
'hasViewPermissions': True,
'hasEditPermissions': can_edit,
})
return collaborator_json
def get_all_collaborators(request):
if request.user.is_staff:
collaborators = {user.username: _get_json_for_user(user) for user in User.objects.exclude(email='')}
else:
collaborators = {}
for project in get_projects_user_can_view(request.user):
collaborators.update(get_project_collaborators_by_username(project, include_permissions=False))
return create_json_response(collaborators)
def get_all_users(request):
user_tups = [(user, _get_json_for_user(user, is_anvil=False))
for user in User.objects.exclude(email='')]
users = [
dict(hasGoogleAuth=is_google_authenticated(user), **user_json)
for user, user_json in user_tups
]
return create_json_response({'users': users})
def get_all_collaborator_options(request):
collaborators = set()
for project in get_local_access_projects(request.user):
collaborators.update(project.get_collaborators())
return create_json_response({
user.username: _get_json_for_user(user, fields=USER_OPTION_FIELDS)
for user in collaborators
})
def test_json_for_user(self):
for user in User.objects.all():
user_json = _get_json_for_user(user)
user_json_keys = set(user_json.keys())
self.assertSetEqual(
user_json_keys,
set(('dateJoined', 'email', 'firstName', 'isStaff', 'lastLogin', 'lastName', 'username', 'displayName'))
)
def test_json_for_user(self):
for user in User.objects.all():
user_json = _get_json_for_user(user)
user_json_keys = set(user_json.keys())
self.assertSetEqual(
user_json_keys,
set(('dateJoined', 'email', 'firstName', 'isStaff',
'lastLogin', 'lastName', 'username', 'displayName')))
def test_json_for_user(self):
for user in User.objects.all():
user_json = _get_json_for_user(user)
user_json_keys = set(user_json.keys())
self.assertSetEqual(
user_json_keys,
set(('date_joined', 'email', 'first_name', 'id', 'is_active',
'is_staff', 'last_login', 'last_name', 'username')))
def dashboard_page_data(request):
"""Returns a JSON object containing information used by the dashboard page:
::
json_response = {
'user': {..},
'familiesByGuid': {..},
'individualsByGuid': {..},
}
"""
cursor = connection.cursor()
if request.user.is_staff:
projects_user_can_view = projects_user_can_edit = None
else:
projects_user_can_view = Project.objects.filter(
can_view_group__user=request.user)
projects_user_can_edit = Project.objects.filter(
can_edit_group__user=request.user)
# defensive programming
edit_but_not_view_permissions = set(
p.guid for p in projects_user_can_edit) - set(
p.guid for p in projects_user_can_view)
if edit_but_not_view_permissions:
raise Exception(
'ERROR: %s has EDIT permissions but not VIEW permissions for: %s'
% (request.user, edit_but_not_view_permissions))
projects_by_guid = _retrieve_projects_by_guid(
cursor,
projects_user_can_view,
projects_user_can_edit,
user_is_staff=request.user.is_staff)
_add_analysis_status_counts(cursor,
projects_by_guid,
user_is_staff=request.user.is_staff)
_add_sample_type_counts(cursor,
projects_by_guid,
user_is_staff=request.user.is_staff)
project_categories_by_guid = _retrieve_project_categories_by_guid(
projects_by_guid, user_is_staff=request.user.is_staff)
cursor.close()
json_response = {
'user': _get_json_for_user(request.user),
'projectsByGuid': projects_by_guid,
'projectCategoriesByGuid': project_categories_by_guid,
}
return create_json_response(json_response)
def _get_json_for_initial_user(user):
user_json = _get_json_for_user(user)
user_json['currentPolicies'] = False
if hasattr(user, 'userpolicy'):
current_privacy = user.userpolicy.privacy_version
current_tos = user.userpolicy.tos_version
user_json[
'currentPolicies'] = current_privacy == SEQR_PRIVACY_VERSION and current_tos == SEQR_TOS_VERSION
return user_json
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 no_login_main_app(request, *args, **kwargs):
"""Loads the react single page app for non-logged in views."""
render_kwargs = {'include_user': False}
user_token = kwargs.get('user_token')
if user_token:
render_kwargs['additional_json'] = {
'newUser':
_get_json_for_user(User.objects.get(password=user_token))
}
elif not request.user.is_anonymous:
render_kwargs['include_user'] = True
if not request.META.get(CSRF_COOKIE_NAME):
rotate_token(request)
return render_app_html(request, **render_kwargs)
def main_app(request, *args, **kwargs):
"""Loads the react single page app."""
html = loader.render_to_string('app.html')
html = html.replace(
"window.initialJSON=null", "window.initialJSON=" +
json.dumps({'user': _get_json_for_user(request.user)},
default=DjangoJSONEncoder().default))
if request.get_host() == 'localhost:3000':
html = re.sub(r'static/app(-.*)js', 'app.js', html)
html = re.sub(r'<link\s+href="/static/app.*css"[^>]*>', '', html)
return HttpResponse(html, content_type="text/html")
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 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 main_app(request, *args, **kwargs):
"""Loads the react single page app."""
return _render_app_html(request,
{'user': _get_json_for_user(request.user)})
def test_json_for_user(self):
for user in User.objects.all():
user_json = _get_json_for_user(user)
user_json_keys = set(user_json.keys())
self.assertSetEqual(user_json_keys, USER_FIELDS)
def main_app(request, *args, **kwargs):
"""Loads the react single page app."""
return _render_app_html(request, {'user': _get_json_for_user(request.user)})
def update_user(request):
request_json = json.loads(request.body)
_update_user_from_json(request.user, request_json)
return create_json_response(_get_json_for_user(request.user))
