2286 lines
101 KiB
Python
2286 lines
101 KiB
Python
"""Issued-prescription management matching the admin route contract."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Callable, Mapping
|
|
from datetime import datetime, timedelta
|
|
from html import escape
|
|
from math import ceil
|
|
from typing import Any
|
|
|
|
from PySide6.QtCore import QDateTime, QEvent, QModelIndex, QRectF, QSize, Qt, QTimer
|
|
from PySide6.QtGui import (
|
|
QColor,
|
|
QFont,
|
|
QFontMetrics,
|
|
QIcon,
|
|
QPainter,
|
|
QPen,
|
|
QTextDocument,
|
|
QTextOption,
|
|
)
|
|
from PySide6.QtWidgets import (
|
|
QAbstractItemView,
|
|
QApplication,
|
|
QComboBox,
|
|
QDateTimeEdit,
|
|
QDialog,
|
|
QDialogButtonBox,
|
|
QFrame,
|
|
QGridLayout,
|
|
QHBoxLayout,
|
|
QHeaderView,
|
|
QLabel,
|
|
QLineEdit,
|
|
QListWidget,
|
|
QListWidgetItem,
|
|
QMenu,
|
|
QMessageBox,
|
|
QPushButton,
|
|
QScrollArea,
|
|
QSizePolicy,
|
|
QStackedWidget,
|
|
QStyle,
|
|
QStyledItemDelegate,
|
|
QStyleOptionButton,
|
|
QStyleOptionViewItem,
|
|
QToolTip,
|
|
QVBoxLayout,
|
|
QWidget,
|
|
)
|
|
|
|
from .. import icons, motion
|
|
from ..dialogs.issued_prescription_ai import (
|
|
PrescriptionAiStatisticsDialog,
|
|
agreement_safe_batch,
|
|
agreement_text,
|
|
batch_running,
|
|
can_open_issued_ai,
|
|
present_issued_prescription_ai,
|
|
state_text,
|
|
status_tooltip,
|
|
)
|
|
from ..dialogs.prescription import (
|
|
AuditPrescriptionDialog,
|
|
DiagnosisDetailDialog,
|
|
PatchPatientDialog,
|
|
PrescriptionDetailDialog,
|
|
PrescriptionEditorDialog,
|
|
PrescriptionOrderDialog,
|
|
PrescriptionOrderListDialog,
|
|
)
|
|
from ..filter_disclosure import FilterDisclosure
|
|
from ..infinite_list import InfiniteList
|
|
from ..prescriptions_style import prescriptions_stylesheet
|
|
from ..reception_style import body_family, heading_family
|
|
from ..widgets import (
|
|
EmptyState,
|
|
MessageBanner,
|
|
PageHeader,
|
|
SortableTable,
|
|
TableColumn,
|
|
display_text,
|
|
first_value,
|
|
format_record_time,
|
|
friendly_error,
|
|
get_value,
|
|
has_permission,
|
|
invoke,
|
|
page_items,
|
|
page_total,
|
|
run_async,
|
|
show_toast,
|
|
)
|
|
|
|
PRESCRIPTIONS_PAGE_QSS = """
|
|
#PrescriptionsPage { background: #F7F7F7; }
|
|
#PrescriptionsPage QLabel[role="pageTitle"] {
|
|
color: #1A1C1F; font-size: 20px; font-weight: 600;
|
|
}
|
|
#PrescriptionsPage QWidget#PageHeader QLabel[role="muted"] {
|
|
color: #606163; font-size: 13px;
|
|
}
|
|
#PrescriptionsPage QFrame#PrescriptionFilterBar,
|
|
#PrescriptionsPage QFrame#PrescriptionTableCard {
|
|
background: #FFFFFF;
|
|
border: 1px solid #EDEDEE;
|
|
border-radius: 12px;
|
|
}
|
|
#PrescriptionsPage QFrame#PrescriptionToolbar {
|
|
background: #FFFFFF;
|
|
border: 0;
|
|
border-bottom: 1px solid #EDEDEE;
|
|
border-top-left-radius: 12px;
|
|
border-top-right-radius: 12px;
|
|
}
|
|
#PrescriptionsPage QFrame#PrescriptionFilterBar QLineEdit,
|
|
#PrescriptionsPage QFrame#PrescriptionFilterBar QComboBox,
|
|
#PrescriptionsPage QFrame#PrescriptionFilterBar QDateTimeEdit {
|
|
min-height: 32px; max-height: 32px; padding: 0 11px;
|
|
border-radius: 8px; font-size: 14px;
|
|
}
|
|
#PrescriptionsPage QPushButton {
|
|
min-height: 34px; max-height: 34px; padding: 0 14px;
|
|
border-radius: 8px; font-size: 13px;
|
|
}
|
|
#PrescriptionsPage QFrame#PrescriptionFilterBar QPushButton {
|
|
min-height: 32px; max-height: 32px;
|
|
}
|
|
#PrescriptionsPage QFrame#PrescriptionToolbar QPushButton {
|
|
min-height: 32px; max-height: 32px; padding: 0 13px;
|
|
}
|
|
#PrescriptionsPage QLabel#PrescriptionCountBadge {
|
|
min-height: 22px; max-height: 22px; padding: 0 9px;
|
|
color: #606163; background: #F7F7F7; border-radius: 11px;
|
|
font-size: 13px; font-weight: 500;
|
|
}
|
|
/* Row actions are ghost buttons. Boxed white buttons sat edge to edge with
|
|
3px gaps, so at 100% scaling they merged into one opaque slab that cut a
|
|
white rectangle through the row's zebra band and its selection wash - the
|
|
action column was the one part of a selected row that did not look selected.
|
|
Resting transparent also drops three borders per row out of the table, which
|
|
is most of what made the list look busy. */
|
|
#PrescriptionsPage QPushButton[rowAction="true"] {
|
|
min-width: 28px; max-width: 28px; min-height: 28px; max-height: 28px;
|
|
padding: 0; border-radius: 7px;
|
|
background: transparent; border: 1px solid transparent;
|
|
}
|
|
#PrescriptionsPage QPushButton[rowAction="true"][labeled="true"] {
|
|
min-width: 64px; max-width: 64px; padding: 0 9px;
|
|
color: #4F63D9; font-weight: 500;
|
|
}
|
|
#PrescriptionsPage QPushButton[rowAction="true"]:hover {
|
|
background: #EEF1FA; border-color: #8B9AD9;
|
|
}
|
|
#PrescriptionsPage QPushButton[rowAction="true"]:pressed {
|
|
background: #EEF1FA; border-color: #8B9AD9;
|
|
}
|
|
#PrescriptionsPage QPushButton[rowAction="true"][danger="true"]:hover {
|
|
background: #FFE4E8; border-color: #FFC0C9;
|
|
}
|
|
#PrescriptionsPage QPushButton[rowAction="true"][danger="true"]:pressed {
|
|
background: #FFD3DA; border-color: #FFA9B6;
|
|
}
|
|
#PrescriptionsPage QTableWidget {
|
|
border: 0; border-radius: 0; background: #FFFFFF;
|
|
alternate-background-color: #F7F7F7; font-size: 14px;
|
|
}
|
|
#PrescriptionsPage QTableWidget::item {
|
|
padding: 4px 8px; border-bottom: 1px solid #EDEDEE;
|
|
}
|
|
/* #FFFFFF is a 1% wash against the #FFFFFF row, so the selected row
|
|
was effectively invisible even though the toolbar's 查看 / 编辑 / 删除
|
|
actions all operate on it. A real tint plus a hover step makes the
|
|
target of those buttons obvious. */
|
|
#PrescriptionsPage QTableWidget::item:hover { background: #F7F7F7; }
|
|
#PrescriptionsPage QTableWidget::item:selected {
|
|
color: #1A1C1F; background: #EEF1FA;
|
|
}
|
|
#PrescriptionsPage QHeaderView::section {
|
|
min-height: 38px; max-height: 38px; padding: 0 8px;
|
|
background: #F7F7F7; color: #6A6B6D;
|
|
border: 0; border-bottom: 1px solid #EDEDEE;
|
|
font-size: 13px; font-weight: 500;
|
|
}
|
|
#PrescriptionsPage QWidget#Pager { min-height: 42px; }
|
|
#PrescriptionsPage QWidget#Pager QPushButton {
|
|
min-width: 34px; max-height: 32px; min-height: 32px; padding: 0 10px;
|
|
}
|
|
#PrescriptionsPage QWidget#Pager QLabel#PagerActive {
|
|
min-width: 48px; min-height: 30px; border-radius: 7px;
|
|
background: #4F63D9; color: #FFFFFF; font-weight: 500;
|
|
}
|
|
#PrescriptionsPage QWidget#BusinessPager QPushButton[pagerPage="true"] {
|
|
min-width: 34px; max-width: 34px; min-height: 32px; max-height: 32px;
|
|
padding: 0; background: #FFFFFF; color: #606163; border-color: #EDEDEE;
|
|
}
|
|
#PrescriptionsPage QWidget#BusinessPager QPushButton {
|
|
min-height: 32px; max-height: 32px;
|
|
}
|
|
#PrescriptionsPage QWidget#BusinessPager QPushButton[pagerPage="true"][active="true"] {
|
|
background: #4F63D9; color: #FFFFFF; border-color: #4F63D9;
|
|
}
|
|
#PrescriptionsPage QWidget#BusinessPager QLabel[pagerSize="true"] {
|
|
min-width: 64px; color: #606163; font-size: 13px;
|
|
}
|
|
|
|
/* The action column is the one cell that still needs real widgets. Keeping its
|
|
host transparent lets the view's own banding and selection wash show through,
|
|
instead of punching a white rectangle through the middle of the selected row. */
|
|
#PrescriptionsPage QWidget#PrescriptionTableCellHost { background: transparent; border: 0; }
|
|
"""
|
|
|
|
|
|
def _painted_icon(kind: str, color: str = "accent", size: int = 16) -> QIcon:
|
|
"""Return a page icon from the shared 24-unit icon grid.
|
|
|
|
``color`` takes a semantic role name; literal hex values still work so the
|
|
handful of remaining bespoke tints keep rendering.
|
|
"""
|
|
|
|
return icons.icon(kind, color, size)
|
|
|
|
|
|
# Decoration item roles. ``SortableTable`` stores the source record in
|
|
# ``UserRole`` on every column, so the delegate reads its own data from offsets
|
|
# above it.
|
|
_ROLE_TAG_KIND = Qt.ItemDataRole.UserRole + 10
|
|
_ROLE_AVATAR = Qt.ItemDataRole.UserRole + 11
|
|
_ROLE_LEAD_ICON = Qt.ItemDataRole.UserRole + 12
|
|
|
|
_TAG_PALETTE = {
|
|
"accent": ("#4F63D9", "#EEF1FA"),
|
|
"success": ("#287B65", "#E7F8F1"),
|
|
"warning": ("#A9691D", "#FFF5DF"),
|
|
"danger": ("#BE4B58", "#FFF0F2"),
|
|
"neutral": ("#606163", "#F7F7F7"),
|
|
}
|
|
|
|
|
|
class _RowDecorationDelegate(QStyledItemDelegate):
|
|
"""Paint status pills and the doctor avatar instead of hosting a widget.
|
|
|
|
Three of the nine columns used to carry a ``QWidget`` in every row purely to
|
|
render a coloured pill or a 20 px avatar. ``QTableWidget.setCellWidget`` is
|
|
the single most expensive call in the refresh path - about 0.3 ms each - so
|
|
a fifteen-row page spent roughly 14 ms per refresh building decoration a
|
|
delegate draws for nothing. Painting it here also means the row-selection
|
|
wash finally covers those three columns, which the widget hosts used to mask.
|
|
"""
|
|
|
|
def paint(self, painter: QPainter, option: Any, index: Any) -> None:
|
|
kind = index.data(_ROLE_TAG_KIND)
|
|
avatar = index.data(_ROLE_AVATAR)
|
|
lead_icon = index.data(_ROLE_LEAD_ICON)
|
|
if not kind and not avatar and not lead_icon:
|
|
super().paint(painter, option, index)
|
|
return
|
|
|
|
style_option = QStyleOptionViewItem(option)
|
|
self.initStyleOption(style_option, index)
|
|
text = style_option.text
|
|
style_option.text = ""
|
|
widget = style_option.widget
|
|
style = widget.style() if widget is not None else QApplication.style()
|
|
style.drawControl(
|
|
QStyle.ControlElement.CE_ItemViewItem, style_option, painter, widget
|
|
)
|
|
|
|
painter.save()
|
|
painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
|
|
rect = style_option.rect
|
|
if kind:
|
|
foreground, background = _TAG_PALETTE.get(kind, _TAG_PALETTE["neutral"])
|
|
font = QFont(style_option.font)
|
|
font.setPixelSize(13)
|
|
font.setWeight(QFont.Weight.Normal)
|
|
painter.setFont(font)
|
|
metrics = QFontMetrics(font)
|
|
label = metrics.elidedText(text, Qt.TextElideMode.ElideRight, rect.width() - 20)
|
|
width = min(metrics.horizontalAdvance(label) + 16, max(rect.width() - 12, 24))
|
|
pill = QRectF(
|
|
rect.center().x() - width / 2.0, rect.center().y() - 10.0, width, 20.0
|
|
)
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
painter.setBrush(QColor(background))
|
|
painter.drawRoundedRect(pill, 4.0, 4.0)
|
|
painter.setPen(QColor(foreground))
|
|
painter.drawText(pill, Qt.AlignmentFlag.AlignCenter, label)
|
|
elif lead_icon:
|
|
glyph = icons.pixmap(str(lead_icon), "soft", 14)
|
|
painter.drawPixmap(
|
|
QRectF(rect.left() + 8, rect.center().y() - 7, 14, 14),
|
|
glyph,
|
|
QRectF(glyph.rect()),
|
|
)
|
|
painter.setPen(QColor("#1A1C1F"))
|
|
painter.setFont(style_option.font)
|
|
text_rect = rect.adjusted(28, 0, -8, 0)
|
|
painter.drawText(
|
|
text_rect,
|
|
int(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter),
|
|
QFontMetrics(style_option.font).elidedText(
|
|
text, Qt.TextElideMode.ElideRight, text_rect.width()
|
|
),
|
|
)
|
|
else:
|
|
initial = str(avatar)[:1] or "医"
|
|
circle = QRectF(rect.left() + 8, rect.center().y() - 10, 20, 20)
|
|
painter.setPen(QPen(QColor("#EDEDEE"), 1.0))
|
|
painter.setBrush(QColor("#F7F7F7"))
|
|
painter.drawEllipse(circle.adjusted(0.5, 0.5, -0.5, -0.5))
|
|
initial_font = QFont(style_option.font)
|
|
initial_font.setPixelSize(10)
|
|
initial_font.setWeight(QFont.Weight.Medium)
|
|
painter.setFont(initial_font)
|
|
painter.setPen(QColor("#6A6B6D"))
|
|
painter.drawText(circle, Qt.AlignmentFlag.AlignCenter, initial)
|
|
painter.setFont(style_option.font)
|
|
painter.setPen(QColor("#1A1C1F"))
|
|
name_rect = rect.adjusted(35, 0, -8, 0)
|
|
painter.drawText(
|
|
name_rect,
|
|
int(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter),
|
|
QFontMetrics(style_option.font).elidedText(
|
|
str(avatar), Qt.TextElideMode.ElideRight, name_rect.width()
|
|
),
|
|
)
|
|
painter.restore()
|
|
|
|
|
|
def _row_action_button(
|
|
kind: str,
|
|
tooltip: str,
|
|
callback: Callable[[], None],
|
|
parent: QWidget,
|
|
*,
|
|
danger: bool = False,
|
|
enabled: bool = True,
|
|
label: str = "",
|
|
mutation: bool = False,
|
|
) -> QPushButton:
|
|
button = QPushButton(parent)
|
|
button.setProperty("rowAction", True)
|
|
button.setProperty("danger", danger)
|
|
button.setProperty("labeled", bool(label))
|
|
button.setProperty("mutationAction", mutation)
|
|
button.setProperty("rowAllowed", enabled)
|
|
button.setText(label)
|
|
button.setAccessibleName(tooltip)
|
|
button.setToolTip(tooltip)
|
|
button.setCursor(Qt.CursorShape.PointingHandCursor)
|
|
button.setFixedSize(64 if label else 28, 28)
|
|
button.setIcon(_painted_icon(kind, "danger" if danger else "accent", 15))
|
|
button.setIconSize(QSize(15, 15))
|
|
button.setEnabled(enabled)
|
|
button.clicked.connect(callback)
|
|
return button
|
|
|
|
|
|
def _int(value: Any, default: int = 0) -> int:
|
|
try:
|
|
return int(value)
|
|
except (TypeError, ValueError):
|
|
return default
|
|
|
|
|
|
def _truthy(value: Any) -> bool:
|
|
if isinstance(value, str):
|
|
return value.strip().lower() not in {"", "0", "false", "no", "off"}
|
|
return bool(value)
|
|
|
|
|
|
def _row_mapping(value: Any) -> dict[str, Any]:
|
|
"""Return only fields actually supplied by an API row when possible."""
|
|
|
|
if isinstance(value, Mapping):
|
|
return dict(value)
|
|
raw = getattr(value, "raw", None)
|
|
if isinstance(raw, Mapping) and raw:
|
|
return dict(raw)
|
|
fields = getattr(value, "__dataclass_fields__", {})
|
|
return {name: getattr(value, name, None) for name in fields if name != "raw"}
|
|
|
|
|
|
def merge_prescription_detail(row: Any, detail: Any) -> dict[str, Any]:
|
|
"""Match the admin editor's ``{...listRow, ...detail}`` state merge."""
|
|
|
|
merged = _row_mapping(row)
|
|
merged.update(_row_mapping(detail))
|
|
# Repository models retain the original API row in ``raw`` and expose
|
|
# canonical alias fields (for example ``patient_phone`` -> ``phone``) on
|
|
# the dataclass. Add those aliases without letting an omitted detail field
|
|
# overwrite a list-only audit/void value with its model default.
|
|
for source in (detail, row):
|
|
fields = getattr(source, "__dataclass_fields__", {})
|
|
for name in fields:
|
|
if name != "raw" and name not in merged:
|
|
merged[name] = getattr(source, name, None)
|
|
return merged
|
|
|
|
|
|
def prescription_status(row: Any) -> tuple[str, str]:
|
|
"""Return the admin audit-column status; void state has its own column."""
|
|
|
|
if _truthy(first_value(row, "business_prescription_audit_rejected", default=False)):
|
|
return "已驳回", "danger"
|
|
status = _int(first_value(row, "audit_status", "status", default=0), 0)
|
|
if status == 2:
|
|
return "已驳回", "danger"
|
|
if status == 1:
|
|
return "已通过", "success"
|
|
return "待审核", "warning"
|
|
|
|
|
|
def is_approved_active(row: Any) -> bool:
|
|
return (
|
|
_int(first_value(row, "audit_status", "status"), 0) == 1
|
|
and _int(first_value(row, "void_status", "is_void"), 0) != 1
|
|
)
|
|
|
|
|
|
def can_patch_patient(row: Any) -> bool:
|
|
return row is not None and _int(first_value(row, "void_status", "is_void"), 0) != 1
|
|
|
|
|
|
def can_create_order(row: Any) -> bool:
|
|
return can_patch_patient(row) and not _truthy(
|
|
first_value(row, "has_prescription_order", default=False)
|
|
)
|
|
|
|
|
|
def can_audit(row: Any) -> bool:
|
|
return (
|
|
row is not None
|
|
and _int(first_value(row, "audit_status", "status"), 0) == 0
|
|
and _int(first_value(row, "void_status", "is_void"), 0) != 1
|
|
)
|
|
|
|
|
|
def can_edit_or_delete(row: Any) -> bool:
|
|
return row is not None and not is_approved_active(row)
|
|
|
|
|
|
def _formula(value: Any) -> str:
|
|
text = str(value or "").strip().lower()
|
|
return "辅方" if text in {"2", "aux", "auxiliary", "辅方"} else "主方"
|
|
|
|
|
|
def _is_blank_prescription(row: Any) -> bool:
|
|
if row is None or _truthy(get_value(row, "is_system_auto")):
|
|
return True
|
|
raw = getattr(row, "raw", None)
|
|
source = raw if isinstance(raw, Mapping) and raw else row
|
|
missing = object()
|
|
herbs = get_value(source, "herbs", missing)
|
|
# Compact historical rows may omit herbs; omission is not an empty prescription.
|
|
if herbs is missing:
|
|
return False
|
|
return not isinstance(herbs, (list, tuple)) or not any(
|
|
str(get_value(herb, "name", "") or "").strip() for herb in herbs
|
|
)
|
|
|
|
|
|
def _order_warnings(row: Any) -> list[str]:
|
|
"""Match the PC list's linked-order checks, including blank herb rows."""
|
|
|
|
raw = getattr(row, "raw", None)
|
|
source = raw if isinstance(raw, Mapping) and raw else row
|
|
try:
|
|
has_order = float(get_value(source, "has_prescription_order", 0) or 0) == 1
|
|
except (TypeError, ValueError):
|
|
has_order = False
|
|
if not has_order:
|
|
return []
|
|
herbs = get_value(source, "herbs", None)
|
|
herbs = herbs if isinstance(herbs, (list, tuple)) else []
|
|
names = []
|
|
for herb in herbs:
|
|
raw_name = get_value(herb, "name", "")
|
|
names.append(str("" if raw_name is None else raw_name).strip())
|
|
names = [name for name in names if name]
|
|
if not names:
|
|
return ["请开方，当前处方药材为空白"]
|
|
seen: set[str] = set()
|
|
duplicate: list[str] = []
|
|
for name in names:
|
|
key = "".join(name.split()).lower()
|
|
if key and key in seen and name not in duplicate:
|
|
duplicate.append(name)
|
|
seen.add(key)
|
|
return [f"已有关联业务订单，当前处方存在重复药材：{'、'.join(duplicate)}"] if duplicate else []
|
|
|
|
|
|
def _sn_cell(_value: Any, row: Any) -> str:
|
|
return str(first_value(row, "sn", "prescription_no", "id", default="—"))
|
|
|
|
|
|
class _PrescriptionNumberDelegate(QStyledItemDelegate):
|
|
"""Paint visible PC-style reminders without changing the sortable SN value."""
|
|
|
|
def document(self, option: QStyleOptionViewItem, index: QModelIndex, width: int) -> QTextDocument:
|
|
row = index.data(Qt.ItemDataRole.UserRole)
|
|
number = str(index.data(Qt.ItemDataRole.DisplayRole) or "—")
|
|
record_id = display_text(first_value(row, "id", "prescription_id", default="—"))
|
|
document = QTextDocument()
|
|
document.setDocumentMargin(0)
|
|
document.setDefaultFont(option.font)
|
|
text_option = document.defaultTextOption()
|
|
text_option.setWrapMode(QTextOption.WrapMode.WrapAtWordBoundaryOrAnywhere)
|
|
document.setDefaultTextOption(text_option)
|
|
paragraphs = [
|
|
f'<p style="margin:0;color:#1A1C1F;font-size:14px;font-weight:500">{escape(number)}</p>',
|
|
f'<p style="margin:2px 0 0;color:#606163;font-size:12px;font-weight:400">ID: {escape(record_id)}</p>',
|
|
]
|
|
paragraphs.extend(
|
|
'<p style="margin:2px 0 0;color:#BE4B58;font-size:13px;font-weight:400">'
|
|
+ escape(warning)
|
|
+ "</p>"
|
|
for warning in _order_warnings(row)
|
|
)
|
|
document.setHtml("".join(paragraphs))
|
|
document.setTextWidth(max(1, width - 16))
|
|
return document
|
|
|
|
def paint(self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex) -> None:
|
|
styled = QStyleOptionViewItem(option)
|
|
self.initStyleOption(styled, index)
|
|
styled.text = ""
|
|
# Passing the widget is what lets the page stylesheet's ``::item:selected``
|
|
# rule apply. Without it this column painted the palette's own highlight,
|
|
# two percent off the wash the rest of the row used - just enough to look
|
|
# like a stray vertical rule down the table.
|
|
table = self.parent()
|
|
table.style().drawControl(
|
|
QStyle.ControlElement.CE_ItemViewItem, styled, painter, table
|
|
)
|
|
document = self.document(option, index, option.rect.width())
|
|
painter.save()
|
|
painter.setClipRect(option.rect)
|
|
painter.translate(option.rect.left() + 8, option.rect.top() + 6)
|
|
document.drawContents(painter)
|
|
painter.restore()
|
|
|
|
def sizeHint(self, option: QStyleOptionViewItem, index: QModelIndex) -> QSize: # noqa: N802
|
|
width = self.parent().columnWidth(index.column())
|
|
document = self.document(option, index, width)
|
|
return QSize(width, max(36, ceil(document.size().height()) + 12))
|
|
|
|
|
|
def _patient_cell(_value: Any, row: Any) -> str:
|
|
gender = first_value(row, "gender", default=None)
|
|
gender_text = "男" if gender in (1, "1") else "女" if gender in (0, "0") else "未知"
|
|
age = first_value(row, "age", default="—")
|
|
return f"{first_value(row, 'patient_name', default='—')} · {gender_text} · {age}岁"
|
|
|
|
|
|
def _source_cell(_value: Any, row: Any) -> str:
|
|
return (
|
|
"空白处方"
|
|
if _truthy(first_value(row, "is_system_auto", "source", default=False))
|
|
else "手工"
|
|
)
|
|
|
|
|
|
def _audit_cell(_value: Any, row: Any) -> str:
|
|
label = prescription_status(row)[0]
|
|
reasons = []
|
|
if _truthy(first_value(row, "business_prescription_audit_rejected", default=False)):
|
|
reasons.append(
|
|
"业务订单审核："
|
|
+ display_text(first_value(row, "business_prescription_audit_remark", default="—"))
|
|
)
|
|
if _int(first_value(row, "audit_status"), 0) == 2:
|
|
reasons.append(
|
|
"消费者处方审核：" + display_text(first_value(row, "audit_remark", default="—"))
|
|
)
|
|
return label + ("\n" + "\n".join(reasons) if reasons else "")
|
|
|
|
|
|
def _void_cell(_value: Any, row: Any) -> str:
|
|
return "作废" if _int(first_value(row, "void_status", "is_void"), 0) == 1 else "—"
|
|
|
|
|
|
def _doctor_cell(_value: Any, row: Any) -> str:
|
|
return str(first_value(row, "doctor_name", "creator_name", default="—"))
|
|
|
|
|
|
def _create_time_cell(value: Any, _row: Any) -> str:
|
|
raw = first_value(_row, "create_time_text", "create_time", default=value)
|
|
return format_record_time(raw)
|
|
|
|
|
|
class _DoctorOptionDelegate(QStyledItemDelegate):
|
|
"""Draw an explicit checked state independent of native item indicators."""
|
|
|
|
def sizeHint(self, option: Any, index: QModelIndex) -> QSize:
|
|
return QSize(220, 36)
|
|
|
|
def paint(self, painter: QPainter, option: Any, index: QModelIndex) -> None:
|
|
checked = index.data(Qt.ItemDataRole.CheckStateRole) == Qt.CheckState.Checked.value
|
|
painter.save()
|
|
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
|
|
rect = option.rect.adjusted(2, 1, -2, -1)
|
|
hovered = bool(option.state & QStyle.StateFlag.State_MouseOver)
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
painter.setBrush(QColor("#EAF2FF" if checked else "#F3F7FD" if hovered else "#FFFFFF"))
|
|
painter.drawRoundedRect(rect, 5, 5)
|
|
box = QRectF(rect.left() + 10, rect.center().y() - 8, 16, 16)
|
|
painter.setPen(QPen(QColor("#1769E8" if checked else "#B8C7DA"), 1))
|
|
painter.setBrush(QColor("#1769E8" if checked else "#FFFFFF"))
|
|
painter.drawRoundedRect(box, 3, 3)
|
|
if checked:
|
|
pen = QPen(QColor("#FFFFFF"), 2)
|
|
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
|
|
painter.setPen(pen)
|
|
x, y = int(box.x()), int(box.y())
|
|
painter.drawLine(x + 4, y + 8, x + 7, y + 11)
|
|
painter.drawLine(x + 7, y + 11, x + 12, y + 5)
|
|
font = QFont(body_family())
|
|
font.setPixelSize(13)
|
|
painter.setFont(font)
|
|
painter.setPen(QColor("#273244"))
|
|
text_rect = rect.adjusted(38, 0, -54, 0)
|
|
label = painter.fontMetrics().elidedText(str(index.data() or ""), Qt.TextElideMode.ElideRight, text_rect.width())
|
|
painter.drawText(text_rect, Qt.AlignmentFlag.AlignVCenter, label)
|
|
if checked:
|
|
painter.setPen(QColor("#1769E8"))
|
|
painter.drawText(rect.adjusted(0, 0, -12, 0), Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter, "已选")
|
|
if option.state & QStyle.StateFlag.State_HasFocus:
|
|
painter.setBrush(Qt.BrushStyle.NoBrush)
|
|
painter.setPen(QPen(QColor("#ADC8F2"), 1))
|
|
painter.drawRoundedRect(rect, 5, 5)
|
|
painter.restore()
|
|
|
|
def editorEvent(self, event: Any, model: Any, option: Any, index: QModelIndex) -> bool:
|
|
# The list handles whole-row toggles, independent of the native checkbox hit area.
|
|
return False
|
|
|
|
|
|
class _DoctorOptionsList(QListWidget):
|
|
@staticmethod
|
|
def _toggle(item: QListWidgetItem | None) -> None:
|
|
if item is not None and item.flags() & Qt.ItemFlag.ItemIsEnabled:
|
|
item.setCheckState(Qt.CheckState.Unchecked if item.checkState() == Qt.CheckState.Checked
|
|
else Qt.CheckState.Checked)
|
|
|
|
def mousePressEvent(self, event: Any) -> None:
|
|
if event.button() == Qt.MouseButton.LeftButton:
|
|
item = self.itemAt(event.position().toPoint())
|
|
self.setCurrentItem(item)
|
|
self._toggle(item)
|
|
event.accept()
|
|
return
|
|
super().mousePressEvent(event)
|
|
|
|
def mouseReleaseEvent(self, event: Any) -> None:
|
|
if event.button() == Qt.MouseButton.LeftButton:
|
|
event.accept()
|
|
return
|
|
super().mouseReleaseEvent(event)
|
|
|
|
def keyPressEvent(self, event: Any) -> None:
|
|
if event.key() == Qt.Key.Key_Space:
|
|
if not event.isAutoRepeat():
|
|
self._toggle(self.currentItem())
|
|
event.accept()
|
|
return
|
|
super().keyPressEvent(event)
|
|
|
|
|
|
class _DoctorSelectionDialog(QDialog):
|
|
def __init__(self, options: Mapping[int, str], selected: set[int], parent: QWidget) -> None:
|
|
super().__init__(parent)
|
|
self.setObjectName("DoctorSelectionDialog")
|
|
self.setWindowTitle("选择医生")
|
|
self.resize(420, 500)
|
|
self.setStyleSheet("""
|
|
QDialog#DoctorSelectionDialog { background: #FFFFFF; color: #273244; }
|
|
QListWidget#DoctorOptionsList { background: #FFFFFF; border: 1px solid #DBE5F2; border-radius: 6px; padding: 3px; }
|
|
QLabel#DoctorSelectionCount { color: #1769E8; font-size: 13px; }
|
|
QDialog#DoctorSelectionDialog QLineEdit { border: 1px solid #DBE5F2; border-radius: 6px; }
|
|
QDialog#DoctorSelectionDialog QLineEdit:focus { border-color: #1769E8; }
|
|
QDialog#DoctorSelectionDialog QPushButton { background: #FFFFFF; color: #273244; border: 1px solid #DBE5F2; border-radius: 6px; }
|
|
QDialog#DoctorSelectionDialog QPushButton:hover { background: #F3F7FD; border-color: #ADC8F2; }
|
|
QDialog#DoctorSelectionDialog QPushButton:disabled { color: #8A97A9; }
|
|
QDialog#DoctorSelectionDialog QPushButton#ConfirmDoctorSelection { background: #1769E8; color: #FFFFFF; border-color: #1769E8; }
|
|
QDialog#DoctorSelectionDialog QPushButton#ConfirmDoctorSelection:hover { background: #125DCE; border-color: #125DCE; }
|
|
""")
|
|
layout = QVBoxLayout(self)
|
|
layout.setContentsMargins(16, 16, 16, 16)
|
|
layout.setSpacing(10)
|
|
self.search = QLineEdit(self)
|
|
self.search.setObjectName("DoctorOptionSearch")
|
|
self.search.setPlaceholderText("搜索医生姓名")
|
|
self.search.setClearButtonEnabled(True)
|
|
layout.addWidget(self.search)
|
|
summary = QHBoxLayout()
|
|
self.count_label = QLabel(self)
|
|
self.count_label.setObjectName("DoctorSelectionCount")
|
|
summary.addWidget(self.count_label, 1)
|
|
self.clear_button = QPushButton("清空选择", self)
|
|
self.clear_button.clicked.connect(self._clear)
|
|
summary.addWidget(self.clear_button)
|
|
layout.addLayout(summary)
|
|
self.listing = _DoctorOptionsList(self)
|
|
self.listing.setObjectName("DoctorOptionsList")
|
|
self.listing.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
|
|
self.listing.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
|
|
self.listing.setMouseTracking(True)
|
|
self.listing.setItemDelegate(_DoctorOptionDelegate(self.listing))
|
|
for doctor_id, name in sorted(options.items(), key=lambda item: item[1]):
|
|
item = QListWidgetItem(name)
|
|
item.setToolTip(name)
|
|
item.setData(Qt.ItemDataRole.UserRole, doctor_id)
|
|
item.setFlags(item.flags() | Qt.ItemFlag.ItemIsUserCheckable)
|
|
item.setCheckState(Qt.CheckState.Checked if doctor_id in selected else Qt.CheckState.Unchecked)
|
|
self.listing.addItem(item)
|
|
layout.addWidget(self.listing, 1)
|
|
self.buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Cancel | QDialogButtonBox.StandardButton.Ok, self)
|
|
self.buttons.button(QDialogButtonBox.StandardButton.Ok).setText("确定")
|
|
self.buttons.button(QDialogButtonBox.StandardButton.Ok).setObjectName("ConfirmDoctorSelection")
|
|
self.buttons.button(QDialogButtonBox.StandardButton.Cancel).setText("取消")
|
|
self.buttons.accepted.connect(self.accept)
|
|
self.buttons.rejected.connect(self.reject)
|
|
layout.addWidget(self.buttons)
|
|
self.listing.itemChanged.connect(self._update_summary)
|
|
self.search.textChanged.connect(self._filter)
|
|
self._update_summary()
|
|
|
|
def selected_ids(self) -> set[int]:
|
|
return {_int(self.listing.item(i).data(Qt.ItemDataRole.UserRole))
|
|
for i in range(self.listing.count())
|
|
if self.listing.item(i).checkState() == Qt.CheckState.Checked}
|
|
|
|
def _update_summary(self, *_args: Any) -> None:
|
|
count = len(self.selected_ids())
|
|
self.count_label.setText(f"已选 {count} 位医生")
|
|
self.clear_button.setEnabled(count > 0)
|
|
|
|
def _filter(self, text: str) -> None:
|
|
query = text.strip().casefold()
|
|
for i in range(self.listing.count()):
|
|
item = self.listing.item(i)
|
|
item.setHidden(query not in item.text().casefold())
|
|
|
|
def _clear(self) -> None:
|
|
for i in range(self.listing.count()):
|
|
self.listing.item(i).setCheckState(Qt.CheckState.Unchecked)
|
|
|
|
|
|
class DoctorMultiSelect(QWidget):
|
|
"""Compact checkable doctor selector fed by list rows/extend data."""
|
|
|
|
def __init__(self, parent: QWidget | None = None) -> None:
|
|
super().__init__(parent)
|
|
self._options: dict[int, str] = {}
|
|
self._selected: set[int] = set()
|
|
layout = QHBoxLayout(self)
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
self.button = QPushButton("全部医生")
|
|
self.button.clicked.connect(self._choose)
|
|
layout.addWidget(self.button)
|
|
|
|
def values(self) -> list[int]:
|
|
return sorted(self._selected)
|
|
|
|
def clear(self) -> None:
|
|
self._selected.clear()
|
|
self._update_text()
|
|
|
|
def update_options(self, rows: list[Any]) -> None:
|
|
for row in rows:
|
|
doctor_id = _int(first_value(row, "id", "creator_id", "doctor_id"), 0)
|
|
name = str(first_value(row, "name", "doctor_name", "creator_name", default="")).strip()
|
|
if doctor_id and name:
|
|
self._options[doctor_id] = name
|
|
self._update_text()
|
|
|
|
def _choose(self) -> None:
|
|
dialog = _DoctorSelectionDialog(self._options, self._selected, self)
|
|
try:
|
|
if dialog.exec() == QDialog.DialogCode.Accepted:
|
|
self._selected = dialog.selected_ids() - {0}
|
|
self._update_text()
|
|
finally:
|
|
dialog.deleteLater()
|
|
|
|
def _update_text(self) -> None:
|
|
if not self._selected:
|
|
self.button.setText("全部医生")
|
|
return
|
|
names = [self._options.get(value, str(value)) for value in sorted(self._selected)]
|
|
self.button.setText("、".join(names[:2]) + (f" 等{len(names)}人" if len(names) > 2 else ""))
|
|
|
|
|
|
def _blue_prescription_icon(kind: str, color: str = "#1769E8", size: int = 15) -> QIcon:
|
|
result = QIcon(icons.icon(kind, color, size))
|
|
result.addPixmap(icons.pixmap(kind, "#A4ADBA", size), QIcon.Mode.Disabled)
|
|
return result
|
|
|
|
|
|
class _PrescriptionCombo(QComboBox):
|
|
def paintEvent(self, event: Any) -> None:
|
|
super().paintEvent(event)
|
|
painter = QPainter(self)
|
|
glyph = icons.pixmap("chevron_down", "#5D6B80", 14)
|
|
painter.drawPixmap(QRectF(self.width() - 25, (self.height() - 14) / 2, 14, 14), glyph, QRectF(glyph.rect()))
|
|
painter.end()
|
|
|
|
|
|
class _PrescriptionDateTime(QDateTimeEdit):
|
|
def paintEvent(self, event: Any) -> None:
|
|
super().paintEvent(event)
|
|
painter = QPainter(self)
|
|
glyph = icons.pixmap("calendar", "#5D6B80" if self.isEnabled() else "#8A97A9", 14)
|
|
painter.drawPixmap(QRectF(self.width() - 25, (self.height() - 14) / 2, 14, 14), glyph, QRectF(glyph.rect()))
|
|
painter.end()
|
|
|
|
|
|
class _PrescriptionDoctorButton(QPushButton):
|
|
def paintEvent(self, event: Any) -> None:
|
|
del event
|
|
option = QStyleOptionButton()
|
|
self.initStyleOption(option)
|
|
option.text = self.fontMetrics().elidedText(self.text(), Qt.TextElideMode.ElideRight, max(1, self.width() - 48))
|
|
painter = QPainter(self)
|
|
self.style().drawControl(QStyle.ControlElement.CE_PushButton, option, painter, self)
|
|
glyph = icons.pixmap("chevron_down", "#5D6B80", 14)
|
|
painter.drawPixmap(QRectF(self.width() - 25, (self.height() - 14) / 2, 14, 14), glyph, QRectF(glyph.rect()))
|
|
painter.end()
|
|
|
|
def setText(self, text: str) -> None: # noqa: N802
|
|
super().setText(text)
|
|
self.setToolTip(text)
|
|
|
|
|
|
def _prescription_cell_background(painter: QPainter, option: Any, index: QModelIndex) -> None:
|
|
selected = bool(option.state & QStyle.StateFlag.State_Selected)
|
|
hovered = bool(option.state & QStyle.StateFlag.State_MouseOver)
|
|
painter.fillRect(option.rect, QColor("#F2F7FF" if selected else "#F8FAFE" if hovered else "#FFFFFF"))
|
|
painter.setPen(QColor("#E6EDF6"))
|
|
painter.drawLine(option.rect.bottomLeft(), option.rect.bottomRight())
|
|
if selected and index.column() == 0:
|
|
painter.fillRect(option.rect.adjusted(0, 0, -option.rect.width() + 3, 0), QColor("#1769E8"))
|
|
if option.state & QStyle.StateFlag.State_HasFocus:
|
|
painter.setPen(QColor("#75A5F0"))
|
|
painter.setBrush(Qt.BrushStyle.NoBrush)
|
|
painter.drawRect(option.rect.adjusted(1, 1, -2, -2))
|
|
|
|
|
|
class _PrescriptionInfoDelegate(QStyledItemDelegate):
|
|
"""Only arrange existing display text; preserve sort, check and source roles."""
|
|
|
|
def initStyleOption(self, option: QStyleOptionViewItem, index: QModelIndex) -> None: # noqa: N802
|
|
super().initStyleOption(option, index)
|
|
if index.column() == 0:
|
|
indicator = self.parent().style().subElementRect(
|
|
QStyle.SubElement.SE_ItemViewItemCheckIndicator, option, self.parent()
|
|
)
|
|
option.rect.translate(option.rect.center().x() - indicator.center().x(), 0)
|
|
|
|
def helpEvent(self, event: Any, view: Any, option: Any, index: Any) -> bool:
|
|
if event is not None and index.isValid() and index.column() not in (0, 2):
|
|
text = index.data(Qt.ItemDataRole.ToolTipRole) or index.data(Qt.ItemDataRole.DisplayRole)
|
|
if text:
|
|
QToolTip.showText(event.globalPos(), str(text), view)
|
|
return True
|
|
return super().helpEvent(event, view, option, index)
|
|
|
|
def paint(self, painter: QPainter, option: Any, index: QModelIndex) -> None:
|
|
painter.save()
|
|
painter.setClipRect(option.rect)
|
|
_prescription_cell_background(painter, option, index)
|
|
rect = option.rect.adjusted(12, 0, -12, -1)
|
|
font = QFont(body_family())
|
|
font.setPixelSize(14)
|
|
painter.setFont(font)
|
|
painter.setPen(QColor("#273244"))
|
|
text = str(index.data(Qt.ItemDataRole.DisplayRole) or "")
|
|
column = index.column()
|
|
if column == 0:
|
|
styled = QStyleOptionViewItem(option)
|
|
self.initStyleOption(styled, index)
|
|
styled.rect = self.parent().style().subElementRect(QStyle.SubElement.SE_ItemViewItemCheckIndicator, styled, self.parent())
|
|
styled.state &= ~(QStyle.StateFlag.State_On | QStyle.StateFlag.State_Off | QStyle.StateFlag.State_NoChange)
|
|
styled.state |= QStyle.StateFlag.State_On if index.data(Qt.ItemDataRole.CheckStateRole) == Qt.CheckState.Checked.value else QStyle.StateFlag.State_Off
|
|
self.parent().style().drawPrimitive(QStyle.PrimitiveElement.PE_IndicatorItemViewItemCheck, styled, painter, self.parent())
|
|
elif column in (3, 6):
|
|
kind = index.data(_ROLE_TAG_KIND)
|
|
foreground, background = {
|
|
"accent": ("#1769E8", "#EDF4FF"), "success": ("#1769E8", "#EDF4FF"),
|
|
"warning": ("#AD640C", "#FFF5E5"), "danger": ("#BE4657", "#FFF0F2"),
|
|
}.get(kind, ("#5D6B80", "#F5F8FD"))
|
|
font.setPixelSize(13)
|
|
painter.setFont(font)
|
|
label = painter.fontMetrics().elidedText(text, Qt.TextElideMode.ElideRight, max(1, rect.width() - 12))
|
|
width = min(rect.width(), painter.fontMetrics().horizontalAdvance(label) + 12)
|
|
pill = QRectF(rect.left(), rect.center().y() - 12, width, 24)
|
|
painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
painter.setBrush(QColor(background))
|
|
painter.drawRoundedRect(pill, 4, 4)
|
|
painter.setPen(QColor(foreground))
|
|
painter.drawText(pill, Qt.AlignmentFlag.AlignCenter, label)
|
|
elif column != 2:
|
|
lines = text.rsplit(" · ", 2) if column == 5 else text.rsplit(" ", 1) if column == 10 else text.splitlines() if column == 12 else [text]
|
|
if len(lines) > 1:
|
|
primary, secondary = lines[0], " · ".join(lines[1:]) if column == 5 else lines[1]
|
|
if column == 5:
|
|
font = QFont(heading_family())
|
|
font.setPixelSize(14)
|
|
font.setWeight(QFont.Weight.Medium)
|
|
painter.setFont(font)
|
|
first_rect = rect.adjusted(0, 0, 0, 0)
|
|
first_rect.setTop(rect.center().y() - 24)
|
|
first_rect.setHeight(24)
|
|
painter.drawText(first_rect, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, painter.fontMetrics().elidedText(primary, Qt.TextElideMode.ElideRight, rect.width()))
|
|
font = QFont(body_family())
|
|
font.setPixelSize(13)
|
|
painter.setFont(font)
|
|
painter.setPen(QColor("#5D6B80"))
|
|
second_rect = first_rect.translated(0, 26)
|
|
painter.drawText(second_rect, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, painter.fontMetrics().elidedText(secondary, Qt.TextElideMode.ElideRight, rect.width()))
|
|
else:
|
|
painter.drawText(rect, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, painter.fontMetrics().elidedText(text, Qt.TextElideMode.ElideRight, rect.width()))
|
|
painter.restore()
|
|
|
|
|
|
class _PrescriptionNumberBlueDelegate(_PrescriptionNumberDelegate):
|
|
"""Keep warnings visible and measured while matching the compact blue list."""
|
|
|
|
def document(self, option: QStyleOptionViewItem, index: QModelIndex, width: int) -> QTextDocument:
|
|
row = index.data(Qt.ItemDataRole.UserRole)
|
|
number = str(index.data(Qt.ItemDataRole.DisplayRole) or "—")
|
|
record_id = display_text(first_value(row, "id", "prescription_id", default="—"))
|
|
document = QTextDocument()
|
|
document.setDocumentMargin(0)
|
|
font = QFont(body_family())
|
|
font.setPixelSize(14)
|
|
document.setDefaultFont(font)
|
|
text_option = document.defaultTextOption()
|
|
text_option.setWrapMode(QTextOption.WrapMode.WrapAtWordBoundaryOrAnywhere)
|
|
document.setDefaultTextOption(text_option)
|
|
paragraphs = [
|
|
f'<p style="margin:0;color:#273244;font-size:14px;font-weight:400">{escape(number)}</p>',
|
|
f'<p style="margin:6px 0 0;color:#5D6B80;font-size:13px;font-weight:400">ID: {escape(record_id)}</p>',
|
|
]
|
|
paragraphs.extend(
|
|
'<p style="margin:6px 0 0;color:#BE4657;font-size:13px;font-weight:400">' + escape(warning) + "</p>"
|
|
for warning in _order_warnings(row)
|
|
)
|
|
document.setHtml("".join(paragraphs))
|
|
document.setTextWidth(max(1, width - 24))
|
|
return document
|
|
|
|
def paint(self, painter: QPainter, option: QStyleOptionViewItem, index: QModelIndex) -> None:
|
|
painter.save()
|
|
painter.setClipRect(option.rect)
|
|
_prescription_cell_background(painter, option, index)
|
|
document = self.document(option, index, option.rect.width())
|
|
painter.translate(option.rect.left() + 12, option.rect.top() + max(12, (option.rect.height() - document.size().height()) / 2))
|
|
document.drawContents(painter)
|
|
painter.restore()
|
|
|
|
def sizeHint(self, option: QStyleOptionViewItem, index: QModelIndex) -> QSize: # noqa: N802
|
|
width = self.parent().columnWidth(index.column())
|
|
document = self.document(option, index, width)
|
|
return QSize(width, max(80, ceil(document.size().height()) + 28))
|
|
|
|
|
|
class _PrescriptionBlueTable(SortableTable):
|
|
def setCellWidget(self, row: int, column: int, widget: QWidget) -> None: # noqa: N802
|
|
super().setCellWidget(row, column, widget)
|
|
if column == 2:
|
|
widget.setObjectName("PrescriptionTableCellHost")
|
|
for button in widget.findChildren(QPushButton):
|
|
kind = {"查看处方": "eye", "编辑处方": "pencil", "删除处方": "trash"}.get(button.accessibleName())
|
|
if kind:
|
|
button.setIcon(_blue_prescription_icon(kind, "#BE4657" if kind == "trash" else "#1769E8"))
|
|
|
|
|
|
class PrescriptionsPage(QWidget):
|
|
"""Complete issued-prescription route: list, workflow actions, print, and orders."""
|
|
|
|
def __init__(
|
|
self,
|
|
repository: Any,
|
|
permissions: Any = None,
|
|
current_user: Any = None,
|
|
parent: QWidget | None = None,
|
|
) -> None:
|
|
super().__init__(parent)
|
|
self.setObjectName("PrescriptionsPage")
|
|
self.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
|
|
self.setStyleSheet(prescriptions_stylesheet())
|
|
self.repository = repository
|
|
self.permissions = permissions
|
|
self.current_user = current_user
|
|
self._page = 1
|
|
self._page_size = 15
|
|
self._generation = 0
|
|
self._loading = False
|
|
self._refresh_pending = False
|
|
self._detail_generation = 0
|
|
self._detail_target = 0
|
|
self._diagnosis_detail_generation = 0
|
|
self._diagnosis_detail_target = 0
|
|
self._mutation_pending = False
|
|
self._ai_statuses: dict[int, dict[str, Any]] = {}
|
|
self._ai_enabled = False
|
|
self._agreement_visible = False
|
|
self._capability_agreement_visible = False
|
|
self._ai_capability_token = 0
|
|
self._ai_capability_pending = False
|
|
self._ai_request_token = 0
|
|
self._ai_pending = False
|
|
self._ai_timer = QTimer(self)
|
|
self._ai_timer.setInterval(5000)
|
|
self._ai_timer.timeout.connect(self._load_ai_statuses)
|
|
self._ai_scroll_timer = QTimer(self)
|
|
self._ai_scroll_timer.setSingleShot(True)
|
|
self._ai_scroll_timer.setInterval(180)
|
|
self._ai_scroll_timer.timeout.connect(self._load_ai_statuses)
|
|
|
|
outer = QVBoxLayout(self)
|
|
outer.setContentsMargins(28, 16, 26, 8)
|
|
self.scroll = QScrollArea()
|
|
self.scroll.setObjectName("PrescriptionWorkspaceScroll")
|
|
self.scroll.setWidgetResizable(True)
|
|
self.scroll.setFrameShape(QFrame.Shape.NoFrame)
|
|
self.scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
|
|
self.content = QWidget()
|
|
self.content.setObjectName("PrescriptionWorkspaceContent")
|
|
root = QVBoxLayout(self.content)
|
|
root.setContentsMargins(0, 0, 0, 0)
|
|
root.setSpacing(10)
|
|
self.scroll.setWidget(self.content)
|
|
outer.addWidget(self.scroll)
|
|
header = PageHeader(
|
|
"已开处方",
|
|
"管理处方审核、患者修正与履约订单；已通过且未作废的处方只允许查看。",
|
|
)
|
|
self.header = header
|
|
header.setFixedHeight(96)
|
|
header.layout().setSpacing(12)
|
|
header.layout().setAlignment(Qt.AlignmentFlag.AlignTop)
|
|
header.layout().itemAt(1).layout().itemAt(0).layout().setSpacing(7)
|
|
header.actions.setSpacing(12)
|
|
self.orders_button = QPushButton("业务订单", header)
|
|
self.orders_button.setMinimumWidth(86)
|
|
self.orders_button.setCursor(Qt.CursorShape.PointingHandCursor)
|
|
self.orders_button.setVisible(has_permission(permissions, "tcm.prescriptionOrder/lists"))
|
|
self.orders_button.clicked.connect(lambda: self._open_orders())
|
|
header.add_action(self.orders_button)
|
|
self.ai_statistics_button = QPushButton("AI 一致度统计", header)
|
|
self.ai_statistics_button.hide()
|
|
self.ai_statistics_button.clicked.connect(self._open_ai_statistics)
|
|
header.add_action(self.ai_statistics_button)
|
|
self.add_button = QPushButton("新增处方", header)
|
|
self.add_button.setObjectName("PrescriptionAddButton")
|
|
self.add_button.setMinimumWidth(122)
|
|
self.add_button.setProperty("variant", "primary")
|
|
self.add_button.setIcon(_blue_prescription_icon("plus", "#FFFFFF"))
|
|
self.add_button.setIconSize(QSize(15, 15))
|
|
self.add_button.setCursor(Qt.CursorShape.PointingHandCursor)
|
|
self.add_button.setVisible(has_permission(permissions, "cf.prescription/add"))
|
|
self.add_button.clicked.connect(self._add_prescription)
|
|
header.add_action(self.add_button)
|
|
root.addWidget(header)
|
|
filters = self._build_filters()
|
|
self.filter_card = filters
|
|
root.addWidget(filters)
|
|
self.filter_disclosure = FilterDisclosure(self, [filters])
|
|
header.add_action(self.filter_disclosure.button)
|
|
header.set_compact()
|
|
self.banner = MessageBanner()
|
|
root.addWidget(self.banner)
|
|
table_card = self._build_table_card()
|
|
self.table_card = table_card
|
|
root.addWidget(table_card, 1)
|
|
for button, kind in ((self.view_button, "eye"), (self.edit_button, "pencil"), (self.delete_button, "trash")):
|
|
button.setIcon(_blue_prescription_icon(kind, "#BE4657" if kind == "trash" else "#1769E8"))
|
|
self._load_doctor_options()
|
|
|
|
def _build_filters(self) -> QWidget:
|
|
frame = QFrame()
|
|
frame.setObjectName("PrescriptionFilterBar")
|
|
frame.setFixedHeight(144)
|
|
grid = QGridLayout(frame)
|
|
self.filter_grid = grid
|
|
grid.setContentsMargins(16, 20, 16, 20)
|
|
grid.setHorizontalSpacing(12)
|
|
grid.setVerticalSpacing(16)
|
|
self.quick_date = _PrescriptionCombo()
|
|
self.quick_date.addItem("全部时间", "all")
|
|
self.quick_date.addItem("今日", "today")
|
|
self.quick_date.addItem("昨日", "yesterday")
|
|
self.quick_date.addItem("前天", "before_yesterday")
|
|
self.quick_date.addItem("自定义", "custom")
|
|
self.quick_date.currentIndexChanged.connect(self._quick_date_changed)
|
|
grid.addWidget(self.quick_date, 0, 0)
|
|
self.start_time = _PrescriptionDateTime(QDateTime.currentDateTime().addDays(-7))
|
|
self.start_time.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
|
|
self.start_time.setCalendarPopup(True)
|
|
self.start_time.setEnabled(False)
|
|
grid.addWidget(self.start_time, 0, 1)
|
|
self.date_separator = QLabel("至")
|
|
self.date_separator.setProperty("role", "muted")
|
|
self.date_separator.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
grid.addWidget(self.date_separator, 0, 2)
|
|
self.end_time = _PrescriptionDateTime(QDateTime.currentDateTime())
|
|
self.end_time.setDisplayFormat("yyyy-MM-dd HH:mm:ss")
|
|
self.end_time.setCalendarPopup(True)
|
|
self.end_time.setEnabled(False)
|
|
grid.addWidget(self.end_time, 0, 3)
|
|
self.audit_filter = _PrescriptionCombo()
|
|
self.audit_filter.addItem("待审核", "pending")
|
|
self.audit_filter.addItem("全部审核状态", "all")
|
|
self.audit_filter.addItem("已通过", "passed")
|
|
self.audit_filter.addItem("未通过", "not_passed")
|
|
self.audit_filter.addItem("已驳回", "rejected")
|
|
self.audit_filter.setCurrentIndex(1)
|
|
grid.addWidget(self.audit_filter, 0, 4)
|
|
self.source_filter = _PrescriptionCombo()
|
|
self.source_filter.addItem("全部来源", "all")
|
|
self.source_filter.addItem("手工", "manual")
|
|
self.source_filter.addItem("空白处方", "system")
|
|
grid.addWidget(self.source_filter, 0, 5)
|
|
self.sn_filter = QLineEdit()
|
|
self.sn_filter.setPlaceholderText("处方编号")
|
|
self.sn_filter.setClearButtonEnabled(True)
|
|
self.sn_filter.returnPressed.connect(self._search)
|
|
grid.addWidget(self.sn_filter, 1, 0)
|
|
self.patient_filter = QLineEdit()
|
|
self.patient_filter.setPlaceholderText("患者姓名")
|
|
self.patient_filter.setClearButtonEnabled(True)
|
|
self.patient_filter.returnPressed.connect(self._search)
|
|
grid.addWidget(self.patient_filter, 1, 1)
|
|
self.doctor_filter = DoctorMultiSelect()
|
|
original_button = self.doctor_filter.button
|
|
self.doctor_filter.layout().removeWidget(original_button)
|
|
original_button.deleteLater()
|
|
self.doctor_filter.button = _PrescriptionDoctorButton("全部医生")
|
|
self.doctor_filter.button.setObjectName("PrescriptionDoctorButton")
|
|
self.doctor_filter.button.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Fixed)
|
|
self.doctor_filter.button.clicked.connect(self.doctor_filter._choose)
|
|
self.doctor_filter.layout().addWidget(self.doctor_filter.button)
|
|
current_id = _int(first_value(self.current_user, "id", "user_id"), 0)
|
|
current_name = str(first_value(self.current_user, "name", "real_name", default="")).strip()
|
|
if current_id and current_name:
|
|
self.doctor_filter.update_options([{"id": current_id, "name": current_name}])
|
|
grid.addWidget(self.doctor_filter, 1, 2, 1, 3)
|
|
self.query_button = QPushButton("查询")
|
|
self.query_button.setObjectName("PrescriptionQueryButton")
|
|
self.query_button.setProperty("variant", "secondary")
|
|
self.query_button.setCursor(Qt.CursorShape.PointingHandCursor)
|
|
self.query_button.clicked.connect(self._search)
|
|
self.filter_actions = QWidget()
|
|
actions = QHBoxLayout(self.filter_actions)
|
|
actions.setContentsMargins(0, 0, 0, 0)
|
|
actions.setSpacing(12)
|
|
actions.addStretch(1)
|
|
self.query_button.setFixedWidth(84)
|
|
actions.addWidget(self.query_button)
|
|
self.reset_button = QPushButton("重置")
|
|
self.reset_button.setProperty("variant", "ghost")
|
|
self.reset_button.setCursor(Qt.CursorShape.PointingHandCursor)
|
|
self.reset_button.clicked.connect(self._reset_filters)
|
|
self.reset_button.setFixedWidth(84)
|
|
actions.addWidget(self.reset_button)
|
|
grid.addWidget(self.filter_actions, 1, 5)
|
|
for column, (minimum, stretch) in enumerate(((140, 190), (212, 270), (20, 0), (212, 250), (150, 190), (180, 170))):
|
|
grid.setColumnMinimumWidth(column, minimum)
|
|
grid.setColumnStretch(column, stretch)
|
|
return frame
|
|
|
|
def _build_table_card(self) -> QWidget:
|
|
card = QFrame()
|
|
card.setObjectName("PrescriptionTableCard")
|
|
card.setMinimumHeight(280)
|
|
layout = QVBoxLayout(card)
|
|
layout.setContentsMargins(1, 0, 1, 1)
|
|
layout.setSpacing(0)
|
|
toolbar_host = QFrame(card)
|
|
toolbar_host.setObjectName("PrescriptionToolbar")
|
|
toolbar_host.setFixedHeight(64)
|
|
toolbar_scroll = QScrollArea()
|
|
toolbar_scroll.setFrameShape(QFrame.Shape.NoFrame)
|
|
toolbar_scroll.setWidgetResizable(True)
|
|
toolbar_scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
|
|
toolbar_scroll.setFixedHeight(71)
|
|
toolbar_scroll.setWidget(toolbar_host)
|
|
toolbar = QHBoxLayout(toolbar_host)
|
|
toolbar.setContentsMargins(16, 7, 16, 7)
|
|
toolbar.setSpacing(8)
|
|
title = QLabel("处方列表")
|
|
title.setProperty("role", "sectionTitle")
|
|
toolbar.addWidget(title)
|
|
self.count_badge = QLabel("共 0 条", toolbar_host)
|
|
self.count_badge.setObjectName("PrescriptionCountBadge")
|
|
toolbar.addWidget(self.count_badge)
|
|
toolbar.addStretch(1)
|
|
self.view_button = self._action_button("查看", "cf.prescription/read", self._view_selected)
|
|
toolbar.addWidget(self.view_button)
|
|
self.ai_report_button = self._action_button("AI 报告", "tcm.prescriptionAi/reports", self._open_ai_report)
|
|
self.ai_report_button.hide()
|
|
toolbar.addWidget(self.ai_report_button)
|
|
self.patch_button = self._action_button(
|
|
"修改患者", "tcm.prescription/patchPatient", self._patch_selected
|
|
)
|
|
toolbar.addWidget(self.patch_button)
|
|
self.create_order_button = self._action_button(
|
|
"创建订单", "tcm.prescriptionOrder/create", self._create_order
|
|
)
|
|
toolbar.addWidget(self.create_order_button)
|
|
self.edit_button = self._action_button("编辑", "cf.prescription/edit", self._edit_selected)
|
|
toolbar.addWidget(self.edit_button)
|
|
self.audit_button = self._action_button(
|
|
"审核", "cf.prescription/audit", self._audit_selected
|
|
)
|
|
toolbar.addWidget(self.audit_button)
|
|
self.delete_button = self._action_button(
|
|
"删除", "cf.prescription/del", self._delete_selected, danger=True
|
|
)
|
|
toolbar.addWidget(self.delete_button)
|
|
refresh = QPushButton("刷新")
|
|
refresh.setProperty("variant", "ghost")
|
|
refresh.setCursor(Qt.CursorShape.PointingHandCursor)
|
|
refresh.setIcon(_blue_prescription_icon("refresh", "#5D6B80"))
|
|
refresh.setIconSize(QSize(15, 15))
|
|
refresh.clicked.connect(self.refresh)
|
|
toolbar.addWidget(refresh)
|
|
layout.addWidget(toolbar_scroll)
|
|
self.ai_status_notice = QLabel("AI 分析：正在检查服务状态。", card)
|
|
self.ai_status_notice.setObjectName("PrescriptionAiStatusNotice")
|
|
self.ai_status_notice.setProperty("role", "muted")
|
|
self.ai_status_notice.setTextFormat(Qt.TextFormat.PlainText)
|
|
self.ai_status_notice.setWordWrap(True)
|
|
self.ai_status_notice.setMargin(12)
|
|
self.ai_status_notice.setAccessibleName("AI 分析状态")
|
|
layout.addWidget(self.ai_status_notice)
|
|
self.stack = QStackedWidget()
|
|
table_host = QWidget()
|
|
table_layout = QVBoxLayout(table_host)
|
|
table_layout.setContentsMargins(0, 0, 0, 0)
|
|
table_layout.setSpacing(0)
|
|
self.table = _PrescriptionBlueTable(
|
|
[
|
|
TableColumn("__selected__", "", 46, lambda _value, _row: ""),
|
|
TableColumn("sn", "处方编号", 260, _sn_cell),
|
|
TableColumn("__actions__", "操作", 150, lambda _value, _row: ""),
|
|
TableColumn("prescription_type", "处方类型", 96),
|
|
TableColumn("is_system_auto", "来源", 88, _source_cell),
|
|
TableColumn("patient_name", "患者信息", 190, _patient_cell),
|
|
TableColumn("audit_status", "审核状态", 110, _audit_cell),
|
|
TableColumn("void_status", "作废", 72, _void_cell),
|
|
TableColumn("doctor_name", "医生信息", 180, _doctor_cell),
|
|
TableColumn("assistant_name", "医助", 125),
|
|
TableColumn("create_time", "创建时间", 180, _create_time_cell),
|
|
TableColumn("__ai_status__", "AI 分析", 144, lambda _value, _row: "—"),
|
|
TableColumn("__ai_agreement__", "与 AI 一致度", 130, lambda _value, _row: "—"),
|
|
]
|
|
)
|
|
self.table.setObjectName("PrescriptionTable")
|
|
self.table.setMouseTracking(True)
|
|
self.table.setAlternatingRowColors(False)
|
|
self.table.verticalHeader().setMinimumSectionSize(80)
|
|
self.table.verticalHeader().setDefaultSectionSize(80)
|
|
self.table.horizontalHeader().setFixedHeight(42)
|
|
self.table.horizontalHeader().setMinimumSectionSize(36)
|
|
self.table.horizontalHeader().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
|
|
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Interactive)
|
|
self.table.horizontalHeader().moveSection(2, 10)
|
|
for column, width in enumerate((42, 192, 144, 108, 94, 144, 108, 80, 137, 83, 128)):
|
|
self.table.setColumnWidth(column, width)
|
|
self.table.setColumnHidden(11, True)
|
|
self.table.setColumnHidden(12, True)
|
|
self.table.horizontalHeaderItem(12).setToolTip("分别显示千问、OpenAI 的药味与剂量一致度；点击查看逐味贡献。")
|
|
self.table.horizontalHeader().viewport().installEventFilter(self)
|
|
self.table.verticalScrollBar().valueChanged.connect(lambda _value: self._schedule_ai_statuses())
|
|
self.table.setWordWrap(False)
|
|
# Rows are not uniform: the number column's delegate grows a row that
|
|
# carries an order warning so the warning text stays readable without a
|
|
# hover, so the table has to keep measuring row heights after a sort or a
|
|
# column resize.
|
|
self.table.model().layoutChanged.connect(self.table.resizeRowsToContents)
|
|
self.table.setItemDelegate(_PrescriptionInfoDelegate(self.table))
|
|
self.table.setItemDelegateForColumn(1, _PrescriptionNumberBlueDelegate(self.table))
|
|
self.table.horizontalHeader().sectionResized.connect(self._number_column_resized)
|
|
self.table.horizontalHeaderItem(0).setIcon(_blue_prescription_icon("checkbox", "#8A97A9", 14))
|
|
self.table.horizontalHeaderItem(0).setTextAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
self.table.itemSelectionChanged.connect(self._selection_changed)
|
|
self.table.itemDoubleClicked.connect(lambda _item: self._view_selected())
|
|
self.table.itemClicked.connect(lambda item: self._open_ai_report() if item.column() in {11, 12} else None)
|
|
self.table.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
|
|
self.table.customContextMenuRequested.connect(self._open_ai_context_menu)
|
|
table_layout.addWidget(self.table, 1)
|
|
self.pager = InfiniteList(self._page_size)
|
|
self.pager.bind(self.table)
|
|
self.stack.addWidget(table_host)
|
|
self.stack.addWidget(
|
|
EmptyState("没有找到处方", "请调整创建时间、审核状态或患者筛选后重试。")
|
|
)
|
|
self.stack.widget(1).layout().itemAt(0).setAlignment(Qt.AlignmentFlag.AlignHCenter)
|
|
layout.addWidget(self.stack, 1)
|
|
layout.addWidget(self.pager)
|
|
return card
|
|
|
|
def resizeEvent(self, event: Any) -> None:
|
|
super().resizeEvent(event)
|
|
if not hasattr(self, "filter_grid"):
|
|
return
|
|
compact = self.width() < 1070
|
|
if getattr(self, "_compact_filters", None) == compact:
|
|
return
|
|
self._compact_filters = compact
|
|
controls = (self.quick_date, self.start_time, self.date_separator, self.end_time,
|
|
self.audit_filter, self.source_filter, self.sn_filter, self.patient_filter,
|
|
self.doctor_filter, self.filter_actions)
|
|
for control in controls:
|
|
self.filter_grid.removeWidget(control)
|
|
for column in range(6):
|
|
self.filter_grid.setColumnMinimumWidth(column, 0)
|
|
self.filter_grid.setColumnStretch(column, 0)
|
|
if compact:
|
|
positions = ((0, 0, 1), (0, 1, 1), (0, 2, 1), (0, 3, 1), (1, 0, 1),
|
|
(1, 1, 1), (1, 2, 2), (2, 0, 1), (2, 1, 2), (2, 3, 1))
|
|
widths = ((136, 180), (208, 250), (20, 0), (208, 250))
|
|
else:
|
|
positions = ((0, 0, 1), (0, 1, 1), (0, 2, 1), (0, 3, 1), (0, 4, 1),
|
|
(0, 5, 1), (1, 0, 1), (1, 1, 1), (1, 2, 3), (1, 5, 1))
|
|
widths = ((140, 190), (212, 270), (20, 0), (212, 250), (150, 190), (180, 170))
|
|
for control, (row, column, span) in zip(controls, positions, strict=True):
|
|
self.filter_grid.addWidget(control, row, column, 1, span)
|
|
for column, (minimum, stretch) in enumerate(widths):
|
|
self.filter_grid.setColumnMinimumWidth(column, minimum)
|
|
self.filter_grid.setColumnStretch(column, stretch)
|
|
self.filter_card.setFixedHeight(200 if compact else 144)
|
|
|
|
def _number_column_resized(self, column: int, _old_size: int, _new_size: int) -> None:
|
|
if column == 1:
|
|
self.table.resizeRowsToContents()
|
|
|
|
def eventFilter(self, watched: Any, event: Any) -> bool:
|
|
if hasattr(self, "table") and watched is self.table.horizontalHeader().viewport() and event.type() in {QEvent.Type.MouseButtonPress, QEvent.Type.MouseButtonRelease, QEvent.Type.MouseButtonDblClick}:
|
|
header = self.table.horizontalHeader()
|
|
position = event.position().toPoint()
|
|
column = header.logicalIndexAt(position)
|
|
if column in {11, 12} and event.button() == Qt.MouseButton.LeftButton:
|
|
relative = position.x() - header.sectionViewportPosition(column)
|
|
# Keep native column resizing, but never rank mixed-model display
|
|
# text or treat unavailable values as numeric zero through sorting.
|
|
if 5 < relative < header.sectionSize(column) - 5:
|
|
return True
|
|
return super().eventFilter(watched, event)
|
|
|
|
def _action_button(
|
|
self,
|
|
text: str,
|
|
permission: str,
|
|
handler: Callable[[], None],
|
|
*,
|
|
danger: bool = False,
|
|
) -> QPushButton:
|
|
# Keep permission-driven initial visibility inside the page hierarchy;
|
|
# otherwise Windows briefly exposes the button as its own window.
|
|
button = QPushButton(text, self)
|
|
button.setCursor(Qt.CursorShape.PointingHandCursor)
|
|
icon_kind = {
|
|
"查看": "eye",
|
|
"编辑": "pencil",
|
|
"删除": "trash",
|
|
}.get(text)
|
|
if icon_kind:
|
|
button.setIcon(
|
|
_painted_icon(icon_kind, "danger" if danger else "accent", 15)
|
|
)
|
|
button.setIconSize(QSize(15, 15))
|
|
if danger:
|
|
button.setProperty("variant", "danger")
|
|
button.setVisible(has_permission(self.permissions, permission))
|
|
button.setEnabled(False)
|
|
button.clicked.connect(handler)
|
|
return button
|
|
|
|
def _load_doctor_options(self) -> None:
|
|
"""Populate the creator multi-select from the repository's doctor catalog."""
|
|
|
|
method = getattr(self.repository, "list_diagnosis_doctors", None)
|
|
if not callable(method):
|
|
return
|
|
run_async(
|
|
method,
|
|
on_success=lambda result: self.doctor_filter.update_options(page_items(result)),
|
|
)
|
|
|
|
def _quick_date_changed(self) -> None:
|
|
custom = self.quick_date.currentData() == "custom"
|
|
self.start_time.setEnabled(custom)
|
|
self.end_time.setEnabled(custom)
|
|
self._search()
|
|
|
|
def _date_filters(self) -> tuple[str, str]:
|
|
value = self.quick_date.currentData()
|
|
if value == "all":
|
|
return "", ""
|
|
if value == "custom":
|
|
return (
|
|
self.start_time.dateTime().toString("yyyy-MM-dd HH:mm:ss"),
|
|
self.end_time.dateTime().toString("yyyy-MM-dd HH:mm:ss"),
|
|
)
|
|
offset = {"today": 0, "yesterday": 1, "before_yesterday": 2}.get(value, 0)
|
|
target = datetime.now().date() - timedelta(days=offset)
|
|
return (
|
|
f"{target.isoformat()} 00:00:00",
|
|
f"{target.isoformat()} 23:59:59",
|
|
)
|
|
|
|
def _search(self) -> None:
|
|
self._page = 1
|
|
self.refresh()
|
|
|
|
def _reset_filters(self) -> None:
|
|
self.quick_date.blockSignals(True)
|
|
self.quick_date.setCurrentIndex(0)
|
|
self.quick_date.blockSignals(False)
|
|
self.start_time.setEnabled(False)
|
|
self.end_time.setEnabled(False)
|
|
self.audit_filter.setCurrentIndex(1)
|
|
self.source_filter.setCurrentIndex(0)
|
|
self.sn_filter.clear()
|
|
self.patient_filter.clear()
|
|
self.doctor_filter.clear()
|
|
self._search()
|
|
|
|
def refresh(self) -> None:
|
|
self._ai_timer.stop()
|
|
self._ai_request_token += 1
|
|
self._ai_pending = False
|
|
self._ai_statuses.clear()
|
|
self._loading = True
|
|
self._refresh_pending = False
|
|
self._generation += 1
|
|
generation = self._generation
|
|
self._load_ai_capabilities()
|
|
page_size = self._page_size
|
|
start_time, end_time = self._date_filters()
|
|
filters: dict[str, Any] = {
|
|
"sn": self.sn_filter.text().strip(),
|
|
"patient_name": self.patient_filter.text().strip(),
|
|
"audit_filter": ""
|
|
if self.audit_filter.currentData() == "all"
|
|
else self.audit_filter.currentData(),
|
|
"source_filter": ""
|
|
if self.source_filter.currentData() == "all"
|
|
else self.source_filter.currentData(),
|
|
"start_time": start_time,
|
|
"end_time": end_time,
|
|
}
|
|
creator_ids = self.doctor_filter.values()
|
|
if creator_ids:
|
|
filters["creator_ids"] = creator_ids
|
|
# 列表加载不再挂横幅。横幅占布局空间，弹出与收起各触发一次重排，
|
|
# 每刷新一次表格就上下跳一次——而轮询定时器每 5 秒就刷新一次。
|
|
# 已有数据时保持旧行可见、静默替换；失败仍然照常报错。
|
|
self.pager.reload(
|
|
lambda page: invoke(self.repository, "prescriptions", page=page, page_size=page_size, **filters),
|
|
lambda result: self._apply_result(result, generation, self.pager.page),
|
|
lambda error: self._load_error(error, generation),
|
|
runner=run_async,
|
|
query_key=filters,
|
|
on_finished=lambda: self._load_finished(generation),
|
|
)
|
|
|
|
def _apply_result(self, result: Any, generation: int, requested_page: int) -> None:
|
|
if generation != self._generation:
|
|
return
|
|
rows = page_items(result)
|
|
self.table.set_rows(rows)
|
|
self._decorate_rows()
|
|
self._render_ai_statuses()
|
|
total = page_total(result, len(rows))
|
|
self.pager.update_state(requested_page, total)
|
|
self.count_badge.setText(f"共 {total} 条")
|
|
motion.switch_stack(self.stack, 0 if rows else 1)
|
|
doctor_rows = []
|
|
for row in rows:
|
|
doctor_rows.append(
|
|
{
|
|
"id": first_value(row, "creator_id", "doctor_id"),
|
|
"name": first_value(row, "doctor_name", "creator_name"),
|
|
}
|
|
)
|
|
extend_doctors = get_value(result, "extend.doctors", None) or get_value(
|
|
result, "doctors", None
|
|
)
|
|
if isinstance(extend_doctors, (list, tuple)):
|
|
doctor_rows.extend(extend_doctors)
|
|
self.doctor_filter.update_options(doctor_rows)
|
|
self.banner.clear()
|
|
if rows and self.table.currentRow() < 0:
|
|
self.table.selectRow(0)
|
|
self._selection_changed()
|
|
self._load_ai_statuses()
|
|
|
|
def _decorate_rows(self) -> None:
|
|
"""Apply the reference table's tags, checkbox, avatar, and row actions."""
|
|
|
|
sorting = self.table.isSortingEnabled()
|
|
self.table.setUpdatesEnabled(False)
|
|
self.table.setSortingEnabled(False)
|
|
try:
|
|
self._decorate_rows_locked()
|
|
finally:
|
|
self.table.setSortingEnabled(sorting)
|
|
self.table.setUpdatesEnabled(True)
|
|
|
|
def _decorate_rows_locked(self) -> None:
|
|
for row_index in range(self.table.rowCount()):
|
|
selector = self.table.item(row_index, 0)
|
|
if selector is None:
|
|
continue
|
|
# Read the row back from the visual table. SortableTable may have
|
|
# already reordered rows, so decorating the original result list
|
|
# can bind an action button to the wrong visible prescription.
|
|
row = selector.data(Qt.ItemDataRole.UserRole)
|
|
if row is None:
|
|
continue
|
|
selector.setFlags(
|
|
selector.flags()
|
|
| Qt.ItemFlag.ItemIsUserCheckable
|
|
| Qt.ItemFlag.ItemIsEnabled
|
|
| Qt.ItemFlag.ItemIsSelectable
|
|
)
|
|
selector.setCheckState(Qt.CheckState.Unchecked)
|
|
selector.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
|
|
sn_item = self.table.item(row_index, 1)
|
|
if sn_item is not None:
|
|
sn_item.setForeground(QColor("#1A1C1F"))
|
|
font = sn_item.font()
|
|
font.setWeight(QFont.Weight.Normal)
|
|
sn_item.setFont(font)
|
|
warnings = _order_warnings(row)
|
|
description = "\n".join(
|
|
[sn_item.text(), f"ID: {first_value(row, 'id', 'prescription_id', default='—')}", *warnings]
|
|
)
|
|
sn_item.setToolTip(description)
|
|
sn_item.setData(Qt.ItemDataRole.AccessibleTextRole, description)
|
|
|
|
type_item = self.table.item(row_index, 3)
|
|
if type_item is not None:
|
|
type_item.setText(
|
|
display_text(first_value(row, "prescription_type", default="—"))
|
|
)
|
|
type_item.setData(_ROLE_TAG_KIND, "accent")
|
|
type_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
|
|
audit_text, audit_kind = prescription_status(row)
|
|
audit_item = self.table.item(row_index, 6)
|
|
if audit_item is not None:
|
|
if "\n" in audit_item.text():
|
|
audit_item.setToolTip(audit_item.text())
|
|
audit_item.setText(audit_text)
|
|
audit_item.setData(_ROLE_TAG_KIND, audit_kind)
|
|
audit_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
|
|
|
|
doctor_item = self.table.item(row_index, 8)
|
|
if doctor_item is not None:
|
|
doctor_item.setData(_ROLE_AVATAR, _doctor_cell(None, row))
|
|
|
|
# 保持宿主透明，让整行的斑马底色与选中底色透过操作列。
|
|
actions_host = QWidget(self.table.viewport())
|
|
actions = QHBoxLayout(actions_host)
|
|
actions.setContentsMargins(3, 0, 3, 0)
|
|
actions.setSpacing(3)
|
|
actions.addStretch(1)
|
|
if has_permission(self.permissions, "cf.prescription/read"):
|
|
actions.addWidget(
|
|
_row_action_button(
|
|
"eye",
|
|
"查看处方",
|
|
lambda _checked=False, target=row: self._run_row_action(
|
|
target, self._view_selected
|
|
),
|
|
actions_host,
|
|
)
|
|
)
|
|
if self._ai_enabled and can_open_issued_ai(self.permissions) and not _is_blank_prescription(row):
|
|
actions.addWidget(
|
|
_row_action_button(
|
|
"eye", "AI 报告",
|
|
lambda _checked=False, target=row: self._run_row_action(target, self._open_ai_report),
|
|
actions_host, label="AI",
|
|
)
|
|
)
|
|
if has_permission(self.permissions, "cf.prescription/edit"):
|
|
actions.addWidget(
|
|
_row_action_button(
|
|
"pencil",
|
|
"编辑处方",
|
|
lambda _checked=False, target=row: self._run_row_action(
|
|
target, self._edit_selected
|
|
),
|
|
actions_host,
|
|
enabled=can_edit_or_delete(row),
|
|
label="编辑",
|
|
mutation=True,
|
|
)
|
|
)
|
|
if has_permission(self.permissions, "cf.prescription/del"):
|
|
actions.addWidget(
|
|
_row_action_button(
|
|
"trash",
|
|
"删除处方",
|
|
lambda _checked=False, target=row: self._run_row_action(
|
|
target, self._delete_selected
|
|
),
|
|
actions_host,
|
|
danger=True,
|
|
enabled=can_edit_or_delete(row),
|
|
mutation=True,
|
|
)
|
|
)
|
|
actions.addStretch(1)
|
|
self.table.setCellWidget(row_index, 2, actions_host)
|
|
self._sync_row_mutation_actions()
|
|
self.table.resizeRowsToContents()
|
|
|
|
def _visible_ai_ids(self) -> list[int]:
|
|
if not self.isVisible() or not self.table.isVisible():
|
|
return []
|
|
ids = []
|
|
viewport = self.table.viewport().rect()
|
|
for index in range(self.table.rowCount()):
|
|
item = self.table.item(index, 0)
|
|
# Column 0 may be horizontally off-screen; use row geometry only.
|
|
top = self.table.rowViewportPosition(index)
|
|
if item is None or top + self.table.rowHeight(index) <= 0 or top >= viewport.height():
|
|
continue
|
|
row = item.data(Qt.ItemDataRole.UserRole)
|
|
if _is_blank_prescription(row):
|
|
continue
|
|
value = _int(first_value(row, "id", "prescription_id"), 0)
|
|
if value > 0:
|
|
ids.append(value)
|
|
return list(dict.fromkeys(ids))[:100]
|
|
|
|
def _schedule_ai_statuses(self) -> None:
|
|
if self.isVisible():
|
|
self._ai_scroll_timer.start()
|
|
|
|
def _load_ai_statuses(self) -> None:
|
|
only_blank = self.table.rowCount() > 0 and all(
|
|
_is_blank_prescription(self.table.item(index, 0).data(Qt.ItemDataRole.UserRole))
|
|
for index in range(self.table.rowCount())
|
|
)
|
|
self.ai_status_notice.setVisible(not only_blank)
|
|
if only_blank:
|
|
self._ai_timer.stop()
|
|
self._set_ai_columns(False)
|
|
return
|
|
method = getattr(self.repository, "list_prescription_ai_statuses", None)
|
|
if not has_permission(self.permissions, "tcm.prescriptionAi/statuses", default=False):
|
|
self._set_ai_columns(False)
|
|
self.ai_status_notice.setText("AI 分析：当前账号没有查看分析状态的权限，请联系管理员授权。")
|
|
return
|
|
if not callable(method):
|
|
self.ai_status_notice.setText("AI 分析：当前数据模式暂不支持此功能。")
|
|
return
|
|
if self._ai_pending:
|
|
return
|
|
ids = self._visible_ai_ids()
|
|
ids = [value for value in ids if value not in self._ai_statuses or batch_running(self._ai_statuses[value])]
|
|
if not ids:
|
|
self._ai_timer.stop()
|
|
if self.table.rowCount() == 0:
|
|
self.ai_status_notice.setText("AI 分析：当前列表没有处方，暂无可查看的分析结果。")
|
|
return
|
|
self._ai_pending = True
|
|
self._ai_request_token += 1
|
|
token, generation = self._ai_request_token, self._generation
|
|
run_async(
|
|
lambda: method(ids),
|
|
on_success=lambda result: self._ai_statuses_ready(result, ids, token, generation),
|
|
on_error=lambda error: self._ai_statuses_error(error, token, generation),
|
|
on_finished=lambda: self._ai_statuses_finished(token),
|
|
)
|
|
|
|
def _ai_statuses_finished(self, token: int) -> None:
|
|
if token == self._ai_request_token:
|
|
self._ai_pending = False
|
|
|
|
def _set_ai_columns(self, enabled: bool) -> None:
|
|
changed = enabled != self._ai_enabled
|
|
self._ai_enabled = enabled
|
|
self.table.setColumnHidden(11, not enabled)
|
|
self.table.setColumnHidden(12, not (enabled and self._agreement_visible))
|
|
if enabled:
|
|
header = self.table.horizontalHeader()
|
|
header.moveSection(header.visualIndex(11), header.visualIndex(4) + 1)
|
|
header.moveSection(header.visualIndex(12), header.visualIndex(11) + 1)
|
|
self.table.setColumnWidth(11, 144)
|
|
self.table.setColumnWidth(12, 130)
|
|
self.table.setColumnWidth(2, 178)
|
|
if changed:
|
|
self._decorate_rows()
|
|
|
|
def _set_agreement_visible(self, visible: bool) -> None:
|
|
self._agreement_visible = visible
|
|
self.table.setColumnHidden(12, not (self._ai_enabled and visible))
|
|
self.ai_statistics_button.setVisible(
|
|
visible and has_permission(self.permissions, "tcm.prescriptionAi/statistics", default=False)
|
|
and callable(getattr(self.repository, "prescription_ai_statistics", None)))
|
|
if not visible:
|
|
self._ai_statuses = {key: agreement_safe_batch(row, False) for key, row in self._ai_statuses.items()}
|
|
for index in range(self.table.rowCount()):
|
|
item = self.table.item(index, 12)
|
|
if item is not None:
|
|
item.setText("")
|
|
item.setToolTip("")
|
|
item.setData(Qt.ItemDataRole.AccessibleTextRole, "")
|
|
|
|
def _load_ai_capabilities(self) -> None:
|
|
self._ai_capability_token += 1
|
|
token, generation = self._ai_capability_token, self._generation
|
|
self._ai_request_token += 1
|
|
self._ai_pending = False
|
|
self._capability_agreement_visible = False
|
|
self._set_agreement_visible(False)
|
|
method = getattr(self.repository, "get_prescription_ai_capabilities", None)
|
|
self._ai_capability_pending = callable(method)
|
|
if not callable(method):
|
|
return
|
|
run_async(method,
|
|
on_success=lambda result: self._ai_capabilities_ready(result, token, generation),
|
|
on_error=lambda _error: self._ai_capabilities_ready({}, token, generation))
|
|
|
|
def _ai_capabilities_ready(self, result: Any, token: int, generation: int) -> None:
|
|
if token != self._ai_capability_token or generation != self._generation:
|
|
return
|
|
self._ai_capability_pending = False
|
|
self._capability_agreement_visible = _row_mapping(result).get("agreement_visible") is True
|
|
self._set_agreement_visible(self._capability_agreement_visible)
|
|
if self._capability_agreement_visible:
|
|
# A previous deny discarded scores, including completed cached batches.
|
|
# Fetch them again after a fresh grant rather than displaying that cache.
|
|
self._ai_statuses.clear()
|
|
if self.isVisible() and not self._loading:
|
|
self._load_ai_statuses()
|
|
|
|
def _ai_statuses_ready(self, result: Any, ids: list[int], token: int, generation: int) -> None:
|
|
if token != self._ai_request_token or generation != self._generation or not self.isVisible():
|
|
return
|
|
data = _row_mapping(result)
|
|
self._set_agreement_visible(self._capability_agreement_visible and data.get("agreement_visible") is True)
|
|
self._set_ai_columns(data.get("enabled") is True)
|
|
if not self._ai_enabled:
|
|
self._ai_timer.stop()
|
|
notice = "AI 分析未启用：暂不生成报告或一致度，请联系管理员启用。"
|
|
if can_open_issued_ai(self.permissions):
|
|
notice += "已有报告仍可从“AI 报告”查看。"
|
|
self.ai_status_notice.setText(notice)
|
|
self.ai_status_notice.setToolTip("")
|
|
self.ai_report_button.setToolTip("自动分析未启用；仍可查看已保存的历史报告。")
|
|
return
|
|
self.ai_status_notice.setText("AI 分析已启用：保存手工处方后自动生成两份报告。"
|
|
+ ("可查看药味与剂量一致度。" if self._agreement_visible else ""))
|
|
self.ai_status_notice.setToolTip("")
|
|
self.ai_report_button.setToolTip("查看两份 AI 报告和候选处方。"
|
|
+ ("可查看逐味对照。" if self._agreement_visible else ""))
|
|
for value in ids:
|
|
self._ai_statuses[value] = {}
|
|
for batch in data.get("items") or []:
|
|
value = _int(get_value(batch, "prescription_id"), 0)
|
|
if value in ids:
|
|
self._ai_statuses[value] = agreement_safe_batch(batch, self._agreement_visible and _row_mapping(batch).get("agreement_visible") is True)
|
|
self._render_ai_statuses()
|
|
if any(batch_running(self._ai_statuses.get(value)) for value in self._visible_ai_ids()):
|
|
self._ai_timer.start()
|
|
else:
|
|
self._ai_timer.stop()
|
|
|
|
def _render_ai_statuses(self) -> None:
|
|
sorting = self.table.isSortingEnabled()
|
|
self.table.setSortingEnabled(False)
|
|
changed = False
|
|
try:
|
|
for index in range(self.table.rowCount()):
|
|
row = self.table.item(index, 0).data(Qt.ItemDataRole.UserRole)
|
|
value = _int(first_value(row, "id", "prescription_id"), 0)
|
|
batch = self._ai_statuses.get(value)
|
|
blank = _is_blank_prescription(row)
|
|
if batch is None and not blank:
|
|
continue
|
|
state = "" if blank else (state_text(batch) if batch else "尚无分析记录")
|
|
agreement = "" if blank or not self._agreement_visible else agreement_text(batch)
|
|
for column, text in ((11, state), (12, agreement)):
|
|
item = self.table.item(index, column)
|
|
if item.text() != text:
|
|
item.setText(text)
|
|
changed = True
|
|
item.setToolTip("" if blank or column == 12 and not self._agreement_visible else status_tooltip(batch))
|
|
item.setData(Qt.ItemDataRole.AccessibleTextRole, text)
|
|
if changed:
|
|
self.table.resizeRowsToContents()
|
|
finally:
|
|
self.table.setSortingEnabled(sorting)
|
|
|
|
def _ai_statuses_error(self, error: Exception, token: int, generation: int) -> None:
|
|
if token == self._ai_request_token and generation == self._generation:
|
|
self._ai_timer.stop()
|
|
self._set_agreement_visible(False)
|
|
self._set_ai_columns(False)
|
|
self.ai_status_notice.setText("AI 分析暂不可用：请稍后刷新；持续无法使用时，请联系管理员检查服务。")
|
|
self.ai_status_notice.setToolTip(friendly_error(error))
|
|
self.ai_report_button.setToolTip("AI 状态暂不可用：" + friendly_error(error))
|
|
|
|
def _open_ai_report(self) -> None:
|
|
row = self._selected()
|
|
if _is_blank_prescription(row):
|
|
return
|
|
value = _int(first_value(row, "id", "prescription_id"), 0)
|
|
if value > 0:
|
|
present_issued_prescription_ai(self.repository, self.permissions, self, prescription_id=value)
|
|
|
|
def _open_ai_context_menu(self, position: Any) -> None:
|
|
if not can_open_issued_ai(self.permissions) or not callable(getattr(self.repository, "list_prescription_ai_reports", None)):
|
|
return
|
|
item = self.table.itemAt(position)
|
|
if item is None:
|
|
return
|
|
self.table.selectRow(item.row())
|
|
row = self._selected()
|
|
if _is_blank_prescription(row):
|
|
return
|
|
menu = QMenu(self.table)
|
|
action = menu.addAction("AI 报告 / 逐味对照" if self._agreement_visible else "AI 报告")
|
|
action.triggered.connect(lambda: self._run_row_action(row, self._open_ai_report))
|
|
self._ai_context_menu = menu
|
|
menu.popup(self.table.viewport().mapToGlobal(position))
|
|
|
|
def _open_ai_statistics(self) -> None:
|
|
if not self._agreement_visible or not has_permission(self.permissions, "tcm.prescriptionAi/statistics", default=False):
|
|
return
|
|
dialog = PrescriptionAiStatisticsDialog(self.repository, self.permissions, self)
|
|
dialog.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
|
|
dialog.show()
|
|
|
|
def _run_row_action(self, row: Any, callback: Callable[[], None]) -> None:
|
|
target_id = _int(first_value(row, "id", "prescription_id", default=None), 0)
|
|
if target_id <= 0:
|
|
self.banner.show_message("处方 ID 无效，请刷新列表后重试。", "warning")
|
|
return
|
|
for row_index in range(self.table.rowCount()):
|
|
item = self.table.item(row_index, 0)
|
|
candidate = item.data(Qt.ItemDataRole.UserRole) if item is not None else None
|
|
candidate_id = _int(
|
|
first_value(candidate, "id", "prescription_id", default=None), 0
|
|
)
|
|
if candidate is row or (
|
|
candidate_id > 0 and candidate_id == target_id
|
|
):
|
|
self.table.selectRow(row_index)
|
|
callback()
|
|
return
|
|
self.banner.show_message("该处方已不在当前列表，请刷新后重试。", "warning")
|
|
|
|
def _load_error(self, error: Exception, generation: int) -> None:
|
|
if generation == self._generation:
|
|
self.banner.show_message(friendly_error(error), "danger")
|
|
|
|
def _load_finished(self, generation: int) -> None:
|
|
if generation == self._generation:
|
|
self._loading = False
|
|
if self._refresh_pending:
|
|
self._refresh_pending = False
|
|
self.refresh()
|
|
|
|
def _selection_changed(self) -> None:
|
|
row = self.table.current_data()
|
|
active = not self._mutation_pending
|
|
self.view_button.setEnabled(active and row is not None)
|
|
ai_available = (
|
|
not _is_blank_prescription(row)
|
|
and can_open_issued_ai(self.permissions)
|
|
and callable(getattr(self.repository, "list_prescription_ai_reports", None))
|
|
)
|
|
self.ai_report_button.setVisible(ai_available)
|
|
self.ai_report_button.setEnabled(ai_available)
|
|
self.patch_button.setEnabled(active and can_patch_patient(row))
|
|
self.create_order_button.setEnabled(active and can_create_order(row))
|
|
self.edit_button.setEnabled(active and can_edit_or_delete(row))
|
|
self.audit_button.setEnabled(active and can_audit(row))
|
|
self.delete_button.setEnabled(active and can_edit_or_delete(row))
|
|
|
|
def _set_mutation_pending(self, pending: bool) -> None:
|
|
self._mutation_pending = pending
|
|
self.add_button.setEnabled(not pending)
|
|
self.orders_button.setEnabled(not pending)
|
|
self._sync_row_mutation_actions()
|
|
self._selection_changed()
|
|
|
|
def _sync_row_mutation_actions(self) -> None:
|
|
for button in self.table.findChildren(QPushButton):
|
|
if not bool(button.property("mutationAction")):
|
|
continue
|
|
button.setEnabled(
|
|
not self._mutation_pending and bool(button.property("rowAllowed"))
|
|
)
|
|
|
|
def _selected(self) -> Any:
|
|
return self.table.current_data()
|
|
|
|
def _get_prescription(self, prescription_id: int) -> Any:
|
|
method = self.repository.get_prescription
|
|
return method(prescription_id)
|
|
|
|
def _load_detail(
|
|
self,
|
|
row: Any,
|
|
callback: Callable[[Any], None],
|
|
*,
|
|
message: str = "正在加载处方详情…",
|
|
) -> None:
|
|
prescription_id = _int(first_value(row, "id", "prescription_id"), 0)
|
|
if not prescription_id:
|
|
self.banner.show_message("处方 ID 无效。", "warning")
|
|
return
|
|
self._detail_generation += 1
|
|
generation = self._detail_generation
|
|
self._detail_target = prescription_id
|
|
self.banner.show_message(message, "info")
|
|
run_async(
|
|
lambda: self._get_prescription(prescription_id),
|
|
on_success=lambda detail: self._detail_success(
|
|
detail, prescription_id, generation, callback
|
|
),
|
|
on_error=lambda error: self._detail_error(error, prescription_id, generation),
|
|
)
|
|
|
|
def _detail_success(
|
|
self,
|
|
detail: Any,
|
|
prescription_id: int,
|
|
generation: int,
|
|
callback: Callable[[Any], None],
|
|
) -> None:
|
|
if generation != self._detail_generation or prescription_id != self._detail_target:
|
|
return
|
|
detail_id = _int(first_value(detail, "id", "prescription_id"), 0)
|
|
if detail_id != prescription_id:
|
|
self.banner.show_message("处方详情与当前选择不一致，请刷新后重试。", "danger")
|
|
return
|
|
self.banner.clear()
|
|
callback(detail)
|
|
|
|
def _detail_error(self, error: Exception, prescription_id: int, generation: int) -> None:
|
|
if generation == self._detail_generation and prescription_id == self._detail_target:
|
|
self.banner.show_message(friendly_error(error), "danger")
|
|
|
|
def _view_selected(self) -> None:
|
|
row = self._selected()
|
|
if row is None or not has_permission(self.permissions, "cf.prescription/read"):
|
|
return
|
|
self._load_detail(row, self._show_detail)
|
|
|
|
def _show_detail(self, detail: Any) -> None:
|
|
if not has_permission(self.permissions, "cf.prescription/read"):
|
|
return
|
|
dialog = PrescriptionDetailDialog(
|
|
detail,
|
|
can_open_diagnosis=has_permission(self.permissions, "tcm.diagnosis/readonlyDetail"),
|
|
can_open_orders=has_permission(self.permissions, "tcm.prescriptionOrder/lists"),
|
|
parent=self,
|
|
)
|
|
dialog.diagnosis_requested.connect(self._open_diagnosis)
|
|
dialog.orders_requested.connect(lambda prescription_id: self._open_orders(prescription_id))
|
|
dialog.exec()
|
|
|
|
def _open_diagnosis(self, diagnosis_id: int) -> None:
|
|
if not has_permission(self.permissions, "tcm.diagnosis/readonlyDetail"):
|
|
self.banner.show_message("无权查看诊单详情。", "danger")
|
|
return
|
|
diagnosis_id = _int(diagnosis_id, 0)
|
|
if diagnosis_id <= 0:
|
|
self.banner.show_message("诊单 ID 无效。", "warning")
|
|
return
|
|
method = getattr(self.repository, "get_diagnosis_detail", None)
|
|
readonly_keyword = True
|
|
if not callable(method):
|
|
method = getattr(self.repository, "diagnosis_readonly_detail", None)
|
|
readonly_keyword = False
|
|
if not callable(method):
|
|
self.banner.show_message("当前 repository 不支持诊单详情。", "danger")
|
|
return
|
|
self._diagnosis_detail_generation += 1
|
|
generation = self._diagnosis_detail_generation
|
|
self._diagnosis_detail_target = diagnosis_id
|
|
self.banner.show_message("正在加载诊单详情…", "info")
|
|
run_async(
|
|
lambda: (
|
|
method(diagnosis_id, readonly=True) if readonly_keyword else method(diagnosis_id)
|
|
),
|
|
on_success=lambda detail: self._diagnosis_detail_success(
|
|
detail, diagnosis_id, generation
|
|
),
|
|
on_error=lambda error: self._diagnosis_detail_error(error, diagnosis_id, generation),
|
|
)
|
|
|
|
def _diagnosis_detail_success(self, detail: Any, diagnosis_id: int, generation: int) -> None:
|
|
if (
|
|
generation != self._diagnosis_detail_generation
|
|
or diagnosis_id != self._diagnosis_detail_target
|
|
):
|
|
return
|
|
self.banner.clear()
|
|
DiagnosisDetailDialog(
|
|
detail,
|
|
self,
|
|
repository=self.repository,
|
|
permissions=self.permissions,
|
|
).exec()
|
|
|
|
def _diagnosis_detail_error(self, error: Exception, diagnosis_id: int, generation: int) -> None:
|
|
if (
|
|
generation == self._diagnosis_detail_generation
|
|
and diagnosis_id == self._diagnosis_detail_target
|
|
):
|
|
self.banner.show_message(friendly_error(error), "danger")
|
|
|
|
def _add_prescription(self) -> None:
|
|
if not has_permission(self.permissions, "cf.prescription/add"):
|
|
return
|
|
dialog = PrescriptionEditorDialog(
|
|
self.repository,
|
|
mode="add",
|
|
current_user=self.current_user,
|
|
parent=self,
|
|
)
|
|
dialog.diagnosis_requested.connect(self._open_diagnosis)
|
|
if dialog.exec() == QDialog.DialogCode.Accepted:
|
|
self._save_prescription(dialog.payload(), None)
|
|
|
|
def _edit_selected(self) -> None:
|
|
row = self._selected()
|
|
if (
|
|
row is None
|
|
or self._mutation_pending
|
|
or not has_permission(self.permissions, "cf.prescription/edit")
|
|
or not can_edit_or_delete(row)
|
|
):
|
|
return
|
|
self._load_detail(
|
|
row,
|
|
lambda detail: self._open_editor(merge_prescription_detail(row, detail)),
|
|
message="正在准备编辑处方…",
|
|
)
|
|
|
|
def _open_editor(self, detail: Any) -> None:
|
|
if not can_edit_or_delete(detail):
|
|
self.banner.show_message("该处方状态已变化，当前不能编辑。", "warning")
|
|
return
|
|
dialog = PrescriptionEditorDialog(
|
|
self.repository,
|
|
detail,
|
|
mode="edit",
|
|
current_user=self.current_user,
|
|
parent=self,
|
|
)
|
|
dialog.diagnosis_requested.connect(self._open_diagnosis)
|
|
if dialog.exec() == QDialog.DialogCode.Accepted:
|
|
self._save_prescription(
|
|
dialog.payload(),
|
|
_int(first_value(detail, "id", "prescription_id"), 0),
|
|
)
|
|
|
|
def _save_prescription(
|
|
self,
|
|
payload: dict[str, Any],
|
|
prescription_id: int | None,
|
|
) -> None:
|
|
permission = "cf.prescription/edit" if prescription_id else "cf.prescription/add"
|
|
if not has_permission(self.permissions, permission):
|
|
return
|
|
self._set_mutation_pending(True)
|
|
if prescription_id:
|
|
|
|
def operation() -> Any:
|
|
return self.repository.update_prescription(
|
|
prescription_id,
|
|
changes=payload,
|
|
)
|
|
|
|
message = "处方已保存并重新进入待审核。"
|
|
else:
|
|
|
|
def operation() -> Any:
|
|
return self.repository.create_prescription(payload)
|
|
|
|
message = "处方已新增并提交审核。"
|
|
run_async(
|
|
operation,
|
|
on_success=lambda _result: self._mutation_success(message),
|
|
on_error=self._mutation_error,
|
|
on_finished=lambda: self._set_mutation_pending(False),
|
|
)
|
|
|
|
def _delete_selected(self) -> None:
|
|
row = self._selected()
|
|
if (
|
|
row is None
|
|
or self._mutation_pending
|
|
or not has_permission(self.permissions, "cf.prescription/del")
|
|
or not can_edit_or_delete(row)
|
|
):
|
|
return
|
|
answer = QMessageBox.warning(
|
|
self,
|
|
"删除处方",
|
|
"确定删除该处方吗？此操作无法撤销。",
|
|
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel,
|
|
QMessageBox.StandardButton.Cancel,
|
|
)
|
|
if answer != QMessageBox.StandardButton.Yes:
|
|
return
|
|
prescription_id = _int(first_value(row, "id", "prescription_id"), 0)
|
|
if prescription_id <= 0:
|
|
self.banner.show_message("处方 ID 无效，请刷新列表后重试。", "warning")
|
|
return
|
|
self._set_mutation_pending(True)
|
|
run_async(
|
|
lambda: self.repository.delete_prescription(prescription_id),
|
|
on_success=lambda _result: self._mutation_success("处方已删除。"),
|
|
on_error=self._mutation_error,
|
|
on_finished=lambda: self._set_mutation_pending(False),
|
|
)
|
|
|
|
def _patch_selected(self) -> None:
|
|
row = self._selected()
|
|
if (
|
|
row is None
|
|
or not has_permission(self.permissions, "tcm.prescription/patchPatient")
|
|
or not can_patch_patient(row)
|
|
):
|
|
return
|
|
dialog = PatchPatientDialog(row, self)
|
|
if dialog.exec() != QDialog.DialogCode.Accepted:
|
|
return
|
|
payload = dialog.payload()
|
|
self._set_mutation_pending(True)
|
|
run_async(
|
|
lambda: self.repository.patch_prescription_patient(
|
|
payload["id"],
|
|
patient_name=payload["patient_name"],
|
|
phone=payload["phone"],
|
|
gender=payload["gender"],
|
|
),
|
|
on_success=lambda _result: self._mutation_success("患者信息已修正。"),
|
|
on_error=self._mutation_error,
|
|
on_finished=lambda: self._set_mutation_pending(False),
|
|
)
|
|
|
|
def _audit_selected(self) -> None:
|
|
row = self._selected()
|
|
if (
|
|
row is None
|
|
or not has_permission(self.permissions, "cf.prescription/audit")
|
|
or not can_audit(row)
|
|
):
|
|
return
|
|
dialog = AuditPrescriptionDialog(row, self)
|
|
if dialog.exec() != QDialog.DialogCode.Accepted:
|
|
return
|
|
payload = dialog.payload()
|
|
self._set_mutation_pending(True)
|
|
run_async(
|
|
lambda: self.repository.audit_prescription(
|
|
payload["id"],
|
|
action=payload["action"],
|
|
remark=payload["remark"],
|
|
),
|
|
on_success=lambda result: self._audit_success(result, payload["action"]),
|
|
on_error=self._mutation_error,
|
|
on_finished=lambda: self._set_mutation_pending(False),
|
|
)
|
|
|
|
def _audit_success(self, result: Any, action: str) -> None:
|
|
message = "处方已驳回并作废。" if action == "reject" else "处方审核已通过。"
|
|
self._mutation_success(message)
|
|
if (
|
|
isinstance(result, Mapping)
|
|
and result.get("wecom_notify_ok") is False
|
|
and result.get("wecom_notify_hint")
|
|
):
|
|
show_toast(self, str(result["wecom_notify_hint"]), "warning", 5000)
|
|
|
|
def _create_order(self) -> None:
|
|
row = self._selected()
|
|
if (
|
|
row is None
|
|
or not has_permission(self.permissions, "tcm.prescriptionOrder/create")
|
|
or not can_create_order(row)
|
|
):
|
|
return
|
|
self._load_detail(row, self._open_order_editor, message="正在准备业务订单…")
|
|
|
|
def _open_order_editor(self, detail: Any) -> None:
|
|
if not has_permission(self.permissions, "tcm.prescriptionOrder/create"):
|
|
return
|
|
dialog = PrescriptionOrderDialog(
|
|
self.repository,
|
|
detail,
|
|
can_select_ship_mode=has_permission(
|
|
self.permissions, "tcm.prescriptionOrder/setShipMode"
|
|
),
|
|
can_view_internal_cost=has_permission(self.permissions, "finance.account_log/lists"),
|
|
can_edit_pharmacy_remark=has_permission(
|
|
self.permissions, "tcm.prescriptionOrder/editRemarkExtra"
|
|
),
|
|
parent=self,
|
|
)
|
|
if dialog.exec() != QDialog.DialogCode.Accepted:
|
|
return
|
|
payload = dialog.payload()
|
|
self._set_mutation_pending(True)
|
|
run_async(
|
|
lambda: self.repository.create_prescription_order(payload),
|
|
on_success=lambda result: self._order_created(result),
|
|
on_error=self._mutation_error,
|
|
on_finished=lambda: self._set_mutation_pending(False),
|
|
)
|
|
|
|
def _order_created(self, result: Any) -> None:
|
|
order_no = first_value(result, "order_no", "data.order_no", default="")
|
|
message = f"业务订单已创建：{order_no}" if order_no else "业务订单已创建。"
|
|
self._mutation_success(message)
|
|
|
|
def _open_orders(self, prescription_id: int | None = None) -> None:
|
|
if not has_permission(self.permissions, "tcm.prescriptionOrder/lists"):
|
|
return
|
|
PrescriptionOrderListDialog(
|
|
self.repository,
|
|
prescription_id=prescription_id,
|
|
permissions=self.permissions,
|
|
parent=self,
|
|
).exec()
|
|
|
|
def _mutation_success(self, message: str) -> None:
|
|
self.banner.clear()
|
|
show_toast(self, message, "success", 3600)
|
|
self.refresh()
|
|
|
|
def _mutation_error(self, error: Exception) -> None:
|
|
message = friendly_error(error)
|
|
self.banner.show_message(message, "danger")
|
|
show_toast(self, message, "danger", 5000)
|
|
|
|
def showEvent(self, event: Any) -> None:
|
|
super().showEvent(event)
|
|
if self.table.rowCount() == 0 and not self._loading:
|
|
self.refresh()
|
|
elif not self._loading:
|
|
self._load_ai_capabilities()
|
|
|
|
def hideEvent(self, event: Any) -> None:
|
|
self._ai_timer.stop()
|
|
self._ai_scroll_timer.stop()
|
|
self._ai_request_token += 1
|
|
self._ai_capability_token += 1
|
|
self._ai_capability_pending = False
|
|
self._ai_pending = False
|
|
super().hideEvent(event)
|
|
|
|
|
|
__all__ = [
|
|
"InfiniteList",
|
|
"PrescriptionsPage",
|
|
"can_audit",
|
|
"can_create_order",
|
|
"can_edit_or_delete",
|
|
"can_patch_patient",
|
|
"is_approved_active",
|
|
"prescription_status",
|
|
]
|