2378 lines
93 KiB
Python
2378 lines
93 KiB
Python
"""Appointment queue page matching ``admin/src/views/tcm/appointment/list.vue``."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Mapping, Sequence
|
|
from copy import deepcopy
|
|
from datetime import date, timedelta
|
|
from html import escape
|
|
from types import MappingProxyType
|
|
from typing import Any
|
|
|
|
from PySide6.QtCore import QDate, Qt, QTimer, QUrl, Signal
|
|
from PySide6.QtGui import QBrush, QColor, QDesktopServices, QPixmap
|
|
from PySide6.QtWidgets import (
|
|
QAbstractItemView,
|
|
QButtonGroup,
|
|
QCheckBox,
|
|
QComboBox,
|
|
QDateEdit,
|
|
QDialog,
|
|
QDialogButtonBox,
|
|
QFrame,
|
|
QHBoxLayout,
|
|
QHeaderView,
|
|
QLabel,
|
|
QLineEdit,
|
|
QMenu,
|
|
QMessageBox,
|
|
QPushButton,
|
|
QTabBar,
|
|
QTextEdit,
|
|
QVBoxLayout,
|
|
QWidget,
|
|
)
|
|
|
|
from ..dialogs import DiagnosisDialog
|
|
from ..dialogs.ai_consult import can_open_ai_consult, present_ai_consult
|
|
from ..dialogs.prescription import (
|
|
PrescriptionDetailDialog,
|
|
PrescriptionEditorDialog,
|
|
build_prescription_clinical_diagnosis,
|
|
build_prescription_visit_no,
|
|
)
|
|
from ..dialogs.prescription_ai import (
|
|
can_open_diagnosis_ai_report,
|
|
present_diagnosis_ai_report,
|
|
)
|
|
from ..theme import mark_business_dialog
|
|
from ..widgets import (
|
|
MessageBanner,
|
|
PageHeader,
|
|
Pager,
|
|
SortableTable,
|
|
TableColumn,
|
|
display_text,
|
|
first_value,
|
|
friendly_error,
|
|
gender_text,
|
|
get_value,
|
|
invoke,
|
|
page_items,
|
|
page_total,
|
|
run_async,
|
|
show_toast,
|
|
)
|
|
|
|
STATUS_TABS: tuple[tuple[str, str | int], ...] = (
|
|
("待接诊", 1),
|
|
("全部", "all"),
|
|
("已过号", 4),
|
|
("已取消", 2),
|
|
("已完成", 3),
|
|
)
|
|
DATE_PRESETS: tuple[tuple[str, str], ...] = (
|
|
("昨天挂号", "yesterday"),
|
|
("前天挂号", "day_before"),
|
|
("当天挂号", "today"),
|
|
("明天挂号", "tomorrow"),
|
|
("后天挂号", "day_after"),
|
|
("不限", ""),
|
|
)
|
|
LIST_POLL_MS = 20_000
|
|
NOTE_LIMIT = 500
|
|
TABLE_CELL_VERTICAL_PADDING = 10
|
|
|
|
_SEMANTIC_COLORS = {
|
|
"success": "#159C79",
|
|
"warning": "#C17A16",
|
|
"danger": "#EC5266",
|
|
"info": "#4776EE",
|
|
"muted": "#7481A3",
|
|
}
|
|
|
|
APPOINTMENTS_LIGHT_QSS = """
|
|
/* 页头此前被压到只剩面包屑（26px），与其余列表页的“面包屑+标题+副标题”
|
|
骨架不一致。这里给它与 PageHeader 自然高度相符的空间。 */
|
|
#AppointmentsPage QWidget#PageHeader {
|
|
min-height: 62px;
|
|
max-height: 62px;
|
|
}
|
|
#AppointmentsPage QFrame#AppointmentFilterPanel {
|
|
min-height: 80px;
|
|
max-height: 80px;
|
|
background-color: #FFFFFF;
|
|
border: 1px solid #E2E7F4;
|
|
border-radius: 10px;
|
|
}
|
|
#AppointmentsPage QFrame#AppointmentMainCard {
|
|
background-color: #FFFFFF;
|
|
border: 1px solid #E2E7F4;
|
|
border-radius: 10px;
|
|
}
|
|
#AppointmentsPage QPushButton[appointmentStat="true"] {
|
|
min-height: 30px;
|
|
max-height: 30px;
|
|
padding: 0 7px;
|
|
color: #59698E;
|
|
background-color: #F8F9FD;
|
|
border: 0;
|
|
border-radius: 8px;
|
|
font-size: 12px;
|
|
}
|
|
#AppointmentsPage QPushButton[appointmentStat="true"]:hover {
|
|
color: #5265F6;
|
|
background-color: #F0F2FF;
|
|
}
|
|
#AppointmentsPage QPushButton[appointmentStat="true"]:checked {
|
|
color: #FFFFFF;
|
|
background-color: #5265F6;
|
|
border-color: #5265F6;
|
|
font-weight: 600;
|
|
}
|
|
/* 这一排全是筛选片，此前按业务语义分别染成紫/绿/琥珀，一行出现四种底色，
|
|
而且颜色和“是否选中”这一真正需要区分的状态互相打架。筛选片一律保持中性，
|
|
只有“待分配医助”在确有待办时才提示为琥珀色。 */
|
|
#AppointmentsPage QPushButton[appointmentStatKind="warning"][hasPending="true"] {
|
|
color: #C17A16;
|
|
background-color: #FFF8ED;
|
|
border-color: #F0DCB6;
|
|
}
|
|
#AppointmentsPage QLineEdit#AppointmentPatientSearch {
|
|
min-height: 30px;
|
|
max-height: 30px;
|
|
background-color: #FFFFFF;
|
|
border: 1px solid #DDE3F0;
|
|
border-radius: 7px;
|
|
}
|
|
#AppointmentsPage QLabel#FilterRowLabel {
|
|
color: #405074;
|
|
font-size: 12px;
|
|
font-weight: 600;
|
|
}
|
|
#AppointmentsPage QLabel#FilterDivider {
|
|
color: #E2E7F4;
|
|
padding: 0 2px;
|
|
}
|
|
#AppointmentsPage QTableWidget#AppointmentTable::item {
|
|
padding: 5px 7px;
|
|
}
|
|
#AppointmentsPage QTableWidget#AppointmentTable QHeaderView::section {
|
|
min-height: 34px;
|
|
background-color: #F8FAFF;
|
|
}
|
|
#AppointmentsPage QTableWidget#AppointmentTable {
|
|
gridline-color: #E9EDF5;
|
|
selection-background-color: #FFFFFF;
|
|
selection-color: #15224A;
|
|
}
|
|
#AppointmentsPage QCheckBox[appointmentSelector="true"]::indicator {
|
|
width: 13px;
|
|
height: 13px;
|
|
background-color: #FFFFFF;
|
|
border: 1px solid #CBD3E7;
|
|
border-radius: 2px;
|
|
}
|
|
#AppointmentsPage QCheckBox[appointmentSelector="true"]::indicator:checked {
|
|
background-color: #5265F6;
|
|
border-color: #5265F6;
|
|
}
|
|
#AppointmentsPage QLabel[tableAppointmentStatus="true"] {
|
|
min-height: 18px;
|
|
max-height: 18px;
|
|
padding: 0 6px;
|
|
color: #5265F6;
|
|
background-color: #EEF1FF;
|
|
border-radius: 4px;
|
|
font-size: 10px;
|
|
font-weight: 600;
|
|
}
|
|
#AppointmentsPage QLabel[tableAppointmentStatusKind="warning"] {
|
|
color: #B97715;
|
|
background-color: #FFF4DF;
|
|
}
|
|
#AppointmentsPage QLabel[tableAppointmentMeta="true"] {
|
|
color: #59698E;
|
|
font-size: 10px;
|
|
}
|
|
#AppointmentsPage QPushButton[tableCancelAction="true"] {
|
|
min-height: 18px;
|
|
max-height: 18px;
|
|
padding: 0 5px;
|
|
color: #EC5266;
|
|
background-color: #FFF4F6;
|
|
border: 0;
|
|
border-radius: 4px;
|
|
font-size: 10px;
|
|
}
|
|
#AppointmentsPage QWidget[appointmentImHost="true"] {
|
|
background-color: transparent;
|
|
}
|
|
#AppointmentsPage QPushButton[appointmentImAction="true"] {
|
|
min-width: 74px;
|
|
min-height: 26px;
|
|
max-height: 26px;
|
|
padding: 0 9px;
|
|
color: #5265F6;
|
|
background-color: #F0F2FF;
|
|
border: 1px solid #D7DEFF;
|
|
border-radius: 7px;
|
|
font-size: 11px;
|
|
font-weight: 600;
|
|
}
|
|
#AppointmentsPage QPushButton[appointmentImAction="true"]:hover {
|
|
color: #FFFFFF;
|
|
background-color: #5265F6;
|
|
border-color: #5265F6;
|
|
}
|
|
#AppointmentsPage QPushButton[appointmentImAction="true"]:focus {
|
|
border-color: #8D9BFF;
|
|
}
|
|
#AppointmentsPage QPushButton[appointmentImAction="true"]:disabled {
|
|
color: #98A3BC;
|
|
background-color: #F7F8FC;
|
|
border-color: #E4E8F2;
|
|
}
|
|
#AppointmentsPage QWidget[appointmentInfoHost="true"] {
|
|
background-color: #FFFFFF;
|
|
}
|
|
#AppointmentsPage QPushButton[compactAction="true"] {
|
|
min-height: 28px;
|
|
max-height: 28px;
|
|
padding: 0 8px;
|
|
border-radius: 7px;
|
|
font-size: 11px;
|
|
}
|
|
#AppointmentsPage QPushButton[variant="chip"] {
|
|
min-height: 34px;
|
|
max-height: 34px;
|
|
padding: 0 12px;
|
|
color: #7481A3;
|
|
background-color: #F8FAFF;
|
|
border: 1px solid #E2E7F4;
|
|
border-radius: 8px;
|
|
}
|
|
#AppointmentsPage QPushButton[variant="chip"]:hover {
|
|
color: #15224A;
|
|
background-color: #F0F3FC;
|
|
border-color: #5265F6;
|
|
}
|
|
#AppointmentsPage QPushButton[variant="chip"]:checked {
|
|
color: #FFFFFF;
|
|
background-color: #5265F6;
|
|
border-color: #5265F6;
|
|
}
|
|
#AppointmentsPage QPushButton[variant="chip"]:focus { border-color: #8D9BFF; }
|
|
#AppointmentsPage QTabBar#AppointmentStatusTabs::tab {
|
|
min-width: 62px;
|
|
min-height: 28px;
|
|
padding: 0 7px;
|
|
color: #7481A3;
|
|
background-color: transparent;
|
|
border: 0;
|
|
border-bottom: 2px solid transparent;
|
|
}
|
|
#AppointmentsPage QTabBar#AppointmentStatusTabs::tab:hover {
|
|
color: #15224A;
|
|
background-color: #F0F3FC;
|
|
}
|
|
#AppointmentsPage QTabBar#AppointmentStatusTabs::tab:selected {
|
|
color: #3C4FD9;
|
|
background-color: #EEF1FF;
|
|
border-bottom-color: #5265F6;
|
|
}
|
|
#AppointmentsPage QPushButton[filterChoice="true"] {
|
|
min-height: 28px;
|
|
max-height: 28px;
|
|
padding: 0 10px;
|
|
color: #405074;
|
|
background-color: transparent;
|
|
border: 1px solid transparent;
|
|
border-radius: 7px;
|
|
}
|
|
#AppointmentsPage QPushButton[filterChoice="true"]:checked {
|
|
color: #5265F6;
|
|
background-color: #F0F1FF;
|
|
border-color: #E0E4FF;
|
|
}
|
|
"""
|
|
|
|
|
|
def _as_int(value: Any, default: int = 0) -> int:
|
|
try:
|
|
return int(value)
|
|
except (TypeError, ValueError):
|
|
return default
|
|
|
|
|
|
def _as_bool(value: Any) -> bool:
|
|
if isinstance(value, str):
|
|
return value.strip().lower() in {"1", "true", "yes", "on"}
|
|
return bool(value)
|
|
|
|
|
|
def _canonical_allowed(permissions: Any, code: str, *, default: bool = True) -> bool:
|
|
if permissions is None:
|
|
return default
|
|
for method_name in ("allows", "has", "can", "contains", "has_permission"):
|
|
method = getattr(permissions, method_name, None)
|
|
if callable(method):
|
|
try:
|
|
return bool(method(code))
|
|
except (TypeError, ValueError):
|
|
continue
|
|
raw = permissions
|
|
for attr in ("codes", "permissions", "values"):
|
|
candidate = getattr(permissions, attr, None)
|
|
if candidate is not None and not callable(candidate):
|
|
raw = candidate
|
|
break
|
|
if isinstance(raw, Mapping):
|
|
nested = first_value(raw, "codes", "permissions", "values", default=None)
|
|
if nested is not None:
|
|
raw = nested
|
|
if isinstance(raw, Mapping):
|
|
available = {str(key) for key, enabled in raw.items() if enabled}
|
|
elif isinstance(raw, str):
|
|
available = {raw}
|
|
else:
|
|
try:
|
|
available = {str(item) for item in raw}
|
|
except TypeError:
|
|
return False
|
|
if "*" in available or code in available:
|
|
return True
|
|
return any(grant.endswith("/*") and code.startswith(grant[:-1]) for grant in available)
|
|
|
|
|
|
def _supports_native_video(repository: Any) -> bool:
|
|
return all(
|
|
callable(getattr(repository, method_name, None))
|
|
for method_name in ("get_call_ticket", "start_call", "bind_call_room", "end_call")
|
|
)
|
|
|
|
|
|
def _is_admin_user(user: Any) -> bool:
|
|
"""Match admin: neither doctor (1) nor assistant (2)."""
|
|
|
|
role_id = first_value(user, "role_id", "role_ids", default=None)
|
|
if isinstance(role_id, Sequence) and not isinstance(role_id, (str, bytes, bytearray)):
|
|
values = {_as_int(item, -1) for item in role_id}
|
|
return 1 not in values and 2 not in values
|
|
value = _as_int(role_id, -1)
|
|
return value not in {1, 2}
|
|
|
|
|
|
def _mask_phone(value: Any, *, can_plain: bool) -> str:
|
|
text = str(value or "").strip()
|
|
if not text:
|
|
return "—"
|
|
if can_plain or "*" in text:
|
|
return text
|
|
digits = "".join(character for character in text if character.isdigit())
|
|
if len(digits) >= 7:
|
|
return f"{digits[:3]}****{digits[-4:]}"
|
|
if len(text) > 4:
|
|
return f"{text[:2]}***{text[-2:]}"
|
|
return "****"
|
|
|
|
|
|
def _diagnosis_id(row: Any) -> int:
|
|
"""Admin appointment rows often store diagnosis id in ``patient_id``."""
|
|
|
|
explicit = _as_int(first_value(row, "diagnosis_id", default=0))
|
|
if explicit > 0:
|
|
return explicit
|
|
return _as_int(first_value(row, "patient_id", default=0))
|
|
|
|
|
|
def _video_patient_id(row: Any) -> int:
|
|
"""Return only the appointment row's explicitly separated patient owner."""
|
|
|
|
return _as_int(first_value(row, "source_patient_id", default=0))
|
|
|
|
|
|
def _appointment_id(row: Any) -> int:
|
|
return _as_int(first_value(row, "id", "appointment_id", default=0))
|
|
|
|
|
|
def _status_value(row: Any) -> int:
|
|
return _as_int(first_value(row, "status", default=0))
|
|
|
|
|
|
_IM_CONSULT_ACTIVE_STATUSES = frozenset({1, 4})
|
|
|
|
|
|
def _im_consult_status_error(row: Any) -> str:
|
|
"""Return why a queue row cannot open the doctor's IM consultation."""
|
|
|
|
status = _status_value(row)
|
|
if status in _IM_CONSULT_ACTIVE_STATUSES:
|
|
return ""
|
|
if status == 2:
|
|
return "已取消的挂号不可进入 IM 问诊"
|
|
if status == 3:
|
|
return "已完成的挂号不可再进入 IM 问诊"
|
|
return "当前挂号状态不可进入 IM 问诊"
|
|
|
|
|
|
def prescription_action_label(row: Any) -> str:
|
|
audit = _as_int(first_value(row, "prescription_audit_status", "audit_status"), -1)
|
|
voided = _as_int(first_value(row, "prescription_void_status", "void_status"), 0)
|
|
explicit = first_value(row, "current_has_prescription", default=None)
|
|
if explicit is None and _as_int(first_value(row, "current_prescription_id", default=0)) <= 0:
|
|
explicit = first_value(row, "has_prescription", default=None)
|
|
has_prescription = (
|
|
_as_bool(explicit)
|
|
if explicit is not None
|
|
else _as_int(
|
|
first_value(row, "current_prescription_id", "prescription_id", default=0),
|
|
0,
|
|
)
|
|
> 0
|
|
or audit in {0, 1, 2}
|
|
)
|
|
if not has_prescription:
|
|
return "开方"
|
|
return "查看" if audit == 1 and voided != 1 else "编辑处方"
|
|
|
|
|
|
def _patient_cell(_value: Any, row: Any, *, can_plain: bool) -> str:
|
|
phone = _mask_phone(
|
|
first_value(row, "patient_phone", "phone", default=""),
|
|
can_plain=can_plain,
|
|
)
|
|
extras = " ".join(
|
|
part
|
|
for part in (
|
|
gender_text(first_value(row, "gender", "gender_desc", default=None)),
|
|
(
|
|
f"{first_value(row, 'age')}岁"
|
|
if first_value(row, "age", default=None) not in (None, "")
|
|
else ""
|
|
),
|
|
(
|
|
f"{first_value(row, 'height')}cm"
|
|
if first_value(row, "height", default=None) not in (None, "")
|
|
else ""
|
|
),
|
|
(
|
|
f"{first_value(row, 'weight')}kg"
|
|
if first_value(row, "weight", default=None) not in (None, "")
|
|
else ""
|
|
),
|
|
)
|
|
if part and part != "—"
|
|
)
|
|
return f"{display_text(first_value(row, 'patient_name'), '—')}\n{phone}" + (
|
|
f"\n{extras}" if extras else ""
|
|
)
|
|
|
|
|
|
def _datetime_cell(_value: Any, row: Any) -> str:
|
|
return (
|
|
f"{display_text(first_value(row, 'appointment_date'), '—')}\n"
|
|
f"{display_text(first_value(row, 'appointment_time'), '—')}"
|
|
)
|
|
|
|
|
|
def _confirmed_cell(_value: Any, row: Any) -> str:
|
|
return (
|
|
"已确认" if _as_bool(first_value(row, "diagnosis_confirmed", default=False)) else "未确认"
|
|
)
|
|
|
|
|
|
def _prescription_cell(_value: Any, row: Any) -> str:
|
|
has_rx = _as_bool(first_value(row, "has_prescription", default=False))
|
|
label = "已开方" if has_rx else "未开方"
|
|
if has_rx and _as_int(first_value(row, "prescription_is_system_auto"), 0) == 1:
|
|
return f"{label}\n系统代开"
|
|
return label
|
|
|
|
|
|
def _status_cell(_value: Any, row: Any) -> str:
|
|
return display_text(
|
|
first_value(row, "status_desc"), str(first_value(row, "status", default="—"))
|
|
)
|
|
|
|
|
|
def _gender_age_cell(_value: Any, row: Any) -> str:
|
|
gender = gender_text(first_value(row, "gender", "gender_desc", default=None))
|
|
age = first_value(row, "age", default=None)
|
|
age_text = f"{age}岁" if age not in (None, "") else "—"
|
|
return f"{gender} · {age_text}"
|
|
|
|
|
|
def _appointment_info_cell(_value: Any, row: Any) -> str:
|
|
status = _status_cell(None, row)
|
|
doctor = display_text(first_value(row, "doctor_name"), "未分配")
|
|
date_text = display_text(first_value(row, "appointment_date"), "—")
|
|
time_text = display_text(first_value(row, "appointment_time"), "—")
|
|
channel = display_text(
|
|
first_value(row, "channel_name", "channel_source_name", "source_name"), "—"
|
|
)
|
|
return f"{status} {doctor}\n{date_text} {time_text}\n最近渠道：{channel}"
|
|
|
|
|
|
def _revisit_cell(_value: Any, row: Any) -> str:
|
|
revisit = first_value(
|
|
row,
|
|
"revisit_time",
|
|
"review_time",
|
|
"revisit_date",
|
|
"review_date",
|
|
default="",
|
|
)
|
|
return display_text(revisit, "无")
|
|
|
|
|
|
def _unserved_cell(_value: Any, row: Any) -> str:
|
|
value = first_value(
|
|
row,
|
|
"unserved_days",
|
|
"unservice_days",
|
|
"not_served_days",
|
|
default=None,
|
|
)
|
|
return display_text(value, "—")
|
|
|
|
|
|
def _offset_date(preset: str) -> date | None:
|
|
today = date.today()
|
|
offsets = {
|
|
"yesterday": -1,
|
|
"day_before": -2,
|
|
"today": 0,
|
|
"tomorrow": 1,
|
|
"day_after": 2,
|
|
}
|
|
if preset not in offsets:
|
|
return None
|
|
return today + timedelta(days=offsets[preset])
|
|
|
|
|
|
def _flatten_departments(
|
|
nodes: Sequence[Any],
|
|
*,
|
|
prefix: str = "",
|
|
) -> list[tuple[int, str]]:
|
|
result: list[tuple[int, str]] = []
|
|
for node in nodes:
|
|
if not isinstance(node, Mapping):
|
|
continue
|
|
dept_id = _as_int(first_value(node, "id", default=0))
|
|
name = str(first_value(node, "name", "label", default="")).strip()
|
|
if dept_id <= 0 or not name:
|
|
continue
|
|
label = f"{prefix}{name}" if not prefix else f"{prefix} / {name}"
|
|
result.append((dept_id, label if not prefix else f"{prefix}/{name}"))
|
|
children = first_value(node, "children", "child", default=[])
|
|
if isinstance(children, Sequence) and not isinstance(children, (str, bytes)):
|
|
child_prefix = name if not prefix else f"{prefix}/{name}"
|
|
result.extend(_flatten_departments(children, prefix=child_prefix))
|
|
return result
|
|
|
|
|
|
def _stable_signature_value(value: Any) -> Any:
|
|
"""Return a deterministic, order-independent representation of API data."""
|
|
|
|
if value is None or isinstance(value, (bool, int, str)):
|
|
return value
|
|
if isinstance(value, float):
|
|
return repr(value)
|
|
if isinstance(value, Mapping):
|
|
items = (
|
|
(str(key), _stable_signature_value(item))
|
|
for key, item in value.items()
|
|
)
|
|
return tuple(sorted(items, key=lambda pair: pair[0]))
|
|
if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
|
|
return tuple(_stable_signature_value(item) for item in value)
|
|
if isinstance(value, (set, frozenset)):
|
|
frozen = (_stable_signature_value(item) for item in value)
|
|
return tuple(sorted(frozen, key=repr))
|
|
dataclass_fields = getattr(type(value), "__dataclass_fields__", None)
|
|
if isinstance(dataclass_fields, Mapping):
|
|
return (
|
|
type(value).__qualname__,
|
|
tuple(
|
|
(name, _stable_signature_value(getattr(value, name, None)))
|
|
for name in dataclass_fields
|
|
),
|
|
)
|
|
state = getattr(value, "__dict__", None)
|
|
if isinstance(state, Mapping):
|
|
return (type(value).__qualname__, _stable_signature_value(state))
|
|
isoformat = getattr(value, "isoformat", None)
|
|
if callable(isoformat):
|
|
try:
|
|
return (type(value).__qualname__, isoformat())
|
|
except (TypeError, ValueError):
|
|
pass
|
|
return (type(value).__qualname__, str(value))
|
|
|
|
|
|
def _appointment_result_signature(rows: Sequence[Any], total: int, extend: Any) -> tuple[Any, ...]:
|
|
"""Build the stable render signature used to short-circuit unchanged polling."""
|
|
|
|
return (
|
|
"appointments-render-v1",
|
|
total,
|
|
_stable_signature_value(rows),
|
|
_stable_signature_value(extend),
|
|
)
|
|
|
|
|
|
class AppointmentsPage(QWidget):
|
|
"""Desktop appointment list with status tabs, filters, call and prescription."""
|
|
|
|
video_requested = Signal(dict)
|
|
|
|
def __init__(
|
|
self,
|
|
repository: Any,
|
|
permissions: Any = None,
|
|
current_user: Any = None,
|
|
parent: QWidget | None = None,
|
|
) -> None:
|
|
super().__init__(parent)
|
|
self.setObjectName("AppointmentsPage")
|
|
self.setStyleSheet(APPOINTMENTS_LIGHT_QSS)
|
|
self.repository = repository
|
|
self.permissions = permissions
|
|
self.current_user = current_user
|
|
self._page = 1
|
|
self._page_size = 15
|
|
self._generation = 0
|
|
self._dept_generation = 0
|
|
self._dict_generation = 0
|
|
self._action_generation = 0
|
|
self._prescription_generation = 0
|
|
self._loading = False
|
|
self._mutation_pending = False
|
|
self._prescription_busy = False
|
|
self._status: str | int = 1
|
|
self._date_preset = "today"
|
|
self._assistant_unassigned = False
|
|
self._start_date = date.today().isoformat()
|
|
self._end_date = self._start_date
|
|
self._status_counts: dict[int, int] = {1: 0, 2: 0, 3: 0, 4: 0}
|
|
self._dict_labels: dict[str, dict[str, str]] = {}
|
|
self._last_render_signature: tuple[Any, ...] | None = None
|
|
self._responsive_narrow: bool | None = None
|
|
self._can_plain_phone = _canonical_allowed(
|
|
permissions, "tcm.diagnosis/phonePlain", default=False
|
|
)
|
|
self._native_video_capable = _supports_native_video(repository)
|
|
self._is_admin = _is_admin_user(current_user)
|
|
|
|
root = QVBoxLayout(self)
|
|
root.setContentsMargins(18, 3, 6, 8)
|
|
root.setSpacing(4)
|
|
# 其余列表页都有“面包屑 + 标题 + 副标题”，这一页此前把标题隐藏了，
|
|
# 导致同一套列表页有两种页头形态。保留页头以对齐全局页面骨架。
|
|
self.header = PageHeader("挂号列表", "管理当日与近期挂号，确认到号、指派医助并进入接诊。")
|
|
root.addWidget(self.header)
|
|
self.filter_panel = self._build_filter_panel()
|
|
root.addWidget(self.filter_panel)
|
|
self.banner = MessageBanner()
|
|
root.addWidget(self.banner)
|
|
self.content_host = self._build_content()
|
|
root.addWidget(self.content_host, 1)
|
|
|
|
self.poll_timer = QTimer(self)
|
|
self.poll_timer.setInterval(LIST_POLL_MS)
|
|
self.poll_timer.timeout.connect(lambda: self.refresh(silent=True))
|
|
self._apply_responsive_layout()
|
|
|
|
def _diagnosis_dialog(self) -> DiagnosisDialog:
|
|
dialog = getattr(self, "_diagnosis_dialog_impl", None)
|
|
if dialog is None:
|
|
dialog = DiagnosisDialog(self.repository, self, permissions=self.permissions)
|
|
dialog.saved.connect(lambda: self.refresh(silent=True))
|
|
self._diagnosis_dialog_impl = dialog
|
|
return dialog
|
|
|
|
def _build_filter_panel(self) -> QWidget:
|
|
frame = QFrame()
|
|
frame.setObjectName("AppointmentFilterPanel")
|
|
layout = QVBoxLayout(frame)
|
|
layout.setContentsMargins(6, 4, 8, 6)
|
|
layout.setSpacing(4)
|
|
|
|
date_row = QHBoxLayout()
|
|
date_row.setSpacing(4)
|
|
self.date_buttons: dict[str, QPushButton] = {}
|
|
self._date_stat_labels: dict[str, str] = {}
|
|
for source_label, preset in DATE_PRESETS:
|
|
label = "全部" if preset == "" else source_label
|
|
button = QPushButton(f"{label} 0")
|
|
button.setCheckable(True)
|
|
button.setProperty("appointmentStat", True)
|
|
button.setMinimumWidth(0)
|
|
button.clicked.connect(
|
|
lambda _checked=False, value=preset: self._set_date_preset(value)
|
|
)
|
|
self.date_buttons[preset] = button
|
|
self._date_stat_labels[preset] = label
|
|
date_row.addWidget(button, 1)
|
|
self.date_buttons["today"].setChecked(True)
|
|
self.date_overflow_button = QPushButton("日期")
|
|
self.date_overflow_button.setProperty("appointmentStat", True)
|
|
date_menu = QMenu(self.date_overflow_button)
|
|
for source_label, preset in DATE_PRESETS:
|
|
action = date_menu.addAction(source_label if preset else "不限日期")
|
|
action.triggered.connect(
|
|
lambda _checked=False, value=preset: self._set_date_preset(value)
|
|
)
|
|
date_menu.addSeparator()
|
|
date_menu.addAction("自定义日期").triggered.connect(self._open_custom_date)
|
|
self.date_overflow_button.setMenu(date_menu)
|
|
date_row.addWidget(self.date_overflow_button)
|
|
|
|
self.pending_stat_button = QPushButton("待预约 0")
|
|
self.pending_stat_button.setProperty("appointmentStat", True)
|
|
self.pending_stat_button.setMinimumWidth(0)
|
|
self.pending_stat_button.clicked.connect(lambda: self._set_status_from_stat(1))
|
|
date_row.addWidget(self.pending_stat_button, 1)
|
|
self.completed_stat_button = QPushButton("已完成 0")
|
|
self.completed_stat_button.setProperty("appointmentStat", True)
|
|
self.completed_stat_button.setMinimumWidth(0)
|
|
self.completed_stat_button.clicked.connect(lambda: self._set_status_from_stat(3))
|
|
date_row.addWidget(self.completed_stat_button, 1)
|
|
self.unassigned_stat_button = QPushButton("待分配医助 0")
|
|
self.unassigned_stat_button.setCheckable(True)
|
|
self.unassigned_stat_button.setProperty("appointmentStat", True)
|
|
self.unassigned_stat_button.setProperty("appointmentStatKind", "warning")
|
|
self.unassigned_stat_button.setMinimumWidth(0)
|
|
self.unassigned_stat_button.clicked.connect(self._toggle_unassigned_filter)
|
|
date_row.addWidget(self.unassigned_stat_button, 1)
|
|
|
|
self.patient_input = QLineEdit()
|
|
self.patient_input.setObjectName("AppointmentPatientSearch")
|
|
self.patient_input.setPlaceholderText("患者姓名 / 手机号")
|
|
self.patient_input.setClearButtonEnabled(True)
|
|
self.patient_input.returnPressed.connect(self._search)
|
|
date_row.addWidget(self.patient_input, 2)
|
|
|
|
search = QPushButton("查询")
|
|
search.setProperty("variant", "primary")
|
|
search.clicked.connect(self._search)
|
|
date_row.addWidget(search)
|
|
layout.addLayout(date_row)
|
|
|
|
filter_row = QHBoxLayout()
|
|
filter_row.setSpacing(5)
|
|
self.status_filter_label = QLabel("挂号状态：")
|
|
self.status_filter_label.setObjectName("FilterRowLabel")
|
|
filter_row.addWidget(self.status_filter_label)
|
|
self.tab_bar = QTabBar()
|
|
self.tab_bar.setObjectName("AppointmentStatusTabs")
|
|
self._tab_indexes: dict[str | int, int] = {}
|
|
for label, value in STATUS_TABS:
|
|
index = self.tab_bar.addTab(label)
|
|
self.tab_bar.setTabData(index, value)
|
|
self._tab_indexes[value] = index
|
|
self.tab_bar.currentChanged.connect(self._tab_changed)
|
|
filter_row.addWidget(self.tab_bar)
|
|
|
|
self.filter_dividers: list[QLabel] = []
|
|
divider = QLabel("│")
|
|
divider.setObjectName("FilterDivider")
|
|
self.filter_dividers.append(divider)
|
|
filter_row.addWidget(divider)
|
|
|
|
self.confirm_filter_label = QLabel("确认状态：")
|
|
self.confirm_filter_label.setObjectName("FilterRowLabel")
|
|
filter_row.addWidget(self.confirm_filter_label)
|
|
self.confirmed_filter = QComboBox(frame)
|
|
self.confirmed_filter.addItem("全部", "")
|
|
self.confirmed_filter.addItem("已确认", "1")
|
|
self.confirmed_filter.addItem("未确认", "0")
|
|
self.confirmed_filter.hide()
|
|
self.confirmed_filter.currentIndexChanged.connect(self._confirmed_combo_changed)
|
|
self.confirmed_group = QButtonGroup(self)
|
|
self.confirmed_group.setExclusive(True)
|
|
self.confirmed_buttons: dict[str, QPushButton] = {}
|
|
for label, value in (("全部", ""), ("已确认", "1"), ("未确认", "0")):
|
|
button = QPushButton(label)
|
|
button.setCheckable(True)
|
|
button.setProperty("filterChoice", True)
|
|
button.clicked.connect(
|
|
lambda _checked=False, selected=value: self._set_confirmed_choice(selected)
|
|
)
|
|
self.confirmed_group.addButton(button)
|
|
self.confirmed_buttons[value] = button
|
|
filter_row.addWidget(button)
|
|
self.confirmed_buttons[""].setChecked(True)
|
|
|
|
divider = QLabel("│")
|
|
divider.setObjectName("FilterDivider")
|
|
self.filter_dividers.append(divider)
|
|
filter_row.addWidget(divider)
|
|
|
|
self.more_filters_button = QPushButton("更多筛选")
|
|
self.more_filters_button.setCheckable(True)
|
|
self.more_filters_button.setProperty("filterChoice", True)
|
|
self.more_filters_button.clicked.connect(self._toggle_advanced_filters)
|
|
filter_row.addWidget(self.more_filters_button)
|
|
|
|
self.dept_filter = QComboBox()
|
|
self.dept_filter.addItem("全部部门", "")
|
|
self.dept_filter.setMinimumWidth(150)
|
|
self.dept_filter.currentIndexChanged.connect(self._search)
|
|
self.dept_filter.hide()
|
|
filter_row.addWidget(self.dept_filter)
|
|
|
|
self.doctor_input = QLineEdit(frame)
|
|
self.doctor_input.setPlaceholderText("医生")
|
|
self.doctor_input.setClearButtonEnabled(True)
|
|
self.doctor_input.setMaximumWidth(120)
|
|
self.doctor_input.hide()
|
|
self.doctor_input.returnPressed.connect(self._search)
|
|
filter_row.addWidget(self.doctor_input)
|
|
filter_row.addStretch(1)
|
|
|
|
custom = QPushButton("自定义日期")
|
|
custom.setProperty("variant", "ghost")
|
|
custom.clicked.connect(self._open_custom_date)
|
|
custom.hide()
|
|
self.custom_date_button = custom
|
|
filter_row.addWidget(custom)
|
|
|
|
reset = QPushButton("重置")
|
|
reset.setProperty("variant", "ghost")
|
|
reset.clicked.connect(self._reset_filters)
|
|
reset.hide()
|
|
self.reset_filter_button = reset
|
|
filter_row.addWidget(reset)
|
|
layout.addLayout(filter_row)
|
|
return frame
|
|
|
|
def _build_content(self) -> QWidget:
|
|
host = QWidget()
|
|
host.setMinimumHeight(0)
|
|
layout = QHBoxLayout(host)
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
layout.setSpacing(4)
|
|
self.content_layout = layout
|
|
self.table_card = self._build_table_card()
|
|
layout.addWidget(self.table_card, 1)
|
|
return host
|
|
|
|
def _build_table_card(self) -> QWidget:
|
|
card = QFrame()
|
|
card.setObjectName("AppointmentMainCard")
|
|
card.setMinimumHeight(0)
|
|
layout = QVBoxLayout(card)
|
|
layout.setContentsMargins(4, 8, 8, 8)
|
|
layout.setSpacing(8)
|
|
|
|
compatibility_host = QWidget(card)
|
|
compatibility_host.hide()
|
|
compatibility_actions = QHBoxLayout(compatibility_host)
|
|
compatibility_actions.setContentsMargins(0, 0, 0, 0)
|
|
self.edit_button = self._action_button("编辑患者", "tcm.diagnosis/edit", self._edit_patient)
|
|
compatibility_actions.addWidget(self.edit_button)
|
|
self.qr_button = self._action_button(
|
|
"视频二维码", "tcm.diagnosis/videoQr", self._request_video_qr
|
|
)
|
|
compatibility_actions.addWidget(self.qr_button)
|
|
self.call_button = self._action_button(
|
|
"通话", "doctor.appointment/prescription", self._request_video
|
|
)
|
|
compatibility_actions.addWidget(self.call_button)
|
|
self.complete_button = self._action_button(
|
|
"完成", "doctor.appointment/complete", self._complete_selected
|
|
)
|
|
compatibility_actions.addWidget(self.complete_button)
|
|
self.prescription_button = self._action_button(
|
|
"开方", "tcm.diagnosis/kaifang", self._open_prescription
|
|
)
|
|
compatibility_actions.addWidget(self.prescription_button)
|
|
self.case_button = self._action_button("病历", "tcm.diagnosis/kaifang", self._view_case)
|
|
compatibility_actions.addWidget(self.case_button)
|
|
self.ai_button = QPushButton("AI 报告", compatibility_host)
|
|
self.ai_button.setProperty("variant", "secondary")
|
|
self.ai_button.setVisible(can_open_diagnosis_ai_report(self.permissions))
|
|
self.ai_button.setEnabled(False)
|
|
self.ai_button.clicked.connect(self._open_ai_report)
|
|
compatibility_actions.addWidget(self.ai_button)
|
|
self.cancel_button = self._action_button(
|
|
"取消挂号",
|
|
"doctor.appointment/cancel",
|
|
self._cancel_selected,
|
|
danger=True,
|
|
)
|
|
compatibility_actions.addWidget(self.cancel_button)
|
|
for index in range(compatibility_actions.count()):
|
|
widget = compatibility_actions.itemAt(index).widget()
|
|
if isinstance(widget, QPushButton):
|
|
widget.setProperty("compactAction", True)
|
|
|
|
actions = QHBoxLayout()
|
|
actions.setSpacing(6)
|
|
self.toolbar_edit_button = QPushButton("编辑患者", card)
|
|
self.toolbar_edit_button.setProperty("variant", "primary")
|
|
self.toolbar_edit_button.setProperty("compactAction", True)
|
|
self.toolbar_edit_button.setVisible(
|
|
_canonical_allowed(self.permissions, "tcm.diagnosis/edit", default=False)
|
|
)
|
|
self.toolbar_edit_button.setEnabled(False)
|
|
self.toolbar_edit_button.clicked.connect(self._edit_patient)
|
|
actions.addWidget(self.toolbar_edit_button)
|
|
self.toolbar_qr_button = QPushButton("视频二维码", card)
|
|
self.toolbar_qr_button.setProperty("variant", "secondary")
|
|
self.toolbar_qr_button.setProperty("compactAction", True)
|
|
self.toolbar_qr_button.setVisible(
|
|
_canonical_allowed(self.permissions, "tcm.diagnosis/videoQr", default=False)
|
|
)
|
|
self.toolbar_qr_button.setEnabled(False)
|
|
self.toolbar_qr_button.clicked.connect(self._request_video_qr)
|
|
actions.addWidget(self.toolbar_qr_button)
|
|
self.toolbar_ai_consult_button = QPushButton("AI 分析", card)
|
|
self.toolbar_ai_consult_button.setProperty("variant", "secondary")
|
|
self.toolbar_ai_consult_button.setProperty("compactAction", True)
|
|
self.toolbar_ai_consult_button.setVisible(can_open_ai_consult(self.permissions))
|
|
self.toolbar_ai_consult_button.setEnabled(False)
|
|
self.toolbar_ai_consult_button.clicked.connect(self._open_ai_consult)
|
|
actions.addWidget(self.toolbar_ai_consult_button)
|
|
self.toolbar_cancel_button = QPushButton("取消挂号", card)
|
|
self.toolbar_cancel_button.setProperty("variant", "danger")
|
|
self.toolbar_cancel_button.setProperty("compactAction", True)
|
|
self.toolbar_cancel_button.setVisible(
|
|
_canonical_allowed(self.permissions, "doctor.appointment/cancel", default=False)
|
|
)
|
|
self.toolbar_cancel_button.setEnabled(False)
|
|
self.toolbar_cancel_button.clicked.connect(self._cancel_selected)
|
|
actions.addWidget(self.toolbar_cancel_button)
|
|
actions.addStretch(1)
|
|
refresh = QPushButton("刷新", card)
|
|
refresh.setProperty("variant", "ghost")
|
|
refresh.setProperty("compactAction", True)
|
|
refresh.clicked.connect(lambda: self.refresh())
|
|
actions.addWidget(refresh)
|
|
layout.addLayout(actions)
|
|
|
|
self.table = SortableTable(
|
|
[
|
|
TableColumn("_selected", "", 36, alignment=Qt.AlignmentFlag.AlignCenter),
|
|
TableColumn("id", "ID", 66),
|
|
TableColumn(
|
|
"patient_name",
|
|
"患者",
|
|
100,
|
|
),
|
|
TableColumn("gender", "性别 / 年龄", 98, formatter=_gender_age_cell),
|
|
TableColumn("appointment_date", "挂号信息", 202, formatter=_appointment_info_cell),
|
|
TableColumn("diagnosis_confirmed", "确认", 90, formatter=_confirmed_cell),
|
|
TableColumn("revisit_time", "复诊", 100, formatter=_revisit_cell),
|
|
TableColumn("assistant_name", "助理", 110),
|
|
TableColumn("has_prescription", "开方", 108, formatter=_prescription_cell),
|
|
TableColumn("unserved_days", "未服务天数", 112, formatter=_unserved_cell),
|
|
TableColumn(
|
|
"_im_consult",
|
|
"IM 问诊",
|
|
104,
|
|
alignment=Qt.AlignmentFlag.AlignCenter,
|
|
),
|
|
]
|
|
)
|
|
self.table.setObjectName("AppointmentTable")
|
|
self.table.setMinimumHeight(0)
|
|
self.table.setWordWrap(True)
|
|
self.table.setVerticalScrollMode(QAbstractItemView.ScrollMode.ScrollPerPixel)
|
|
header = self.table.horizontalHeader()
|
|
header.setFixedHeight(34)
|
|
header.setStretchLastSection(False)
|
|
header.setSectionResizeMode(4, QHeaderView.ResizeMode.Stretch)
|
|
header.setSectionResizeMode(10, QHeaderView.ResizeMode.Fixed)
|
|
self.table.verticalHeader().setDefaultSectionSize(60)
|
|
self.table.itemSelectionChanged.connect(self._selection_changed)
|
|
self.table.itemDoubleClicked.connect(lambda _item: self._open_detail())
|
|
layout.addWidget(self.table, 1)
|
|
self.pager = Pager(self._page_size)
|
|
self.pager.setMaximumHeight(38)
|
|
self.pager.page_changed.connect(self._page_changed)
|
|
layout.addWidget(self.pager)
|
|
return card
|
|
|
|
def _apply_responsive_layout(self) -> None:
|
|
"""Collapse only the date filters when horizontal space is limited."""
|
|
|
|
narrow = self.width() < 1120
|
|
for preset in ("yesterday", "day_before", "tomorrow", "day_after"):
|
|
self.date_buttons[preset].setVisible(not narrow)
|
|
self.date_overflow_button.setVisible(narrow)
|
|
self.status_filter_label.setVisible(not narrow)
|
|
self.confirm_filter_label.setVisible(not narrow)
|
|
self._responsive_narrow = narrow
|
|
|
|
def resizeEvent(self, event: Any) -> None:
|
|
super().resizeEvent(event)
|
|
self._apply_responsive_layout()
|
|
|
|
def _run_video_row_action(self, row: Any, callback: Any) -> None:
|
|
appointment_id = _appointment_id(row)
|
|
for row_index in range(self.table.rowCount()):
|
|
cell = self.table.item(row_index, 0)
|
|
if (
|
|
cell is not None
|
|
and _appointment_id(cell.data(Qt.ItemDataRole.UserRole)) == appointment_id
|
|
):
|
|
self.table.selectRow(row_index)
|
|
break
|
|
callback()
|
|
|
|
def _action_button(
|
|
self,
|
|
label: str,
|
|
permission: str,
|
|
slot: Any,
|
|
*,
|
|
danger: bool = False,
|
|
) -> QPushButton:
|
|
# Permission visibility is evaluated before the toolbar layout adopts
|
|
# the button. Give it a real owner up front so setVisible(True) cannot
|
|
# create a transient top-level HWND on Windows.
|
|
button = QPushButton(label, self)
|
|
button.setProperty("variant", "danger" if danger else "secondary")
|
|
button.setVisible(_canonical_allowed(self.permissions, permission, default=False))
|
|
button.setEnabled(False)
|
|
button.clicked.connect(slot)
|
|
button.setProperty("permission", permission)
|
|
return button
|
|
|
|
def _set_status_from_stat(self, status: int) -> None:
|
|
index = self._tab_indexes.get(status)
|
|
if index is not None:
|
|
self.tab_bar.setCurrentIndex(index)
|
|
return
|
|
self._status = status
|
|
self._page = 1
|
|
self.refresh()
|
|
|
|
def _toggle_unassigned_filter(self, checked: bool) -> None:
|
|
self._assistant_unassigned = bool(checked)
|
|
self._page = 1
|
|
self.refresh()
|
|
|
|
def _set_confirmed_choice(self, value: str) -> None:
|
|
index = self.confirmed_filter.findData(value)
|
|
self.confirmed_filter.setCurrentIndex(max(0, index))
|
|
|
|
def _confirmed_combo_changed(self, _index: int = 0) -> None:
|
|
value = str(self.confirmed_filter.currentData() or "")
|
|
for key, button in self.confirmed_buttons.items():
|
|
button.setChecked(key == value)
|
|
self._search()
|
|
|
|
def _toggle_advanced_filters(self, checked: bool) -> None:
|
|
self.dept_filter.setVisible(checked)
|
|
self.doctor_input.setVisible(checked and self._is_admin)
|
|
self.custom_date_button.setVisible(checked)
|
|
self.reset_filter_button.setVisible(checked)
|
|
|
|
def _tab_changed(self, index: int) -> None:
|
|
if index < 0:
|
|
return
|
|
value = self.tab_bar.tabData(index)
|
|
self._status = "all" if value == "all" else _as_int(value, 1)
|
|
self._page = 1
|
|
self.refresh()
|
|
|
|
def _set_date_preset(self, preset: str) -> None:
|
|
self._date_preset = preset
|
|
for key, button in self.date_buttons.items():
|
|
button.setChecked(key == preset)
|
|
overflow_labels = {
|
|
"yesterday": "昨天",
|
|
"day_before": "前天",
|
|
"tomorrow": "明天",
|
|
"day_after": "后天",
|
|
}
|
|
self.date_overflow_button.setText(overflow_labels.get(preset, "日期"))
|
|
target = _offset_date(preset)
|
|
if target is None:
|
|
self._start_date = ""
|
|
self._end_date = ""
|
|
else:
|
|
text = target.isoformat()
|
|
self._start_date = text
|
|
self._end_date = text
|
|
self._page = 1
|
|
self.refresh()
|
|
|
|
def _open_custom_date(self) -> None:
|
|
dialog = QDialog(self)
|
|
dialog.setWindowTitle("自定义日期")
|
|
dialog.resize(440, 300)
|
|
layout = QVBoxLayout(dialog)
|
|
layout.setContentsMargins(24, 22, 24, 18)
|
|
layout.setSpacing(12)
|
|
title = QLabel("自定义日期")
|
|
title.setProperty("dialogRole", "title")
|
|
layout.addWidget(title)
|
|
start = QDateEdit(
|
|
QDate.fromString(self._start_date or date.today().isoformat(), "yyyy-MM-dd")
|
|
)
|
|
start.setCalendarPopup(True)
|
|
start.setDisplayFormat("yyyy-MM-dd")
|
|
end = QDateEdit(QDate.fromString(self._end_date or date.today().isoformat(), "yyyy-MM-dd"))
|
|
end.setCalendarPopup(True)
|
|
end.setDisplayFormat("yyyy-MM-dd")
|
|
layout.addWidget(QLabel("开始日期"))
|
|
layout.addWidget(start)
|
|
layout.addWidget(QLabel("结束日期"))
|
|
layout.addWidget(end)
|
|
buttons = QDialogButtonBox(
|
|
QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
|
|
)
|
|
primary_button = buttons.button(QDialogButtonBox.StandardButton.Ok)
|
|
primary_button.setText("应用日期")
|
|
primary_button.setProperty("variant", "primary")
|
|
buttons.button(QDialogButtonBox.StandardButton.Cancel).setText("取消")
|
|
buttons.accepted.connect(dialog.accept)
|
|
buttons.rejected.connect(dialog.reject)
|
|
layout.addWidget(buttons)
|
|
mark_business_dialog(dialog, "AppointmentCustomDateDialog")
|
|
if dialog.exec() != QDialog.DialogCode.Accepted:
|
|
return
|
|
start_date = start.date().toString("yyyy-MM-dd")
|
|
end_date = end.date().toString("yyyy-MM-dd")
|
|
if start_date > end_date:
|
|
show_toast(self, "开始日期不能晚于结束日期。", "warning")
|
|
return
|
|
self._date_preset = ""
|
|
for button in self.date_buttons.values():
|
|
button.setChecked(False)
|
|
self.date_buttons[""].setChecked(True)
|
|
self.date_overflow_button.setText("自定义")
|
|
self._start_date = start_date
|
|
self._end_date = end_date
|
|
self._page = 1
|
|
self.refresh()
|
|
|
|
def _search(self) -> None:
|
|
self._page = 1
|
|
self.refresh()
|
|
|
|
def _reset_filters(self) -> None:
|
|
self.patient_input.clear()
|
|
self.doctor_input.clear()
|
|
self._assistant_unassigned = False
|
|
self.unassigned_stat_button.setChecked(False)
|
|
self.confirmed_filter.setCurrentIndex(0)
|
|
self.dept_filter.setCurrentIndex(0)
|
|
self._status = 1
|
|
index = self._tab_indexes.get(1, 0)
|
|
self.tab_bar.blockSignals(True)
|
|
self.tab_bar.setCurrentIndex(index)
|
|
self.tab_bar.blockSignals(False)
|
|
self._set_date_preset("today")
|
|
|
|
def _page_changed(self, page: int) -> None:
|
|
self._page = max(1, page)
|
|
self.refresh()
|
|
|
|
def _query_filters(self) -> dict[str, Any]:
|
|
filters: dict[str, Any] = {
|
|
"include_status_counts": 1,
|
|
"patient_name": self.patient_input.text().strip(),
|
|
}
|
|
if self._status != "all":
|
|
filters["status"] = self._status
|
|
if self._start_date:
|
|
filters["start_date"] = self._start_date
|
|
if self._end_date:
|
|
filters["end_date"] = self._end_date
|
|
if not self._start_date and not self._end_date:
|
|
filters["diag_scope_relax"] = 1
|
|
confirmed = self.confirmed_filter.currentData()
|
|
if confirmed not in (None, ""):
|
|
filters["diagnosis_confirmed"] = confirmed
|
|
dept_id = self.dept_filter.currentData()
|
|
if dept_id not in (None, ""):
|
|
filters["assistant_dept_id"] = dept_id
|
|
if self._is_admin:
|
|
doctor_name = self.doctor_input.text().strip()
|
|
if doctor_name:
|
|
filters["doctor_name"] = doctor_name
|
|
if self._assistant_unassigned:
|
|
filters["assistant_unassigned"] = 1
|
|
return filters
|
|
|
|
def refresh(self, *, silent: bool = False) -> None:
|
|
if self._loading and not silent:
|
|
return
|
|
self._generation += 1
|
|
generation = self._generation
|
|
self._loading = True
|
|
if not silent:
|
|
self.banner.show_message("正在加载挂号列表…", "info")
|
|
filters = self._query_filters()
|
|
page = self._page
|
|
page_size = self._page_size
|
|
run_async(
|
|
lambda: invoke(
|
|
self.repository,
|
|
"list_appointments",
|
|
page_no=page,
|
|
page_size=page_size,
|
|
**filters,
|
|
),
|
|
on_success=lambda result: self._loaded(result, generation, silent),
|
|
on_error=lambda error: self._load_error(error, generation, silent),
|
|
on_finished=lambda: self._load_finished(generation),
|
|
)
|
|
|
|
def _loaded(self, result: Any, generation: int, silent: bool) -> None:
|
|
if generation != self._generation:
|
|
return
|
|
rows = page_items(result)
|
|
total = page_total(result)
|
|
extend = get_value(result, "extend", {}) or {}
|
|
signature = (
|
|
self._page,
|
|
_stable_signature_value(self._query_filters()),
|
|
*_appointment_result_signature(rows, total, extend),
|
|
)
|
|
if signature == self._last_render_signature:
|
|
if not silent:
|
|
self.banner.clear()
|
|
return
|
|
self._last_render_signature = signature
|
|
status_count = get_value(extend, "status_count", {}) or {}
|
|
if isinstance(status_count, Mapping):
|
|
for key in (1, 2, 3, 4):
|
|
value = status_count.get(key, status_count.get(str(key)))
|
|
if isinstance(value, (int, float)):
|
|
self._status_counts[key] = int(value)
|
|
self._update_tab_badges()
|
|
self._update_stat_chips(rows, total, extend)
|
|
self.table.set_rows(rows)
|
|
self._install_table_selectors()
|
|
self._install_appointment_info_cells()
|
|
self._install_im_consult_actions()
|
|
self._fit_table_rows()
|
|
for row_index in range(self.table.rowCount()):
|
|
source_item = self.table.item(row_index, 0)
|
|
source = source_item.data(Qt.ItemDataRole.UserRole) if source_item is not None else None
|
|
confirmed_kind = (
|
|
"success"
|
|
if _as_bool(first_value(source, "diagnosis_confirmed", default=False))
|
|
else "warning"
|
|
)
|
|
prescription_kind = (
|
|
"success"
|
|
if _as_bool(first_value(source, "has_prescription", default=False))
|
|
else "muted"
|
|
)
|
|
for column, kind in (
|
|
(5, confirmed_kind),
|
|
(8, prescription_kind),
|
|
):
|
|
item = self.table.item(row_index, column)
|
|
if item is not None:
|
|
item.setForeground(QBrush(QColor(_SEMANTIC_COLORS[kind])))
|
|
self.pager.update_state(self._page, total)
|
|
if not silent:
|
|
self.banner.clear()
|
|
if rows and self.table.currentRow() < 0:
|
|
self.table.selectRow(0)
|
|
self._selection_changed()
|
|
|
|
def _update_stat_chips(
|
|
self,
|
|
rows: Sequence[Any],
|
|
total: int,
|
|
extend: Any,
|
|
) -> None:
|
|
date_counts = first_value(extend, "date_counts", "date_count", default={})
|
|
if not isinstance(date_counts, Mapping):
|
|
date_counts = {}
|
|
visible_dates: dict[str, int] = {}
|
|
for row in rows:
|
|
key = str(first_value(row, "appointment_date", default="") or "")
|
|
if key:
|
|
visible_dates[key] = visible_dates.get(key, 0) + 1
|
|
for preset, button in self.date_buttons.items():
|
|
label = self._date_stat_labels[preset]
|
|
if preset == "":
|
|
count = total
|
|
else:
|
|
target = _offset_date(preset)
|
|
date_key = target.isoformat() if target is not None else ""
|
|
raw = date_counts.get(
|
|
preset,
|
|
date_counts.get(date_key, visible_dates.get(date_key, 0)),
|
|
)
|
|
count = _as_int(raw)
|
|
button.setText(f"{label} {count}")
|
|
self.pending_stat_button.setText(f"待预约 {self._status_counts.get(1, 0)}")
|
|
self.completed_stat_button.setText(f"已完成 {self._status_counts.get(3, 0)}")
|
|
unassigned = first_value(
|
|
extend,
|
|
"unassigned_count",
|
|
"assistant_unassigned_count",
|
|
default=None,
|
|
)
|
|
if unassigned is None:
|
|
unassigned = sum(
|
|
1
|
|
for row in rows
|
|
if _as_int(first_value(row, "assistant_id", default=0)) <= 0
|
|
and not str(first_value(row, "assistant_name", default="") or "").strip()
|
|
)
|
|
unassigned_count = _as_int(unassigned)
|
|
self.unassigned_stat_button.setText(f"待分配医助 {unassigned_count}")
|
|
# 只有真的有待办时才点亮，避免筛选栏常态就是一排彩色。
|
|
self.unassigned_stat_button.setProperty("hasPending", unassigned_count > 0)
|
|
style = self.unassigned_stat_button.style()
|
|
style.unpolish(self.unassigned_stat_button)
|
|
style.polish(self.unassigned_stat_button)
|
|
|
|
def _install_table_selectors(self) -> None:
|
|
for row_index in range(self.table.rowCount()):
|
|
host = QWidget(self.table)
|
|
layout = QHBoxLayout(host)
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
selector = QCheckBox(host)
|
|
selector.setProperty("appointmentSelector", True)
|
|
selector.setToolTip("选择患者")
|
|
selector.clicked.connect(
|
|
lambda checked=False, index=row_index: (
|
|
self.table.selectRow(index) if checked else None
|
|
)
|
|
)
|
|
layout.addWidget(selector)
|
|
self.table.setCellWidget(row_index, 0, host)
|
|
item = self.table.item(row_index, 0)
|
|
if item is not None:
|
|
item.setText("")
|
|
|
|
def _install_appointment_info_cells(self) -> None:
|
|
for row_index in range(self.table.rowCount()):
|
|
source_item = self.table.item(row_index, 0)
|
|
row = source_item.data(Qt.ItemDataRole.UserRole) if source_item is not None else None
|
|
host = QWidget(self.table)
|
|
host.setProperty("appointmentInfoHost", True)
|
|
host.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
|
|
layout = QVBoxLayout(host)
|
|
layout.setContentsMargins(7, 4, 5, 3)
|
|
layout.setSpacing(1)
|
|
heading = QHBoxLayout()
|
|
heading.setContentsMargins(0, 0, 0, 0)
|
|
heading.setSpacing(5)
|
|
status_text = _status_cell(None, row)
|
|
status = QLabel(status_text, host)
|
|
status.setProperty("tableAppointmentStatus", True)
|
|
status.setProperty(
|
|
"tableAppointmentStatusKind",
|
|
"warning" if "挂号" in status_text or _status_value(row) == 1 else "primary",
|
|
)
|
|
heading.addWidget(status)
|
|
doctor = QLabel(display_text(first_value(row, "doctor_name"), "未分配"), host)
|
|
heading.addWidget(doctor)
|
|
heading.addStretch(1)
|
|
if _status_value(row) == 1 and _canonical_allowed(
|
|
self.permissions, "doctor.appointment/cancel", default=False
|
|
):
|
|
cancel = QPushButton("取消", host)
|
|
cancel.setProperty("tableCancelAction", True)
|
|
cancel.clicked.connect(
|
|
lambda _checked=False, source=row: self._run_video_row_action(
|
|
source, self._cancel_selected
|
|
)
|
|
)
|
|
heading.addWidget(cancel)
|
|
layout.addLayout(heading)
|
|
date_label = QLabel(
|
|
f"{display_text(first_value(row, 'appointment_date'), '—')} "
|
|
f"{display_text(first_value(row, 'appointment_time'), '—')}",
|
|
host,
|
|
)
|
|
date_label.setProperty("tableAppointmentMeta", True)
|
|
layout.addWidget(date_label)
|
|
channel = display_text(
|
|
first_value(row, "channel_name", "channel_source_name", "source_name"),
|
|
"—",
|
|
)
|
|
channel_label = QLabel(f"最近渠道：{channel}", host)
|
|
channel_label.setProperty("tableAppointmentMeta", True)
|
|
layout.addWidget(channel_label)
|
|
self.table.setCellWidget(row_index, 4, host)
|
|
patient = self.table.item(row_index, 2)
|
|
if patient is not None:
|
|
font = patient.font()
|
|
font.setBold(True)
|
|
patient.setFont(font)
|
|
|
|
def _install_im_consult_actions(self) -> None:
|
|
"""Render a doctor-initiated IM entry for every appointment row."""
|
|
|
|
action_column = 10
|
|
has_permission = _canonical_allowed(
|
|
self.permissions,
|
|
"doctor.appointment/prescription",
|
|
default=False,
|
|
)
|
|
for row_index in range(self.table.rowCount()):
|
|
source_item = self.table.item(row_index, 0)
|
|
row = source_item.data(Qt.ItemDataRole.UserRole) if source_item is not None else None
|
|
host = QWidget(self.table)
|
|
host.setProperty("appointmentImHost", True)
|
|
host.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
|
|
layout = QHBoxLayout(host)
|
|
layout.setContentsMargins(5, 0, 5, 0)
|
|
layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
|
|
button = QPushButton("IM 问诊", host)
|
|
button.setObjectName("AppointmentImConsultButton")
|
|
button.setProperty("appointmentImAction", True)
|
|
patient_name = display_text(first_value(row, "patient_name"), "患者")
|
|
button.setAccessibleName(f"与{patient_name}进行 IM 问诊")
|
|
|
|
identifiers_ready = (
|
|
_appointment_id(row) > 0
|
|
and _diagnosis_id(row) > 0
|
|
and _video_patient_id(row) > 0
|
|
)
|
|
status_error = _im_consult_status_error(row)
|
|
enabled = (
|
|
has_permission
|
|
and self._native_video_capable
|
|
and identifiers_ready
|
|
and not status_error
|
|
)
|
|
button.setEnabled(enabled)
|
|
if not has_permission:
|
|
tooltip = "当前账号无 IM 问诊权限"
|
|
elif not self._native_video_capable:
|
|
tooltip = "当前工作站未配置完整的视频问诊能力"
|
|
elif not identifiers_ready:
|
|
tooltip = "患者、诊单或挂号标识不完整"
|
|
elif status_error:
|
|
tooltip = status_error
|
|
else:
|
|
tooltip = "打开患者 IM，可发送消息并从会话中发起视频"
|
|
button.setToolTip(tooltip)
|
|
button.clicked.connect(
|
|
lambda _checked=False, source=row: self._run_video_row_action(
|
|
source,
|
|
self._request_video,
|
|
)
|
|
)
|
|
layout.addWidget(button)
|
|
self.table.setCellWidget(row_index, action_column, host)
|
|
item = self.table.item(row_index, action_column)
|
|
if item is not None:
|
|
item.setText("")
|
|
|
|
def _fit_table_rows(self) -> None:
|
|
"""Give each appointment row enough height for its real line count."""
|
|
|
|
line_height = max(16, self.table.fontMetrics().lineSpacing())
|
|
for row_index in range(self.table.rowCount()):
|
|
line_count = max(
|
|
(
|
|
(item.text().count("\n") + 1)
|
|
for column in range(self.table.columnCount())
|
|
if (item := self.table.item(row_index, column)) is not None
|
|
),
|
|
default=1,
|
|
)
|
|
height = line_count * line_height + TABLE_CELL_VERTICAL_PADDING
|
|
self.table.setRowHeight(row_index, max(60, min(66, height)))
|
|
|
|
def _load_error(self, error: Exception, generation: int, silent: bool) -> None:
|
|
if generation != self._generation:
|
|
return
|
|
if silent:
|
|
return
|
|
self.banner.show_message(friendly_error(error), "danger")
|
|
|
|
def _load_finished(self, generation: int) -> None:
|
|
if generation == self._generation:
|
|
self._loading = False
|
|
|
|
def _update_tab_badges(self) -> None:
|
|
for label, value in STATUS_TABS:
|
|
index = self._tab_indexes.get(value)
|
|
if index is None:
|
|
continue
|
|
if value == "all":
|
|
self.tab_bar.setTabText(index, label)
|
|
continue
|
|
count = self._status_counts.get(_as_int(value), 0)
|
|
text = f"{label} ({count})" if count else label
|
|
self.tab_bar.setTabText(index, text)
|
|
|
|
def _selection_changed(self) -> None:
|
|
row = self.table.current_data()
|
|
has_row = row is not None
|
|
status = _status_value(row) if has_row else 0
|
|
not_completed = has_row and status != 3
|
|
self.edit_button.setEnabled(has_row and _diagnosis_id(row) > 0)
|
|
self.qr_button.setEnabled(
|
|
not_completed
|
|
and _video_patient_id(row) > 0
|
|
and _as_int(first_value(row, "doctor_id", default=0)) > 0
|
|
)
|
|
self.call_button.setEnabled(
|
|
has_row
|
|
and not _im_consult_status_error(row)
|
|
and self._native_video_capable
|
|
and _appointment_id(row) > 0
|
|
and _diagnosis_id(row) > 0
|
|
and _video_patient_id(row) > 0
|
|
)
|
|
self.complete_button.setEnabled(not_completed and _appointment_id(row) > 0)
|
|
self.prescription_button.setEnabled(has_row and _diagnosis_id(row) > 0)
|
|
self.prescription_button.setText(prescription_action_label(row) if has_row else "开方")
|
|
self.case_button.setEnabled(has_row and _appointment_id(row) > 0)
|
|
self.ai_button.setEnabled(has_row and _diagnosis_id(row) > 0)
|
|
self.toolbar_ai_consult_button.setEnabled(
|
|
has_row and can_open_ai_consult(self.permissions) and _diagnosis_id(row) > 0
|
|
)
|
|
self.cancel_button.setEnabled(has_row and status == 1)
|
|
self.toolbar_edit_button.setEnabled(has_row and _diagnosis_id(row) > 0)
|
|
self.toolbar_qr_button.setEnabled(
|
|
not_completed
|
|
and _video_patient_id(row) > 0
|
|
and _as_int(first_value(row, "doctor_id", default=0)) > 0
|
|
)
|
|
self.toolbar_cancel_button.setEnabled(has_row and status == 1)
|
|
|
|
def _current_row(self) -> Any | None:
|
|
return self.table.current_data()
|
|
|
|
def _edit_patient(self) -> None:
|
|
if not _canonical_allowed(self.permissions, "tcm.diagnosis/edit", default=False):
|
|
return
|
|
row = self._current_row()
|
|
diagnosis_id = _diagnosis_id(row)
|
|
if diagnosis_id <= 0:
|
|
show_toast(self, "该预约没有关联诊单信息。", "warning")
|
|
return
|
|
self._diagnosis_dialog().open_for(diagnosis_id, editable=True, seed=row)
|
|
|
|
def _open_ai_report(self) -> None:
|
|
if not can_open_diagnosis_ai_report(self.permissions):
|
|
show_toast(self, "当前账号没有查看 AI 报告权限。", "warning")
|
|
return
|
|
row = self._current_row()
|
|
diagnosis_id = _diagnosis_id(row)
|
|
if diagnosis_id <= 0:
|
|
show_toast(self, "该预约没有关联诊单信息。", "warning")
|
|
return
|
|
payload = dict(row) if isinstance(row, Mapping) else {}
|
|
payload.update(
|
|
{
|
|
"id": diagnosis_id,
|
|
"diagnosis_id": diagnosis_id,
|
|
"patient_name": first_value(row, "patient_name", default="患者"),
|
|
}
|
|
)
|
|
present_diagnosis_ai_report(self.repository, self.permissions, self, payload)
|
|
|
|
def open_selected_ai_consult(self) -> bool:
|
|
"""Open the diagnosis-scoped assistant for the selected appointment."""
|
|
|
|
row = self._current_row()
|
|
diagnosis_id = _diagnosis_id(row)
|
|
if (
|
|
row is None
|
|
or diagnosis_id <= 0
|
|
or not can_open_ai_consult(self.permissions)
|
|
):
|
|
return False
|
|
present_ai_consult(
|
|
self.repository,
|
|
self.permissions,
|
|
self,
|
|
diagnosis_id=diagnosis_id,
|
|
patient_id=_video_patient_id(row),
|
|
seed=row,
|
|
source_title="问诊列表",
|
|
)
|
|
return True
|
|
|
|
def _open_ai_consult(self) -> None:
|
|
if not self.open_selected_ai_consult():
|
|
show_toast(self, "请先选择一条有关联诊单的问诊记录。", "warning")
|
|
|
|
def _request_video(self) -> None:
|
|
if not _canonical_allowed(
|
|
self.permissions, "doctor.appointment/prescription", default=False
|
|
):
|
|
return
|
|
if not self._native_video_capable:
|
|
show_toast(self, "当前工作站未配置完整的视频问诊能力。", "warning")
|
|
return
|
|
row = self._current_row()
|
|
if row is None:
|
|
return
|
|
status_error = _im_consult_status_error(row)
|
|
if status_error:
|
|
show_toast(self, f"{status_error}。", "warning")
|
|
return
|
|
appointment_id = _appointment_id(row)
|
|
diagnosis_id = _diagnosis_id(row)
|
|
patient_id = _video_patient_id(row)
|
|
if appointment_id <= 0 or diagnosis_id <= 0 or patient_id <= 0:
|
|
show_toast(self, "患者、诊单或挂号标识不完整，无法进入 IM 问诊。", "warning")
|
|
return
|
|
self.video_requested.emit(
|
|
{
|
|
"source": "appointments",
|
|
"appointment_id": appointment_id,
|
|
"patient_id": patient_id,
|
|
"diagnosis_id": diagnosis_id,
|
|
"patient_name": first_value(row, "patient_name", default="患者"),
|
|
# Open IM first. The doctor explicitly starts video from the
|
|
# conversation instead of requiring an already-live call.
|
|
"mode": "im",
|
|
"record": row,
|
|
}
|
|
)
|
|
|
|
def _request_video_qr(self) -> None:
|
|
if not _canonical_allowed(self.permissions, "tcm.diagnosis/videoQr", default=False):
|
|
return
|
|
required_methods = (
|
|
"get_mini_program_config",
|
|
"generate_video_qrcode",
|
|
"download_public_image",
|
|
)
|
|
if not all(callable(getattr(self.repository, name, None)) for name in required_methods):
|
|
show_toast(self, "当前仓库未提供视频二维码能力。", "warning")
|
|
return
|
|
row = self._current_row()
|
|
if row is None or _status_value(row) == 3:
|
|
return
|
|
diagnosis_id = _diagnosis_id(row)
|
|
patient_id = _video_patient_id(row)
|
|
doctor_id = _as_int(first_value(row, "doctor_id", default=0))
|
|
share_user_id = _as_int(first_value(self.current_user, "id", default=0))
|
|
if diagnosis_id <= 0 or patient_id <= 0 or doctor_id <= 0 or share_user_id <= 0:
|
|
show_toast(self, "患者或不完整的医生/用户标识，无法生成二维码。", "warning")
|
|
return
|
|
snapshot = deepcopy(row)
|
|
self._action_generation += 1
|
|
generation = self._action_generation
|
|
self.banner.show_message("正在生成视频二维码…", "info")
|
|
|
|
def _worker() -> dict[str, Any]:
|
|
config = invoke(self.repository, "get_mini_program_config")
|
|
if not str(first_value(config, "app_id", default="") or "").strip():
|
|
raise ValueError("小程序未配置，请先在管理后台配置小程序信息")
|
|
generated = invoke(
|
|
self.repository,
|
|
"generate_video_qrcode",
|
|
diagnosis_id=diagnosis_id,
|
|
doctor_id=doctor_id,
|
|
patient_id=patient_id,
|
|
share_user_id=share_user_id,
|
|
)
|
|
if not isinstance(generated, Mapping):
|
|
raise ValueError("服务器未返回有效的二维码结果")
|
|
result = dict(generated)
|
|
url = str(result.get("qrcode_url") or "").strip()
|
|
if not url:
|
|
raise ValueError("服务器未返回可用的二维码地址")
|
|
try:
|
|
result["_image_bytes"] = invoke(self.repository, "download_public_image", url=url)
|
|
except Exception as exc:
|
|
result["_image_error"] = friendly_error(exc)
|
|
return result
|
|
|
|
run_async(
|
|
_worker,
|
|
on_success=lambda result: self._show_qr(snapshot, result, generation),
|
|
on_error=lambda error: self._action_error(error, generation),
|
|
)
|
|
|
|
def _show_qr(self, row: Any, result: Any, generation: int) -> None:
|
|
if generation != self._action_generation:
|
|
return
|
|
url = str(first_value(result, "qrcode_url", default="") or "").strip()
|
|
if not url:
|
|
self.banner.show_message("服务器未返回可用的二维码地址。", "danger")
|
|
return
|
|
self.banner.clear()
|
|
dialog = self._build_qr_dialog(row, url, result)
|
|
dialog.exec()
|
|
|
|
def _build_qr_dialog(self, row: Any, url: str, result: Any) -> QDialog:
|
|
"""Build an in-app QR preview with external-open and retry fallbacks."""
|
|
|
|
dialog = QDialog(self)
|
|
dialog.setWindowTitle("小程序二维码")
|
|
dialog.setObjectName("VideoQrDialog")
|
|
dialog.resize(470, 590)
|
|
layout = QVBoxLayout(dialog)
|
|
layout.setContentsMargins(24, 22, 24, 18)
|
|
layout.setSpacing(12)
|
|
title = QLabel("视频问诊二维码")
|
|
title.setProperty("dialogRole", "title")
|
|
title.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
layout.addWidget(title)
|
|
message = QLabel(
|
|
f"患者：{display_text(first_value(row, 'patient_name'), '患者')}\n"
|
|
"请使用微信扫描下方二维码进入视频问诊"
|
|
)
|
|
message.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
layout.addWidget(message)
|
|
|
|
image_label = QLabel()
|
|
image_label.setObjectName("VideoQrImage")
|
|
image_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
image_label.setWordWrap(True)
|
|
image_label.setFixedSize(300, 300)
|
|
image_bytes = first_value(result, "_image_bytes", default=b"")
|
|
pixmap = QPixmap()
|
|
loaded = isinstance(image_bytes, (bytes, bytearray)) and pixmap.loadFromData(
|
|
bytes(image_bytes)
|
|
)
|
|
if loaded:
|
|
image_label.setPixmap(
|
|
pixmap.scaled(
|
|
280,
|
|
280,
|
|
Qt.AspectRatioMode.KeepAspectRatio,
|
|
Qt.TransformationMode.SmoothTransformation,
|
|
)
|
|
)
|
|
else:
|
|
reason = str(first_value(result, "_image_error", default="") or "").strip()
|
|
image_label.setText(
|
|
"二维码图片加载失败\n请重新生成或在浏览器中打开" + (f"\n{reason}" if reason else "")
|
|
)
|
|
image_row = QHBoxLayout()
|
|
image_row.addStretch(1)
|
|
image_row.addWidget(image_label)
|
|
image_row.addStretch(1)
|
|
layout.addLayout(image_row)
|
|
|
|
link = QLabel(f'<a href="{escape(url, quote=True)}">打开服务器二维码</a>')
|
|
link.setOpenExternalLinks(True)
|
|
link.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
layout.addWidget(link)
|
|
field = QLineEdit(url)
|
|
field.setObjectName("VideoQrUrl")
|
|
field.setReadOnly(True)
|
|
layout.addWidget(field)
|
|
buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
|
|
retry_button = buttons.addButton("重新生成", QDialogButtonBox.ButtonRole.ActionRole)
|
|
open_button = buttons.addButton("浏览器打开", QDialogButtonBox.ButtonRole.ActionRole)
|
|
retry_button.setProperty("variant", "secondary")
|
|
open_button.setProperty("variant", "primary")
|
|
open_button.clicked.connect(lambda: QDesktopServices.openUrl(QUrl.fromUserInput(url)))
|
|
retry_button.clicked.connect(dialog.accept)
|
|
retry_button.clicked.connect(lambda: QTimer.singleShot(0, self._request_video_qr))
|
|
buttons.button(QDialogButtonBox.StandardButton.Close).setText("关闭")
|
|
buttons.rejected.connect(dialog.reject)
|
|
layout.addWidget(buttons)
|
|
mark_business_dialog(dialog, "VideoQrDialog")
|
|
for button in (retry_button, open_button):
|
|
button.style().unpolish(button)
|
|
button.style().polish(button)
|
|
return dialog
|
|
|
|
def _complete_selected(self) -> None:
|
|
if not _canonical_allowed(self.permissions, "doctor.appointment/complete", default=False):
|
|
return
|
|
row = self._current_row()
|
|
appointment_id = _appointment_id(row)
|
|
if appointment_id <= 0 or self._mutation_pending:
|
|
return
|
|
can_note = _canonical_allowed(
|
|
self.permissions, "doctor.appointment/addDoctorNote", default=False
|
|
)
|
|
note = ""
|
|
if can_note:
|
|
dialog = QDialog(self)
|
|
dialog.setWindowTitle("完成问诊")
|
|
dialog.resize(500, 360)
|
|
layout = QVBoxLayout(dialog)
|
|
layout.setContentsMargins(24, 22, 24, 18)
|
|
layout.setSpacing(12)
|
|
title = QLabel("完成问诊")
|
|
title.setProperty("dialogRole", "title")
|
|
layout.addWidget(title)
|
|
prompt = QLabel("是否添加医生备注？")
|
|
prompt.setProperty("dialogRole", "subtitle")
|
|
layout.addWidget(prompt)
|
|
editor = QTextEdit()
|
|
editor.setPlaceholderText("填写完成备注，将追加到医生备注时间轴")
|
|
editor.setMaximumHeight(120)
|
|
layout.addWidget(editor)
|
|
buttons = QDialogButtonBox(
|
|
QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
|
|
)
|
|
primary_button = buttons.button(QDialogButtonBox.StandardButton.Ok)
|
|
primary_button.setText("确认完成")
|
|
primary_button.setProperty("variant", "primary")
|
|
buttons.button(QDialogButtonBox.StandardButton.Cancel).setText("取消")
|
|
buttons.accepted.connect(dialog.accept)
|
|
buttons.rejected.connect(dialog.reject)
|
|
layout.addWidget(buttons)
|
|
mark_business_dialog(dialog, "AppointmentCompleteDialog")
|
|
if dialog.exec() != QDialog.DialogCode.Accepted:
|
|
return
|
|
note = editor.toPlainText().strip()[:NOTE_LIMIT]
|
|
else:
|
|
answer = QMessageBox.question(
|
|
self,
|
|
"完成问诊",
|
|
"确认完成该挂号吗？",
|
|
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel,
|
|
QMessageBox.StandardButton.Cancel,
|
|
)
|
|
if answer != QMessageBox.StandardButton.Yes:
|
|
return
|
|
diagnosis_id = _diagnosis_id(row)
|
|
snapshot_note = note
|
|
self._mutation_pending = True
|
|
self._action_generation += 1
|
|
generation = self._action_generation
|
|
self.banner.show_message("正在完成问诊…", "info")
|
|
|
|
def _worker() -> str:
|
|
invoke(self.repository, "complete_appointment", appointment_id=appointment_id)
|
|
if snapshot_note and diagnosis_id > 0:
|
|
try:
|
|
invoke(
|
|
self.repository,
|
|
"add_doctor_note",
|
|
diagnosis_id=diagnosis_id,
|
|
content=snapshot_note,
|
|
)
|
|
except Exception:
|
|
return "问诊已完成，但备注未保存"
|
|
elif snapshot_note and diagnosis_id <= 0:
|
|
return "问诊已完成，但该预约没有关联诊单，备注未保存"
|
|
return ""
|
|
|
|
run_async(
|
|
_worker,
|
|
on_success=lambda warning: self._complete_done(warning, generation),
|
|
on_error=lambda error: self._action_error(error, generation),
|
|
on_finished=lambda: self._mutation_finished(generation),
|
|
)
|
|
|
|
def _complete_done(self, warning: str, generation: int) -> None:
|
|
if generation != self._action_generation:
|
|
return
|
|
if warning:
|
|
self.banner.show_message(warning, "warning")
|
|
else:
|
|
self.banner.show_message("操作成功。", "success")
|
|
self.refresh(silent=True)
|
|
|
|
def _cancel_selected(self) -> None:
|
|
if not _canonical_allowed(self.permissions, "doctor.appointment/cancel", default=False):
|
|
return
|
|
row = self._current_row()
|
|
appointment_id = _appointment_id(row)
|
|
if appointment_id <= 0 or _status_value(row) != 1 or self._mutation_pending:
|
|
return
|
|
answer = QMessageBox.question(
|
|
self,
|
|
"取消挂号",
|
|
"确定要取消该挂号吗？",
|
|
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel,
|
|
QMessageBox.StandardButton.Cancel,
|
|
)
|
|
if answer != QMessageBox.StandardButton.Yes:
|
|
return
|
|
self._mutation_pending = True
|
|
self._action_generation += 1
|
|
generation = self._action_generation
|
|
self.banner.show_message("正在取消挂号…", "info")
|
|
run_async(
|
|
lambda: invoke(
|
|
self.repository,
|
|
"cancel_diagnosis_appointment",
|
|
appointment_id=appointment_id,
|
|
),
|
|
on_success=lambda _result: self._cancel_done(generation),
|
|
on_error=lambda error: self._action_error(error, generation),
|
|
on_finished=lambda: self._mutation_finished(generation),
|
|
)
|
|
|
|
def _cancel_done(self, generation: int) -> None:
|
|
if generation != self._action_generation:
|
|
return
|
|
self.banner.show_message("取消成功。", "success")
|
|
self.refresh(silent=True)
|
|
|
|
def _mutation_finished(self, generation: int) -> None:
|
|
if generation == self._action_generation:
|
|
self._mutation_pending = False
|
|
self._selection_changed()
|
|
|
|
def _action_error(self, error: Exception, generation: int) -> None:
|
|
if generation == self._action_generation:
|
|
self.banner.show_message(friendly_error(error), "danger")
|
|
|
|
def _open_prescription(self) -> None:
|
|
if not _canonical_allowed(self.permissions, "tcm.diagnosis/kaifang", default=False):
|
|
return
|
|
row = self._current_row()
|
|
if _diagnosis_id(row) <= 0 or _appointment_id(row) <= 0:
|
|
show_toast(self, "该预约缺少诊单信息，请先编辑患者。", "warning")
|
|
return
|
|
mode = "view" if prescription_action_label(row) == "查看" else "open"
|
|
self._begin_prescription_load(row, mode=mode)
|
|
|
|
def _view_case(self) -> None:
|
|
if not _canonical_allowed(self.permissions, "tcm.diagnosis/kaifang", default=False):
|
|
return
|
|
row = self._current_row()
|
|
appointment_id = _appointment_id(row)
|
|
if appointment_id <= 0:
|
|
show_toast(self, "预约信息不完整。", "warning")
|
|
return
|
|
self._prescription_generation += 1
|
|
generation = self._prescription_generation
|
|
self._prescription_busy = True
|
|
self.banner.show_message("正在加载病历处方…", "info")
|
|
run_async(
|
|
lambda: invoke(
|
|
self.repository,
|
|
"get_prescription_by_appointment",
|
|
appointment_id=appointment_id,
|
|
),
|
|
on_success=lambda existing: self._case_loaded(existing, generation),
|
|
on_error=lambda error: self._prescription_error(error, generation),
|
|
on_finished=lambda: self._prescription_finished(generation),
|
|
)
|
|
|
|
def _case_loaded(self, existing: Any, generation: int) -> None:
|
|
if generation != self._prescription_generation:
|
|
return
|
|
self.banner.clear()
|
|
if existing is None or _as_int(first_value(existing, "id", default=0)) <= 0:
|
|
show_toast(self, "该预约暂无病历记录，请先开方。", "warning")
|
|
return
|
|
dialog = PrescriptionDetailDialog(
|
|
existing,
|
|
initial_tab="case",
|
|
can_open_diagnosis=_canonical_allowed(
|
|
self.permissions, "tcm.diagnosis/readonlyDetail", default=False
|
|
),
|
|
parent=self,
|
|
)
|
|
dialog.diagnosis_requested.connect(self._open_diagnosis_id)
|
|
dialog.exec()
|
|
|
|
def _begin_prescription_load(self, row: Any, *, mode: str = "open") -> None:
|
|
snapshot = deepcopy(row)
|
|
self._prescription_generation += 1
|
|
generation = self._prescription_generation
|
|
self._prescription_busy = True
|
|
self.prescription_button.setEnabled(False)
|
|
self.banner.show_message("正在核对诊单处方上下文…", "info")
|
|
appointment_id = _appointment_id(snapshot)
|
|
run_async(
|
|
lambda: invoke(
|
|
self.repository,
|
|
"get_prescription_by_appointment",
|
|
appointment_id=appointment_id,
|
|
),
|
|
on_success=lambda existing: self._prescription_loaded(
|
|
existing,
|
|
snapshot,
|
|
generation,
|
|
mode,
|
|
),
|
|
on_error=lambda error: self._prescription_error(error, generation),
|
|
on_finished=lambda: self._prescription_finished(generation),
|
|
)
|
|
|
|
def _prescription_loaded(
|
|
self,
|
|
existing: Any,
|
|
row: Any,
|
|
generation: int,
|
|
mode: str = "open",
|
|
) -> None:
|
|
if generation != self._prescription_generation:
|
|
return
|
|
self.banner.clear()
|
|
if existing is not None and _as_int(first_value(existing, "id", default=0)) > 0:
|
|
approved = _as_int(first_value(existing, "audit_status", "status"), -1) == 1
|
|
voided = _as_int(first_value(existing, "void_status", "is_void"), 0) == 1
|
|
actual_id = _as_int(first_value(existing, "id", "prescription_id", default=0))
|
|
expected_id = _as_int(
|
|
first_value(row, "current_prescription_id", default=0)
|
|
)
|
|
actual_appointment_id = _as_int(
|
|
first_value(existing, "appointment_id", default=0)
|
|
)
|
|
expected_appointment_id = _appointment_id(row)
|
|
identity_changed = (
|
|
(expected_id > 0 and actual_id != expected_id)
|
|
or (
|
|
actual_appointment_id > 0
|
|
and expected_appointment_id > 0
|
|
and actual_appointment_id != expected_appointment_id
|
|
)
|
|
)
|
|
if mode == "view" and (not approved or voided or identity_changed):
|
|
self.banner.show_message(
|
|
"当前挂号的处方状态已变化，请刷新列表后重试。",
|
|
"warning",
|
|
)
|
|
return
|
|
if not approved or voided:
|
|
self._open_existing_prescription_editor(existing)
|
|
else:
|
|
dialog = PrescriptionDetailDialog(
|
|
existing,
|
|
can_open_diagnosis=_canonical_allowed(
|
|
self.permissions, "tcm.diagnosis/readonlyDetail", default=False
|
|
),
|
|
parent=self,
|
|
)
|
|
dialog.diagnosis_requested.connect(self._open_diagnosis_id)
|
|
dialog.exec()
|
|
return
|
|
if mode == "view":
|
|
self.banner.show_message(
|
|
"当前挂号没有可查看的处方，请刷新列表后重试。",
|
|
"warning",
|
|
)
|
|
return
|
|
self._begin_case_record_load(row)
|
|
|
|
def _open_existing_prescription_editor(self, prescription: Any) -> None:
|
|
prescription_id = _as_int(first_value(prescription, "id", "prescription_id", default=0))
|
|
if prescription_id <= 0:
|
|
self.banner.show_message("处方编号不完整，无法编辑。", "danger")
|
|
return
|
|
dialog = PrescriptionEditorDialog(
|
|
self.repository,
|
|
prescription,
|
|
mode="edit",
|
|
current_user=self.current_user,
|
|
parent=self,
|
|
)
|
|
diagnosis_signal = getattr(dialog, "diagnosis_requested", None)
|
|
if diagnosis_signal is not None:
|
|
diagnosis_signal.connect(self._open_diagnosis_id)
|
|
if dialog.exec() != QDialog.DialogCode.Accepted:
|
|
return
|
|
frozen_payload = MappingProxyType(dialog.payload())
|
|
self._mutation_pending = True
|
|
self._action_generation += 1
|
|
generation = self._action_generation
|
|
self.banner.show_message("正在保存处方…", "info")
|
|
run_async(
|
|
lambda: invoke(
|
|
self.repository,
|
|
"update_prescription",
|
|
prescription=prescription_id,
|
|
changes=frozen_payload,
|
|
),
|
|
on_success=lambda _result: self._prescription_updated(generation),
|
|
on_error=lambda error: self._action_error(error, generation),
|
|
on_finished=lambda: self._mutation_finished(generation),
|
|
)
|
|
|
|
def _prescription_updated(self, generation: int) -> None:
|
|
if generation != self._action_generation:
|
|
return
|
|
self.banner.show_message("处方已保存并重新进入待审核。", "success")
|
|
self.refresh(silent=True)
|
|
|
|
def _begin_case_record_load(self, row: Any) -> None:
|
|
snapshot = deepcopy(row)
|
|
diagnosis_id = _diagnosis_id(snapshot)
|
|
self._prescription_generation += 1
|
|
generation = self._prescription_generation
|
|
self._prescription_busy = True
|
|
self.prescription_button.setEnabled(False)
|
|
self.banner.show_message("正在生成不可变病例快照…", "info")
|
|
run_async(
|
|
lambda: invoke(
|
|
self.repository,
|
|
"get_diagnosis_detail",
|
|
diagnosis_id=diagnosis_id,
|
|
),
|
|
on_success=lambda detail: self._case_record_loaded(detail, snapshot, generation),
|
|
on_error=lambda error: self._prescription_error(error, generation),
|
|
on_finished=lambda: self._prescription_finished(generation),
|
|
)
|
|
|
|
def _case_record_loaded(self, detail: Any, row: Any, generation: int) -> None:
|
|
if generation != self._prescription_generation:
|
|
return
|
|
self.banner.clear()
|
|
actual_id = _as_int(first_value(detail, "id", "diagnosis_id", default=0))
|
|
expected = _diagnosis_id(row)
|
|
if actual_id != expected:
|
|
self.banner.show_message("服务端诊单与当前行不一致，已停止开方。", "danger")
|
|
return
|
|
self._open_prescription_editor(row, deepcopy(detail))
|
|
|
|
def _prescription_seed(self, record: Any, case_record: Any) -> dict[str, Any]:
|
|
diagnosis = get_value(case_record, "diagnosis", None) or case_record or {}
|
|
patient = get_value(case_record, "patient", None) or {}
|
|
|
|
def authoritative(*keys: str, default: Any = None) -> Any:
|
|
return first_value(
|
|
diagnosis,
|
|
*keys,
|
|
default=first_value(
|
|
patient, *keys, default=first_value(record, *keys, default=default)
|
|
),
|
|
)
|
|
|
|
gender = authoritative("gender", default=1)
|
|
if _as_int(gender, 1) == 2:
|
|
gender = 0
|
|
diagnosis_id = _diagnosis_id(record)
|
|
appointment_id = _appointment_id(record)
|
|
return {
|
|
"diagnosis_id": diagnosis_id,
|
|
"appointment_id": appointment_id,
|
|
"case_record": deepcopy(case_record),
|
|
"patient_name": authoritative("patient_name", "name", default=""),
|
|
"phone": authoritative("phone", "patient_phone", default=""),
|
|
"gender": gender,
|
|
"age": authoritative("age", default=None),
|
|
"visit_no": build_prescription_visit_no(
|
|
diagnosis_id=diagnosis_id, appointment_id=appointment_id
|
|
),
|
|
"tongue": authoritative("tongue", "tongue_coating", default=""),
|
|
"tongue_image": authoritative("tongue_image", default=""),
|
|
"pulse": authoritative("pulse", default=""),
|
|
"pulse_condition": authoritative("pulse_condition", default=""),
|
|
"clinical_diagnosis": build_prescription_clinical_diagnosis(
|
|
diagnosis, patient, record, case_record
|
|
),
|
|
"doctor_name": first_value(
|
|
self.current_user, "name", "real_name", default=first_value(record, "doctor_name")
|
|
),
|
|
}
|
|
|
|
def _open_diagnosis_id(self, diagnosis_id: int) -> None:
|
|
if diagnosis_id > 0:
|
|
self._diagnosis_dialog().open_view_only(diagnosis_id)
|
|
|
|
def _open_prescription_editor(self, record: Any, case_record: Any) -> None:
|
|
seed = self._prescription_seed(record, case_record)
|
|
dialog = PrescriptionEditorDialog(
|
|
self.repository,
|
|
seed,
|
|
mode="add",
|
|
current_user=self.current_user,
|
|
parent=self,
|
|
)
|
|
diagnosis_signal = getattr(dialog, "diagnosis_requested", None)
|
|
if diagnosis_signal is not None:
|
|
diagnosis_signal.connect(self._open_diagnosis_id)
|
|
if dialog.exec() != QDialog.DialogCode.Accepted:
|
|
return
|
|
payload = dialog.payload()
|
|
payload["diagnosis_id"] = seed["diagnosis_id"]
|
|
payload["appointment_id"] = seed["appointment_id"]
|
|
payload["case_record"] = deepcopy(case_record)
|
|
frozen_payload = MappingProxyType(payload)
|
|
self._mutation_pending = True
|
|
self._action_generation += 1
|
|
generation = self._action_generation
|
|
self.banner.show_message("正在提交处方…", "info")
|
|
run_async(
|
|
lambda: invoke(self.repository, "create_prescription", prescription=frozen_payload),
|
|
on_success=lambda _result: self._prescription_created(generation),
|
|
on_error=lambda error: self._action_error(error, generation),
|
|
on_finished=lambda: self._mutation_finished(generation),
|
|
)
|
|
|
|
def _prescription_created(self, generation: int) -> None:
|
|
if generation != self._action_generation:
|
|
return
|
|
self.banner.show_message("处方已开具并提交审核。", "success")
|
|
self.refresh(silent=True)
|
|
|
|
def _prescription_error(self, error: Exception, generation: int) -> None:
|
|
if generation == self._prescription_generation:
|
|
self.banner.show_message(friendly_error(error), "danger")
|
|
|
|
def _prescription_finished(self, generation: int) -> None:
|
|
if generation == self._prescription_generation:
|
|
self._prescription_busy = False
|
|
self._selection_changed()
|
|
|
|
def _open_detail(self) -> None:
|
|
row = self._current_row()
|
|
appointment_id = _appointment_id(row)
|
|
if appointment_id <= 0:
|
|
return
|
|
if not callable(getattr(self.repository, "get_appointment_detail", None)):
|
|
show_toast(self, "当前仓库未提供挂号详情能力。", "warning")
|
|
return
|
|
self._action_generation += 1
|
|
generation = self._action_generation
|
|
diagnosis_id = _diagnosis_id(row)
|
|
self.banner.show_message("正在加载挂号详情…", "info")
|
|
|
|
def _worker() -> dict[str, Any]:
|
|
detail = dict(
|
|
invoke(self.repository, "get_appointment_detail", appointment_id=appointment_id)
|
|
)
|
|
target = diagnosis_id or _as_int(detail.get("patient_id") or detail.get("diagnosis_id"))
|
|
if target > 0 and callable(getattr(self.repository, "get_diagnosis_detail", None)):
|
|
try:
|
|
diagnosis = invoke(
|
|
self.repository,
|
|
"get_diagnosis_detail",
|
|
diagnosis_id=target,
|
|
)
|
|
if isinstance(diagnosis, Mapping):
|
|
merged = dict(detail)
|
|
merged.update(dict(diagnosis))
|
|
return merged
|
|
except Exception:
|
|
return detail
|
|
return detail
|
|
|
|
run_async(
|
|
_worker,
|
|
on_success=lambda detail: self._show_detail(detail, generation),
|
|
on_error=lambda error: self._action_error(error, generation),
|
|
)
|
|
|
|
def _show_detail(self, detail: Mapping[str, Any], generation: int) -> None:
|
|
if generation != self._action_generation:
|
|
return
|
|
self.banner.clear()
|
|
dialog = QDialog(self)
|
|
dialog.setWindowTitle("挂号详情")
|
|
dialog.setObjectName("AppointmentDetailDialog")
|
|
dialog.resize(720, 560)
|
|
layout = QVBoxLayout(dialog)
|
|
layout.setContentsMargins(24, 22, 24, 18)
|
|
layout.setSpacing(12)
|
|
title = QLabel("挂号详情")
|
|
title.setProperty("dialogRole", "title")
|
|
layout.addWidget(title)
|
|
body = QTextEdit()
|
|
body.setReadOnly(True)
|
|
body.setHtml(self._detail_html(detail))
|
|
layout.addWidget(body)
|
|
buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
|
|
buttons.button(QDialogButtonBox.StandardButton.Close).setText("关闭")
|
|
buttons.rejected.connect(dialog.reject)
|
|
layout.addWidget(buttons)
|
|
mark_business_dialog(dialog, "AppointmentDetailDialog")
|
|
dialog.exec()
|
|
|
|
def _detail_html(self, detail: Mapping[str, Any]) -> str:
|
|
def cell(label: str, value: Any) -> str:
|
|
return (
|
|
f"<tr><th style='text-align:left;color:#667085;padding:4px 12px 4px 0;'>"
|
|
f"{escape(label)}</th>"
|
|
f"<td style='padding:4px 0;'>{escape(display_text(value))}</td></tr>"
|
|
)
|
|
|
|
period = first_value(detail, "period", default="")
|
|
period_text = (
|
|
"上午"
|
|
if period == "morning"
|
|
else "下午"
|
|
if period == "afternoon"
|
|
else display_text(period)
|
|
)
|
|
sections = [
|
|
(
|
|
"预约信息",
|
|
[
|
|
("挂号ID", first_value(detail, "id")),
|
|
("状态", first_value(detail, "status_desc")),
|
|
("医生", first_value(detail, "doctor_name")),
|
|
(
|
|
"预约时间",
|
|
f"{display_text(first_value(detail, 'appointment_date'))} "
|
|
f"{display_text(first_value(detail, 'appointment_time'))}",
|
|
),
|
|
("时段", period_text),
|
|
(
|
|
"预约类型",
|
|
first_value(detail, "appointment_type_desc", "appointment_type_text"),
|
|
),
|
|
],
|
|
),
|
|
(
|
|
"患者信息",
|
|
[
|
|
("姓名", first_value(detail, "patient_name")),
|
|
("手机号", first_value(detail, "phone", "patient_phone")),
|
|
("身份证号", first_value(detail, "id_card")),
|
|
("性别", gender_text(first_value(detail, "gender"))),
|
|
("年龄", first_value(detail, "age")),
|
|
("诊断日期", first_value(detail, "diagnosis_date")),
|
|
("身高(cm)", first_value(detail, "height")),
|
|
("体重(kg)", first_value(detail, "weight")),
|
|
("地区", first_value(detail, "region")),
|
|
],
|
|
),
|
|
(
|
|
"备注",
|
|
[("备注", first_value(detail, "remark") or "无")],
|
|
),
|
|
]
|
|
parts = ["<div style='font-family:Microsoft YaHei,sans-serif;font-size:13px;'>"]
|
|
for title, rows in sections:
|
|
parts.append(f"<h3 style='margin:12px 0 6px;'>{escape(title)}</h3><table>")
|
|
for label, value in rows:
|
|
parts.append(cell(label, value))
|
|
parts.append("</table>")
|
|
parts.append("</div>")
|
|
return "".join(parts)
|
|
|
|
def _load_departments(self) -> None:
|
|
if not callable(getattr(self.repository, "list_departments", None)):
|
|
return
|
|
self._dept_generation += 1
|
|
generation = self._dept_generation
|
|
run_async(
|
|
lambda: invoke(self.repository, "list_departments"),
|
|
on_success=lambda rows: self._departments_loaded(rows, generation),
|
|
on_error=lambda _error: None,
|
|
)
|
|
|
|
def _departments_loaded(self, rows: Any, generation: int) -> None:
|
|
if generation != self._dept_generation:
|
|
return
|
|
current = self.dept_filter.currentData()
|
|
self.dept_filter.blockSignals(True)
|
|
self.dept_filter.clear()
|
|
self.dept_filter.addItem("全部部门", "")
|
|
sequence = rows if isinstance(rows, Sequence) and not isinstance(rows, (str, bytes)) else []
|
|
for dept_id, label in _flatten_departments(sequence):
|
|
self.dept_filter.addItem(label, dept_id)
|
|
index = self.dept_filter.findData(current)
|
|
self.dept_filter.setCurrentIndex(max(0, index))
|
|
self.dept_filter.blockSignals(False)
|
|
|
|
def showEvent(self, event: Any) -> None:
|
|
super().showEvent(event)
|
|
self._load_departments()
|
|
if not self.poll_timer.isActive():
|
|
self.poll_timer.start()
|
|
if self.table.rowCount() == 0 and not self._loading:
|
|
self.refresh()
|
|
|
|
def hideEvent(self, event: Any) -> None:
|
|
self.poll_timer.stop()
|
|
super().hideEvent(event)
|
|
|
|
|
|
__all__ = ["AppointmentsPage", "prescription_action_label"]
|