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)