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 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)
