1866 lines
71 KiB
Python
1866 lines
71 KiB
Python
"""Element-aligned appointment drawer used by patient and diagnosis workspaces."""
|
||
|
||
from __future__ import annotations
|
||
|
||
from collections.abc import Callable, Mapping, Sequence
|
||
from contextlib import suppress
|
||
from types import MappingProxyType
|
||
from typing import Any
|
||
|
||
from PySide6.QtCore import (
|
||
QDate,
|
||
QEvent,
|
||
QPoint,
|
||
QRect,
|
||
QSize,
|
||
Qt,
|
||
QTime,
|
||
QTimer,
|
||
)
|
||
from PySide6.QtGui import QColor, QMouseEvent, QPainter, QPaintEvent, QPen, QResizeEvent
|
||
from PySide6.QtWidgets import (
|
||
QButtonGroup,
|
||
QComboBox,
|
||
QDialog,
|
||
QFrame,
|
||
QGraphicsDropShadowEffect,
|
||
QGraphicsOpacityEffect,
|
||
QHBoxLayout,
|
||
QLabel,
|
||
QLayout,
|
||
QLayoutItem,
|
||
QLineEdit,
|
||
QPlainTextEdit,
|
||
QPushButton,
|
||
QRadioButton,
|
||
QScrollArea,
|
||
QSizePolicy,
|
||
QStackedWidget,
|
||
QStyle,
|
||
QToolButton,
|
||
QVBoxLayout,
|
||
QWidget,
|
||
)
|
||
|
||
from ..core.appointment_modes import APPOINTMENT_MODES
|
||
from .theme import main_window_target_rect
|
||
from .widgets import (
|
||
display_text,
|
||
first_value,
|
||
friendly_error,
|
||
get_value,
|
||
invoke,
|
||
page_items,
|
||
run_async,
|
||
)
|
||
|
||
APPOINTMENT_DRAWER_QSS = r"""
|
||
QDialog#AppointmentDrawerOverlay {
|
||
background-color: transparent;
|
||
color: #1A1C1F;
|
||
font-size: 14px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerPanel {
|
||
background-color: #FFFFFF;
|
||
border-left: 1px solid #EDEDEE;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerHeader {
|
||
background-color: #FFFFFF;
|
||
border: 0;
|
||
border-bottom: 1px solid #EDEDEE;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QLabel#AppointmentDrawerTitle {
|
||
color: #1A1C1F;
|
||
font-size: 18px;
|
||
font-weight: 600;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QToolButton#AppointmentDrawerClose {
|
||
min-width: 32px;
|
||
max-width: 32px;
|
||
min-height: 32px;
|
||
max-height: 32px;
|
||
padding: 0;
|
||
border: 0;
|
||
border-radius: 4px;
|
||
background-color: transparent;
|
||
color: #606163;
|
||
font-size: 22px;
|
||
font-weight: 400;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QToolButton#AppointmentDrawerClose:hover {
|
||
color: #1A1C1F;
|
||
background-color: #F0F0F0;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QScrollArea#AppointmentDrawerBody,
|
||
QDialog#AppointmentDrawerOverlay QScrollArea#AppointmentSlotScroll,
|
||
QDialog#AppointmentDrawerOverlay QScrollArea#AppointmentDrawerBody > QWidget > QWidget,
|
||
QDialog#AppointmentDrawerOverlay QScrollArea#AppointmentSlotScroll > QWidget > QWidget {
|
||
border: 0;
|
||
background-color: #FFFFFF;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QWidget#AppointmentDrawerBodyContent {
|
||
background-color: #FFFFFF;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QLabel[appointmentLabel="true"] {
|
||
color: #1A1C1F;
|
||
font-size: 14px;
|
||
font-weight: 500;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QLabel[appointmentMuted="true"] {
|
||
color: #606163; font-size: 13px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QComboBox,
|
||
QDialog#AppointmentDrawerOverlay QLineEdit,
|
||
QDialog#AppointmentDrawerOverlay QPlainTextEdit {
|
||
min-height: 30px;
|
||
padding: 0 11px;
|
||
border: 1px solid #EDEDEE;
|
||
border-radius: 9px;
|
||
background-color: #FFFFFF;
|
||
color: #1A1C1F;
|
||
selection-background-color: #EEF1FA;
|
||
selection-color: #1A1C1F; font-size: 14px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPlainTextEdit {
|
||
padding: 7px 11px; font-size: 14px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QComboBox:hover,
|
||
QDialog#AppointmentDrawerOverlay QLineEdit:hover,
|
||
QDialog#AppointmentDrawerOverlay QPlainTextEdit:hover {
|
||
border-color: #8B9AD9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QComboBox:focus,
|
||
QDialog#AppointmentDrawerOverlay QLineEdit:focus,
|
||
QDialog#AppointmentDrawerOverlay QPlainTextEdit:focus {
|
||
border: 2px solid #8B9AD9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QComboBox::drop-down {
|
||
width: 28px;
|
||
border: 0;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QComboBox QAbstractItemView {
|
||
background-color: #FFFFFF;
|
||
color: #1A1C1F;
|
||
border: 1px solid #EDEDEE;
|
||
selection-background-color: #EEF1FA;
|
||
selection-color: #1A1C1F;
|
||
outline: 0; font-size: 14px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QRadioButton {
|
||
min-height: 24px;
|
||
spacing: 8px;
|
||
color: #1A1C1F;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QRadioButton::indicator {
|
||
width: 12px;
|
||
height: 12px;
|
||
border-radius: 7px;
|
||
border: 1px solid #EDEDEE;
|
||
background-color: #FFFFFF;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QRadioButton::indicator:hover {
|
||
border-color: #4156C4;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QRadioButton::indicator:checked {
|
||
width: 4px;
|
||
height: 4px;
|
||
border: 5px solid #4F63D9;
|
||
border-radius: 7px;
|
||
background-color: #FFFFFF;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QRadioButton:focus {
|
||
color: #4F63D9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentDate="true"] {
|
||
min-height: 38px;
|
||
max-height: 38px;
|
||
padding: 0;
|
||
border: 1px solid #EDEDEE;
|
||
border-radius: 8px;
|
||
background-color: #FFFFFF;
|
||
color: #1A1C1F;
|
||
font-size: 14px;
|
||
font-weight: 500;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentDate="true"]:hover {
|
||
color: #4156C4;
|
||
border-color: #4156C4;
|
||
background-color: #EEF1FA;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentDate="true"]:focus {
|
||
border-color: #8B9AD9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentDate="true"]:checked {
|
||
color: #FFFFFF;
|
||
border-color: #4F63D9;
|
||
background-color: #4F63D9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentSlotsPanel {
|
||
background-color: #F7F7F7;
|
||
border: 0;
|
||
border-radius: 8px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QLabel#AppointmentSlotsTitle {
|
||
color: #1A1C1F;
|
||
font-size: 15px;
|
||
font-weight: 500;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton#AppointmentRefreshSlots {
|
||
min-height: 24px;
|
||
max-height: 24px;
|
||
padding: 0 7px;
|
||
border: 0;
|
||
border-radius: 4px;
|
||
background-color: transparent;
|
||
color: #4F63D9;
|
||
font-size: 13px;
|
||
font-weight: 500;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton#AppointmentRefreshSlots:hover {
|
||
background-color: #EEF1FA;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] {
|
||
min-width: 110px;
|
||
min-height: 70px;
|
||
padding: 0 8px;
|
||
border: 2px solid #EDEDEE;
|
||
border-radius: 8px;
|
||
background-color: #FFFFFF;
|
||
color: #1A1C1F;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] QLabel#AppointmentSlotTime {
|
||
color: #1A1C1F;
|
||
font-size: 15px;
|
||
font-weight: 500;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] QLabel#AppointmentSlotStatus {
|
||
padding: 0 8px;
|
||
border-radius: 4px;
|
||
background-color: #F7F7F7;
|
||
color: #606163;
|
||
font-size: 13px;
|
||
font-weight: 400;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"][availability="available"] QLabel#AppointmentSlotStatus {
|
||
color: #287B65;
|
||
background-color: #EAF9F3;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"]:hover:enabled {
|
||
color: #4156C4;
|
||
border-color: #4156C4;
|
||
background-color: #EEF1FA;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"]:focus:enabled {
|
||
border-color: #8B9AD9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"]:checked {
|
||
color: #FFFFFF;
|
||
border-color: #4F63D9;
|
||
background: #4F63D9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] QLabel#AppointmentSlotTime[slotSelected="true"],
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] QLabel#AppointmentSlotStatus[slotSelected="true"] {
|
||
color: #FFFFFF;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] QLabel#AppointmentSlotStatus[slotSelected="true"] {
|
||
background-color: rgba(255, 255, 255, 46);
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"]:disabled {
|
||
color: #8E8F90;
|
||
border-color: #EDEDEE;
|
||
background-color: #F7F7F7;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] QLabel#AppointmentSlotTime:disabled,
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] QLabel#AppointmentSlotStatus:disabled {
|
||
color: #8E8F90;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QPushButton[appointmentSlot="true"] QLabel#AppointmentSlotStatus:disabled {
|
||
background-color: #F7F7F7;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QWidget#AppointmentInlineEmpty {
|
||
background-color: transparent;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QLabel#AppointmentEmptyText {
|
||
color: #606163;
|
||
font-size: 14px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentAlert[kind="info"] {
|
||
background-color: #EEF1FA;
|
||
border: 1px solid #EDEDEE;
|
||
border-radius: 9px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentAlert[kind="warning"] {
|
||
background-color: #FFF5E6;
|
||
border: 1px solid #F6E3C4;
|
||
border-radius: 9px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentAlert[kind="danger"] {
|
||
background-color: #FFF1F3;
|
||
border: 1px solid #F7D7DC;
|
||
border-radius: 9px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentAlert[kind="success"] {
|
||
background-color: #EAF9F3;
|
||
border: 1px solid #D4F0E5;
|
||
border-radius: 9px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentAlert[kind="info"] QLabel {
|
||
color: #4F63D9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentAlert[kind="warning"] QLabel {
|
||
color: #A9691D;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentAlert[kind="danger"] QLabel {
|
||
color: #BE4B58;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentAlert[kind="success"] QLabel {
|
||
color: #287B65;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerFooter {
|
||
background-color: #FFFFFF;
|
||
border: 0;
|
||
border-top: 1px solid #EDEDEE;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerFooter QPushButton {
|
||
min-height: 30px;
|
||
max-height: 30px;
|
||
padding: 0 15px;
|
||
border: 1px solid #EDEDEE;
|
||
border-radius: 9px;
|
||
background-color: #FFFFFF;
|
||
color: #1A1C1F;
|
||
font-size: 13px;
|
||
font-weight: 500;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerFooter QPushButton:hover {
|
||
color: #4156C4;
|
||
border-color: #4156C4;
|
||
background-color: #EEF1FA;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerFooter QPushButton:focus {
|
||
border-color: #8B9AD9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerFooter QPushButton[primary="true"] {
|
||
color: #FFFFFF;
|
||
border-color: #4F63D9;
|
||
background: #4F63D9;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerFooter QPushButton[primary="true"]:hover {
|
||
color: #FFFFFF;
|
||
border-color: #4156C4;
|
||
background-color: #4156C4;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentDrawerFooter QPushButton:disabled {
|
||
color: #FFFFFF;
|
||
border-color: #EDEDEE;
|
||
background-color: #8E8F90;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QFrame#AppointmentLoadingOverlay {
|
||
background-color: rgba(255, 255, 255, 218);
|
||
border: 0;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QLabel#AppointmentLoadingText {
|
||
color: #606163;
|
||
font-size: 14px;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QScrollBar:vertical {
|
||
width: 6px;
|
||
margin: 0;
|
||
border: 0;
|
||
background: transparent;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QScrollBar::handle:vertical {
|
||
min-height: 30px;
|
||
border-radius: 3px;
|
||
background-color: #EDEDEE;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QScrollBar::handle:vertical:hover {
|
||
background-color: #E4E4E5;
|
||
}
|
||
|
||
QDialog#AppointmentDrawerOverlay QScrollBar::add-line:vertical,
|
||
QDialog#AppointmentDrawerOverlay QScrollBar::sub-line:vertical {
|
||
height: 0;
|
||
}
|
||
"""
|
||
|
||
_APPOINTMENT_DARK_REPLACEMENTS = (
|
||
("color: #FFFFFF", "color: #EEF2FF"),
|
||
("selection-color: #134E4A", "selection-color: #EEF2FF"),
|
||
("selection-background-color: #A0CFFF", "selection-background-color: #6675F5"),
|
||
("selection-background-color: #ECFEFF", "selection-background-color: #29334F"),
|
||
("rgba(255, 255, 255, 218)", "rgba(8, 11, 20, 224)"),
|
||
("rgba(255, 255, 255, 46)", "rgba(238, 242, 255, 30)"),
|
||
("#FFFFFF", "#101626"),
|
||
("#F8F9FA", "#151D31"),
|
||
("#F5F7FA", "#151D31"),
|
||
("#F4F4F5", "#151D31"),
|
||
("#F0F9FF", "#151D31"),
|
||
("#ECFEFF", "#1B2440"),
|
||
("#FDF6EC", "#151D31"),
|
||
("#FEF0F0", "#151D31"),
|
||
("#F0F9EB", "#151D31"),
|
||
("#DCDFE6", "#29334F"),
|
||
("#E2EBE8", "#29334F"),
|
||
("#D5E5E2", "#29334F"),
|
||
("#D9ECFF", "#29334F"),
|
||
("#FAECD8", "#29334F"),
|
||
("#FDE2E2", "#29334F"),
|
||
("#E1F3D8", "#29334F"),
|
||
("#134E4A", "#EEF2FF"),
|
||
("#5B7A76", "#9AA7C0"),
|
||
("#C0C4CC", "#9AA7C0"),
|
||
("#0891B2", "#6675F5"),
|
||
("#79BBFF", "#6675F5"),
|
||
("#66B1FF", "#78A7FF"),
|
||
("#A5F3FC", "#6675F5"),
|
||
("#A0CFFF", "#29334F"),
|
||
("#67C23A", "#49C6A5"),
|
||
("#E6A23C", "#E4B967"),
|
||
("#F56C6C", "#F07886"),
|
||
# Run last: the text-color rewrite above also matches the suffix of
|
||
# ``background-color``. Restore those surfaces after all palette mapping.
|
||
("background-color: #EEF2FF", "background-color: #101626"),
|
||
("background: #EEF2FF", "background: #101626"),
|
||
)
|
||
# Light is the default application theme. Keep the replacement table available
|
||
# for a future explicit dark-mode switch, but do not mutate the light source QSS.
|
||
|
||
|
||
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 _invoke_first(repository: Any, names: Sequence[str], **kwargs: Any) -> Any:
|
||
for name in names:
|
||
if callable(getattr(repository, name, None)):
|
||
return invoke(repository, name, **kwargs)
|
||
return invoke(repository, names[0], **kwargs)
|
||
|
||
|
||
class FlowLayout(QLayout):
|
||
"""Compact wrapping layout based on Qt's canonical Flow Layout example."""
|
||
|
||
def __init__(
|
||
self,
|
||
parent: QWidget | None = None,
|
||
margin: int = 0,
|
||
horizontal_spacing: int = 10,
|
||
vertical_spacing: int = 10,
|
||
) -> None:
|
||
super().__init__(parent)
|
||
self._items: list[QLayoutItem] = []
|
||
self._horizontal_spacing = horizontal_spacing
|
||
self._vertical_spacing = vertical_spacing
|
||
self.setContentsMargins(margin, margin, margin, margin)
|
||
|
||
def addItem(self, item: QLayoutItem) -> None: # noqa: N802 - Qt API
|
||
self._items.append(item)
|
||
|
||
def count(self) -> int:
|
||
return len(self._items)
|
||
|
||
def itemAt(self, index: int) -> QLayoutItem | None: # noqa: N802 - Qt API
|
||
return self._items[index] if 0 <= index < len(self._items) else None
|
||
|
||
def takeAt(self, index: int) -> QLayoutItem | None: # noqa: N802 - Qt API
|
||
return self._items.pop(index) if 0 <= index < len(self._items) else None
|
||
|
||
def expandingDirections(self) -> Qt.Orientations: # noqa: N802 - Qt API
|
||
return Qt.Orientation(0)
|
||
|
||
def hasHeightForWidth(self) -> bool: # noqa: N802 - Qt API
|
||
return True
|
||
|
||
def heightForWidth(self, width: int) -> int: # noqa: N802 - Qt API
|
||
return self._do_layout(QRect(0, 0, width, 0), True)
|
||
|
||
def setGeometry(self, rect: QRect) -> None: # noqa: N802 - Qt API
|
||
super().setGeometry(rect)
|
||
self._do_layout(rect, False)
|
||
|
||
def sizeHint(self) -> QSize: # noqa: N802 - Qt API
|
||
return self.minimumSize()
|
||
|
||
def minimumSize(self) -> QSize: # noqa: N802 - Qt API
|
||
size = QSize()
|
||
for item in self._items:
|
||
size = size.expandedTo(item.minimumSize())
|
||
margins = self.contentsMargins()
|
||
return size + QSize(margins.left() + margins.right(), margins.top() + margins.bottom())
|
||
|
||
def _smart_spacing(self, pixel_metric: QStyle.PixelMetric) -> int:
|
||
parent = self.parent()
|
||
if isinstance(parent, QWidget):
|
||
return parent.style().pixelMetric(pixel_metric, None, parent)
|
||
return 6
|
||
|
||
def _do_layout(self, rect: QRect, test_only: bool) -> int:
|
||
left, top, right, bottom = self.getContentsMargins()
|
||
effective = rect.adjusted(left, top, -right, -bottom)
|
||
x = effective.x()
|
||
y = effective.y()
|
||
line_height = 0
|
||
for item in self._items:
|
||
widget = item.widget()
|
||
if widget is not None and widget.isHidden():
|
||
continue
|
||
horizontal = self._horizontal_spacing
|
||
if horizontal < 0:
|
||
horizontal = self._smart_spacing(QStyle.PixelMetric.PM_LayoutHorizontalSpacing)
|
||
vertical = self._vertical_spacing
|
||
if vertical < 0:
|
||
vertical = self._smart_spacing(QStyle.PixelMetric.PM_LayoutVerticalSpacing)
|
||
next_x = x + item.sizeHint().width() + horizontal
|
||
if next_x - horizontal > effective.right() and line_height > 0:
|
||
x = effective.x()
|
||
y += line_height + vertical
|
||
next_x = x + item.sizeHint().width() + horizontal
|
||
line_height = 0
|
||
if not test_only:
|
||
item.setGeometry(QRect(QPoint(x, y), item.sizeHint()))
|
||
x = next_x
|
||
line_height = max(line_height, item.sizeHint().height())
|
||
return y + line_height - rect.y() + bottom
|
||
|
||
|
||
class _Spinner(QWidget):
|
||
def __init__(self, parent: QWidget | None = None) -> None:
|
||
super().__init__(parent)
|
||
self._angle = 0
|
||
self.setFixedSize(30, 30)
|
||
self._timer = QTimer(self)
|
||
self._timer.setInterval(45)
|
||
self._timer.timeout.connect(self._advance)
|
||
|
||
def start(self) -> None:
|
||
self._timer.start()
|
||
self.show()
|
||
|
||
def stop(self) -> None:
|
||
self._timer.stop()
|
||
|
||
def _advance(self) -> None:
|
||
self._angle = (self._angle + 24) % 360
|
||
self.update()
|
||
|
||
def paintEvent(self, event: QPaintEvent) -> None: # noqa: N802 - Qt API
|
||
del event
|
||
painter = QPainter(self)
|
||
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
|
||
pen = QPen(QColor("#4F63D9"), 3)
|
||
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
|
||
painter.setPen(pen)
|
||
painter.drawArc(self.rect().adjusted(4, 4, -4, -4), self._angle * 16, 255 * 16)
|
||
|
||
|
||
class _LoadingOverlay(QFrame):
|
||
def __init__(self, parent: QWidget) -> None:
|
||
super().__init__(parent)
|
||
self.setObjectName("AppointmentLoadingOverlay")
|
||
layout = QVBoxLayout(self)
|
||
layout.setContentsMargins(20, 20, 20, 20)
|
||
layout.setSpacing(10)
|
||
layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.spinner = _Spinner(self)
|
||
layout.addWidget(self.spinner, 0, Qt.AlignmentFlag.AlignCenter)
|
||
self.label = QLabel("正在加载…")
|
||
self.label.setObjectName("AppointmentLoadingText")
|
||
self.label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
layout.addWidget(self.label, 0, Qt.AlignmentFlag.AlignCenter)
|
||
self.hide()
|
||
|
||
def show_message(self, text: str) -> None:
|
||
self.label.setText(text)
|
||
self.setGeometry(self.parentWidget().rect())
|
||
self.raise_()
|
||
self.show()
|
||
self.spinner.start()
|
||
|
||
def clear(self) -> None:
|
||
self.spinner.stop()
|
||
self.hide()
|
||
|
||
|
||
class _Alert(QFrame):
|
||
def __init__(self, parent: QWidget | None = None) -> None:
|
||
super().__init__(parent)
|
||
self.setObjectName("AppointmentAlert")
|
||
self.setProperty("kind", "info")
|
||
layout = QHBoxLayout(self)
|
||
layout.setContentsMargins(12, 9, 12, 9)
|
||
layout.setSpacing(9)
|
||
self.icon = QLabel("i")
|
||
self.icon.setFixedSize(18, 18)
|
||
self.icon.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.icon.setStyleSheet("font-weight:700;")
|
||
self.label = QLabel()
|
||
self.label.setWordWrap(True)
|
||
layout.addWidget(self.icon)
|
||
layout.addWidget(self.label, 1)
|
||
self.hide()
|
||
|
||
def show_message(self, text: str, kind: str = "info") -> None:
|
||
glyphs = {"info": "i", "warning": "!", "danger": "!", "success": "✓"}
|
||
self.icon.setText(glyphs.get(kind, "i"))
|
||
self.label.setText(text)
|
||
self.setProperty("kind", kind)
|
||
self.style().unpolish(self)
|
||
self.style().polish(self)
|
||
self.show()
|
||
|
||
def clear(self) -> None:
|
||
self.label.clear()
|
||
self.hide()
|
||
|
||
|
||
class _InlineEmpty(QWidget):
|
||
def __init__(self, text: str = "请先选择医生", parent: QWidget | None = None) -> None:
|
||
super().__init__(parent)
|
||
self.setObjectName("AppointmentInlineEmpty")
|
||
self.setMinimumHeight(138)
|
||
layout = QVBoxLayout(self)
|
||
layout.setContentsMargins(12, 18, 12, 18)
|
||
layout.setSpacing(5)
|
||
layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.illustration = _EmptyIllustration(self)
|
||
layout.addWidget(self.illustration, 0, Qt.AlignmentFlag.AlignCenter)
|
||
self.label = QLabel(text)
|
||
self.label.setObjectName("AppointmentEmptyText")
|
||
self.label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.label.setWordWrap(True)
|
||
layout.addWidget(self.label)
|
||
|
||
def set_text(self, text: str) -> None:
|
||
self.label.setText(text)
|
||
|
||
|
||
class _EmptyIllustration(QWidget):
|
||
"""Small neutral illustration matching Element's 80 px empty-state footprint."""
|
||
|
||
def __init__(self, parent: QWidget | None = None) -> None:
|
||
super().__init__(parent)
|
||
self.setFixedSize(80, 60)
|
||
self.setAccessibleName("空状态插图")
|
||
|
||
def paintEvent(self, event: QPaintEvent) -> None: # noqa: N802 - Qt API
|
||
del event
|
||
painter = QPainter(self)
|
||
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
|
||
painter.setPen(Qt.PenStyle.NoPen)
|
||
painter.setBrush(QColor("#F7F7F7"))
|
||
painter.drawEllipse(QRect(9, 48, 62, 8))
|
||
|
||
painter.setPen(QPen(QColor("#EDEDEE"), 1))
|
||
painter.setBrush(QColor("#FFFFFF"))
|
||
painter.drawRoundedRect(QRect(22, 21, 36, 27), 4, 4)
|
||
painter.setBrush(QColor("#F0F0F0"))
|
||
painter.drawRoundedRect(QRect(18, 15, 44, 12), 4, 4)
|
||
painter.setPen(QPen(QColor("#606163"), 2))
|
||
painter.drawLine(30, 35, 50, 35)
|
||
painter.drawLine(34, 41, 46, 41)
|
||
painter.end()
|
||
|
||
|
||
class _HoverLiftButton(QPushButton):
|
||
"""Button with a subtle two-pixel lift and blue-tinted shadow on hover."""
|
||
|
||
def __init__(self, text: str = "", parent: QWidget | None = None) -> None:
|
||
super().__init__(text, parent)
|
||
self._lifted = False
|
||
self._base_position = QPoint()
|
||
|
||
def enterEvent(self, event: QEvent) -> None: # noqa: N802 - Qt API
|
||
if self.isEnabled() and not self._lifted:
|
||
self._base_position = self.pos()
|
||
self.move(self.x(), self.y() - 2)
|
||
shadow = QGraphicsDropShadowEffect(self)
|
||
shadow.setBlurRadius(12)
|
||
shadow.setOffset(0, 4)
|
||
shadow.setColor(QColor(26, 28, 31, 72))
|
||
self.setGraphicsEffect(shadow)
|
||
self._lifted = True
|
||
super().enterEvent(event)
|
||
|
||
def leaveEvent(self, event: QEvent) -> None: # noqa: N802 - Qt API
|
||
if self._lifted:
|
||
self.move(self._base_position)
|
||
self.setGraphicsEffect(None)
|
||
self._lifted = False
|
||
super().leaveEvent(event)
|
||
|
||
|
||
class _SlotCard(_HoverLiftButton):
|
||
"""Two-line time card matching Element's independent time/status typography."""
|
||
|
||
def __init__(self, time_text: str, status_text: str) -> None:
|
||
super().__init__()
|
||
self.setAccessibleName(f"{time_text} {status_text}")
|
||
layout = QVBoxLayout(self)
|
||
layout.setContentsMargins(8, 8, 8, 8)
|
||
layout.setSpacing(6)
|
||
layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.time_label = QLabel(time_text)
|
||
self.time_label.setObjectName("AppointmentSlotTime")
|
||
self.time_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.time_label.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
|
||
layout.addWidget(self.time_label)
|
||
self.status_label = QLabel(status_text)
|
||
self.status_label.setObjectName("AppointmentSlotStatus")
|
||
self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
|
||
self.status_label.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
|
||
layout.addWidget(self.status_label)
|
||
self.toggled.connect(self._sync_label_selection)
|
||
|
||
def _sync_label_selection(self, checked: bool) -> None:
|
||
# Qt does not reliably resolve ancestor pseudo states for child labels.
|
||
for label in (self.time_label, self.status_label):
|
||
label.setProperty("slotSelected", checked)
|
||
label.style().unpolish(label)
|
||
label.style().polish(label)
|
||
label.update()
|
||
|
||
|
||
class AppointmentDrawer(QDialog):
|
||
"""Full-window modal overlay with an Element-style 60% right drawer."""
|
||
|
||
CHANNEL_DETAIL_NAMES = {"自媒体4H", "自媒体3Q", "自媒体3H", "自媒体2H", "自媒体2Q"}
|
||
|
||
def __init__(
|
||
self,
|
||
row: Any,
|
||
repository: Any = None,
|
||
parent: QWidget | None = None,
|
||
*,
|
||
autoload: bool = True,
|
||
async_runner: Callable[..., Any] | None = None,
|
||
) -> None:
|
||
super().__init__(parent)
|
||
self.row = row
|
||
self.repository = repository
|
||
self._run_async = async_runner or run_async
|
||
self.diagnosis_id = _as_int(first_value(row, "diagnosis_id", "id"))
|
||
self._load_generation = 0
|
||
self._roster_generation = 0
|
||
self._slot_generation = 0
|
||
self._setting = False
|
||
self._initial_loaded = False
|
||
self._today_blocking = False
|
||
self._channel_names: dict[str, str] = {}
|
||
self._doctor_buttons: dict[int, QRadioButton] = {}
|
||
self._date_buttons: dict[str, _HoverLiftButton] = {}
|
||
self._slot_buttons: dict[str, _HoverLiftButton] = {}
|
||
self._slot_available: dict[str, bool] = {}
|
||
self._slot_restore_selection = ""
|
||
self._active_loading = ""
|
||
self._owner = parent.window() if parent is not None else None
|
||
|
||
self.setObjectName("AppointmentDrawerOverlay")
|
||
self.setWindowTitle("预约问诊")
|
||
self.setModal(True)
|
||
self.setWindowModality(Qt.WindowModality.WindowModal)
|
||
self.setWindowFlag(Qt.WindowType.FramelessWindowHint, True)
|
||
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
|
||
self.setStyleSheet(APPOINTMENT_DRAWER_QSS)
|
||
self.resize(self._owner.size() if self._owner is not None else QSize(1024, 640))
|
||
if self._owner is not None:
|
||
self._owner.installEventFilter(self)
|
||
|
||
root = QHBoxLayout(self)
|
||
root.setContentsMargins(0, 0, 0, 0)
|
||
root.setSpacing(0)
|
||
root.addStretch(1)
|
||
|
||
self.panel = QFrame()
|
||
self.panel.setObjectName("AppointmentDrawerPanel")
|
||
self.panel.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Expanding)
|
||
panel_layout = QVBoxLayout(self.panel)
|
||
panel_layout.setContentsMargins(0, 0, 0, 0)
|
||
panel_layout.setSpacing(0)
|
||
root.addWidget(self.panel)
|
||
|
||
self.header = self._build_header()
|
||
panel_layout.addWidget(self.header)
|
||
self.body_scroll = QScrollArea()
|
||
self.body_scroll.setObjectName("AppointmentDrawerBody")
|
||
self.body_scroll.setWidgetResizable(True)
|
||
self.body_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
|
||
self.body_scroll.setFrameShape(QFrame.Shape.NoFrame)
|
||
self.body_content = QWidget()
|
||
self.body_content.setObjectName("AppointmentDrawerBodyContent")
|
||
self.body_layout = QVBoxLayout(self.body_content)
|
||
self.body_layout.setContentsMargins(16, 16, 16, 20)
|
||
self.body_layout.setSpacing(14)
|
||
self.body_scroll.setWidget(self.body_content)
|
||
panel_layout.addWidget(self.body_scroll, 1)
|
||
self.footer = self._build_footer()
|
||
panel_layout.addWidget(self.footer)
|
||
|
||
self._body_viewport = self.body_scroll.viewport()
|
||
self.loading_overlay = _LoadingOverlay(self._body_viewport)
|
||
self._body_viewport.installEventFilter(self)
|
||
|
||
self._build_form()
|
||
self._update_drawer_width()
|
||
self._sync_channel_detail_visibility()
|
||
self._show_time_empty("请先选择医生")
|
||
self._update_submit_state()
|
||
if autoload:
|
||
self._load_initial_options()
|
||
|
||
@property
|
||
def drawer_width(self) -> int:
|
||
return self.panel.width()
|
||
|
||
@property
|
||
def doctor_buttons(self) -> Mapping[int, QRadioButton]:
|
||
return MappingProxyType(self._doctor_buttons)
|
||
|
||
@property
|
||
def date_buttons(self) -> Mapping[str, QPushButton]:
|
||
return MappingProxyType(self._date_buttons)
|
||
|
||
@property
|
||
def slot_buttons(self) -> Mapping[str, QPushButton]:
|
||
return MappingProxyType(self._slot_buttons)
|
||
|
||
@staticmethod
|
||
def _rows(value: Any, key: str = "") -> list[Any]:
|
||
rows = page_items(value)
|
||
if rows:
|
||
return rows
|
||
if isinstance(value, Sequence) and not isinstance(value, (str, bytes)):
|
||
return list(value)
|
||
if isinstance(value, Mapping):
|
||
candidate = value.get(key) if key else None
|
||
if isinstance(candidate, Sequence) and not isinstance(candidate, (str, bytes)):
|
||
return list(candidate)
|
||
data = value.get("data")
|
||
if isinstance(data, Mapping):
|
||
candidate = data.get(key)
|
||
if isinstance(candidate, Sequence) and not isinstance(candidate, (str, bytes)):
|
||
return list(candidate)
|
||
return []
|
||
|
||
def _build_header(self) -> QWidget:
|
||
header = QFrame()
|
||
header.setObjectName("AppointmentDrawerHeader")
|
||
header.setFixedHeight(58)
|
||
layout = QHBoxLayout(header)
|
||
layout.setContentsMargins(16, 0, 12, 0)
|
||
title = QLabel("预约问诊")
|
||
title.setObjectName("AppointmentDrawerTitle")
|
||
layout.addWidget(title)
|
||
layout.addStretch(1)
|
||
close_button = QToolButton()
|
||
close_button.setObjectName("AppointmentDrawerClose")
|
||
close_button.setText("×")
|
||
close_button.setToolTip("关闭")
|
||
close_button.clicked.connect(self.reject)
|
||
layout.addWidget(close_button)
|
||
self.close_button = close_button
|
||
return header
|
||
|
||
def _build_footer(self) -> QWidget:
|
||
footer = QFrame()
|
||
footer.setObjectName("AppointmentDrawerFooter")
|
||
layout = QHBoxLayout(footer)
|
||
layout.setContentsMargins(16, 12, 16, 12)
|
||
layout.setSpacing(12)
|
||
layout.addStretch(1)
|
||
self.cancel_button = QPushButton("取消")
|
||
self.cancel_button.clicked.connect(self.reject)
|
||
layout.addWidget(self.cancel_button)
|
||
self.ok_button = QPushButton("确定")
|
||
self.ok_button.setProperty("primary", True)
|
||
self.ok_button.setEnabled(False)
|
||
self.ok_button.clicked.connect(self.accept)
|
||
layout.addWidget(self.ok_button)
|
||
return footer
|
||
|
||
def _build_form(self) -> None:
|
||
self.banner = _Alert()
|
||
self.body_layout.addWidget(self.banner)
|
||
self.conflict_alert = _Alert()
|
||
self.body_layout.addWidget(self.conflict_alert)
|
||
|
||
self.form_labels: list[QLabel] = []
|
||
self.last_visit_label = QLabel("无就诊记录")
|
||
self.last_visit_label.setProperty("appointmentMuted", True)
|
||
self.last_visit_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
|
||
self._add_form_row("上次就诊:", self.last_visit_label)
|
||
|
||
method_container = QWidget()
|
||
method_layout = QHBoxLayout(method_container)
|
||
method_layout.setContentsMargins(0, 0, 0, 0)
|
||
method_layout.setSpacing(12)
|
||
self.appointment_method_radio = QRadioButton("选择时段预约有专医生")
|
||
self.appointment_method_radio.setChecked(True)
|
||
method_layout.addWidget(self.appointment_method_radio)
|
||
method_layout.addStretch(1)
|
||
self._add_form_row("预约方式:", method_container)
|
||
|
||
type_container = QWidget()
|
||
type_layout = QHBoxLayout(type_container)
|
||
type_layout.setContentsMargins(0, 0, 0, 0)
|
||
self.appointment_type_radio = QRadioButton("视频问诊")
|
||
self.appointment_type_radio.setChecked(True)
|
||
type_layout.addWidget(self.appointment_type_radio)
|
||
self.text_appointment_type_radio = QRadioButton("图文问诊")
|
||
type_layout.addWidget(self.text_appointment_type_radio)
|
||
self.appointment_type_group = QButtonGroup(self)
|
||
self.appointment_type_group.addButton(self.appointment_type_radio, 0)
|
||
self.appointment_type_group.addButton(self.text_appointment_type_radio, 1)
|
||
type_layout.addStretch(1)
|
||
self._add_form_row("预约类型:", type_container)
|
||
self.appointment_type = QComboBox(self)
|
||
for label, value in APPOINTMENT_MODES:
|
||
self.appointment_type.addItem(label, value)
|
||
self.appointment_type_group.idClicked.connect(self.appointment_type.setCurrentIndex)
|
||
self.appointment_type.currentIndexChanged.connect(
|
||
lambda index: self.appointment_type_group.button(index).setChecked(True)
|
||
if self.appointment_type_group.button(index) is not None else None
|
||
)
|
||
self.appointment_type.hide()
|
||
|
||
patient_container = QWidget()
|
||
patient_layout = QHBoxLayout(patient_container)
|
||
patient_layout.setContentsMargins(0, 0, 0, 0)
|
||
patient_name = display_text(
|
||
first_value(self.row, "patient_name", "name", default="当前患者")
|
||
)
|
||
self.patient_radio = QRadioButton(patient_name)
|
||
self.patient_radio.setChecked(True)
|
||
patient_layout.addWidget(self.patient_radio)
|
||
patient_layout.addStretch(1)
|
||
self._add_form_row("选择患者:", patient_container)
|
||
|
||
self.channel_source = QComboBox()
|
||
self.channel_source.setMaximumWidth(360)
|
||
self.channel_source.addItem("正在加载渠道…", "")
|
||
self.channel_source.currentIndexChanged.connect(self._channel_changed)
|
||
self._add_form_row("渠道来源:", self.channel_source, required=True)
|
||
|
||
self.channel_source_detail = QLineEdit()
|
||
self.channel_source_detail.setMaximumWidth(360)
|
||
self.channel_source_detail.setMaxLength(128)
|
||
self.channel_source_detail.setPlaceholderText("请输入自媒体相关补充内容")
|
||
self.channel_source_detail.textChanged.connect(self._update_submit_state)
|
||
self.channel_detail_row = self._add_form_row(
|
||
"自媒体补充:", self.channel_source_detail, required=True
|
||
)
|
||
self.channel_detail_row.hide()
|
||
|
||
self.doctor_group = QButtonGroup(self)
|
||
self.doctor_group.setExclusive(True)
|
||
self.doctor_container = QWidget()
|
||
self.doctor_flow = FlowLayout(
|
||
self.doctor_container, horizontal_spacing=12, vertical_spacing=8
|
||
)
|
||
self.doctor_empty = QLabel("正在加载医生…")
|
||
self.doctor_empty.setProperty("appointmentMuted", True)
|
||
self.doctor_flow.addWidget(self.doctor_empty)
|
||
self._add_form_row("预约医生:", self.doctor_container, align_top=True)
|
||
self.doctor_combo = QComboBox(self)
|
||
self.doctor_combo.addItem("正在加载医生…", 0)
|
||
self.doctor_combo.hide()
|
||
self.doctor_combo.currentIndexChanged.connect(self._doctor_changed)
|
||
|
||
self.time_container = QWidget()
|
||
self.time_container.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Maximum)
|
||
time_layout = QVBoxLayout(self.time_container)
|
||
time_layout.setContentsMargins(0, 0, 0, 0)
|
||
time_layout.setSpacing(0)
|
||
self.time_stack = QStackedWidget()
|
||
self.time_stack.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Maximum)
|
||
self.time_empty = _InlineEmpty("请先选择医生")
|
||
self.time_stack.addWidget(self.time_empty)
|
||
self.appointment_time_container = QWidget()
|
||
self.appointment_time_container.setSizePolicy(
|
||
QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Maximum
|
||
)
|
||
appointment_time_layout = QVBoxLayout(self.appointment_time_container)
|
||
appointment_time_layout.setContentsMargins(0, 0, 0, 0)
|
||
appointment_time_layout.setSpacing(20)
|
||
self.date_container = QWidget()
|
||
self.date_flow = FlowLayout(self.date_container, horizontal_spacing=10, vertical_spacing=10)
|
||
appointment_time_layout.addWidget(self.date_container)
|
||
self.slots_panel = QFrame()
|
||
self.slots_panel.setObjectName("AppointmentSlotsPanel")
|
||
self.slots_panel.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Maximum)
|
||
self.slots_panel.setFixedHeight(164)
|
||
slots_panel_layout = QVBoxLayout(self.slots_panel)
|
||
slots_panel_layout.setContentsMargins(16, 16, 16, 16)
|
||
slots_panel_layout.setSpacing(14)
|
||
slots_header = QHBoxLayout()
|
||
slots_title = QLabel("可预约时段")
|
||
slots_title.setObjectName("AppointmentSlotsTitle")
|
||
slots_header.addWidget(slots_title)
|
||
slots_header.addStretch(1)
|
||
self.refresh_slots_button = QPushButton("刷新")
|
||
self.refresh_slots_button.setObjectName("AppointmentRefreshSlots")
|
||
self.refresh_slots_button.clicked.connect(self._refresh_slots)
|
||
slots_header.addWidget(self.refresh_slots_button)
|
||
slots_panel_layout.addLayout(slots_header)
|
||
self.slot_state_stack = QStackedWidget()
|
||
self.slot_state_stack.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
||
self.slot_state_stack.setFixedHeight(94)
|
||
self.slot_empty = _InlineEmpty("请选择日期")
|
||
self.slot_empty.setMinimumHeight(92)
|
||
self.slot_state_stack.addWidget(self.slot_empty)
|
||
self.slot_scroll = QScrollArea()
|
||
self.slot_scroll.setObjectName("AppointmentSlotScroll")
|
||
self.slot_scroll.setWidgetResizable(True)
|
||
self.slot_scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
|
||
self.slot_scroll.setMinimumHeight(94)
|
||
self.slot_scroll.setMaximumHeight(450)
|
||
self.slot_scroll.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
|
||
self.slot_content = QWidget()
|
||
self.slot_flow = FlowLayout(self.slot_content, horizontal_spacing=10, vertical_spacing=10)
|
||
self.slot_scroll.setWidget(self.slot_content)
|
||
self._slot_viewport = self.slot_scroll.viewport()
|
||
self._slot_viewport.installEventFilter(self)
|
||
self.slot_state_stack.addWidget(self.slot_scroll)
|
||
slots_panel_layout.addWidget(self.slot_state_stack)
|
||
appointment_time_layout.addWidget(self.slots_panel)
|
||
self.time_stack.addWidget(self.appointment_time_container)
|
||
time_layout.addWidget(self.time_stack)
|
||
self._add_form_row("预约时间:", self.time_container, align_top=True)
|
||
self.date_combo = QComboBox(self)
|
||
self.date_combo.addItem("请先选择医生", "")
|
||
self.date_combo.hide()
|
||
self.date_combo.currentIndexChanged.connect(self._date_changed)
|
||
self.slot_combo = QComboBox(self)
|
||
self.slot_combo.addItem("请先选择排班日期", "")
|
||
self.slot_combo.hide()
|
||
self.slot_combo.currentIndexChanged.connect(self._slot_selection_changed)
|
||
self.slot_group = QButtonGroup(self)
|
||
self.slot_group.setExclusive(True)
|
||
|
||
self.remark = QPlainTextEdit()
|
||
self.remark.setPlaceholderText("请输入备注信息")
|
||
self.remark.setFixedHeight(70)
|
||
self._add_form_row("备注:", self.remark, align_top=True)
|
||
self.body_layout.addStretch(1)
|
||
|
||
def _add_form_row(
|
||
self,
|
||
label_text: str,
|
||
field: QWidget,
|
||
*,
|
||
required: bool = False,
|
||
align_top: bool = False,
|
||
) -> QWidget:
|
||
row = QWidget()
|
||
layout = QHBoxLayout(row)
|
||
layout.setContentsMargins(0, 0, 0, 0)
|
||
layout.setSpacing(12)
|
||
label = QLabel(
|
||
f"{label_text[:-1]} *:" if required and label_text.endswith(":") else label_text
|
||
)
|
||
label.setProperty("appointmentLabel", True)
|
||
label.setFixedWidth(100)
|
||
label.setAlignment(
|
||
Qt.AlignmentFlag.AlignRight
|
||
| (Qt.AlignmentFlag.AlignTop if align_top else Qt.AlignmentFlag.AlignVCenter)
|
||
)
|
||
if align_top:
|
||
label.setContentsMargins(0, 7, 0, 0)
|
||
self.form_labels.append(label)
|
||
layout.addWidget(label)
|
||
layout.addWidget(field, 1)
|
||
self.body_layout.addWidget(row)
|
||
return row
|
||
|
||
def _load_initial_options(self) -> None:
|
||
self._load_generation += 1
|
||
generation = self._load_generation
|
||
diagnosis_id = self.diagnosis_id
|
||
today = QDate.currentDate().toString("yyyy-MM-dd")
|
||
self._set_loading("initial", "正在加载医生、渠道与挂号状态…")
|
||
|
||
def query() -> dict[str, Any]:
|
||
doctors = _invoke_first(self.repository, ("list_diagnosis_doctors",))
|
||
channels = invoke(self.repository, "get_dictionary", dictionary_type="channels")
|
||
appointments = _invoke_first(
|
||
self.repository,
|
||
("list_appointments",),
|
||
patient_id=diagnosis_id,
|
||
start_date=today,
|
||
end_date=today,
|
||
page_no=1,
|
||
page_size=50,
|
||
)
|
||
try:
|
||
last_visits = _invoke_first(
|
||
self.repository,
|
||
("list_appointments",),
|
||
patient_id=diagnosis_id,
|
||
status=3,
|
||
page_no=1,
|
||
page_size=1,
|
||
)
|
||
except Exception:
|
||
last_visits = []
|
||
return {
|
||
"doctors": doctors,
|
||
"channels": channels,
|
||
"appointments": appointments,
|
||
"last_visits": last_visits,
|
||
}
|
||
|
||
self._run_async(
|
||
query,
|
||
on_success=lambda result: self._apply_initial_options(result, generation),
|
||
on_error=lambda error: self._load_error(error, generation),
|
||
)
|
||
|
||
def _apply_initial_options(self, result: Any, generation: int) -> None:
|
||
if generation != self._load_generation:
|
||
return
|
||
doctors = self._rows(get_value(result, "doctors", []))
|
||
channels = self._rows(get_value(result, "channels", []), "channels")
|
||
appointments = self._rows(get_value(result, "appointments", []))
|
||
last_visits = self._rows(get_value(result, "last_visits", []))
|
||
self._today_blocking = any(
|
||
_as_int(first_value(item, "status", "appointment_status"), -1) in {1, 4}
|
||
for item in appointments
|
||
)
|
||
self._set_last_visit(last_visits)
|
||
self._setting = True
|
||
try:
|
||
self._populate_doctors(doctors)
|
||
self.channel_source.clear()
|
||
self.channel_source.addItem("请选择渠道来源", "")
|
||
self._channel_names.clear()
|
||
ordered_channels = sorted(
|
||
(
|
||
item
|
||
for item in channels
|
||
if _as_int(first_value(item, "status", default=1), 1) != 0
|
||
),
|
||
key=lambda item: (
|
||
-_as_int(first_value(item, "sort", default=0)),
|
||
-_as_int(first_value(item, "id", default=0)),
|
||
),
|
||
)
|
||
for channel in ordered_channels:
|
||
value = str(first_value(channel, "value", "id", default="") or "")
|
||
name = display_text(first_value(channel, "name", "label"), "")
|
||
if not value or not name:
|
||
continue
|
||
self.channel_source.addItem(name, value)
|
||
self._channel_names[value] = name
|
||
finally:
|
||
self._setting = False
|
||
self._initial_loaded = bool(doctors and self._channel_names)
|
||
self._sync_channel_detail_visibility()
|
||
self._update_conflict_alert()
|
||
self._clear_loading("initial")
|
||
if not doctors:
|
||
self.doctor_empty.setText("暂无可预约医生")
|
||
self.doctor_empty.show()
|
||
self._show_time_empty("暂无可预约医生")
|
||
self.banner.show_message("没有可预约医生，已停止提交。", "warning")
|
||
elif not self._channel_names:
|
||
self.banner.show_message("没有可用渠道字典，已停止提交。", "warning")
|
||
else:
|
||
self.banner.clear()
|
||
if not doctors:
|
||
pass
|
||
elif self.doctor_combo.currentData():
|
||
self._doctor_changed()
|
||
else:
|
||
self._show_time_empty("请先选择医生")
|
||
self._update_submit_state()
|
||
|
||
def _set_last_visit(self, rows: Sequence[Any]) -> None:
|
||
if rows:
|
||
item = rows[0]
|
||
date_text = str(first_value(item, "appointment_date", "date", default="") or "")
|
||
time_text = str(
|
||
first_value(
|
||
item,
|
||
"appointment_time",
|
||
"time_text",
|
||
"appointment_time_text",
|
||
default="",
|
||
)
|
||
or ""
|
||
)
|
||
rendered = " ".join(part for part in (date_text, time_text) if part)
|
||
self.last_visit_label.setText(rendered or "无就诊记录")
|
||
return
|
||
seeded = first_value(
|
||
self.row,
|
||
"last_visit",
|
||
"last_visit_at",
|
||
"last_appointment_at",
|
||
default="",
|
||
)
|
||
self.last_visit_label.setText(display_text(seeded, "无就诊记录"))
|
||
|
||
def _populate_doctors(self, doctors: Sequence[Any]) -> None:
|
||
self._clear_flow(self.doctor_flow)
|
||
self._doctor_buttons.clear()
|
||
self.doctor_group = QButtonGroup(self)
|
||
self.doctor_group.setExclusive(True)
|
||
self.doctor_combo.clear()
|
||
self.doctor_combo.addItem("请选择医生", 0)
|
||
preferred = _as_int(first_value(self.row, "appointment_doctor_id", "doctor_id", default=0))
|
||
selected_index = 0
|
||
for doctor in doctors:
|
||
doctor_id = _as_int(first_value(doctor, "id", "doctor_id"))
|
||
if doctor_id <= 0:
|
||
continue
|
||
name = display_text(first_value(doctor, "name", "doctor_name"))
|
||
self.doctor_combo.addItem(name, doctor_id)
|
||
button = QRadioButton(name)
|
||
button.setProperty("doctorId", doctor_id)
|
||
button.clicked.connect(
|
||
lambda _checked=False, value=doctor_id: self._select_doctor(value)
|
||
)
|
||
self.doctor_group.addButton(button, doctor_id)
|
||
self.doctor_flow.addWidget(button)
|
||
self._doctor_buttons[doctor_id] = button
|
||
if doctor_id == preferred:
|
||
selected_index = self.doctor_combo.count() - 1
|
||
if not self._doctor_buttons:
|
||
self.doctor_empty = QLabel("暂无可预约医生")
|
||
self.doctor_empty.setProperty("appointmentMuted", True)
|
||
self.doctor_flow.addWidget(self.doctor_empty)
|
||
else:
|
||
self.doctor_combo.setCurrentIndex(selected_index)
|
||
if selected_index > 0:
|
||
selected_id = _as_int(self.doctor_combo.currentData())
|
||
button = self._doctor_buttons.get(selected_id)
|
||
if button is not None:
|
||
button.setChecked(True)
|
||
|
||
def _load_error(self, error: Exception, generation: int) -> None:
|
||
if generation != self._load_generation:
|
||
return
|
||
self._initial_loaded = False
|
||
self._clear_loading("initial")
|
||
self.banner.show_message(f"预约基础数据加载失败：{friendly_error(error)}", "danger")
|
||
self._show_time_empty("基础数据加载失败")
|
||
self._update_submit_state()
|
||
|
||
def _select_doctor(self, doctor_id: int) -> None:
|
||
index = self.doctor_combo.findData(doctor_id)
|
||
if index >= 0 and index != self.doctor_combo.currentIndex():
|
||
self.doctor_combo.setCurrentIndex(index)
|
||
elif index >= 0:
|
||
self._doctor_changed()
|
||
|
||
def _doctor_changed(self) -> None:
|
||
if self._setting:
|
||
return
|
||
doctor_id = _as_int(self.doctor_combo.currentData())
|
||
for value, button in self._doctor_buttons.items():
|
||
button.setChecked(value == doctor_id)
|
||
self._clear_dates()
|
||
self._clear_slots("请先选择排班日期")
|
||
if doctor_id <= 0:
|
||
self._show_time_empty("请先选择医生")
|
||
self._update_submit_state()
|
||
return
|
||
self._show_time_empty("正在加载医生排班…")
|
||
self._roster_generation += 1
|
||
generation = self._roster_generation
|
||
start = QDate.currentDate().toString("yyyy-MM-dd")
|
||
end = QDate.currentDate().addDays(6).toString("yyyy-MM-dd")
|
||
query = MappingProxyType(
|
||
{
|
||
"doctor_id": doctor_id,
|
||
"start_date": start,
|
||
"end_date": end,
|
||
"status": 1,
|
||
"page_no": 1,
|
||
"page_size": 100,
|
||
}
|
||
)
|
||
self._set_loading("roster", "正在加载医生排班…")
|
||
self._run_async(
|
||
lambda: _invoke_first(
|
||
self.repository,
|
||
("list_appointment_rosters", "appointment_rosters", "roster_lists"),
|
||
**query,
|
||
),
|
||
on_success=lambda result: self._apply_rosters(result, doctor_id, generation),
|
||
on_error=lambda error: self._roster_error(error, doctor_id, generation),
|
||
)
|
||
|
||
def _apply_rosters(self, result: Any, doctor_id: int, generation: int) -> None:
|
||
if generation != self._roster_generation or doctor_id != _as_int(
|
||
self.doctor_combo.currentData()
|
||
):
|
||
return
|
||
today = QDate.currentDate()
|
||
end = today.addDays(6)
|
||
dates: set[str] = set()
|
||
for item in self._rows(result):
|
||
raw = str(first_value(item, "date", "appointment_date", "roster_date", default=""))
|
||
parsed = QDate.fromString(raw[:10], "yyyy-MM-dd")
|
||
if parsed.isValid() and today <= parsed <= end:
|
||
dates.add(parsed.toString("yyyy-MM-dd"))
|
||
ordered = sorted(dates)
|
||
self._setting = True
|
||
try:
|
||
self._populate_dates(ordered)
|
||
if ordered:
|
||
today_value = today.toString("yyyy-MM-dd")
|
||
preferred = next(
|
||
(
|
||
value
|
||
for value in ordered
|
||
if not (self._today_blocking and value == today_value)
|
||
),
|
||
ordered[0],
|
||
)
|
||
self.date_combo.setCurrentIndex(self.date_combo.findData(preferred))
|
||
self._sync_date_buttons(preferred)
|
||
finally:
|
||
self._setting = False
|
||
self._clear_loading("roster")
|
||
if not ordered:
|
||
self._show_time_empty("该医生暂无排班")
|
||
self.banner.show_message("该医生未来 7 天暂无可预约排班。", "warning")
|
||
self._update_conflict_alert()
|
||
self._update_submit_state()
|
||
return
|
||
self.banner.clear()
|
||
self.time_stack.setCurrentWidget(self.appointment_time_container)
|
||
self._date_changed()
|
||
|
||
def _roster_error(self, error: Exception, doctor_id: int, generation: int) -> None:
|
||
if generation != self._roster_generation or doctor_id != _as_int(
|
||
self.doctor_combo.currentData()
|
||
):
|
||
return
|
||
self._clear_loading("roster")
|
||
self._show_time_empty("排班加载失败")
|
||
self.banner.show_message(f"排班加载失败：{friendly_error(error)}", "danger")
|
||
self._update_submit_state()
|
||
|
||
def _populate_dates(self, dates: Sequence[str]) -> None:
|
||
self._clear_flow(self.date_flow)
|
||
self._date_buttons.clear()
|
||
self.date_combo.clear()
|
||
self.date_combo.addItem("请选择排班日期", "")
|
||
week_days = ["日", "一", "二", "三", "四", "五", "六"]
|
||
for value in dates:
|
||
parsed = QDate.fromString(value, "yyyy-MM-dd")
|
||
if not parsed.isValid():
|
||
continue
|
||
label = f"{parsed.toString('MM月dd日')} ({week_days[parsed.dayOfWeek() % 7]})"
|
||
self.date_combo.addItem(label, value)
|
||
button = _HoverLiftButton(label)
|
||
button.setProperty("appointmentDate", True)
|
||
button.setCheckable(True)
|
||
button.setFixedSize(130, 40)
|
||
button.clicked.connect(lambda _checked=False, date=value: self._select_date(date))
|
||
self.date_flow.addWidget(button)
|
||
self._date_buttons[value] = button
|
||
|
||
def _select_date(self, value: str) -> None:
|
||
index = self.date_combo.findData(value)
|
||
if index >= 0 and index != self.date_combo.currentIndex():
|
||
self.date_combo.setCurrentIndex(index)
|
||
elif index >= 0:
|
||
self._date_changed()
|
||
|
||
def _date_changed(self) -> None:
|
||
if self._setting:
|
||
return
|
||
doctor_id = _as_int(self.doctor_combo.currentData())
|
||
appointment_date = str(self.date_combo.currentData() or "")
|
||
self._sync_date_buttons(appointment_date)
|
||
self._clear_slots(
|
||
"正在加载可用号源…" if doctor_id and appointment_date else "请选择排班日期"
|
||
)
|
||
self._update_conflict_alert()
|
||
if doctor_id <= 0 or not appointment_date:
|
||
self._update_submit_state()
|
||
return
|
||
self._request_slots(doctor_id, appointment_date)
|
||
|
||
def _request_slots(
|
||
self,
|
||
doctor_id: int,
|
||
appointment_date: str,
|
||
*,
|
||
restore_selection: str = "",
|
||
) -> None:
|
||
self._slot_generation += 1
|
||
generation = self._slot_generation
|
||
self._slot_restore_selection = restore_selection
|
||
query = MappingProxyType(
|
||
{
|
||
"doctor_id": doctor_id,
|
||
"appointment_date": appointment_date,
|
||
"period": "all",
|
||
}
|
||
)
|
||
self.refresh_slots_button.setEnabled(False)
|
||
self.refresh_slots_button.setText("刷新中…")
|
||
loading_text = "正在刷新可用号源…" if restore_selection else "正在加载可用号源…"
|
||
self._set_loading("slots", loading_text)
|
||
self._run_async(
|
||
lambda: _invoke_first(
|
||
self.repository,
|
||
("get_available_appointment_slots", "available_appointment_slots"),
|
||
**query,
|
||
),
|
||
on_success=lambda result: self._apply_slots(
|
||
result, doctor_id, appointment_date, generation
|
||
),
|
||
on_error=lambda error: self._slot_error(error, doctor_id, appointment_date, generation),
|
||
)
|
||
|
||
def _apply_slots(
|
||
self, result: Any, doctor_id: int, appointment_date: str, generation: int
|
||
) -> None:
|
||
if (
|
||
generation != self._slot_generation
|
||
or doctor_id != _as_int(self.doctor_combo.currentData())
|
||
or appointment_date != str(self.date_combo.currentData() or "")
|
||
):
|
||
return
|
||
rows = self._rows(result, "slots")
|
||
today = QDate.currentDate().toString("yyyy-MM-dd")
|
||
now = QTime.currentTime()
|
||
slots: list[tuple[str, bool, str]] = []
|
||
for item in rows:
|
||
if isinstance(item, str):
|
||
raw_time = item
|
||
available = True
|
||
quota = 1
|
||
else:
|
||
raw_time = str(first_value(item, "time", "appointment_time", default=""))
|
||
available = _as_bool(first_value(item, "available", default=False))
|
||
quota = _as_int(first_value(item, "quota", default=1), 1)
|
||
if not raw_time:
|
||
continue
|
||
parsed = QTime.fromString(raw_time[:5], "HH:mm")
|
||
expired = appointment_date == today and parsed.isValid() and parsed <= now
|
||
can_book = available and quota > 0 and not expired
|
||
# Vue keeps expired slots in the grid and renders every unavailable slot as
|
||
# “已约”. Expiry still participates in the availability calculation above.
|
||
status = "可约" if can_book else "已约"
|
||
slots.append((raw_time, can_book, status))
|
||
restore = self._slot_restore_selection
|
||
self._populate_slots(slots)
|
||
if restore and self._slot_available.get(restore, False):
|
||
index = self.slot_combo.findData(restore)
|
||
if index >= 0:
|
||
self.slot_combo.setCurrentIndex(index)
|
||
self._slot_restore_selection = ""
|
||
self._clear_loading("slots")
|
||
self.refresh_slots_button.setEnabled(True)
|
||
self.refresh_slots_button.setText("刷新")
|
||
if slots:
|
||
self.banner.clear()
|
||
self.slot_state_stack.setCurrentWidget(self.slot_scroll)
|
||
QTimer.singleShot(0, self._update_slot_scroll_height)
|
||
else:
|
||
self.slot_empty.set_text("该排班暂无可用号源")
|
||
self.slot_state_stack.setFixedHeight(94)
|
||
self.slots_panel.setFixedHeight(164)
|
||
self.slot_state_stack.setCurrentWidget(self.slot_empty)
|
||
self._update_submit_state()
|
||
|
||
def _populate_slots(self, slots: Sequence[tuple[str, bool, str]]) -> None:
|
||
self._clear_flow(self.slot_flow)
|
||
self._slot_buttons.clear()
|
||
self._slot_available.clear()
|
||
self.slot_group = QButtonGroup(self)
|
||
self.slot_group.setExclusive(True)
|
||
self._setting = True
|
||
try:
|
||
self.slot_combo.clear()
|
||
self.slot_combo.addItem("请选择可用号源", "")
|
||
for raw_time, available, status in slots:
|
||
self.slot_combo.addItem(f"{raw_time} · {status}", raw_time)
|
||
button = _SlotCard(raw_time, status)
|
||
button.setProperty("appointmentSlot", True)
|
||
button.setProperty("availability", "available" if available else "unavailable")
|
||
button.setProperty(
|
||
"slotState",
|
||
"available" if available else "unavailable",
|
||
)
|
||
button.setCheckable(available)
|
||
button.setEnabled(available)
|
||
button.setMinimumSize(110, 70)
|
||
button.clicked.connect(
|
||
lambda _checked=False, value=raw_time: self._select_slot(value)
|
||
)
|
||
self.slot_group.addButton(button)
|
||
self.slot_flow.addWidget(button)
|
||
self._slot_buttons[raw_time] = button
|
||
self._slot_available[raw_time] = available
|
||
if not available:
|
||
opacity = QGraphicsOpacityEffect(button)
|
||
opacity.setOpacity(0.6)
|
||
button.setGraphicsEffect(opacity)
|
||
finally:
|
||
self._setting = False
|
||
|
||
def _select_slot(self, value: str) -> None:
|
||
if not self._slot_available.get(value, False):
|
||
return
|
||
index = self.slot_combo.findData(value)
|
||
if index >= 0:
|
||
self.slot_combo.setCurrentIndex(index)
|
||
|
||
def _slot_selection_changed(self) -> None:
|
||
if self._setting:
|
||
return
|
||
value = str(self.slot_combo.currentData() or "")
|
||
for slot_value, button in self._slot_buttons.items():
|
||
button.setChecked(slot_value == value and self._slot_available.get(slot_value, False))
|
||
self._update_submit_state()
|
||
|
||
def _slot_error(
|
||
self, error: Exception, doctor_id: int, appointment_date: str, generation: int
|
||
) -> None:
|
||
if (
|
||
generation != self._slot_generation
|
||
or doctor_id != _as_int(self.doctor_combo.currentData())
|
||
or appointment_date != str(self.date_combo.currentData() or "")
|
||
):
|
||
return
|
||
self._slot_restore_selection = ""
|
||
self._clear_loading("slots")
|
||
self.refresh_slots_button.setEnabled(True)
|
||
self.refresh_slots_button.setText("刷新")
|
||
self.slot_empty.set_text("号源加载失败")
|
||
self.slot_state_stack.setFixedHeight(94)
|
||
self.slots_panel.setFixedHeight(164)
|
||
self.slot_state_stack.setCurrentWidget(self.slot_empty)
|
||
self.banner.show_message(f"号源加载失败：{friendly_error(error)}", "danger")
|
||
self._update_submit_state()
|
||
|
||
def _refresh_slots(self) -> None:
|
||
doctor_id = _as_int(self.doctor_combo.currentData())
|
||
appointment_date = str(self.date_combo.currentData() or "")
|
||
if doctor_id <= 0 or not appointment_date:
|
||
return
|
||
selected = str(self.slot_combo.currentData() or "")
|
||
self._clear_slots("正在刷新可用号源…")
|
||
self._request_slots(doctor_id, appointment_date, restore_selection=selected)
|
||
|
||
def _channel_changed(self) -> None:
|
||
if self._setting:
|
||
return
|
||
self._sync_channel_detail_visibility()
|
||
self._update_submit_state()
|
||
|
||
def _sync_channel_detail_visibility(self) -> None:
|
||
requires_detail = self._channel_requires_detail()
|
||
self.channel_detail_row.setVisible(requires_detail)
|
||
if not requires_detail and self.channel_source_detail.text():
|
||
previous = self.channel_source_detail.blockSignals(True)
|
||
self.channel_source_detail.clear()
|
||
self.channel_source_detail.blockSignals(previous)
|
||
|
||
def _channel_requires_detail(self) -> bool:
|
||
value = str(self.channel_source.currentData() or "")
|
||
return self._channel_names.get(value, "") in self.CHANNEL_DETAIL_NAMES
|
||
|
||
def _update_conflict_alert(self) -> None:
|
||
if not self._today_blocking:
|
||
self.conflict_alert.clear()
|
||
return
|
||
today = QDate.currentDate().toString("yyyy-MM-dd")
|
||
if str(self.date_combo.currentData() or "") == today:
|
||
self.conflict_alert.show_message(
|
||
"该患者今日已有挂号（已预约或已过号），不能重复预约今天，请改选其他日期。",
|
||
"warning",
|
||
)
|
||
else:
|
||
self.conflict_alert.show_message(
|
||
"该患者今日已有挂号记录；可为患者预约其他日期的时段。",
|
||
"info",
|
||
)
|
||
|
||
def _update_submit_state(self) -> None:
|
||
if not hasattr(self, "ok_button"):
|
||
return
|
||
date_value = str(self.date_combo.currentData() or "") if hasattr(self, "date_combo") else ""
|
||
slot_value = str(self.slot_combo.currentData() or "") if hasattr(self, "slot_combo") else ""
|
||
today_blocked = self._today_blocking and date_value == QDate.currentDate().toString(
|
||
"yyyy-MM-dd"
|
||
)
|
||
complete = bool(
|
||
self._initial_loaded
|
||
and _as_int(self.doctor_combo.currentData()) > 0
|
||
and date_value
|
||
and slot_value
|
||
and self._slot_available.get(slot_value, False)
|
||
and self.channel_source.currentData()
|
||
and not today_blocked
|
||
and (not self._channel_requires_detail() or self.channel_source_detail.text().strip())
|
||
)
|
||
self.ok_button.setEnabled(complete)
|
||
|
||
def payload(self) -> dict[str, Any]:
|
||
# firstvisit.myPatient/createAppointment deliberately names the diagnosis
|
||
# identifier ``patient_id``. source_patient_id is only used by video.
|
||
return {
|
||
"diagnosis_id": self.diagnosis_id,
|
||
"patient_id": self.diagnosis_id,
|
||
"doctor_id": _as_int(self.doctor_combo.currentData()),
|
||
"appointment_date": str(self.date_combo.currentData() or ""),
|
||
"appointment_time": str(self.slot_combo.currentData() or ""),
|
||
"period": "all",
|
||
"appointment_type": str(self.appointment_type.currentData() or "video"),
|
||
"remark": self.remark.toPlainText().strip(),
|
||
"channel_source": str(self.channel_source.currentData() or ""),
|
||
"channel_source_detail": self.channel_source_detail.text().strip(),
|
||
}
|
||
|
||
def accept(self) -> None:
|
||
self._update_submit_state()
|
||
if not self.ok_button.isEnabled():
|
||
if self._today_blocking and str(
|
||
self.date_combo.currentData() or ""
|
||
) == QDate.currentDate().toString("yyyy-MM-dd"):
|
||
self.banner.show_message("该患者今天已有预约或过号，请选择其他日期。", "warning")
|
||
else:
|
||
self.banner.show_message("请完整选择医生、排班、可用号源和渠道。", "warning")
|
||
return
|
||
super().accept()
|
||
|
||
def reject(self) -> None:
|
||
self._invalidate_requests()
|
||
super().reject()
|
||
|
||
def done(self, result: int) -> None:
|
||
self._invalidate_requests()
|
||
owner = getattr(self, "_owner", None)
|
||
if owner is not None:
|
||
with suppress(RuntimeError):
|
||
owner.removeEventFilter(self)
|
||
super().done(result)
|
||
|
||
def showEvent(self, event: QEvent) -> None: # noqa: N802 - Qt API
|
||
self._sync_to_owner()
|
||
super().showEvent(event)
|
||
QTimer.singleShot(0, self._sync_to_owner)
|
||
|
||
def paintEvent(self, event: QPaintEvent) -> None: # noqa: N802 - Qt API
|
||
painter = QPainter(self)
|
||
painter.fillRect(self.rect(), QColor(26, 28, 31, 196))
|
||
painter.end()
|
||
super().paintEvent(event)
|
||
|
||
def resizeEvent(self, event: QResizeEvent) -> None: # noqa: N802 - Qt API
|
||
self._update_drawer_width()
|
||
if hasattr(self, "loading_overlay"):
|
||
self.loading_overlay.setGeometry(self.body_scroll.viewport().rect())
|
||
super().resizeEvent(event)
|
||
|
||
def eventFilter(self, watched: Any, event: QEvent) -> bool: # noqa: N802 - Qt API
|
||
owner = getattr(self, "_owner", None)
|
||
if (
|
||
owner is not None
|
||
and watched is owner
|
||
and event.type()
|
||
in {
|
||
QEvent.Type.Resize,
|
||
QEvent.Type.Move,
|
||
QEvent.Type.Show,
|
||
}
|
||
):
|
||
QTimer.singleShot(0, self._sync_to_owner)
|
||
elif watched is getattr(self, "_body_viewport", None) and event.type() in {
|
||
QEvent.Type.Resize,
|
||
QEvent.Type.Show,
|
||
}:
|
||
try:
|
||
self.loading_overlay.setGeometry(watched.rect())
|
||
except RuntimeError:
|
||
return False
|
||
elif watched is getattr(self, "_slot_viewport", None) and event.type() in {
|
||
QEvent.Type.Resize,
|
||
QEvent.Type.Show,
|
||
}:
|
||
QTimer.singleShot(0, self._update_slot_scroll_height)
|
||
return super().eventFilter(watched, event)
|
||
|
||
def mousePressEvent(self, event: QMouseEvent) -> None: # noqa: N802 - Qt API
|
||
if not self.panel.geometry().contains(event.position().toPoint()):
|
||
event.accept()
|
||
return
|
||
super().mousePressEvent(event)
|
||
|
||
def _sync_to_owner(self) -> None:
|
||
target = main_window_target_rect(self)
|
||
if target is not None:
|
||
self.setGeometry(target)
|
||
self._update_drawer_width()
|
||
return
|
||
if self._owner is None:
|
||
self._update_drawer_width()
|
||
return
|
||
top_left = self._owner.mapToGlobal(QPoint(0, 0))
|
||
self.setGeometry(QRect(top_left, self._owner.size()))
|
||
self._update_drawer_width()
|
||
|
||
def _update_drawer_width(self) -> None:
|
||
if not hasattr(self, "panel"):
|
||
return
|
||
target = max(1, int(round(self.width() * 0.60)))
|
||
self.panel.setFixedWidth(target)
|
||
|
||
def _set_loading(self, token: str, message: str) -> None:
|
||
self._active_loading = token
|
||
if hasattr(self, "loading_overlay"):
|
||
self.loading_overlay.show_message(message)
|
||
|
||
def _clear_loading(self, token: str) -> None:
|
||
if self._active_loading != token:
|
||
return
|
||
self._active_loading = ""
|
||
self.loading_overlay.clear()
|
||
|
||
def _show_time_empty(self, text: str) -> None:
|
||
self.time_empty.set_text(text)
|
||
self.time_stack.setCurrentWidget(self.time_empty)
|
||
|
||
def _clear_dates(self) -> None:
|
||
self._setting = True
|
||
try:
|
||
self._clear_flow(self.date_flow)
|
||
self._date_buttons.clear()
|
||
self.date_combo.clear()
|
||
self.date_combo.addItem("请先选择医生", "")
|
||
finally:
|
||
self._setting = False
|
||
|
||
def _clear_slots(self, message: str) -> None:
|
||
self._setting = True
|
||
try:
|
||
self._clear_flow(self.slot_flow)
|
||
self._slot_buttons.clear()
|
||
self._slot_available.clear()
|
||
self.slot_combo.clear()
|
||
self.slot_combo.addItem(message, "")
|
||
finally:
|
||
self._setting = False
|
||
self.slot_empty.set_text(message)
|
||
self.slot_state_stack.setFixedHeight(94)
|
||
self.slots_panel.setFixedHeight(164)
|
||
self.slot_state_stack.setCurrentWidget(self.slot_empty)
|
||
self._update_submit_state()
|
||
|
||
def _update_slot_scroll_height(self) -> None:
|
||
if not self._slot_buttons or self.slot_state_stack.currentWidget() is not self.slot_scroll:
|
||
return
|
||
viewport_width = max(110, self.slot_scroll.viewport().width())
|
||
content_height = max(70, self.slot_flow.heightForWidth(viewport_width))
|
||
target = max(94, min(450, content_height + 4))
|
||
self.slot_content.setMinimumHeight(content_height)
|
||
if self.slot_scroll.height() != target:
|
||
self.slot_scroll.setFixedHeight(target)
|
||
if self.slot_state_stack.height() != target:
|
||
self.slot_state_stack.setFixedHeight(target)
|
||
panel_height = target + 70
|
||
if self.slots_panel.height() != panel_height:
|
||
self.slots_panel.setFixedHeight(panel_height)
|
||
|
||
def _sync_date_buttons(self, selected: str) -> None:
|
||
for value, button in self._date_buttons.items():
|
||
button.setChecked(value == selected)
|
||
|
||
@staticmethod
|
||
def _clear_flow(layout: FlowLayout) -> None:
|
||
while layout.count():
|
||
item = layout.takeAt(0)
|
||
widget = item.widget() if item is not None else None
|
||
if widget is not None:
|
||
widget.hide()
|
||
widget.deleteLater()
|
||
|
||
def _invalidate_requests(self) -> None:
|
||
self._load_generation += 1
|
||
self._roster_generation += 1
|
||
self._slot_generation += 1
|
||
if hasattr(self, "loading_overlay"):
|
||
self.loading_overlay.clear()
|
||
|
||
|
||
__all__ = ["APPOINTMENT_DRAWER_QSS", "AppointmentDrawer", "FlowLayout"]
|