def find_gesture(): gest_code = request.args.get('gesture', None) healthcare_plan_id = request.args.get('healthcare_plan_id', None) patient_id = int(request.args.get('patient_id', None)) patient, appointment = checks.get_patient_appointment( patient_id=patient_id) if gest_code: gest_code = gest_code.split(" ") words = u"%" for word in gest_code: words = words + u'{}%'.format(word) cotations = ( meta.session.query(act.Cotation) .join(act.Gesture) .filter(act.Cotation.healthcare_plan_id == healthcare_plan_id) .filter(or_( act.Gesture.alias.ilike(words), act.Gesture.code.ilike(words), act.Gesture.name.ilike(words) ) ) .all() ) if not cotations: return jsonify(success=False) gestures = {} for cotation in cotations: gestures[str(cotation.id)] = (cotation.gesture.name, cotation.gesture.code, str(cotation.price)) return jsonify(success=True, **gestures) return jsonify(success=False)
def add_to_materio_vigilance(appointment_id, quantity, material): """ update both: materio_vigilance.quantity_used and material.actual_quantity """ patient, appointment = checks.get_patient_appointment( appointment_id=appointment_id) materio_vigilance = ( meta.session.query(traceability.MaterioVigilance) .filter( traceability.MaterioVigilance.appointment_id == appointment_id, traceability.MaterioVigilance.material_id == material.id ) .one_or_none() ) if not materio_vigilance: values = { 'material_id': material.id, 'appointment_id': appointment_id, 'quantity_used': quantity } new_materio_vigilance = traceability.MaterioVigilance(**values) meta.session.add(new_materio_vigilance) meta.session.commit() materio_vigilance = new_materio_vigilance else: materio_vigilance.quantity_used = ( materio_vigilance.quantity_used + quantity ) meta.session.commit() material.actual_quantity = ( material.actual_quantity - quantity ) meta.session.commit() return materio_vigilance
def list_statement(patient_id, appointment_id): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT, constants.ROLE_SECRETARY ] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) quotes = ( meta.session.query(statements.Quote) .filter(statements.Quote.patient_id == patient_id) .join(schedule.Appointment, schedule.Agenda) .order_by(schedule.Agenda.starttime.desc()) .all() ) bills = ( meta.session.query(statements.Bill) .filter(statements.Bill.patient_id == patient_id) .join(schedule.Appointment, schedule.Agenda) .order_by(schedule.Agenda.starttime.desc()) .all() ) if constants.LOCALE == 'br': nfes = (meta.session.query(statements.NotaFiscalBr) .filter(statements.NotaFiscalBr.patient_id == patient_id) .order_by(statements.NotaFiscalBr.timestamp.desc()) .all() ) else: nfes = [] return render_template('list_statements.html', patient=patient, appointment=appointment, quotes_id='', quotes=quotes, bills=bills, nfes=nfes, constants=constants)
def list_acts(patient_id, appointment_id=0): """ Sends to template a list of tuples : ( gesture, tooth, act_info, act_specialty ) """ # Everybody but admin should enter this function ; however, # what is displayed should depends on whom is looking. # This will be taken care of in the html_template, by jinja. if session['role'] == constants.ROLE_ADMIN: return redirect(url_for('index')) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) acts = checks.get_patient_acts(patient.id, None, [ act.AppointmentCotationReference.appointment_id, ] ) payments = ( meta.session.query(compta.Payment) .filter(compta.Payment.patient_id == patient_id) .all() ) return render_template("list_patient_acts.html", patient=patient, appointment=appointment, acts=acts, payments=payments)
def add_nota_fiscal(patient_id, appointment_id=0): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT, constants.ROLE_SECRETARY ] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) document_form = NotaFiscalForm(request.form) if request.method == 'POST' and document_form.validate(): document_data = request.files[document_form.document.name].read() if document_data: new_file = insert_document_in_db(document_data, document_form.document_type.data, appointment) values = { 'patient_id': patient_id, 'document_id': new_file.id, } new_nota_fiscal = statements.NotaFiscalBr(**values) meta.session.add(new_nota_fiscal) meta.session.commit() return render_template('add_nota_fiscal.html', patient=patient, appointment=appointment, document_form=document_form)
def add_file_to_tooth_event(patient_id, appointment_id, event_id): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT ] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) event = ( meta.session.query(teeth.Event) .filter(teeth.Event.id == event_id) .one() ) document_form = DocumentForm(request.form) if document_form.validate(): document_data = request.files[document_form.document.name].read() if document_data: new_file = insert_document_in_db(document_data, document_form.document_type.data, appointment) if new_file not in event.files: event.files.append(new_file) meta.session.commit() return redirect(url_for('show_tooth', patient_id=patient_id, appointment_id=appointment_id, tooth_codename=event.tooth.codename))
def add_patient_survey(appointment_id): patient, appointment = checks.get_patient_appointment(appointment_id=appointment_id) patient_survey_form = PatientSurveyForm(request.form) patient_survey_form.appointment_id.choices = [ (appointment.id, appointment.agenda.starttime) for appointment in meta.session.query(schedule.Appointment) .filter(schedule.Appointment.patient_id == patient.id) .all() ] if patient_survey_form.validate(): # !!! Beware of this two variables really seemful ! Bad. anamnesis_appointment = ( meta.session.query(schedule.Appointment) .filter(schedule.Appointment.id == patient_survey_form.appointment_id.data) .one() ) appointment_anamnesis = ( meta.session.query(anamnesis.Anamnesis) .filter(anamnesis.Anamnesis.appointment_id == anamnesis_appointment.id) .all() ) document_data = request.files[patient_survey_form.document.name].read() if document_data: new_file = insert_document_in_db(document_data, constants.FILE_ANAMNESIS, anamnesis_appointment) for anamnesis_entry in appointment_anamnesis: if not anamnesis_entry.file_id: anamnesis_entry.file_id = new_file.id meta.session.commit() return redirect(url_for("list_anamnesis", patient_id=patient.id, appointment_id=appointment.id))
def choose_clinic_gestures_from_cotation(appointment_id): """ The POST action comes from view_clinic_report. """ patient, appointment = checks.get_patient_appointment( appointment_id=appointment_id) form = ChooseCotationForReportForm(request.form) form.cotation_id.choices = [ (cot.id, cot.gesture.name) for cot in meta.session.query(act.Cotation) .join(act.Gesture, act.Specialty) .order_by(act.Specialty.name, act.Gesture.name) .all() ] if form.validate(): # define which cotation we are working with cotation = ( meta.session.query(act.Cotation) .filter(act.Cotation.id == form.cotation_id.data) .one() ) # Define anatomic_locations we are working with anatomic_locations = "" if not form.anatomic_location.data: form.anatomic_location.data = 0 try: if int(form.anatomic_location.data) >= 0 : anatomic_locations = str(form.anatomic_location.data) except ValueError: for idx, anat_loc in\ enumerate(teeth.get_teeth_list(form.anatomic_location.data)) : if idx: anatomic_locations = anatomic_locations + "," anatomic_locations = anatomic_locations + str(anat_loc) # create form with clinic_gestures associated with this cotation cg_form = ClinicGesturesFromCotationForm(request.form) for cg_cot_ref in sorted(cotation.clinic_gestures, key=lambda cg_cot_ref: ( cg_cot_ref.appointment_number, cg_cot_ref.sequence ) ): cg_keep_form = ClinicGestureKeepForm(request.form) cg_keep_form.clinic_gesture_id = cg_cot_ref.clinic_gesture_id cg_keep_form.clinic_gesture_data = cg_cot_ref.clinic_gesture.name cg_keep_form.keep = cg_cot_ref.appears_on_clinic_report cg_form.clinic_gestures.append_entry(cg_keep_form) # cg_form.clinic_gestures.entries = [ entry for entry in # cg_form.clinic_gestures.entries if entry.data['clinic_gesture_id'] # ] cg_form.price.data = cotation.price return render_template('choose_clinic_gestures_from_cotation.html', anatomic_locations=anatomic_locations, patient=patient, appointment=appointment, cotation_id=cotation.id, form=cg_form, constants=constants) return redirect(url_for('view_clinic_report', appointment_id=appointment.id))
def update_appointment(body_id, appointment_id): if session['role'] == constants.ROLE_ADMIN: return redirect(url_for('index')) patient, appointment = checks.get_patient_appointment(body_id, appointment_id) agenda_form = AgendaForm(request.form) appointment_form = AppointmentForm(request.form) appointment_form.dentist_id.choices = [ (user.id, user.firstname + " " + user.lastname ) for user in meta.session.query(users.OdontuxUser).filter( users.OdontuxUser.role == constants.ROLE_DENTIST)\ .all() ] appointment_form.dental_unit_id.choices = [ (dental_unit.id, dental_unit.name) for dental_unit in meta.session.query(users.DentalUnit).all() ] if (request.method == 'POST' and agenda_form.validate() and appointment_form.validate() ): # get the agenda entry: agenda = ( meta.session.query(schedule.Agenda) .filter(schedule.Agenda.appointment_id == appointment_id) .one() ) # verify the day_time infos (starttime, endtime) = agenda_handler(agenda_form.day.data, agenda_form.starthour.data, agenda_form.startmin.data, agenda_form.durationhour.data, agenda_form.durationmin.data, agenda_form.endhour.data, agenda_form.endmin.data) # update appointment infos: for f in get_appointment_field_list(): setattr(appointment, f, getattr(appointment_form, f).data) for f,g in (("starttime", starttime), ("endtime", endtime)): setattr(agenda, f, g) meta.session.commit() return redirect(url_for('patient_appointment', appointment_id=appointment_id)) (day, starthour, startmin, durationhour, durationmin, endhour, endmin) = \ reverse_agenda_handler(appointment.agenda.starttime, appointment.agenda.endtime) # prepopulate agenda fields : for f,g in ( ("day", day), ("starthour", starthour), ("startmin", startmin), ("durationhour", durationhour), ("durationmin", durationmin), ("endhour", endhour), ("endmin", endmin) ): getattr(agenda_form, f).data = g # prepoputate appointments fields: for f in get_appointment_field_list(): getattr(appointment_form, f).data = getattr(appointment, f) return render_template('update_appointment.html', patient=patient, appointment_form=appointment_form, agenda_form=agenda_form, appointment=appointment)
def list_anamnesis(patient_id, appointment_id=None): authorized_roles = [constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT] if session["role"] not in authorized_roles: return redirect(url_for("index")) survey_form = ChooseSurveyForm(request.form) survey_form.survey_id.choices = meta.session.query(anamnesis.Survey.id, anamnesis.Survey.name).all() patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) global_anamnesis = with_polymorphic(anamnesis.Anamnesis, "*") patient_anamnesis = ( meta.session.query(global_anamnesis) .filter(anamnesis.Anamnesis.patient_id == patient_id) .order_by( anamnesis.Anamnesis.alert.desc(), anamnesis.Anamnesis.anamnesis_type, anamnesis.MedicalHistory.type, anamnesis.MedicalHistory.disease, anamnesis.Anamnesis.time_stamp, ) .all() ) doctor = meta.session.query(md.MedecineDoctor).filter(md.MedecineDoctor.id == patient.gen_doc_id).one_or_none() patient_survey_form = PatientSurveyForm(request.form) patient_survey_form.appointment_id.choices = [ (appointment.id, appointment.agenda.starttime) for appointment in meta.session.query(schedule.Appointment) .filter( schedule.Appointment.patient_id == patient.id, schedule.Appointment.id.in_([anamnesis_entry.appointment_id for anamnesis_entry in patient_anamnesis]), ) .join(schedule.Agenda) .order_by(schedule.Agenda.starttime.desc()) .all() ] anamnesis_files = ( meta.session.query(documents.Files) .filter(documents.Files.id.in_([anamn.file_id for anamn in patient_anamnesis])) .order_by(documents.Files.timestamp.desc()) .all() ) return render_template( "patient_anamnesis.html", patient=patient, appointment=appointment, patient_anamnesis=patient_anamnesis, doctor=doctor, survey_form=survey_form, constants=constants, patient_survey_form=patient_survey_form, anamnesis_files=anamnesis_files, )
def choose_event_location(patient_id, appointment_id): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT ] if not session['role'] in authorized_roles: return redirect(url_for('index')) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) return render_template('choose_event_location.html', patient=patient, appointment=appointment)
def make_payment(patient_id, appointment_id): patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) payment_form = PatientPaymentForm(request.form) payment_form.mean_id.choices = [ (mean.id, mean.odontux_name) for mean in meta.session.query(compta.PaymentType).filter(compta.PaymentType.active.is_(True)).all() ] if request.method == "POST" and payment_form.validate(): # get the gnucash mean_account_odontux_asset name mean = meta.session.query(compta.PaymentType).filter(compta.PaymentType.id == payment_form.mean_id.data).one() # create gnucash instance in advance for not having problem after # payment registered in odontux gcpayment = gnucash_handler.GnuCashPayment(patient_id, patient.dentist_id) pdf_out = make_payment_receipt(patient_id, appointment_id, payment_form, mean) if not pdf_out: return render_template( "make_payment.html", patient=patient, appointment=appointment, payment_form=payment_form ) filename = md5.new(pdf_out).hexdigest() with open(os.path.join(app.config["DOCUMENT_FOLDER"], filename), "w") as f: f.write(pdf_out) file_values = {"md5": filename, "file_type": constants.FILE_RECEIPT, "mimetype": "application/pdf"} new_file = meta.session.query(documents.Files).filter(documents.Files.md5 == filename).one_or_none() if not new_file: new_file = documents.Files(**file_values) meta.session.add(new_file) meta.session.commit() receipt_values = { "patient_id": patient_id, "mean_id": payment_form.mean_id.data, "receipt_id": new_file.id, "amount": payment_form.amount.data, "comments": payment_form.comments.data, "cashin_date": datetime.date.today(), } new_payment = compta.Payment(**receipt_values) meta.session.add(new_payment) meta.session.commit() # Record payment in gnucash and create bill: gcpayment.add_payment(new_payment.mean_id, new_payment.amount, new_payment.cashin_date) return redirect(url_for("list_acts", patient_id=patient_id, appointment_id=appointment_id)) if request.method == "GET": if patient.balance() < 0: payment_form.amount.data = abs(patient.balance()) else: payment_form.amount.data = 0 payment_form.patient_id.data = patient.id return render_template("make_payment.html", patient=patient, appointment=appointment, payment_form=payment_form)
def apply_payment_to_gesture(patient_id, gesture_id): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT, constants.ROLE_SECRETARY, ] if session["role"] not in authorized_roles: return abort(403) appointment_cotation = ( meta.session.query(act.AppointmentCotationReference) .filter(act.AppointmentCotationReference.id == gesture_id) .one() ) patient, appointment = checks.get_patient_appointment(patient_id=patient_id) if patient.balance() < 0: return redirect(url_for("list_acts", patient_id=patient_id)) if appointment_cotation.price <= patient.already_paid() - patient.gestures_marked_as_paid(): appointment_cotation.is_paid = True meta.session.commit() gestures_in_invoice = ( meta.session.query(act.AppointmentCotationReference) .filter(act.AppointmentCotationReference.invoice_id == appointment_cotation.invoice_id) .all() ) if all([gesture.is_paid for gesture in gestures_in_invoice]): invoice = gnucash_handler.GnuCashInvoice( patient.id, appointment_cotation.appointment_id, None, invoice_id=appointment_cotation.invoice_id ) apply_payment_to_invoice = invoice.apply_payment() gestures_id_in_bill = "" # create a bill for user: for index, gesture in enumerate(gestures_in_invoice): if index == 0: gestures_id_in_bill = str(gesture.id) else: gestures_id_in_bill = gestures_id_in_bill + "," + str(gesture.id) return redirect( url_for( "choose_gestures_in_bill", patient_id=patient_id, appointment_id=appointment_cotation.appointment_id, gestures_id_in_bill=gestures_id_in_bill, ) ) ##### return redirect(url_for("list_acts", patient_id=patient_id))
def patient_payments(patient_id, appointment_id=0): patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) payments = meta.session.query(compta.Payment).filter(compta.Payment.patient_id == patient_id).all() bills = meta.session.query(statements.Bill).filter(statements.Bill.patient_id == patient_id).all() currency_symbol = constants.CURRENCY_SYMBOL return render_template( "patient_payments.html", patient=patient, appointment=appointment, payments=payments, bills=bills, currency_symbol=currency_symbol, )
def show_tooth(patient_id, appointment_id, tooth_codename): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE ] if session['role'] not in authorized_roles: return redirect(url_for('index')) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) tooth = ( meta.session.query(teeth.Tooth) .filter(teeth.Tooth.patient_id == patient_id, teeth.Tooth.codename == tooth_codename ) .one_or_none() ) if tooth: gum = ( meta.session.query(teeth.Gum) .filter(teeth.Gum.id == tooth.id).one() ) # we want that appears only events that occured before the # actual_appointment we're in. all_event_type = with_polymorphic(teeth.Event, '*') events = ( meta.session.query(all_event_type) .filter( teeth.Event.tooth_id == tooth.id, teeth.Event.appointment_id.in_( meta.session.query(schedule.Agenda.appointment_id) .filter( schedule.Agenda.starttime <= appointment.agenda.starttime ) ) ) .join(schedule.Appointment, schedule.Agenda) .order_by( schedule.Agenda.starttime.desc(), teeth.Event.location ) .all() ) document_form = DocumentForm(request.form) return render_template('show_tooth.html', patient=patient, appointment=appointment, tooth=tooth, gum=gum, constants=constants, events=events, document_form=document_form)
def patient_appointment(appointment_id): """ """ authorized_roles = [ constants.ROLE_DENTIST ] if session['role'] not in authorized_roles: return redirect(url_for('index')) patient, appointment = checks.get_patient_appointment( appointment_id=appointment_id) acts = checks.get_patient_acts(patient.id, appointment.id, [ act.AppointmentCotationReference.anatomic_location ] ) return render_template("patient_appointment.html", patient=patient, appointment=appointment, acts=acts)
def list_teeth(patient_id, appointment_id=None): authorized_roles = [ constants.ROLE_DENTIST ] if session['role'] not in authorized_roles: return redirect(url_for('index')) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) teeth = [] for tooth in patient.teeth: teeth.append( ( tooth.id, constants.ANATOMIC_LOCATION_TEETH[tooth.codename][1], constants.TOOTH_STATES[tooth.state][0], tooth.surveillance ) ) return render_template('list_teeth.html', patient=patient, appointment=appointment, teeth=teeth)
def choose_drugs_to_prescribe(patient_id, appointment_id, drug_list=''): """ session['prescription'] = [ drug_id_1, drug_id_2 ] """ authorized_roles = [ constants.ROLE_DENTIST ] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) drugs_prescribed = [] if drug_list: drugs_prescribed = [ drug_id for drug_id in drug_list.split(",") ] prescribed = ( meta.session.query(medication.DrugPrescribed) .filter(medication.DrugPrescribed.id.in_(drugs_prescribed)) .join(medication.DrugFamily) .order_by( medication.DrugFamily.name, medication.DrugPrescribed.molecule) .all() ) other_drugs = ( meta.session.query(medication.DrugPrescribed) .filter(~medication.DrugPrescribed.id.in_(drugs_prescribed)) .join(medication.DrugFamily) .order_by( medication.DrugFamily.name, medication.DrugPrescribed.molecule) .all() ) if drug_list: return render_template('choose_drugs_to_prescribe.html', patient=patient, appointment=appointment, prescribed=prescribed, other_drugs=other_drugs, drug_list=drug_list) return render_template('choose_drugs_to_prescribe.html', patient=patient, appointment=appointment, prescribed=prescribed, other_drugs=other_drugs)
def list_appointments(patient_id): # Go to index if the admin tries to look at appointments # or if we aren't in a patient file. if session['role'] == constants.ROLE_ADMIN: return abort(403) # Get the patient in database, and the list of his appointments. patient, appointment = checks.get_patient_appointment( patient_id=patient_id) appointments = ( meta.session.query(schedule.Appointment) .filter(schedule.Appointment.patient_id == patient_id) .join(schedule.Agenda) .order_by(schedule.Agenda.starttime.desc()) .all() ) return render_template("list_patient_appointments.html", patient=patient, appointment=appointment, appointments=appointments)
def add_materio_vigilance_to_clinic_report(appointment_id): patient, appointment = checks.get_patient_appointment( appointment_id=appointment_id) material_form = ChooseMaterialForReportForm(request.form) materials_for_materio_vigilance = ( meta.session.query(assets.Material) .filter( assets.Material.end_of_use.is_(None), assets.Material.end_use_reason == constants.END_USE_REASON_IN_USE_STOCK, assets.Material.start_of_use.isnot(None), ~assets.Material.id.in_( meta.session.query( traceability.MaterioVigilance.material_id) .filter(traceability.MaterioVigilance.appointment_id == appointment.id ) ) ) .join(assets.MaterialCategory, act.Specialty) .order_by( act.Specialty.name, assets.MaterialCategory.commercial_name, assets.MaterialCategory.brand ) .all() ) material_form.material_id.choices = [ ( material.id, material.asset_category.commercial_name + " " + material.asset_category.brand ) for material in materials_for_materio_vigilance ] if material_form.validate(): material = ( meta.session.query(assets.Material) .get(material_form.material_id.data) ) materio_vigilance = add_to_materio_vigilance(appointment_id, material.asset_category.automatic_decrease, material) return redirect(url_for('view_clinic_report', appointment_id=appointment_id))
def portal_certificate(patient_id, appointment_id): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT, constants.ROLE_SECRETARY] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) certifs = ( meta.session.query(certificates.Certificate) .filter(certificates.Certificate.patient_id == patient_id) ) presences = ( certifs .filter(certificates.Certificate.certif_type ==\ constants.FILE_PRESENCE) .join(schedule.Appointment, schedule.Agenda) .order_by(schedule.Agenda.starttime.desc()) .all() ) cessations = ( certifs .filter(certificates.Certificate.certif_type ==\ constants.FILE_CESSATION) .join(schedule.Appointment, schedule.Agenda) .order_by(schedule.Agenda.starttime.desc()) .all() ) requisitions = ( certifs .filter(certificates.Certificate.certif_type ==\ constants.FILE_REQUISITION) .join(schedule.Appointment, schedule.Agenda) .order_by(schedule.Agenda.starttime.desc()) .all() ) return render_template('list_certificates.html', patient=patient, appointment=appointment, presences=presences, cessations=cessations, requisitions=requisitions)
def add_event_tooth_located(patient_id, appointment_id): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT ] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) ( tooth_form, event_form, crown_event_form, root_event_form, periodontal_event_form, tooth_model_form ) = get_event_forms(appointment) if ( request.method == 'POST' and event_form.validate() and tooth_form.validate() ): def _update_tooth_datas(tooth, tooth_values): tooth.state = tooth_values['state'] tooth.surveillance = tooth_values['surveillance'] meta.session.commit() teeth_to_add = get_teeth_list(event_form.teeth.data) tooth_values = { 'state': tooth_form.choose_tooth_state.data, 'surveillance': tooth_form.surveillance.data, } values = { 'appointment_id': event_form.appointment_id.data, 'description': event_form.description.data, 'comment': event_form.comment.data, 'color': event_form.color.data, 'location': event_form.location.data, 'state': tooth_form.choose_tooth_state.data, } if ( event_form.location.data == constants.TOOTH_EVENT_LOCATION_TOOTH ): for tooth_codename in teeth_to_add: tooth = get_patient_tooth(patient_id, tooth_codename) _update_tooth_datas(tooth, tooth_values) values['tooth_id'] = tooth.id new_tooth_event = teeth.ToothEvent(**values) meta.session.add(new_tooth_event) meta.session.commit() elif ( event_form.location.data == constants.TOOTH_EVENT_LOCATION_CROWN and crown_event_form.validate() ): crown_values = { 'state': crown_event_form.choose_crown_state.data, 'tooth_shade': crown_event_form.tooth_shade.data, } values.update(crown_values) for tooth_codename in teeth_to_add: tooth = get_patient_tooth(patient_id, tooth_codename) # working with event_values for state ! _update_tooth_datas(tooth, tooth_values) values['tooth_id'] = tooth.id for side in crown_sides(): values[side] = getattr(crown_event_form, side).data new_crown_event = teeth.CrownEvent(**values) meta.session.add(new_crown_event) meta.session.commit() elif ( event_form.location.data == constants.TOOTH_EVENT_LOCATION_ROOT and root_event_form.validate() ): root_values = { 'state': root_event_form.choose_root_state.data, } values.update(root_values) for tooth_codename in teeth_to_add: tooth = get_patient_tooth(patient_id, tooth_codename) # working with event_values for state ! _update_tooth_datas(tooth, tooth_values) values['tooth_id'] = tooth.id for root_canal in root_canals(): values[root_canal] =\ getattr(root_event_form, root_canal).data new_root_event = teeth.RootCanalEvent(**values) meta.session.add(new_root_event) meta.session.commit() elif ( event_form.location.data == constants.TOOTH_EVENT_LOCATION_PERIODONTAL and periodontal_event_form.validate() ): periodontal_values = { 'furcation': periodontal_event_form.furcation.data, 'recession': periodontal_event_form.recession.data, 'pocket_depth': periodontal_event_form.pocket_depth.data, } values.update(periodontal_values) del values['state'] # As there is no "state" in PeriodontalEvent for tooth_codename in teeth_to_add: tooth = get_patient_tooth(patient_id, tooth_codename) gum = get_patient_gum(patient_id, tooth_codename) # updating gum table gum.state = periodontal_event_form.choose_periodontal_state.data gum.bleeding = periodontal_event_form.bleeding.data # working with event_values for state ! _update_tooth_datas(tooth, tooth_values) values['tooth_id'] = tooth.id for site in periodontal_locations(): values[site] = getattr(periodontal_event_form, site).data new_periodontal_event = teeth.PeriodontalEvent(**values) meta.session.add(new_periodontal_event) meta.session.commit() return redirect(url_for('add_event_tooth_located', patient_id=patient_id, appointment_id=appointment_id)) if request.method == 'POST': clear_form = False else: clear_form = True return render_template('add_event_tooth_located.html', patient=patient, appointment=appointment, tooth_form=tooth_form, event_form=event_form, crown_event_form=crown_event_form, root_event_form=root_event_form, periodontal_event_form=periodontal_event_form, clear_form=clear_form)
def add_cg_to_cr(appointment_id, clinic_gesture_id, anatomic_location): """ anatomic_location = int. * Create a clinic_report entry with a clinic_gesture. * Add material in use from model_material_category from clinic_gesture to MaterioVigilance and update quantities * If clinic_gesture as a model_event, create the event adapted """ def _needs_redondance(appointment, material, mat_cg_ref): number_of_same_cg_in_appointment = [ cr.clinic_gesture for cr in appointment.clinic_reports if cr.clinic_gesture_id == mat_cg_ref.clinic_gesture_id ] if not ( ( len(number_of_same_cg_in_appointment) - 1 ) % mat_cg_ref.enter_in_various_gestures ): return True else: return False patient, appointment = checks.get_patient_appointment( appointment_id=appointment_id) clinic_gesture = ( meta.session.query(act.ClinicGesture) .filter(act.ClinicGesture.id == clinic_gesture_id ) .one() ) ## ## Create new clinic_report entry values = { 'appointment_id': appointment_id, 'clinic_gesture_id': clinic_gesture_id, 'anatomic_location': int(anatomic_location), 'duration': clinic_gesture.duration, } new_clinic_report = act.ClinicReport(**values) meta.session.add(new_clinic_report) # or: appointment.clinic_reports.append(new_clinic_report) try: meta.session.commit() except sqlalchemy.exc.IntegrityError: meta.session.rollback() appointment.clinic_reports.reorder() meta.session.commit() ## ## Update Material and MaterioVigilance for mat_cg_ref in new_clinic_report.clinic_gesture.materials: material_used = cost.get_material_used(mat_cg_ref.id) if ( _needs_redondance(appointment, material_used, mat_cg_ref) and material_used ): materio_vigilance = add_to_materio_vigilance(appointment_id, mat_cg_ref.mean_quantity, material_used) new_clinic_report.materio_vigilance.append(materio_vigilance) meta.session.commit() ## ## Create event if clinic_gesture.event_model_id: event_model = ( meta.session.query(model_teeth.EventModel) .filter(model_teeth.EventModel.id == clinic_gesture.event_model_id ) .one() ) tooth = teeth.get_patient_tooth(appointment.patient_id, int(anatomic_location)) tooth.state = event_model.tooth_state tooth.surveillance = event_model.surveillance values = { 'appointment_id': appointment_id, 'tooth_id': tooth.id, 'location': event_model.location, 'state': event_model.state, 'description': event_model.description, 'comment': event_model.comment, 'color': event_model.color, } if event_model.location == constants.TOOTH_EVENT_LOCATION_PERIODONTAL : pass elif event_model.location == constants.TOOTH_EVENT_LOCATION_TOOTH: pass elif event_model.location == constants.TOOTH_EVENT_LOCATION_CROWN: new_crown_event = model_teeth.CrownEvent(**values) meta.session.add(new_crown_event) meta.session.commit() for att in [ 'state', 'is_occlusal', 'is_buccal', 'is_lingual', 'is_mesial', 'is_distal', 'tooth_shade' ] : setattr(new_crown_event, att, getattr(event_model, att)) elif event_model.location == constants.TOOTH_EVENT_LOCATION_ROOT: new_root_event = model_teeth.RootCanalEvent(**values) meta.session.add(new_root_event) meta.session.commit() for att in [ 'state', 'is_central', 'is_buccal', 'is_lingual', 'is_mesial', 'is_distal', 'is_mesio_buccal', 'is_disto_buccal', 'is_mesio_lingual', 'is_disto_lingual', 'is_mesio_buccal_2' ] : setattr(new_root_event, att, getattr(event_model, att)) meta.session.commit() return new_clinic_report
def update_clinic_report(appointment_id): patient, appointment = checks.get_patient_appointment( appointment_id=appointment_id) clinic_report_form = ClinicReportForm(request.form) if clinic_report_form.validate(): for entry in clinic_report_form.clinic_gestures.entries: if entry.old_duration.data != entry.new_duration.data: clinic_report = ( meta.session.query(act.ClinicReport) .filter(act.ClinicReport.id == int(entry.clinic_report_id.data) ) .one() ) clinic_report.duration = datetime.timedelta( seconds=int(entry.new_duration.data) * 60 ) meta.session.commit() for entry in clinic_report_form.materials_used.entries: if entry.new_quantity_used.data is None: entry.new_quantity_used.data = 0 if Decimal(entry.old_quantity_used.data) ==\ entry.new_quantity_used.data: continue material = ( meta.session.query(assets.Material) .filter(assets.Material.id == int(entry.material_id.data)) .one() ) materio_vigilance = ( meta.session.query(traceability.MaterioVigilance) .filter( traceability.MaterioVigilance.appointment_id == appointment.id, traceability.MaterioVigilance.material_id == material.id) .one() ) delta_quantity = Decimal(entry.old_quantity_used.data) -\ entry.new_quantity_used.data materio_vigilance.quantity_used -= delta_quantity material.actual_quantity += delta_quantity meta.session.commit() # Case the material was marked as terminated, but finally there is # some left : if ( material.end_of_use == appointment.agenda.endtime.date() and material.end_use_reason == constants.END_USE_REASON_NATURAL_END and material.actual_quantity > 0 ): material.end_of_use = None material.end_use_reason = constants.END_USE_REASON_IN_USE_STOCK meta.session.commit() # Case material terminate : if material.actual_quantity <= 0: material.end_of_use = appointment.agenda.endtime.date() material.end_use_reason = constants.END_USE_REASON_NATURAL_END meta.session.commit() return redirect(url_for('view_clinic_report', appointment_id=appointment.id))
def make_bill(patient_id, appointment_id, gestures_id_in_bill): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT, constants.ROLE_SECRETARY ] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) gestures_in_bill = ( meta.session.query(act.AppointmentCotationReference) .filter(act.AppointmentCotationReference.id.in_( [ int(gid) for gid in gestures_id_in_bill.split(",") ] ) ) .all() ) bill_form = BillForm(request.form) if request.method == 'GET': for gesture in gestures_in_bill: gesture_form = GestureForm(request.form) gesture_form.gesture_id = gesture.id gesture_form.gesture_name = gesture.gesture.name gesture_form.date =\ gesture.appointment.agenda.starttime.date().isoformat() gesture_form.anatomic_location = gesture.anatomic_location gesture_form.price = gesture.price bill_form.gestures.append_entry(gesture_form) pdf_out = make_invoice_payment_bill(patient_id, gestures_in_bill[-1].appointment_id, bill_form) if request.method == 'POST' and bill_form.validate(): if 'update' in request.form: return render_template('make_bill.html', patient=patient, appointment=appointment, constants=constants, bill_form=bill_form, gestures_id_in_bill=gestures_id_in_bill, pdf_out=b64encode(pdf_out)) elif 'preview' in request.form: response = make_response(pdf_out) response.mimetype = 'application/pdf' return response elif 'save_print' in request.form: response = make_response(pdf_out) response.mimetype = 'application/pdf' filename = md5.new(pdf_out).hexdigest() with open(os.path.join( app.config['DOCUMENT_FOLDER'], filename), 'w') as f: f.write(pdf_out) file_values = { 'md5': filename, 'file_type': constants.FILE_BILL, 'mimetype': 'application/pdf', } new_file = documents.Files(**file_values) meta.session.add(new_file) meta.session.commit() bill_values = { 'patient_id': patient_id, 'appointment_id': gestures_in_bill[-1].appointment_id, 'dentist_id': appointment.dentist_id, 'type': constants.FILE_BILL, 'file_id': new_file.id, } new_bill = statements.Bill(**bill_values) meta.session.add(new_bill) meta.session.commit() for gesture in bill_form.gestures: values = { 'bill_id': new_bill.id, 'appointment_cotation_id': int(gesture.gesture_id.data), } new_gesture =\ statements.BillAppointmentCotationReference(**values) meta.session.add(new_gesture) meta.session.commit() return response return render_template('make_bill.html', patient=patient, appointment=appointment, constants=constants, bill_form=bill_form, gestures_id_in_bill=gestures_id_in_bill)
def view_clinic_report(appointment_id): patient, appointment = checks.get_patient_appointment( appointment_id=appointment_id) cotation_form = ChooseCotationForReportForm(request.form) cotation_form.cotation_id.choices = [ ( cotation.id, cotation.gesture.name + " " + cotation.healthcare_plan.name) for cotation in meta.session.query(act.Cotation) .filter(act.Cotation.healthcare_plan_id.in_( [ hc.id for hc in patient.hcs ] ) ) .join(act.Gesture, act.Specialty, act.HealthCarePlan) .order_by(act.Specialty.name, act.Gesture.name, act.HealthCarePlan.name.desc()) .all() ] cg_form = ChooseClinicGestureForReportForm(request.form) cg_form.clinic_gesture_id.choices = [ ( cg.id, cg.specialty.name[0:3] + " " + cg.name ) for cg in meta.session.query(act.ClinicGesture) .filter(act.ClinicGesture.before_first_patient.is_(False), act.ClinicGesture.after_last_patient.is_(False), act.ClinicGesture.before_each_appointment.is_(False), act.ClinicGesture.after_each_appointment.is_(False) ) .join(act.Specialty) .order_by(act.Specialty.name, act.ClinicGesture.name ) .all() ] clinic_report_form = ClinicReportForm(request.form) clinic_gestures = [ clinic_report for clinic_report in sorted(appointment.clinic_reports, key=lambda clinic_report: clinic_report.sequence) ] # Case dentist_fees and hour_cost isn't provided yet: if not appointment.dentist_fees: appointment.dentist_fees = ( meta.session.query(act.HealthCarePlanUserReference.hour_fees) .filter( act.HealthCarePlanUserReference.user_id == appointment.dentist_id, act.HealthCarePlanUserReference.healthcare_plan_id.in_( [ hcp.id for hcp in appointment.patient.hcs ] ) ) .order_by(act.HealthCarePlanUserReference.hour_fees) .first() ) if not appointment.dentist_fees: appointment.dentist_fees = 1 meta.session.commit() if not appointment.hour_cost: appointment.hour_cost = round(cost.get_hourly_operational_cost(), 2) meta.session.commit() # In case this day is the first where happens something, we add in this # clinic report the material that is used every morning and every night # before opening and closing the dental_unit # We need to check this first. # TODO Add a verification if material found is only materials use in an # autoclave cycle because it doesn't count material_used_this_day = ( meta.session.query(traceability.MaterioVigilance) .filter( traceability.MaterioVigilance.appointment_id.in_( meta.session.query(schedule.Agenda.appointment_id) .filter( cast(schedule.Agenda.starttime, Date) == appointment.agenda.starttime.date(), schedule.Agenda.dental_unit_id == appointment.dental_unit_id ) ) ) .all() ) # In case no material has been marqued used in this appointment, we now add # the minimum material used in each appointment # This query is made before adding eventual "material before first patient # TODO Add a verification if material found is only materials use in an # autoclave cycle because it doesn't count material_each_appointment = ( meta.session.query(traceability.MaterioVigilance) .filter(traceability.MaterioVigilance.appointment_id == appointment.id) .all() ) if not material_used_this_day: cg_every_work_day = ( meta.session.query(act.ClinicGesture) .filter(or_( act.ClinicGesture.before_first_patient.is_(True), act.ClinicGesture.after_last_patient.is_(True) ) ) .all() ) for cg in cg_every_work_day: for mat_cg_ref in cg.materials: material_used = cost.get_material_used(mat_cg_ref.id) opening_materio_vigilance = add_to_materio_vigilance( appointment.id, mat_cg_ref.mean_quantity, material_used) if not material_each_appointment: cg_all_appointment = ( meta.session.query(act.ClinicGesture) .filter(or_( act.ClinicGesture.before_each_appointment.is_(True), act.ClinicGesture.after_each_appointment.is_(True) ) ) .all() ) for cg in cg_all_appointment: for mat_cg_ref in cg.materials: material_used = cost.get_material_used(mat_cg_ref.id) materio_vigilance_appointment = add_to_materio_vigilance( appointment.id, mat_cg_ref.mean_quantity, material_used) material_form = ChooseMaterialForReportForm(request.form) materials_for_materio_vigilance = ( meta.session.query(assets.Material) .filter( assets.Material.end_of_use.is_(None), assets.Material.end_use_reason == constants.END_USE_REASON_IN_USE_STOCK, assets.Material.start_of_use.isnot(None), ~assets.Material.id.in_( meta.session.query( traceability.MaterioVigilance.material_id) .filter(traceability.MaterioVigilance.appointment_id == appointment.id ) ) ) .join(assets.MaterialCategory, act.Specialty) .order_by( act.Specialty.name, assets.MaterialCategory.commercial_name, assets.MaterialCategory.brand ) .all() ) material_form.material_id.choices = [ ( material.id, material.asset_category.commercial_name + " " + material.asset_category.brand ) for material in materials_for_materio_vigilance ] # only appears cotation that were administraly officially indentified, # by a single clinic gesture in the global gesture repair. cotations = [ cot for cot in sorted(appointment.administrative_gestures, key=lambda cot: ( cot.gesture.name, cot.anatomic_location ) ) ] for mat_vig in sorted(appointment.materio_vigilance, key=lambda mat_vig:( mat_vig.material.asset_category.asset_specialty.name, mat_vig.material.asset_category.commercial_name) ): mat_vig_form = MaterioVigilanceForm(request.form) mat_vig_form.material_id = mat_vig.material_id mat_vig_form.old_quantity_used = mat_vig.quantity_used mat_vig_form.new_quantity_used = mat_vig.quantity_used mat_vig_form.material_data = ( mat_vig.material.asset_category.commercial_name + " | " + str(mat_vig.material.actual_quantity) + " " + constants.UNITIES[mat_vig.material.asset_category.unity][1] ) clinic_report_form.materials_used.append_entry(mat_vig_form) for clinic_report in sorted(appointment.clinic_reports, key=lambda clinic_report: ( clinic_report.anatomic_location, clinic_report.sequence ) ): hour_duration = clinic_report.duration.seconds / 3600 * 60 minute_duration = clinic_report.duration.seconds % 3600 / 60 cg_duration_form = ClinicGestureDurationForm(request.form) cg_duration_form.clinic_report_id = clinic_report.id cg_duration_form.clinic_gesture_id = clinic_report.clinic_gesture_id cg_duration_form.anatomic_location = clinic_report.anatomic_location cg_duration_form.old_duration = str(hour_duration + minute_duration) cg_duration_form.new_duration = hour_duration + minute_duration cg_duration_form.clinic_gesture_data =\ clinic_report.clinic_gesture.name clinic_report_form.clinic_gestures.append_entry(cg_duration_form) return render_template('view_clinic_report.html', patient=patient, appointment=appointment, cotations=cotations, clinic_report_form=clinic_report_form, cotation_form=cotation_form, cg_form=cg_form, material_form=material_form, constants=constants)
def create_quote_proposition(patient_id, appointment_id, quotes_id=''): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT ] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) if not quotes_id: quotes = ( meta.session.query(statements.Quote) .filter(statements.Quote.appointment_id == appointment_id, statements.Quote.file_id.is_(None) ) .all() ) for quote in quotes: if not quotes_id: quotes_id = str(quote.id) continue quotes_id = quotes_id + "," + str(quote.id) else: quotes = ( meta.session.query(statements.Quote) .filter(statements.Quote.id.in_( [ int(i) for i in quotes_id.split(",") ] )) .all() ) quote_form = QuotePropositionForm(request.form) quote_form.healthcare_plan_id.choices = [ (hcp.id, hcp.name) for hcp in meta.session.query(act.HealthCarePlan) .filter(act.HealthCarePlan.id.in_(patient.healthcare_plans_id)) .all() ] quote_gesture_form = QuoteGestureForm(request.form) if request.method == 'POST': if ( 'proposition-0-add_gesture' in request.form and quote_form.validate() ): quote_gesture_form.cotation_id =\ quote_form.proposition[0].cotation_id.data quote_gesture_form.anatomic_location =\ quote_form.proposition[0].anatomic_location.data quote_gesture_form.gesture_code =\ quote_form.proposition[0].gesture_code.data quote_gesture_form.gesture_name =\ quote_form.proposition[0].gesture_name.data quote_gesture_form.price =\ quote_form.proposition[0].price.data quote_gesture_form.appointment_number =\ quote_form.proposition[0].appointment_number.data quote_form.proposition.append_entry(quote_gesture_form) elif 'remove_last' in request.form: quote_form.proposition.pop_entry() elif 'add_proposition' in request.form: if ( len(quote_form.proposition.entries) == 0 or len(quote_form.proposition.entries) == 1 and not quote_form.proposition.entries[0].gesture_code.data ): return redirect(url_for('create_quote_proposition', patient_id=patient_id, appointment_id=appointment_id, quotes_id=quotes_id)) # create new proposition of quote if quote_form.treatment_duration.data: if quote_form.duration_unity.data == 'month': treatment_duration =quote_form.treatment_duration.data * 30 elif quote_form.duration_unity.data == 'week': treatment_duration = quote_form.treatment_duration.data * 7 else: treatment_duration = quote_form.treatment_duration.data treatment_duration =datetime.timedelta(days=treatment_duration) else: treatment_duration = None values = { 'patient_id': patient_id, 'dentist_id': appointment.dentist_id, 'appointment_id': appointment_id, 'type': constants.FILE_QUOTE, 'validity': appointment.agenda.starttime +\ datetime.timedelta(days=quote_form.validity.data * 30), 'treatment_duration': treatment_duration, } new_proposition_quote = statements.Quote(**values) meta.session.add(new_proposition_quote) meta.session.commit() # insert gesture in this proposition of quote while quote_form.proposition.entries: entry = quote_form.proposition.pop_entry().data if not entry['cotation_id']: continue gesture = ( meta.session.query(act.Gesture) .filter(act.Gesture.code == entry['gesture_code'], act.Gesture.cotations.any( act.Cotation.id == entry['cotation_id']) ) .one_or_none() ) if not gesture: continue gesture_entry = { 'quote_id': new_proposition_quote.id, 'cotation_id': entry['cotation_id'], 'gesture_id': gesture.id, 'anatomic_location': entry['anatomic_location'], 'price': entry['price'], 'appointment_number': entry['appointment_number'], } new_gesture_in_proposition =\ statements.QuoteGestureReference(**gesture_entry) meta.session.add(new_gesture_in_proposition) meta.session.commit() if not quotes_id: quotes_id = str(new_proposition_quote.id) else: quotes_id = quotes_id + "," +\ str(new_proposition_quote.id) # We reload the create_quote_proposition to enter in a new GET return redirect(url_for('create_quote_proposition', patient_id=patient_id, appointment_id=appointment_id, quotes_id=quotes_id)) elif 'preview' in request.form: pdf_out = make_quote(patient_id, appointment_id, quotes) response = make_response(pdf_out) response.mimetype = 'application/pdf' return response elif 'save_print' in request.form: pdf_out = make_quote(patient_id, appointment_id, quotes) response = make_response(pdf_out) response.mimetype = 'application/pdf' filename = md5.new(pdf_out).hexdigest() with open(os.path.join( app.config['DOCUMENT_FOLDER'], filename), 'w') as f: f.write(pdf_out) file_values = { 'md5': filename, 'file_type': constants.FILE_QUOTE, 'mimetype': 'application/pdf', } file_in_db = ( meta.session.query(documents.Files) .filter(documents.Files.md5 == filename) .one_or_none() ) new_file = documents.Files(**file_values) meta.session.add(new_file) meta.session.commit() for quote in quotes: quote.file_id = new_file.id meta.session.commit() return response return render_template('create_quote_proposition.html', patient=patient, appointment=appointment, quotes=quotes, quote_form=quote_form, quotes_id=quotes_id) quote_form.healthcare_plan_id.data = quote_form.healthcare_plan_id.data quote_form.validity.data = constants.QUOTE_VALIDITY if quotes: pdf_out = make_quote(patient_id, appointment_id, quotes) pdf_out = b64encode(pdf_out) return render_template('create_quote_proposition.html', patient=patient, appointment=appointment, quotes=quotes, quote_form=quote_form, quotes_id=quotes_id, pdf_out=pdf_out) return render_template('create_quote_proposition.html', patient=patient, appointment=appointment, quotes=quotes, quote_form=quote_form, quotes_id=quotes_id, pdf_out=None)
def choose_gestures_in_bill(patient_id, appointment_id, gestures_id_in_bill=""): authorized_roles = [ constants.ROLE_DENTIST, constants.ROLE_NURSE, constants.ROLE_ASSISTANT, constants.ROLE_SECRETARY ] if session['role'] not in authorized_roles: return abort(403) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) patient_appointments_id = [ a.id for a in patient.appointments ] # get id list of gestures that could be in bill gestures_panel = ( meta.session.query(act.AppointmentCotationReference) .join(schedule.Appointment, schedule.Agenda) .filter( act.AppointmentCotationReference.appointment_id.in_( patient_appointments_id), act.AppointmentCotationReference.is_paid.is_(True), ~act.AppointmentCotationReference.id.in_( meta.session.query( statements.BillAppointmentCotationReference.appointment_cotation_id) ), schedule.Agenda.starttime <= appointment.agenda.starttime ) .order_by(schedule.Agenda.starttime) .all() ) gestures_id_panel = [ gesture.id for gesture in gestures_panel ] # get id list of gestures that are to be in bill if not gestures_id_in_bill: gestures_id_in_bill = [ gesture.id for gesture in gestures_panel ] else: gestures_id_in_bill = [ int(i) for i in gestures_id_in_bill.split(",") ] gestures_in_bill = ( meta.session.query(act.AppointmentCotationReference) .filter( act.AppointmentCotationReference.id.in_(gestures_id_in_bill)) .join(schedule.Appointment, schedule.Agenda) .order_by(schedule.Agenda.starttime) .all() ) # get id list of gestures that won't be in bill gestures_not_in_bill = ( meta.session.query(act.AppointmentCotationReference) .filter( act.AppointmentCotationReference.id.in_(gestures_id_panel), ~act.AppointmentCotationReference.id.in_(gestures_id_in_bill) ) .all() ) gestures_id_in_bill = ",".join( [ str(gest.id) for gest in gestures_in_bill ] ) return render_template('choose_gestures_in_bill.html', patient=patient, appointment=appointment, constants=constants, gestures_in_bill=gestures_in_bill, gestures_not_in_bill=gestures_not_in_bill, gestures_id_in_bill=gestures_id_in_bill)
def add_patient_appointment(body_id, meeting_id=0): 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('index')) agenda_form = AgendaForm(request.form) meeting = ( meta.session.query(schedule.Agenda) .filter(schedule.Agenda.id == meeting_id) .one_or_none() ) if meeting: day, starthour, startmin, durationhour, durationmin, endhour, endmin =\ reverse_agenda_handler(meeting.starttime, meeting.endtime) agenda_form.meeting_id.data = meeting.id agenda_form.day.data = day agenda_form.starthour.data = starthour agenda_form.startmin.data = startmin agenda_form.durationhour.data = durationhour agenda_form.durationmin.data = durationmin agenda_form.endhour.data = endhour agenda_form.endmin.data = endmin appointment_form = AppointmentForm(request.form) appointment_form.dentist_id.choices = [ (user.id, user.firstname + " " + user.lastname ) for user in meta.session.query(users.OdontuxUser).filter( users.OdontuxUser.role == constants.ROLE_DENTIST)\ .all() ] appointment_form.dental_unit_id.choices = [ ( dental_unit.id, dental_unit.name ) for dental_unit in meta.session.query(users.DentalUnit).all() ] if (request.method == 'POST' and agenda_form.validate() and appointment_form.validate() ): # get the appointment agenda schedule first, to raise exception if # agenda problems (starttime, endtime) = agenda_handler(agenda_form.day.data, agenda_form.starthour.data, agenda_form.startmin.data, agenda_form.durationhour.data, agenda_form.durationmin.data, agenda_form.endhour.data, agenda_form.endmin.data) # add the appointment infos args = { f: getattr(appointment_form, f).data for f in get_appointment_field_list() } new_appointment = schedule.Appointment(**args) meta.session.add(new_appointment) meta.session.commit() # if every thing went fine until now, we just have to add to database # agenda data, and we're done. if agenda_form.meeting_id.data: appointment_in_agenda = ( meta.session.query(schedule.Agenda) .filter(schedule.Agenda.id == agenda_form.meeting_id.data) .one_or_none() ) if appointment_in_agenda: appointment_in_agenda.appointment_id = new_appointment.id meta.session.commit() return redirect(url_for('patient_appointment', appointment_id=new_appointment.id)) # dentist_fees = ( meta.session.query(act.HealthCarePlanUserReference) # .filter( # act.HealthCarePlanUserReference.healthcare_plan_id.in_( # [ hcp.id for hcp in patient.hcs] ), # act.HealthCarePlanUserReference.user_id == # appointment.dentist_id ) # .order_by(act.HealthCarePlanUserReference.hour_fees) # .first() # ) # if not dentist_fees: # dentist_fees = 1 # # hour_cost = cost.get_hourly_operational_cost() args = {} args['dentist_id'] = new_appointment.dentist_id args['date_taker_id'] = new_appointment.dentist_id args['dental_unit_id'] = new_appointment.dental_unit_id args['appointment_id'] = new_appointment.id args['starttime'] = starttime args['endtime'] = endtime # args['hour_cost'] = hour_cost # args['dentist_fees'] = dentist_fees new_schedule = schedule.Agenda(**args) meta.session.add(new_schedule) meta.session.commit() return redirect(url_for('patient_appointment', appointment_id=new_appointment.id)) if not agenda_form.day.data: agenda_form.day.data = datetime.date.today() if session['role'] == constants.ROLE_DENTIST: appointment_form.dentist_id.data = session['user_id'] patient, appointment = checks.get_patient_appointment(patient_id=body_id) return render_template('add_patient_appointment.html', patient=patient, agenda_form=agenda_form, appointment_form=appointment_form)
def add_anamnesis_entry(patient_id, appointment_id, survey_id=None, survey_entry=None): authorized_roles = [constants.ROLE_DENTIST] if session["role"] not in authorized_roles: return redirect(url_for("index")) patient, appointment = checks.get_patient_appointment(patient_id, appointment_id) anamnesis_form = AnamnesisForm(request.form) anamnesis_form.anamnesis_type.choices = [(id, info[0]) for id, info in constants.ANAMNESIS.items()] medical_history_form = MedicalHistoryForm(request.form) medical_history_form.medical_type.choices = constants.MEDICAL_HISTORIES.items() medical_history_form.disease.choices = constants.DISEASES.items() addiction_form = AddictionForm(request.form) addiction_form.addiction_type.choices = constants.ADDICTIONS.items() treatment_form = TreatmentForm(request.form) past_surgery_form = PastSurgeryForm(request.form) allergy_form = AllergyForm(request.form) allergy_form.allergy_type.choices = constants.ALLERGIES.items() allergy_form.reaction.choices = [(al_re[0], al_re[1][0]) for al_re in constants.ALLERGIC_REACTIONS.items()] oral_hygiene_form = OralHygieneForm(request.form) oral_hygiene_form.oral_type.choices = constants.ORAL_HYGIENE.items() if survey_entry: question = ( meta.session.query(anamnesis.Question) .join(anamnesis.SurveyQuestionsOrder) .filter( anamnesis.SurveyQuestionsOrder.survey_id == survey_id, anamnesis.SurveyQuestionsOrder.position == survey_entry, ) .one_or_none() ) if question: anamnesis_form.question_id.data = question.id else: question = None if request.method == "POST" and anamnesis_form.validate(): anamnesis_values = { "patient_id": patient_id, "appointment_id": appointment_id, "anamnesis_type": anamnesis_form.anamnesis_type.data, "alert": anamnesis_form.alert.data, "document": anamnesis_form.document.data, } if question: anamnesis_values["question_id"] = question.id if survey_entry: survey_entry += 1 if ( anamnesis_form.anamnesis_type.data == constants.ANAMNESIS_MEDICAL_HISTORY and medical_history_form.validate() ): values = { "type": medical_history_form.medical_type.data, "disease": medical_history_form.disease.data, "name": medical_history_form.denomination.data, "icd10": medical_history_form.icd10.data, "comment": medical_history_form.medical_comment.data, } values.update(anamnesis_values) new_medical_history = anamnesis.MedicalHistory(**values) meta.session.add(new_medical_history) meta.session.commit() elif anamnesis_form.anamnesis_type.data == constants.ANAMNESIS_ADDICTION and addiction_form.validate(): values = { "type": addiction_form.addiction_type.data, "comment": addiction_form.addiction_comment.data, "begin": addiction_form.begin_addiction.data, "end": addiction_form.end_addiction.data, } values.update(anamnesis_values) new_addiction = anamnesis.Addiction(**values) meta.session.add(new_addiction) meta.session.commit() elif anamnesis_form.anamnesis_type.data == constants.ANAMNESIS_TREATMENT and treatment_form.validate(): values = { "name": treatment_form.molecule.data, "posologia": treatment_form.posologia.data, "begin": treatment_form.begin_treatment.data, "end": treatment_form.end_treatment.data, } values.update(anamnesis_values) new_treatment = anamnesis.Treatment(**values) meta.session.add(new_treatment) meta.session.commit() elif anamnesis_form.anamnesis_type.data == constants.ANAMNESIS_PAST_SURGERY and past_surgery_form.validate(): values = { "surgery_type": past_surgery_form.surgery_type.data, "problem": past_surgery_form.problem.data, "complication": past_surgery_form.complication.data, } values.update(anamnesis_values) new_past_surgery = anamnesis.PastSurgery(**values) meta.session.add(new_past_surgery) meta.session.commit() elif anamnesis_form.anamnesis_type.data == constants.ANAMNESIS_ALLERGY and allergy_form.validate(): values = { "type": allergy_form.allergy_type.data, "allergen": allergy_form.allergen.data, "reaction": allergy_form.reaction.data, } values.update(anamnesis_values) new_allergy = anamnesis.Allergy(**values) meta.session.add(new_allergy) meta.session.commit() elif anamnesis_form.anamnesis_type.data == constants.ANAMNESIS_ORAL_HYGIENE and oral_hygiene_form.validate(): values = { "type": oral_hygiene_form.oral_type.data, "frequency": oral_hygiene_form.frequency.data, "comment": oral_hygiene_form.oral_comment.data, } values.update(anamnesis_values) new_oral_hygiene = anamnesis.OralHygiene(**values) meta.session.add(new_oral_hygiene) meta.session.commit() else: if survey_entry: survey_entry -= 1 clear_form = False render_template( "add_anamnesis_entry.html", patient=patient, appointment=appointment, question=question, survey_id=survey_id, survey_entry=survey_entry, anamnesis_form=anamnesis_form, medical_history_form=medical_history_form, addiction_form=addiction_form, treatment_form=treatment_form, past_surgery_form=past_surgery_form, allergy_form=allergy_form, oral_hygiene_form=oral_hygiene_form, constants=constants, clear_form=clear_form, ) return redirect( url_for( "add_anamnesis_entry", patient_id=patient_id, appointment_id=appointment_id, survey_id=survey_id, survey_entry=survey_entry, ) ) clear_form = True return render_template( "add_anamnesis_entry.html", patient=patient, appointment=appointment, question=question, survey_id=survey_id, survey_entry=survey_entry, anamnesis_form=anamnesis_form, medical_history_form=medical_history_form, addiction_form=addiction_form, treatment_form=treatment_form, past_surgery_form=past_surgery_form, allergy_form=allergy_form, oral_hygiene_form=oral_hygiene_form, constants=constants, clear_form=clear_form, )