mirror of
https://github.com/Southampton-RSG/breccia-mapper.git
synced 2026-03-03 11:27:09 +00:00
141 lines
5.0 KiB
Python
141 lines
5.0 KiB
Python
"""
|
|
Views for displaying networks of :class:`People` and :class:`Relationship`s.
|
|
"""
|
|
|
|
import logging
|
|
import typing
|
|
|
|
from django.contrib.auth.mixins import LoginRequiredMixin
|
|
from django.db.models import Q
|
|
from django.forms import ValidationError
|
|
from django.utils import timezone
|
|
from django.views.generic import TemplateView
|
|
|
|
from people import forms, models, serializers
|
|
|
|
logger = logging.getLogger(__name__) # pylint: disable=invalid-name
|
|
|
|
|
|
def filter_by_form_answers(model: typing.Type, answerset_model: typing.Type,
|
|
relationship_key: str):
|
|
"""Build a filter to select based on form responses."""
|
|
def inner(form, at_date):
|
|
answerset_set = answerset_model.objects.filter(
|
|
Q(replaced_timestamp__gte=at_date)
|
|
| Q(replaced_timestamp__isnull=True),
|
|
timestamp__lte=at_date)
|
|
|
|
# Filter answers to relationship questions
|
|
for field, values in form.cleaned_data.items():
|
|
if field.startswith(f'{form.question_prefix}question_') and values:
|
|
answerset_set = answerset_set.filter(
|
|
question_answers__in=values)
|
|
|
|
return model.objects.filter(
|
|
pk__in=answerset_set.values_list(relationship_key, flat=True))
|
|
|
|
return inner
|
|
|
|
|
|
filter_relationships = filter_by_form_answers(models.Relationship,
|
|
models.RelationshipAnswerSet,
|
|
'relationship')
|
|
|
|
filter_organisations = filter_by_form_answers(models.Organisation,
|
|
models.OrganisationAnswerSet,
|
|
'organisation')
|
|
|
|
filter_people = filter_by_form_answers(models.Person, models.PersonAnswerSet,
|
|
'person')
|
|
|
|
|
|
class NetworkView(LoginRequiredMixin, TemplateView):
|
|
"""View to display relationship network."""
|
|
template_name = 'people/network.html'
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
all_forms = self.get_forms()
|
|
if all(map(lambda f: f.is_valid(), all_forms.values())):
|
|
return self.forms_valid(all_forms)
|
|
|
|
return self.forms_invalid(all_forms)
|
|
|
|
def get_forms(self):
|
|
form_kwargs = self.get_form_kwargs()
|
|
|
|
return {
|
|
'relationship': forms.NetworkRelationshipFilterForm(**form_kwargs),
|
|
'person': forms.NetworkPersonFilterForm(**form_kwargs),
|
|
'organisation': forms.NetworkOrganisationFilterForm(**form_kwargs),
|
|
}
|
|
|
|
def get_form_kwargs(self):
|
|
"""Add GET params to form data."""
|
|
kwargs = {}
|
|
|
|
if self.request.method == 'GET':
|
|
kwargs['data'] = self.request.GET
|
|
|
|
if self.request.method in ('POST', 'PUT'):
|
|
kwargs['data'] = self.request.POST
|
|
|
|
return kwargs
|
|
|
|
def get_context_data(self, **kwargs):
|
|
"""
|
|
Add filtered QuerySets of :class:`Person` and :class:`Relationship` to the context.
|
|
"""
|
|
context = super().get_context_data(**kwargs)
|
|
|
|
all_forms = self.get_forms()
|
|
context['relationship_form'] = all_forms['relationship']
|
|
context['person_form'] = all_forms['person']
|
|
context['organisation_form'] = all_forms['organisation']
|
|
|
|
if not all(map(lambda f: f.is_valid(), all_forms.values())):
|
|
return context
|
|
|
|
relationship_at_date = all_forms['relationship'].cleaned_data['date']
|
|
if not relationship_at_date:
|
|
relationship_at_date = timezone.now().date()
|
|
|
|
person_at_date = all_forms['person'].cleaned_data['date']
|
|
if not person_at_date:
|
|
person_at_date = timezone.now().date()
|
|
|
|
organisation_at_date = all_forms['organisation'].cleaned_data['date']
|
|
if not organisation_at_date:
|
|
organisation_at_date = timezone.now().date()
|
|
|
|
# Filter on timestamp__date doesn't seem to work on MySQL
|
|
# To compare datetimes we need at_date to be midnight at
|
|
# the *end* of the day in question - so add one day here
|
|
relationship_at_date += timezone.timedelta(days=1)
|
|
|
|
context['person_set'] = serializers.PersonSerializer(
|
|
filter_people(all_forms['person'], person_at_date),
|
|
many=True).data
|
|
|
|
context['organisation_set'] = serializers.OrganisationSerializer(
|
|
filter_organisations(all_forms['organisation'], organisation_at_date),
|
|
many=True).data
|
|
|
|
context['relationship_set'] = serializers.RelationshipSerializer(
|
|
filter_relationships(all_forms['relationship'], relationship_at_date),
|
|
many=True).data
|
|
|
|
logger.info('Found %d distinct relationships matching filters',
|
|
len(context['relationship_set']))
|
|
|
|
return context
|
|
|
|
def forms_valid(self, all_forms):
|
|
try:
|
|
return self.render_to_response(self.get_context_data())
|
|
|
|
except ValidationError:
|
|
return self.forms_invalid(all_forms)
|
|
|
|
def forms_invalid(self, all_forms):
|
|
return self.render_to_response(self.get_context_data())
|