218 lines
7.6 KiB
Python
218 lines
7.6 KiB
Python
"""
|
|
Table view + model for displaying orders.
|
|
|
|
Using QAbstractTableModel instead of QTableWidget on purpose: it scales
|
|
to thousands of rows, and features like sorting and the company/source
|
|
filters below are straightforward extensions of this model rather than
|
|
rewrites.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from typing import List, Any, Optional
|
|
|
|
from PyQt6.QtCore import Qt, QAbstractTableModel, QModelIndex, QSortFilterProxyModel, pyqtSignal
|
|
from PyQt6.QtWidgets import (
|
|
QTableView,
|
|
QAbstractItemView,
|
|
QHeaderView,
|
|
QWidget,
|
|
QVBoxLayout,
|
|
QHBoxLayout,
|
|
QComboBox,
|
|
QLineEdit,
|
|
QLabel,
|
|
)
|
|
|
|
from app.models import Order
|
|
|
|
COLUMNS = [
|
|
("company", "Company"),
|
|
("ticket_number", "Ticket #"),
|
|
("skus_display", "SKUs"),
|
|
("source", "Source"),
|
|
("external_id", "Source ID"),
|
|
("summary", "Summary"),
|
|
("status", "Status"),
|
|
("source_created_at", "Created"),
|
|
("imported_at", "Imported"),
|
|
("fulfilled", "Fulfilled"),
|
|
]
|
|
|
|
ALL_COMPANIES = "All Companies"
|
|
ALL_SOURCES = "All Sources"
|
|
|
|
|
|
class OrdersTableModel(QAbstractTableModel):
|
|
def __init__(self, orders: List[Order] | None = None, parent=None):
|
|
super().__init__(parent)
|
|
self._orders: List[Order] = orders or []
|
|
|
|
def set_orders(self, orders: List[Order]) -> None:
|
|
self.beginResetModel()
|
|
self._orders = orders
|
|
self.endResetModel()
|
|
|
|
def rowCount(self, parent: QModelIndex = QModelIndex()) -> int:
|
|
return len(self._orders)
|
|
|
|
def columnCount(self, parent: QModelIndex = QModelIndex()) -> int:
|
|
return len(COLUMNS)
|
|
|
|
def headerData(self, section, orientation, role=Qt.ItemDataRole.DisplayRole):
|
|
if role != Qt.ItemDataRole.DisplayRole:
|
|
return None
|
|
if orientation == Qt.Orientation.Horizontal:
|
|
return COLUMNS[section][1]
|
|
return str(section + 1)
|
|
|
|
def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole) -> Any:
|
|
if not index.isValid() or role != Qt.ItemDataRole.DisplayRole:
|
|
return None
|
|
order = self._orders[index.row()]
|
|
field_name, _ = COLUMNS[index.column()]
|
|
|
|
if field_name == "skus_display":
|
|
return ", ".join(order.skus or [])
|
|
|
|
value = getattr(order, field_name)
|
|
if value is None:
|
|
return ""
|
|
if field_name == "fulfilled":
|
|
return "Yes" if value else "No"
|
|
return str(value)
|
|
|
|
def order_at(self, row: int) -> Order:
|
|
return self._orders[row]
|
|
|
|
|
|
class OrdersFilterProxyModel(QSortFilterProxyModel):
|
|
"""Filters by company, source, and a free-text search across ticket/SKU/summary."""
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent)
|
|
self.company_filter: str = ALL_COMPANIES
|
|
self.source_filter: str = ALL_SOURCES
|
|
self.search_text: str = ""
|
|
|
|
def set_company_filter(self, company: str) -> None:
|
|
self.company_filter = company
|
|
self.invalidateFilter()
|
|
|
|
def set_source_filter(self, source: str) -> None:
|
|
self.source_filter = source
|
|
self.invalidateFilter()
|
|
|
|
def set_search_text(self, text: str) -> None:
|
|
self.search_text = text.strip().lower()
|
|
self.invalidateFilter()
|
|
|
|
def filterAcceptsRow(self, source_row: int, source_parent: QModelIndex) -> bool:
|
|
model: OrdersTableModel = self.sourceModel()
|
|
order = model.order_at(source_row)
|
|
|
|
if self.company_filter != ALL_COMPANIES and order.company != self.company_filter:
|
|
return False
|
|
if self.source_filter != ALL_SOURCES and order.source != self.source_filter:
|
|
return False
|
|
|
|
if self.search_text:
|
|
haystack = " ".join(
|
|
[
|
|
order.ticket_number or "",
|
|
order.external_id or "",
|
|
order.summary or "",
|
|
" ".join(order.skus or []),
|
|
]
|
|
).lower()
|
|
if self.search_text not in haystack:
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
class OrdersTableView(QWidget):
|
|
"""Filter bar + sortable, read-only, full-row-selection table."""
|
|
|
|
order_double_clicked = pyqtSignal(object) # emits the Order that was double-clicked
|
|
|
|
def __init__(self, parent=None):
|
|
super().__init__(parent)
|
|
|
|
self._source_model = OrdersTableModel()
|
|
self._proxy_model = OrdersFilterProxyModel()
|
|
self._proxy_model.setSourceModel(self._source_model)
|
|
|
|
layout = QVBoxLayout(self)
|
|
layout.setContentsMargins(0, 0, 0, 0)
|
|
|
|
filter_bar = QHBoxLayout()
|
|
filter_bar.addWidget(QLabel("Company:"))
|
|
self.company_combo = QComboBox()
|
|
self.company_combo.addItem(ALL_COMPANIES)
|
|
self.company_combo.currentTextChanged.connect(self._proxy_model.set_company_filter)
|
|
filter_bar.addWidget(self.company_combo)
|
|
|
|
filter_bar.addWidget(QLabel("Source:"))
|
|
self.source_combo = QComboBox()
|
|
self.source_combo.addItem(ALL_SOURCES)
|
|
self.source_combo.currentTextChanged.connect(self._proxy_model.set_source_filter)
|
|
filter_bar.addWidget(self.source_combo)
|
|
|
|
filter_bar.addWidget(QLabel("Search:"))
|
|
self.search_box = QLineEdit()
|
|
self.search_box.setPlaceholderText("Ticket #, SKU, or summary...")
|
|
self.search_box.textChanged.connect(self._proxy_model.set_search_text)
|
|
filter_bar.addWidget(self.search_box, stretch=1)
|
|
|
|
layout.addLayout(filter_bar)
|
|
|
|
self.table = QTableView()
|
|
self.table.setModel(self._proxy_model)
|
|
self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
|
|
self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
|
|
self.table.setSortingEnabled(True)
|
|
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
|
|
self.table.horizontalHeader().setStretchLastSection(False)
|
|
self.table.doubleClicked.connect(self._on_row_double_clicked)
|
|
layout.addWidget(self.table)
|
|
|
|
def _on_row_double_clicked(self, index) -> None:
|
|
source_index = self._proxy_model.mapToSource(index)
|
|
order = self._source_model.order_at(source_index.row())
|
|
self.order_double_clicked.emit(order)
|
|
|
|
def set_orders(self, orders: List[Order]) -> None:
|
|
self._source_model.set_orders(orders)
|
|
self.table.resizeColumnsToContents()
|
|
self._refresh_filter_options(orders)
|
|
|
|
def _refresh_filter_options(self, orders: List[Order]) -> None:
|
|
for combo, attr, all_label in (
|
|
(self.company_combo, "company", ALL_COMPANIES),
|
|
(self.source_combo, "source", ALL_SOURCES),
|
|
):
|
|
current = combo.currentText()
|
|
values = sorted({getattr(o, attr) for o in orders if getattr(o, attr)})
|
|
combo.blockSignals(True)
|
|
combo.clear()
|
|
combo.addItem(all_label)
|
|
combo.addItems(values)
|
|
restore_index = combo.findText(current)
|
|
combo.setCurrentIndex(restore_index if restore_index >= 0 else 0)
|
|
combo.blockSignals(False)
|
|
|
|
def selected_order(self) -> Optional[Order]:
|
|
indexes = self.table.selectionModel().selectedRows()
|
|
if not indexes:
|
|
return None
|
|
source_index = self._proxy_model.mapToSource(indexes[0])
|
|
return self._source_model.order_at(source_index.row())
|
|
|
|
def visible_orders(self) -> List[Order]:
|
|
"""Orders currently passing the active filters - used for export."""
|
|
result = []
|
|
for row in range(self._proxy_model.rowCount()):
|
|
source_index = self._proxy_model.mapToSource(self._proxy_model.index(row, 0))
|
|
result.append(self._source_model.order_at(source_index.row()))
|
|
return result
|