def api_move_client():
j = request.get_json()
try:
ticket_id = int(j['ticket_id'])
destination_tid = j['destination_ticket_id']
except (ValueError, KeyError):
return jsonify(
None, 418,
'Both ticket_id and destination_ticket_id must be specified')
source = ScheduleTicket.query.get(ticket_id)
oldCT = source.client_ticket
dest = ScheduleTicket.query.get(destination_tid)
if dest.client:
return jsonify(None, 418, 'Destination ticket is busy')
ct = ScheduleClientTicket()
ct.appointmentType_id = oldCT.appointmentType_id
ct.client_id = oldCT.client_id
ct.createDatetime = datetime.datetime.now()
ct.modifyDatetime = ct.createDatetime
ct.isUrgent = oldCT.isUrgent
ct.infisFrom = oldCT.infisFrom
ct.ticket_id = destination_tid
oldCT.deleted = 1
db.session.add(ct)
db.session.add(oldCT)
db.session.commit()
return jsonify(None)
def api_patient_appointments():
client_id = parse_id(request.args, 'client_id')
every = request.args.get('every', False)
if client_id is False:
return abort(404)
context = ClientVisualizer()
if client_id:
if Client.query.filter(Client.id == client_id).count():
return jsonify(context.make_appointments(client_id, every))
else:
return abort(404)
return jsonify(None, 400, 'Can\'t!')
def kladr_search_street(city_code=None, search_query=None, limit=100):
result = []
if city_code is None or search_query is None:
return jsonify([])
response = requests.get(u'{0}kladr/street/search/{1}/{2}/{3}/'.format(
app.config['VESTA_URL'], city_code, search_query, limit))
for street in response.json()['data']:
data = {
'code': street['identcode'],
'name': u'{0} {1}'.format(street['fulltype'], street['name'])
}
result.append(data)
return jsonify(result)
def api_delete_event():
event_id = request.json.get('event_id')
if not event_id:
return abort(404)
event = Event.query.get_or_404(event_id)
def can_delete_event(event):
# TODO: check payments
if current_user.has_right('evtDelAll') or current_user.has_right(
'adm'):
return True, ''
elif current_user.has_right('evtDelOwn'):
if event.execPerson_id == current_user.id:
return True, ''
elif event.createPerson_id == current_user.id:
# Проверка, что все действия не были изменены после создания обращения
# или, что не появилось новых действий
for action in event.actions:
if action.modifyPerson_id != event.createPerson_id:
return False, u'В обращении были созданы новые или отредактированы первоначальные документы'
return True, ''
return False, u'У пользователя нет прав на удаление обращения'
ok, msg = can_delete_event(event)
if ok:
event.deleted = 1
db.session.add(event)
db.session.query(Action).filter(Action.event_id == event.id).update(
{
Action.deleted: 1,
}, synchronize_session=False)
db.session.query(Visit).filter(Visit.event_id == event.id).update(
{
Visit.deleted: 1,
}, synchronize_session=False)
db.session.query(ScheduleClientTicket).filter(
ScheduleClientTicket.event_id == event.id).update(
{
ScheduleClientTicket.event_id: None,
},
synchronize_session=False)
db.session.commit()
return jsonify(None)
return jsonify({
'name': msg,
'data': {
'err_msg': u'Удаление запрещено'
}
}, 403, 'delete event error')
def api_kladr_street_get():
from application.models.kladr_models import Street
city = request.args['city']
street = request.args['street']
res = Street.query.filter(Street.CODE.startswith(city[:-2]),
Street.NAME.startswith(street)).all()
return jsonify([{'name': r.NAME, 'code': r.CODE} for r in res])
def api_search_persons():
try:
query_string = request.args['q']
except (KeyError, ValueError):
return abort(404)
result = SearchPerson.search(query_string)
def cat(item):
return {
'display':
u'#%d - %s %s %s (%s)' %
(item['id'], item['lastname'], item['firstname'], item['patrname'],
item['speciality']),
'name':
u'%s %s %s' %
(item['lastname'], item['firstname'], item['patrname']),
'speciality':
item['speciality'],
'id':
item['id'],
'tokens': [item['lastname'], item['firstname'], item['patrname']] +
item['speciality'].split(),
}
data = map(cat, result['result']['items'])
return jsonify(data)
def handle_event_error(err):
return jsonify({
'name': err.message,
'data': {
'err_msg': err.data
}
}, 422, 'error')
def api_event_new_get():
event = Event()
event.eventType = EventType.get_default_et()
event.organisation = Organisation.query.filter_by(
infisCode=str(ORGANISATION_INFIS_CODE)).first()
event.isPrimaryCode = EventPrimary.primary[0]
event.order = EventOrder.planned[0]
ticket_id = request.args.get('ticket_id')
if ticket_id:
ticket = ScheduleClientTicket.query.get(int(ticket_id))
client_id = ticket.client_id
setDate = ticket.ticket.begDateTime
note = ticket.note
exec_person_id = ticket.ticket.schedule.person_id
else:
client_id = int(request.args['client_id'])
setDate = datetime.datetime.now()
note = ''
exec_person_id = safe_current_user_id()
event.execPerson_id = exec_person_id
event.execPerson = Person.query.get(exec_person_id)
event.orgStructure = event.execPerson.org_structure
event.client = Client.query.get(client_id)
event.setDate = setDate
event.note = note
db.session.add(event)
v = EventVisualizer()
return jsonify({
'event': v.make_event(event),
'payment': v.make_event_payment(None)
})
def page_not_found(e):
if request_wants_json():
return jsonify(unicode(e),
result_code=404,
result_name=u'Page not found')
flash(u'Указанный вами адрес не найден')
return render_template('404.html'), 404
def api_schedule():
person_id_s = request.args.get('person_ids')
client_id_s = request.args.get('client_id')
start_date_s = request.args.get('start_date')
one_day = bool(request.args.get('one_day', False))
reception_type = request.args.get('reception_type')
related = bool(request.args.get('related', False))
try:
start_date = datetime.datetime.strptime(start_date_s,
'%Y-%m-%d').date()
if one_day:
end_date = start_date + datetime.timedelta(days=1)
else:
end_date = start_date + datetime.timedelta(weeks=1)
client_id = int(client_id_s) if client_id_s else None
except ValueError:
return abort(400)
result = {
'schedules': [],
}
context = ScheduleVisualizer()
context.client_id = client_id
context.reception_type = reception_type
if person_id_s and not person_id_s == '[]':
if person_id_s.startswith('[') and person_id_s.endswith(']'):
person_ids = set(
int(person_id) for person_id in person_id_s[1:-1].split(','))
else:
try:
person_ids = {int(person_id_s)}
except ValueError:
person_ids = set()
else:
person_ids = set()
if related:
if not client_id:
return abort(400)
persons = Person.query.\
join(ScheduleClientTicket.ticket, ScheduleTicket.schedule, Schedule.person).\
filter(start_date <= Schedule.date, Schedule.date <= end_date).\
filter(ScheduleClientTicket.client_id == client_id, ScheduleClientTicket.deleted == 0).\
distinct()
related_schedules = context.make_persons_schedule(
persons, start_date, end_date)
related_person_ids = set(person.id for person in persons)
person_ids -= related_person_ids
result['related_schedules'] = related_schedules
if person_ids:
persons = Person.query.filter(Person.id.in_(person_ids))
schedules = context.make_persons_schedule(persons, start_date,
end_date)
result['schedules'] = schedules
return jsonify(result)
def api_delete_action():
action_id = request.json['action_id']
if action_id:
action = Action.query.filter(Action.id == action_id)
action.update({Action.deleted: 1}, synchronize_session=False)
db.session.commit()
return jsonify(None)
def api_get_action_ped():
at_id = parse_id(request.args, 'action_type_id')
if at_id is False:
return abort(404)
at = ActionType.query.get(at_id)
if not at:
return abort(404)
return jsonify({'ped': get_planned_end_datetime(at_id)})
def api_persons_tree_schedule_info():
beg_date = safe_date(request.args.get('beg_date'))
end_date = safe_date(request.args.get('end_date'))
if not (beg_date and end_date):
return abort(404)
result = db.session.query(Schedule.person_id).filter(
Schedule.deleted == 0, Schedule.reasonOfAbsence_id.is_(None),
beg_date <= Schedule.date, Schedule.date <= end_date).distinct()
return jsonify({'persons_with_scheds': [row[0] for row in result]})
def api_service_delete_service():
# TODO: validations
action_ids = request.json['action_id_list']
if action_ids:
actions = Action.query.filter(Action.id.in_(action_ids))
actions.update({Action.deleted: 1}, synchronize_session=False)
db.session.commit()
return jsonify(None)
def api_refbook(name):
for mod in (enums, ):
if hasattr(mod, name):
ref_book = getattr(mod, name)
res = jsonify(ref_book.rb()['objects'])
return res
for mod in (exists, schedule, actions, client, event):
if hasattr(mod, name):
ref_book = getattr(mod, name)
if 'deleted' in ref_book.__dict__:
res = jsonify(
ref_book.query.filter_by(deleted=0).order_by(
ref_book.id).all())
else:
res = ref_book.query.order_by(ref_book.id).all()
res = jsonify(res)
return res
return abort(404)
def kladr_search_city(search_query=None, limit=300):
result = []
if search_query is None:
return jsonify([])
response = requests.get(u'{0}kladr/psg/search/{1}/{2}/'.format(
app.config['VESTA_URL'], search_query, limit))
for city in response.json()['data']:
data = {
'code': city['identcode'],
'name': u'{0}. {1}'.format(city['shorttype'], city['name'])
}
if city['parents']:
for parent in city['parents']:
data['name'] = u'{0}, {1}. {2}'.format(data['name'],
parent['shorttype'],
parent['name'])
result.append(data)
return jsonify(result)
def api_atl_get():
# not used?
at_class = int(request.args['at_class'])
if not (0 <= at_class < 4):
return abort(401)
result = int_get_atl(at_class)
return jsonify(result)
def api_appointment():
"""
Запись (отмена записи) пациента на приём.
Параметры:
client_id (int) - id пациента
ticket_id (int) - ScheduleTicket.id
[opt] appointment_type_code (str) - rbAppointmentType.code
[opt] delete (bool) - удалять ли запись
[opt] note (str) - жалобы
"""
data = request.get_json()
client_id = int(data['client_id'])
ticket_id = int(data['ticket_id'])
create_person = data.get('create_person', current_user.get_id())
appointment_type_code = data.get('appointment_type_code', 'amb')
delete = bool(data.get('delete', False))
ticket = ScheduleTicket.query.get(ticket_id)
if not ticket:
return abort(404)
client_ticket = ticket.client_ticket
if client_ticket and client_ticket.client_id != client_id:
return jsonify(
None, 400,
u'Талончик занят другим пациентом (%d)' % client_ticket.client_id)
if delete:
if not client_ticket:
return abort(404)
client_ticket.deleted = 1
db.session.commit()
return jsonify(None)
if not client_ticket:
client_ticket = ScheduleClientTicket()
client_ticket.client_id = client_id
client_ticket.ticket_id = ticket_id
client_ticket.createDatetime = client_ticket.modifyDatetime = datetime.datetime.now(
)
client_ticket.createPerson_id = client_ticket.modifyPerson_id = create_person
client_ticket.appointmentType = rbAppointmentType.query.filter(
rbAppointmentType.code == appointment_type_code).first()
db.session.add(client_ticket)
if 'note' in data:
client_ticket.note = data['note']
db.session.commit()
return jsonify(None)
def api_service_change_account():
# not used
data = request.json
if data['actions']:
actions = Action.query.filter(Action.id.in_(data['actions']))
actions.update({Action.account: data['account']},
synchronize_session=False)
db.session.commit()
return jsonify(None)
def api_get_events():
from application.models.event import Event
from application.models.exists import Contract
flt = request.get_json()
base_query = Event.query.join(Client)
context = EventVisualizer()
if 'id' in flt:
event = base_query.filter(Event.id == flt['id']).first()
return jsonify({
'pages':
1,
'items': [context.make_short_event(event)] if event else []
})
if 'client_id' in flt:
base_query = base_query.filter(Event.client_id == flt['client_id'])
if 'exec_person_id' in flt:
base_query = base_query.filter(
Event.execPerson_id == flt['exec_person_id'])
if 'beg_date' in flt:
base_query = base_query.filter(
Event.setDate >= datetime.datetime.strptime(
flt['beg_date'], '%Y-%m-%d').date())
if 'unfinished' in flt:
base_query = base_query.filter(Event.execDate.is_(None))
elif 'end_date' in flt:
base_query = base_query.filter(
Event.execDate <= datetime.datetime.strptime(
flt['end_date'], '%Y-%m-%d').date())
if 'request_type_id' in flt:
base_query = base_query.join(EventType).filter(
EventType.requestType_id == flt['request_type_id'])
if 'finance_id' in flt:
base_query = base_query.join(Contract).filter(
Contract.finance_id == flt['finance_id'])
per_page = int(flt.get('per_page', 20))
page = int(flt.get('page', 1))
base_query = base_query.order_by(Event.setDate)
paginate = base_query.paginate(page, per_page, False)
return jsonify({
'pages':
paginate.pages,
'items': [context.make_short_event(event) for event in paginate.items]
})
def api_client_payment_info_get():
try:
client_id = int(request.args['client_id'])
except (KeyError, ValueError):
return abort(400)
client = Client.query.get(client_id)
vis = EventVisualizer()
res = vis.make_event_payment(None, client)
return jsonify(res)
def api_patient_get():
client_id = parse_id(request.args, 'client_id')
if client_id is False:
return abort(404)
context = ClientVisualizer()
if client_id:
client = Client.query.get(client_id)
if not client:
return abort(404)
if 'for_servicing' in request.args:
return jsonify(context.make_client_info_for_servicing(client))
elif 'short' in request.args:
return jsonify(context.make_short_client_info(client))
return jsonify({'client_data': context.make_client_info(client)})
else:
client = Client()
db.session.add(
client
) # требуется привязанный к сессии клиент для доступа к некоторым атрибутам (documents)
return jsonify({'client_data': context.make_client_info(client)})
def api_action_new_get():
src_action = Action.query.get(int(request.args['src_action_id'])) \
if 'src_action_id' in request.args else None
action_type_id = int(request.args['action_type_id'])
event_id = int(request.args['event_id'])
action = create_action(action_type_id, event_id, src_action=src_action)
v = ActionVisualizer()
result = v.make_action(action)
db.session.rollback()
return jsonify(result)
def api_diagnosis_save():
current_datetime = datetime.datetime.now()
data = request.json
diagnosis_id = data.get('diagnosis_id')
diagnostic_id = data.get('diagnostic_id')
if diagnosis_id:
diagnosis = Diagnosis.query.get(diagnosis_id)
else:
diagnosis = Diagnosis()
diagnosis.createDatetime = current_datetime
if diagnostic_id:
diagnostic = Diagnostic.query.get(diagnostic_id)
else:
diagnostic = Diagnostic()
diagnostic.createDatetime = current_datetime
diagnosis.modifyDatetime = current_datetime
diagnostic.modifyDatetime = current_datetime
diagnosis.client_id = data['client_id']
diagnosis.person_id = data['person']['id']
diagnosis.diagnosisType_id = safe_traverse(data, 'diagnosis_type', 'id')
diagnosis.character_id = safe_traverse(data, 'character', 'id')
diagnosis.dispanser_id = safe_traverse(data, 'dispanser', 'id')
diagnosis.traumaType_id = safe_traverse(data, 'trauma', 'id')
diagnosis.MKB = safe_traverse(data, 'mkb', 'code') or ''
diagnosis.MKBEx = safe_traverse(data, 'mkb_ex', 'code') or ''
if not diagnosis.endDate:
diagnosis.endDate = current_datetime
db.session.add(diagnosis)
diagnostic.event_id = data['event_id']
diagnostic.diagnosis = diagnosis
diagnostic.diagnosisType_id = safe_traverse(data, 'diagnosis_type', 'id')
diagnostic.character_id = safe_traverse(data, 'character', 'id')
diagnostic.stage_id = safe_traverse(data, 'stage', 'id')
diagnostic.phase_id = safe_traverse(data, 'phase', 'id')
diagnostic.dispanser_id = safe_traverse(data, 'dispanser', 'id')
diagnostic.traumaType_id = safe_traverse(data, 'trauma', 'id')
diagnostic.healthGroup_id = safe_traverse(data, 'health_group', 'id')
diagnostic.result_id = safe_traverse(data, 'result', 'id')
diagnostic.notes = data.get('notes', '')
diagnostic.sanatorium = 0
diagnostic.hospital = 0
diagnostic.speciality_id = 1
diagnostic.version = 0
diagnostic.rbAcheResult_id = safe_traverse(data, 'ache_result', 'id')
if not diagnostic.setDate:
diagnostic.setDate = current_datetime
db.session.add(diagnostic)
db.session.commit()
return jsonify(None)
def api_create_lab_direction():
ja = request.get_json()
event_id = ja['event_id']
event = Event.query.get(event_id)
org_structure = event.current_org_structure
if not org_structure:
return jsonify(
{'message': u'Пациент не привязан ни к одному из отделений.'}, 422,
'ERROR')
for j in ja['directions']:
action_type_id = j['type_id']
assigned = j['assigned']
data = {'plannedEndDate': dateutil_parse(j['planned_end_date'])}
action = create_new_action(action_type_id,
event_id,
assigned=assigned,
data=data)
db.session.add(action)
db.session.commit()
return jsonify(None)
def api_service_remove_coord():
# not used
data = request.json
if data['action_id']:
actions = Action.query.filter(Action.id.in_(data['action_id']))
actions.update({
Action.coordDate: None,
Action.coordPerson_id: None
},
synchronize_session=False)
db.session.commit()
return jsonify(None)
def api_search_clients():
try:
query_string = request.args['q']
limit = int(request.args.get('limit', 100))
except (KeyError, ValueError):
return abort(404)
base_query = Client.query
id_list = []
if query_string:
result = SearchPatient.search(query_string)
id_list = [item['id'] for item in result['result']['items']]
if id_list:
base_query = base_query.filter(Client.id.in_(id_list))
else:
return jsonify([])
clients = base_query.order_by(db.func.field(Client.id,
*id_list)).limit(limit).all()
context = ClientVisualizer()
if 'short' in request.args:
return jsonify(map(context.make_short_client_info, clients))
else:
return jsonify(map(context.make_search_client_info, clients))
def api_day_schedule():
person_id = parse_id(request.args, 'person_id')
if person_id is False:
return abort(400)
try:
start_date = datetime.datetime.strptime(request.args.get('start_date'),
'%Y-%m-%d').date()
end_date = start_date + datetime.timedelta(days=1)
except ValueError:
return abort(400)
context = ScheduleVisualizer()
person = Person.query.get(person_id)
return jsonify(
context.make_person_schedule_description(person, start_date, end_date))
def api_schedule_description():
person_id = parse_id(request.args, 'person_id')
if person_id is False:
return abort(400)
start_date_s = request.args.get('start_date')
try:
start_date = datetime.datetime.strptime(start_date_s, '%Y-%m').date()
end_date = start_date + datetime.timedelta(
calendar.monthrange(start_date.year, start_date.month)[1])
except ValueError:
return abort(400)
context = ScheduleVisualizer()
person = Person.query.get(person_id)
return jsonify(
context.make_person_schedule_description(person, start_date, end_date))
def api_event_info():
event_id = int(request.args['event_id'])
event = Event.query.get(event_id)
vis = EventVisualizer()
data = {
'event': vis.make_event(event),
}
if current_user.role_in('admin'):
data['diagnoses'] = vis.make_diagnoses(event)
data['payment'] = vis.make_event_payment(event)
data['services'] = vis.make_event_services(event_id)
elif current_user.role_in('doctor'):
data['diagnoses'] = vis.make_diagnoses(event)
elif current_user.role_in(('rRegistartor', 'clinicRegistrator')):
data['payment'] = vis.make_event_payment(event)
data['services'] = vis.make_event_services(event_id)
return jsonify(data)
