def update_user(body_id, form_to_display):
user = forms._get_body(body_id, "user")
if not forms._check_body_perm(user, "user"):
return redirect(url_for('list_users'))
# For updating info of user, we're dealing with the form
gen_info_form = OdontuxUserGeneralInfoForm(request.form)
gen_info_form.title.choices = forms.get_title_choice_list()
hours_a_week = 0
if session['role'] == constants.ROLE_ADMIN:
gen_info_admin_form = OdontuxUserGeneralInfoAdminForm(request.form)
gen_info_admin_form.role.choices = constants.ROLES.items()
hours_a_week = (
cost.get_dental_unit_week_hours().total_seconds() / 3600
)
else:
gen_info_admin_form = ""
# hours por semana
if user.role == constants.ROLE_DENTIST:
dentist_specific_form = DentistSpecificForm(request.form)
else:
dentist_specific_form = ""
if (session['role'] == constants.ROLE_ADMIN
and user.role == constants.ROLE_DENTIST):
dentist_specific_admin_form = DentistSpecificAdminForm(request.form)
else:
dentist_specific_admin_form = ""
if request.method == 'POST' and gen_info_form.validate():
for f in get_gen_info_field_list():
setattr(user, f, getattr(gen_info_form, f).data)
if user.role == constants.ROLE_DENTIST:
for f in get_dentist_specific_field_list():
setattr(user, f, getattr(dentist_specific_form, f).data)
if (session['role'] == constants.ROLE_ADMIN
and gen_info_admin_form.validate() ):
for f in get_gen_info_admin_field_list():
setattr(user, f, getattr(gen_info_admin_form, f).data)
if user.role == constants.ROLE_DENTIST:
for f in get_dentist_specific_admin_field_list():
setattr(user, f,
getattr(dentist_specific_admin_form, f).data)
meta.session.commit()
return redirect(url_for('update_user',
body_id=body_id,
form_to_display="gen_info"))
# When loading the whole update page, we use the form containing all fields
# after prepopulating it
for f in get_gen_info_field_list():
getattr(gen_info_form, f).data = getattr(user, f)
if user.role == constants.ROLE_DENTIST:
for f in get_dentist_specific_field_list():
getattr(dentist_specific_form, f).data = getattr(user, f)
if session['role'] == constants.ROLE_ADMIN:
for f in get_gen_info_admin_field_list():
getattr(gen_info_admin_form, f).data = getattr(user, f)
if user.role == constants.ROLE_DENTIST:
for f in get_dentist_specific_admin_field_list():
try:
getattr(dentist_specific_admin_form, f).data =\
getattr(user, f)
except:
pass
timesheet_form = generate_timesheet_form(user.role)
# populate timesheet_form
for weekday in range(7):
for period in constants.PERIODS.keys():
TS = (
meta.session.query(users.TimeSheet)
.filter(
users.TimeSheet.user_id == user.id,
users.TimeSheet.weekday == weekday,
users.TimeSheet.period == period
)
.one_or_none()
)
if TS:
timesheet_form[weekday][period].begin.data = TS.begin
timesheet_form[weekday][period].end.data = TS.end
timesheet_form[weekday][period].dental_unit_id.data =\
TS.dental_unit_id
address_form = forms.AddressForm(request.form)
phone_form = forms.PhoneForm(request.form)
mail_form = forms.MailForm(request.form)
password_form = OdontuxUserPasswordForm(request.form)
return render_template('/update_user.html',
user=user,
form_to_display=form_to_display,
gen_info_form=gen_info_form,
gen_info_admin_form=gen_info_admin_form,
address_form=address_form,
phone_form=phone_form,
mail_form=mail_form,
password_form=password_form,
dentist_specific_form=dentist_specific_form,
timesheet_form=timesheet_form,
calendar=calendar,
constants=constants,
hours_a_week=hours_a_week,
dentist_specific_admin_form=dentist_specific_admin_form)
def update_patient(body_id, form_to_display):
""" """
patient = forms._get_body(body_id, "patient")
if not forms._check_body_perm(patient, "patient"):
return redirect(url_for('list_patients', body_id=body_id))
# only need form for *patient_gen_info* update here.
# Others are only needed for the 'GET', see below.
gen_info_form = PatientGeneralInfoForm(request.form)
gen_info_form.title.choices = forms.get_title_choice_list()
gen_info_form.office_id.choices = [ (office.id, office.office_name)
for office in meta.session.query(users.DentalOffice).all() ]
gen_info_form.dentist_id.choices = [ (dentist.id, dentist.firstname + " "
+ dentist.lastname)
for dentist in meta.session.query(users.OdontuxUser).filter(
users.OdontuxUser.role == constants.ROLE_DENTIST).order_by(
users.OdontuxUser.lastname).all()
]
if request.method == 'POST' and gen_info_form.validate():
for f in get_gen_info_field_list():
setattr(patient, f, getattr(gen_info_form, f).data)
# if not gen_info_form.family_id.data or not gen_info_form.family_member.data:
# new_family = administration.Family()
# meta.session.add(new_family)
# meta.session.commit()
# patient.family_id = new_family.id
# else:
# patient.family_id = gen_info_form.family_id.data
meta.session.commit()
# We should update in gnucash too the patient
comptability = gnucash_handler.GnuCashCustomer(patient.id,
patient.dentist_id)
customer = comptability.update_customer()
return redirect(url_for('update_patient', body_id=body_id,
form_to_display="gen_info"))
# When we 'GET' the page, we need all form, and fill in
# the gen_info and SSN_form from here
for f in get_gen_info_field_list():
getattr(gen_info_form, f).data = getattr(patient, f)
# # payer
# for payer in patient.family.payers:
# if patient.id == payer.id:
# gen_info_form.payer.data = True
# gen_info_form.family_id.data = patient.family_id
#
address_form = forms.AddressForm(request.form)
phone_form = forms.PhoneForm(request.form)
mail_form = forms.MailForm(request.form)
# need to return patient both as "patient" AND "body" :
# as "patient" for the header pagetitle,
# as "body" for the updating form.
other_healthcare_plans = (
meta.session.query(act.HealthCarePlan)
.filter(
act.HealthCarePlan.active.is_(True),
~act.HealthCarePlan.patients.any(
administration.Patient.id == patient.id)
)
.all()
)
return render_template('/update_patient.html', body=patient,
patient=patient,
gen_info_form=gen_info_form,
address_form=address_form,
phone_form=phone_form,
mail_form=mail_form,
other_healthcare_plans=other_healthcare_plans)
def add_user():
if session['role'] != constants.ROLE_ADMIN:
return redirect(url_for("index"))
gen_info_form = OdontuxUserGeneralInfoForm(request.form)
gen_info_form.title.choices = forms.get_title_choice_list()
gen_info_admin_form = OdontuxUserGeneralInfoAdminForm(request.form)
gen_info_admin_form.role.choices = constants.ROLES.items()
dentist_specific_form = DentistSpecificForm(request.form)
dentist_specific_admin_form = DentistSpecificAdminForm(request.form)
address_form = forms.AddressForm(request.form)
phone_form = forms.PhoneForm(request.form)
mail_form = forms.MailForm(request.form)
password_form = OdontuxUserPasswordForm(request.form)
if (request.method == 'POST' and gen_info_form.validate()
and address_form.validate() and phone_form.validate()
and mail_form.validate and password_form.validate()
):
values = {}
for f in get_gen_info_field_list():
values[f] = getattr(gen_info_form, f).data
for f in get_gen_info_admin_field_list():
values[f] = getattr(gen_info_admin_form, f).data
for f in get_password_field_list():
values[f] = b64encode(scrypt.encrypt(os.urandom(64),
getattr(password_form, f).data.encode("utf_8"),
maxtime=0.5))
for f in get_dentist_specific_field_list():
values[f] = getattr(dentist_specific_form, f).data
for f in get_dentist_specific_admin_field_list():
values[f] = getattr(dentist_specific_admin_form, f).data
new_odontuxuser = users.OdontuxUser(**values)
meta.session.add(new_odontuxuser)
address_args = {f: getattr(address_form, f).data
for f in forms.address_fields}
if any(address_args.values()):
new_address = contact.Address(**address_args)
meta.session.add(new_address)
meta.session.commit()
new_odontuxuser.address_id = new_address.id
# new_odontuxuser.addresses.append(contact.Address(
# **address_args))
#
phone_args = {g: getattr(phone_form, f).data
for f,g in forms.phone_fields}
if any(phone_args.values()):
new_odontuxuser.phones.append(contact.Phone(**phone_args))
mail_args = {f: getattr(mail_form, f).data for f in forms.mail_fields}
if any(mail_args.values()):
new_odontuxuser.mails.append(contact.Mail(**mail_args))
meta.session.commit()
return redirect(url_for('list_users'))
return render_template('/add_user.html/',
gen_info_form=gen_info_form,
gen_info_admin_form=gen_info_admin_form,
address_form=address_form,
phone_form=phone_form,
mail_form=mail_form,
password_form=password_form,
dentist_specific_form=dentist_specific_form,
dentist_specific_admin_form=dentist_specific_admin_form)
def add_patient(meeting_id=0):
""" Adding a new patient in database
"""
# the administrator don't have the right/use to create patient
# this task should be reserve to other roles, which are
# Secretary (when the patient first call/come, she may create a file
# Assisant/Nurse to help the dentist
# The dentist himself
authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE,
constants.ROLE_ASSISTANT, constants.ROLE_SECRETARY ]
if session['role'] not in authorized_roles:
return redirect(url_for("allpatients"))
# Forms used for adding a new patient :
# two are patient's specific :
gen_info_form = PatientGeneralInfoForm(request.form)
gen_info_form.title.choices = forms.get_title_choice_list()
gen_info_form.office_id.choices = [ (office.id, office.office_name)
for office in meta.session.query(users.DentalOffice).all() ]
gen_info_form.dentist_id.choices = [ (dentist.id, dentist.firstname + " "
+ dentist.lastname)
for dentist in meta.session.query(users.OdontuxUser)
.filter(users.OdontuxUser.role == constants.ROLE_DENTIST,
users.OdontuxUser.active.is_(True))
.order_by(users.OdontuxUser.lastname)
.all()
]
if len(gen_info_form.dentist_id.choices) > 1:
gen_info_form.dentist_id.choices.insert( 0, (0, "") )
hcp_patient_form = HealthCarePlanPatientForm(request.form)
hcp_patient_form.healthcare_plans_id.choices = [ (hc.id, hc.name)
for hc in meta.session.query(act.HealthCarePlan)
.filter(act.HealthCarePlan.active.is_(True))
.all() ]
if not hcp_patient_form.healthcare_plans_id.choices:
return redirect(url_for('add_healthcare_plan'))
# three are used for odontux_users and medecine doctors, too
address_form = forms.AddressForm(request.form)
phone_form = forms.PhoneForm(request.form)
mail_form = forms.MailForm(request.form)
if (request.method == 'POST' and gen_info_form.validate()
and address_form.validate()
and phone_form.validate() and mail_form.validate() ):
# Verify patient isn't already in database
patient = checks.is_body_already_in_database(gen_info_form, "patient")
if patient:
return redirect(url_for('update_patient',
body_id=patient.id,
form_to_display="gen_info"))
values = {f: getattr(gen_info_form, f).data
for f in get_gen_info_field_list()}
new_patient = administration.Patient(**values)
meta.session.add(new_patient)
meta.session.commit()
for healthcare_plan_id in hcp_patient_form.healthcare_plans_id.data:
hcp = ( meta.session.query(act.HealthCarePlan)
.filter(act.HealthCarePlan.id == healthcare_plan_id)
.one()
)
new_patient.hcs.append(hcp)
meta.session.commit()
# # A family is define in odontux mostly by the fact that
# # they live together.
# family_field_list = ['family_id']
# for f in family_field_list:
# # If patient in a family that is already in database, just tell
# # which family he's in.
# if getattr(gen_info_form, f).data:
# value[f] = int(getattr(gen_info_form, f).data)
# else:
# # Create new family and put the new patient in it.
# new_family = administration.Family()
# meta.session.add(new_family)
# meta.session.commit()
# new_patient.family_id = new_family.id
# meta.session.commit()
# Give the patient, member of family an address
address_args = {f: getattr(address_form, f).data
for f in forms.address_fields}
if any(address_args.values()):
new_address = contact.Address(**address_args)
meta.session.add(new_address)
meta.session.commit()
new_patient.address_id = new_address.id
meta.session.commit()
# # Now, we'll see if patient will pay for himself and for his family ;
# # if not, it must be someone from his family who'll pay.
# if gen_info_form.payer.data:
# # Mark the patient as a payer
# new_payer = administration.Payer(**{'id': new_patient.id})
# meta.session.add(new_payer)
# meta.session.commit()
# # precise that in his family, he pays.
# new_patient.family.payers.append(new_payer)
# meta.session.commit()
#
# Phone number, in order to contact him.
phone_args = {g: getattr(phone_form, f).data
for f,g in forms.phone_fields}
if any(phone_args.values()):
new_patient.phones.append(contact.Phone(**phone_args))
meta.session.commit()
# Mail
mail_args = {f: getattr(mail_form, f).data for f in forms.mail_fields}
if any(mail_args.values()):
new_patient.mails.append(contact.Mail(**mail_args))
meta.session.commit()
# ##################################
# # The Social Security Number : SSN
# ##################################
# # The social security info may have been entered via the
# # socialsecurity_id, encountered in gen_info_form, and which
# # is used usually while insering children of already known patients
# # in database.
# if SSN_form.SSN.data:
# # Verify if number already in database, for example children who
# # are under parent's social security.
# try:
# SSN_id = meta.session.query(SocialSecurityLocale)\
# .filter(SocialSecurityLocale.number\
# == SSN_form.SSN.data).one().id
#
# # If the number is new to database :
# except sqlalchemy.orm.exc.NoResultFound:
# SSN_args = {g: getattr(SSN_form, f).data
# for f,g in get_SSN_field_list() }
# new_SSN = SocialSecurityLocale(**SSN_args)
# meta.session.add(new_SSN)
# meta.session.commit()
# SSN_id = new_SSN.id
#
# else:
# # If there weren't any SSNumber given, try anyway to add "cmu"
# # and insurance hypothetic values into database
# SSN_args = {g: getattr(SSN_form, f).data
# for f,g in get_SSN_field_list() }
# new_SSN = SocialSecurityLocale(**SSN_args)
# meta.session.add(new_SSN)
# meta.session.commit()
# SSN_id = new_SSN.id
#
# # Tell Patient class the SSN he is related to.
# new_patient.socialsecurity_id = SSN_id
# meta.session.commit()
#Add the new patient to gnucash !
comptability = gnucash_handler.GnuCashCustomer(new_patient.id,
new_patient.dentist_id)
customer = comptability.add_customer()
return redirect(url_for('add_patient_appointment',
body_id=new_patient.id,
meeting_id=meeting_id))
return render_template("add_patient.html",
gen_info_form=gen_info_form,
address_form=address_form,
phone_form=phone_form,
mail_form=mail_form,
hcp_patient_form=hcp_patient_form,
meeting_id=meeting_id)
