def register_doctor(self):
data = {}
validation_error = field_validation.validate_fields(
self.data, 'DOCTOR_REGISTRATION')
if validation_error:
return validation_error, 400
user_instance = self.get_or_create_user()
data['work_ex'] = self.data.get('work_ex')
data['qualification'] = self.data.get('qualification')
doctor_instance = models.Doctor(**data)
db.session.add(doctor_instance)
db.session.commit()
try:
password = hashlib.sha256(
self.data.get('password').encode('utf-8')).hexdigest()
user_mapping_instance = models.UserMapping(
user_id=user_instance.id,
entity_id=doctor_instance.id,
entity_type=self.type,
password=password)
db.session.add(user_mapping_instance)
db.session.commit()
except (IntegrityError, ):
db.session.rollback()
db.session.delete(doctor_instance)
db.session.commit()
return {'error': 'User already exists'}, 400
return {'message': 'User successfully created'}, 201
def register_patient(self):
validation_error = field_validation.validate_fields(
self.data, 'PATIENT_REGISTRATION')
if validation_error:
return validation_error, 400
user_instance = self.get_or_create_user()
patient_instance = models.Patient(address="")
db.session.add(patient_instance)
db.session.commit()
try:
password = hashlib.sha256(
self.data.get('password').encode('utf-8')).hexdigest()
user_mapping_instance = models.UserMapping(
user_id=user_instance.id,
entity_id=patient_instance.id,
entity_type=self.type,
password=password)
db.session.add(user_mapping_instance)
db.session.commit()
except (IntegrityError):
db.session.rollback()
db.session.delete(patient_instance)
db.session.commit()
return {'error': 'User already exists.'}, 400
return {'message': 'User successfully created'}, 201
def login(self):
data = {}
validation_error = field_validation.validate_fields(self.data, 'LOGIN')
if validation_error:
return validation_error, 400
username = self.data.get('phone_number')
password = self.data.get('password')
password = hashlib.sha256(password.encode('utf-8')).hexdigest()
try:
user_instance = models.User.query.filter_by(
username=username).first()
user_mapping_instance = models.UserMapping.query.filter_by(
user_id=user_instance.id, entity_type=self.type).first()
if not user_mapping_instance:
return {'error': 'User not found'}, 400
except:
return {'error': 'User not found'}, 400
if password != user_mapping_instance.password:
return constants.LOGIN_ERROR, 400
user_info = self.serilize(user_instance)
entity_instance = self.get_entity_instance(
user_mapping_instance.entity_id)
user_details = self.serilize(entity_instance)
token = str(uuid.uuid4()).replace('-', '')
token_instance = self.get_token_instance(user_instance.id, token,
self.type)
db.session.add(token_instance)
db.session.commit()
data['user_info'] = user_info
data['user_details'] = user_details
data['auth_token'] = token
return data, 200
def update_medicine(self):
validation_error = field_validation.validate_fields(
self.data, 'UPDATE_MEDICINE')
if validation_error:
return validation_error, 400
user_id = self.get_user_instance
data = {}
data['user_id'] = user_id
data['medicine_id'] = self.data.get('medicine_id')
data['in_stock'] = self.data.get('in_stock')
available_medicine_instance = models.AvailableMedicine(**data)
db.session.add(available_medicine_instance)
db.session.commit()
def write_prescription(self):
data = {}
doctor_instance = self.get_user_instance
data['doctor_id'] = doctor_instance
if self.data.get('patient_data'):
assert_error = self.create_patient_instance()
if assert_error:
return assert_error, 400
data['patient_id'] = self.patient_instance.id
data['timestamp'] = datetime.now()
prescription_instance = prescription_model.Prescription(**data)
db.session.add(prescription_instance)
db.session.commit()
treatment_list = self.data.get('treatment')
for treatment in treatment_list:
validation_error = field_validation.validate_fields(
treatment, 'TREATMENT')
if validation_error:
return validation_error, 400
treatment_data = {}
treatment_data['prescription_id'] = prescription_instance.id
treatment_data['medication'] = treatment.get('medication')
treatment_instance = prescription_model.Treatment(**treatment_data)
db.session.add(treatment_instance)
diagnosis_list = self.data.get('diagnosis')
for diagnosis in diagnosis_list:
validation_error = field_validation.validate_fields(
diagnosis, 'DIAGNOSIS')
if validation_error:
return validation_error, 400
diagnosis_data = {}
diagnosis_data['prescription_id'] = prescription_instance.id
diagnosis_data['cause'] = diagnosis.get('cause')
diagnosis_instance = prescription_model.Diagnosis(**diagnosis_data)
db.session.add(diagnosis_instance)
db.session.commit()
return {'message': 'Prescription created successfully.'}, 200
def create_patient_instance(self):
data = self.data.get('patient_data')
try:
patient_user_instance = user_model.User.query.filter_by(
username=data.get('phone_number')).first()
patient_mapping_instance = user_model.UserMapping.query.filter_by(
user_id=patient_user_instance.id).first()
patient_instance = user_model.Patient.query.filter_by(
id=patient_mapping_instance.entity_id).first()
if patient_user_instance:
self.patient_instance = patient_user_instance
return
except Exception:
pass
user_data, user_mapping_data, patient_data = {}, {}, {}
validation_error = field_validation.validate_fields(
data, 'PATIENT_INFO')
if validation_error:
return validation_error
user_data['username'] = data.get('phone_number')
full_name = data.get('patient_name')
user_data.update(self.parse_full_name(full_name))
user_instance = user_model.User(**user_data)
patient_data['dob'] = parser.parse(data.get('dob'))
patient_data['gender'] = data.get('patient_gender')
patient_data['address'] = data.get('address', str())
patient_instance = user_model.Patient(**patient_data)
try:
db.session.add(user_instance)
db.session.add(patient_instance)
db.session.commit()
user_mapping_data['user_id'] = user_instance.id
user_mapping_data['entity_id'] = patient_instance.id
user_mapping8_data['entity_type'] = 'Patient'
user_mapping_data['password'] = hashlib.sha256(
data.get('phone_number').encode('utf-8')).hexdigest()
user_mapping_instance = user_model.UserMapping(**user_mapping_data)
db.session.add(user_mapping_instance)
db.session.commit()
self.patient_instance = user_instance
except (IntegrityError, ):
db.session.rollback()
db.session.delete(patient_instance)
db.session.commit()
return {'error': 'User already exists'}