def to_representation(self, instance): config = instance.resort.incident_template incident_json = get_incident_data(instance.incident_pk) ret = super(IncidentListSerializer, self).to_representation(instance) incident_status = ret['incident_status'] ret.update(incident_json) data = get_extra_incident_info(config, incident_json, instance.incident_pk, 'list', self.context['data_key']) ret.update(data) ret.update( get_patient_info(instance.incident_pk, self.context['data_key'])) try: ret['incident_status'] = incident_status_option(incident_status) except: ret['incident_status'] = "" if instance.resort.use_sequential_incident_id == 1 and instance.assigned_to.user_connected == 1: ret['incident_pk'] = instance.incident_sequence else: ret['incident_pk'] = instance.incident_pk notes = IncidentNotes.objects.filter( incident=instance).order_by('-note_date') ret['notes'] = IncidentNotesSerializer(notes, fields=('note_id', 'note_date', 'note', 'user'), many=True).data return replace_null(ret)
def to_representation(self, instance): final_representation = {} ret = super(UserResortSerializer, self).to_representation(instance) final_representation.update(ret['user']) final_representation.update({"resort": ret['resort']}) try: devices = Devices.objects.filter(device_user=instance.user, device_state=0) devices_data = DeviceSerializer(devices, fields=('device_id', 'device_type', 'device_os'), many=True) final_representation['devices'] = devices_data.data except: final_representation['devices'] = [] try: from apps.custom_user.utils import userrole_option final_representation['role_id'] = userrole_option(int(ret['role'])) except: final_representation['role_id'] = "" try: final_representation['user_status'] = construct_options( USER_STATUS, ret['user_status']) except: final_representation['user_status'] = "" return replace_null(final_representation)
def to_representation(self, instance): ret = super(UserSerializer, self).to_representation(instance) try: ret['user_connected'] = construct_options(UserConnected, ret['user_connected']) except: pass return replace_null(ret)
def to_representation(self, instance): ret = super(DeviceSerializer, self).to_representation(instance) device_state = ret.get('device_state') try: if device_state is not None: ret['device_state'] = construct_options(DeviceState, device_state) except: pass return replace_null(ret)
def to_representation(self, instance): ret = super(LocationSerializer, self).to_representation(instance) location_status = ret.get('location_status') if location_status is not None: try: ret['location_status'] = construct_options(LOCATION_STATUS, location_status) except: pass return replace_null(ret)
def to_representation(self, instance): domain = instance.domain_id.domain ret = super(ResortSerializer, self).to_representation(instance) dispatch_field_choice = ret.get('dispatch_field_choice') if dispatch_field_choice is not None: ret['dispatch_field_choice'] = ast.literal_eval(dispatch_field_choice) map_kml = ret.get('map_kml') image = ret.get('resort_logo') # default_unit_distance = ret.get('default_unit_distance') map_type = ret.get('map_type') print_on_device = ret.get('print_on_device') # default_unit_temp = ret.get('default_unit_temp') # default_unit_length = ret.get('default_unit_length') # default_unit_weight = ret.get('default_unit_weight') report_form = ret.get('report_form') unit_format = ret.get('unit_format') default_unit_paper = ret.get('default_unit_paper') domain_id = ret.get('domain_id') datetime_format = ret.get('datetime_format') try: # if default_unit_distance is not None: # ret['default_unit_distance'] = construct_options(DistanceUnit, default_unit_distance) if map_type is not None: ret['map_type'] = construct_options(MapType, map_type) if print_on_device is not None: ret['print_on_device'] = construct_options(Choice, print_on_device) # if default_unit_temp is not None: # ret['default_unit_temp'] = construct_options(TemperatureUnit, default_unit_temp) # if default_unit_length is not None: # ret['default_unit_length'] = construct_options(LengthUnit, default_unit_length) # if default_unit_distance is not None: # ret['default_unit_distance'] = construct_options(DistanceUnit, default_unit_distance) # if default_unit_weight is not None: # ret['default_unit_weight'] = construct_options(WeightUnit, default_unit_weight) # if map_kml is not None and map_kml: # ret['map_kml'] = settings.SCHEME + domain + '/static' + ret['map_kml'].split('static')[1] # if image is not None and image: # ret['resort_logo'] = settings.SCHEME + domain + '/static' + ret['resort_logo'].split('static')[1] # if report_form is not None and report_form: # ret['report_form'] = settings.SCHEME + domain + '/static' + ret['report_form'].split('static')[1] if unit_format is not None: ret['unit_format'] = construct_options(UnitType, unit_format) if default_unit_paper is not None: ret['default_unit_paper'] = construct_options(PaperSize, default_unit_paper) if datetime_format is not None: ret['datetime_format'] = construct_options(DATETIME_FORMAT, datetime_format) if domain_id is not None: ret['domain_id'] = domain except: pass return replace_null(ret)
def to_representation(self, instance): # Add assignment if its found assignment = StockAssignment.objects.filter(controlled_substance_stock=instance) if assignment: assignment_data = StockAssignmentSerializer(assignment[0], fields=('controlled_substance_stock_assignment_id', 'dt_added', 'dt_used', 'user', 'incident_id')).data else: assignment_data = {} ret = super(StockReportSerializer, self).to_representation(instance) ret['assignment'] = assignment_data return replace_null(ret)
def to_representation(self, instance): ret = super(StockAssignmentSerializer, self).to_representation(instance) controlled_substance_stock_assignment_status = ret.get('controlled_substance_stock_assignment_status') if controlled_substance_stock_assignment_status is not None: try: ret['controlled_substance_stock_assignment_status'] = construct_options(STOCK_ASSIGNMENT_STATUS, controlled_substance_stock_assignment_status) except: pass try: if 'incident_id' in ret: ret['incident_pk'] = instance.incident_id.incident_sequence if instance.incident_id.resort.use_sequential_incident_id else instance.incident_id.incident_pk except: pass return replace_null(ret)
def to_representation(self, instance): config = instance.resort.incident_template incident_json = get_incident_data(instance.incident_pk) ret = super(IncidentStatusReportSerializer, self).to_representation(instance) data = get_extra_incident_info_status_report(config, incident_json) ret.update(data) try: ret['incident_status'] = incident_status_option_for_status_report( ret['incident_status']) except: ret['incident_status'] = "" if instance.resort.use_sequential_incident_id == 1 and instance.assigned_to.user_connected == 1: ret['incident_pk'] = instance.incident_sequence else: ret['incident_pk'] = instance.incident_pk return replace_null(ret)
def to_representation(self, instance): ret = super(IncidentNotesSerializer, self).to_representation(instance) ret = replace_null(ret) return_data = { "field_52ca448dg94ja3": ret['note'], "field_52ca448dg94ja4": ret['note_date'] } try: return_data.update({ "field_52ca448dg94ja5": { "key": str(ret['user']), "value": instance.user.name } }) except: pass try: return_data.update({"note_id": ret['note_id']}) except: pass return return_data
def to_representation(self, instance): ret = super(StatusHistorySerializer, self).to_representation(instance) return replace_null(ret)
def to_representation(self, instance): from apps.custom_user.utils import userrole_option ret = super(UserResortListSerializer, self).to_representation(instance) ret['role'] = userrole_option(int(ret['role'])) return replace_null(ret)
def to_representation(self, instance): ret = super(AssetSerializer, self).to_representation(instance) return replace_null(ret)
def to_representation(self, instance): ret = super(RoutingCompanySerializer, self).to_representation(instance) return replace_null(ret)
def to_representation(self, instance): ret = super(ControlledSubstancesSerializer, self).to_representation(instance) return replace_null(ret)
def to_representation(self, instance): ret = super(AreaSerializer, self).to_representation(instance) if 'location_count' in self.context: ret['location_count'] = ResortLocation.objects.filter(resort=self.context['resort'], area=instance, location_status=LIVE).count() return replace_null(ret)
def to_representation(self, instance): ret = super(IncidentTemplateExceptionsSerializer, self).to_representation(instance) return replace_null(ret)
def migrate_encrypted_patient_info(apps, schema_editor): from apps.incidents.utils import dictfetchall from helper_functions import create_client Resort = apps.get_model("resorts", "Resort") client = create_client() response = client.generate_data_key(KeyId=settings.GLOBAL_KMS_KEY_ID, KeySpec='AES_256') cursor = connection.cursor() cursor.execute("""SELECT incident_patient_id, pgp_pub_decrypt(name, keys.privkey) AS name, pgp_pub_decrypt(address, keys.privkey) AS address, pgp_pub_decrypt(suburb, keys.privkey) AS suburb, pgp_pub_decrypt(state, keys.privkey) AS state, pgp_pub_decrypt(postcode, keys.privkey) AS postcode, pgp_pub_decrypt(phone, keys.privkey) AS phone, pgp_pub_decrypt(email, keys.privkey) AS email, pgp_pub_decrypt(dob, keys.privkey) AS dob FROM incidents_patients CROSS JOIN (SELECT dearmor(%s) As privkey) As keys;""", [settings.GPG_PRIVATE_KEY, ]) data = dictfetchall(cursor) for each_data in data: each_data = replace_null(each_data) cursor.execute("""UPDATE incidents_patients SET name = pgp_sym_encrypt(v.name, keys.datakey, 'compress-algo=1, cipher-algo=aes256'), address = pgp_sym_encrypt(v.address, keys.datakey, 'compress-algo=1, cipher-algo=aes256'), suburb = pgp_sym_encrypt(v.suburb, keys.datakey, 'compress-algo=1, cipher-algo=aes256'), state = pgp_sym_encrypt(v.state,keys.datakey, 'compress-algo=1, cipher-algo=aes256'), postcode = pgp_sym_encrypt(v.postcode, keys.datakey, 'compress-algo=1, cipher-algo=aes256'), phone = pgp_sym_encrypt(v.phone,keys.datakey, 'compress-algo=1, cipher-algo=aes256'), email = pgp_sym_encrypt(v.email, keys.datakey, 'compress-algo=1, cipher-algo=aes256'), dob = pgp_sym_encrypt(v.dob, keys.datakey, 'compress-algo=1, cipher-algo=aes256') FROM ( VALUES ( %s, %s, %s, %s, %s, %s, %s, %s ) ) AS v ( name, address, suburb, state, postcode, phone, email, dob ) CROSS JOIN ( SELECT %s::TEXT AS datakey) AS keys WHERE incidents_patients.incident_patient_id = %s;""", [each_data['name'], each_data['address'], each_data['suburb'], each_data['state'], each_data['postcode'], each_data['phone'], each_data['email'], each_data['dob'], base64.b64encode(response['Plaintext']), each_data['incident_patient_id']]) resorts = Resort.objects.all().update(enc_data_key=base64.b64encode(response['CiphertextBlob'])) cursor.close()