def form_valid(self, form):
raw_data = self.request.FILES['data_file'].read()
data = json.loads(raw_data)
demographics = data['demographics'][0]
demographics['date_of_birth'] = serialization.deserialize_date(
demographics['date_of_birth'])
matcher = PeakFlowMatcher(demographics)
patient, created = matcher.match_or_create()
episode = patient.episode_set.get()
self.patient = patient
self.episode = episode
peak_flow_days = data['episodes']['1']['peak_flow_day']
for day_data in peak_flow_days:
day_data['date'] = serialization.deserialize_date(day_data['date'])
day, created = episode.peakflowday_set.get_or_create(
date=day_data['date'])
for key, value in day_data.items():
setattr(day, key, value)
day.save()
return super(ImportView, self).form_valid(form)
def import_patient(data, user=None):
"""
Given a datastructure representing a Patient, import that patient.
If required, pass in the user as a kwarg.
1. Match or create the patient
2. Iterate through episodes in the patient data, creating them as required
"""
validate_import_data(data)
demographics = data['demographics'][0]
demographics['date_of_birth'] = serialization.deserialize_date(
demographics['date_of_birth'])
matcher = OpalExportMatcher(demographics)
patient, created = matcher.match_or_create(user=user)
episodes = data.pop('episodes')
for episode in episodes.values():
create_episode_for_patient(patient, episode, user=user)
for key, value in data.items():
if key == 'demographics':
continue # We already did that one.
import_patient_subrecord_data(key, value, patient, user=user)
return
def query(self, given_query):
val = serialization.deserialize_date(given_query['query'])
qs = Episode.objects.exclude(end=None)
if given_query['queryType'] == 'Before':
return qs.filter(end__lte=val)
elif given_query['queryType'] == 'After':
return qs.filter(end__gte=val)
else:
err = "unrecognised query type for the end episode query with {}"
raise SearchException(err.format(given_query['queryType']))
def query(self, given_query):
val = serialization.deserialize_date(given_query['query'])
qs = Episode.objects.exclude(start=None)
if given_query['queryType'] == 'Before':
return qs.filter(start__lte=val)
elif given_query['queryType'] == 'After':
return qs.filter(start__gte=val)
else:
err = "unrecognised query type for the start episode query with {}"
raise SearchException(err.format(given_query['queryType']))
def update_from_dict(self, data, user, force=False, fields=None):
logging.info("updating {0} with {1} for {2}".format(
self.__class__.__name__, data, user
))
if fields is None:
fields = set(self._get_fieldnames_to_serialize())
if self.consistency_token and not force:
try:
consistency_token = data.pop('consistency_token')
except KeyError:
msg = 'Missing field (consistency_token) for {}'
raise exceptions.MissingConsistencyTokenError(
msg.format(self.__class__.__name__)
)
if consistency_token != self.consistency_token:
raise exceptions.ConsistencyError
post_save = []
unknown_fields = set(data.keys()) - fields
if unknown_fields:
raise exceptions.APIError(
'Unexpected fieldname(s): %s' % list(unknown_fields))
for name in fields:
value = data.get(name, None)
if name == 'consistency_token':
continue # shouldn't be needed - Javascripts bug?
setter = getattr(self, 'set_' + name, None)
if setter is not None:
setter(value, user, data)
else:
if name in data:
field_type = self._get_field_type(name)
if field_type == models.fields.related.ManyToManyField:
post_save.append(
functools.partial(self.save_many_to_many,
name,
value,
field_type))
else:
DateTimeField = models.fields.DateTimeField
if value and field_type == models.fields.DateField:
value = serialization.deserialize_date(value)
elif value and field_type == DateTimeField:
value = serialization.deserialize_datetime(value)
elif value and field_type == models.fields.TimeField:
value = serialization.deserialize_time(value)
setattr(self, name, value)
self.set_consistency_token()
self.save()
for some_func in post_save:
some_func()
def test_deserialize_already_a_date(self):
value = datetime.date(1959, 4, 22)
d = serialization.deserialize_date(value)
self.assertEqual(datetime.date(1959, 4, 22), d)
def test_deserialize_invalid_date(self):
value = '22-04-1959'
with self.assertRaises(ValueError):
serialization.deserialize_date(value)
def test_deserialize_date(self):
value = '22/04/1959'
d = serialization.deserialize_date(value)
self.assertEqual(datetime.date(1959, 4, 22), d)
