376 lines
12 KiB
Python
376 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
from datetime import datetime, timedelta, timezone
|
|
from typing import Optional
|
|
|
|
from sqlalchemy import and_, case, desc, func, or_, update
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy.future import select
|
|
from sqlalchemy.orm import selectinload
|
|
|
|
from ..models import SupportTicket, SupportTicketMessage, User
|
|
|
|
ACTIVE_STATUSES = {"open", "awaiting_user", "awaiting_admin"}
|
|
CLOSED_STATUSES = {"resolved", "closed"}
|
|
_UNSET = object()
|
|
|
|
|
|
def _status_condition(status: Optional[str]):
|
|
normalized = (status or "").strip().lower()
|
|
if not normalized or normalized in {"all", "any"}:
|
|
return None
|
|
if normalized == "active":
|
|
return SupportTicket.status.in_(ACTIVE_STATUSES)
|
|
if normalized == "closed":
|
|
return SupportTicket.status.in_(CLOSED_STATUSES)
|
|
return SupportTicket.status == normalized
|
|
|
|
|
|
async def create_ticket(
|
|
session: AsyncSession,
|
|
user_id: int,
|
|
subject: str,
|
|
category: str,
|
|
priority: str,
|
|
first_message_body: str,
|
|
) -> SupportTicket:
|
|
now = datetime.now(timezone.utc)
|
|
ticket = SupportTicket(
|
|
user_id=user_id,
|
|
subject=subject,
|
|
category=category,
|
|
priority=priority,
|
|
status="awaiting_admin",
|
|
last_message_at=now,
|
|
last_message_role="user",
|
|
unread_admin_count=1,
|
|
unread_user_count=0,
|
|
admin_last_notified_at=now,
|
|
admin_last_emailed_at=now,
|
|
)
|
|
session.add(ticket)
|
|
await session.flush()
|
|
message = SupportTicketMessage(
|
|
ticket_id=ticket.ticket_id,
|
|
author_role="user",
|
|
author_user_id=user_id,
|
|
body=first_message_body,
|
|
is_internal_note=False,
|
|
created_at=now,
|
|
)
|
|
session.add(message)
|
|
await session.flush()
|
|
await session.refresh(ticket)
|
|
return ticket
|
|
|
|
|
|
async def add_message(
|
|
session: AsyncSession,
|
|
ticket_id: int,
|
|
author_role: str,
|
|
author_user_id: Optional[int],
|
|
body: str,
|
|
is_internal_note: bool = False,
|
|
) -> Optional[SupportTicketMessage]:
|
|
stmt = select(SupportTicket).where(SupportTicket.ticket_id == ticket_id).with_for_update()
|
|
result = await session.execute(stmt)
|
|
ticket = result.scalar_one_or_none()
|
|
if not ticket:
|
|
return None
|
|
|
|
now = datetime.now(timezone.utc)
|
|
message = SupportTicketMessage(
|
|
ticket_id=ticket_id,
|
|
author_role=author_role,
|
|
author_user_id=author_user_id,
|
|
body=body,
|
|
is_internal_note=bool(is_internal_note),
|
|
created_at=now,
|
|
)
|
|
session.add(message)
|
|
|
|
ticket.last_message_at = now
|
|
ticket.last_message_role = author_role
|
|
ticket.updated_at = now
|
|
if author_role == "user":
|
|
ticket.unread_admin_count = int(ticket.unread_admin_count or 0) + 1
|
|
if ticket.status not in CLOSED_STATUSES:
|
|
ticket.status = "awaiting_admin"
|
|
elif author_role == "admin" and not is_internal_note:
|
|
ticket.unread_user_count = int(ticket.unread_user_count or 0) + 1
|
|
if ticket.status not in CLOSED_STATUSES:
|
|
ticket.status = "awaiting_user"
|
|
|
|
await session.flush()
|
|
await session.refresh(message)
|
|
return message
|
|
|
|
|
|
async def record_admin_notification(
|
|
session: AsyncSession,
|
|
ticket_id: int,
|
|
*,
|
|
notified_at: Optional[datetime] = None,
|
|
emailed_at: Optional[datetime] = None,
|
|
) -> None:
|
|
values = {}
|
|
if notified_at is not None:
|
|
values["admin_last_notified_at"] = notified_at
|
|
if emailed_at is not None:
|
|
values["admin_last_emailed_at"] = emailed_at
|
|
if not values:
|
|
return
|
|
await session.execute(
|
|
update(SupportTicket).where(SupportTicket.ticket_id == ticket_id).values(**values)
|
|
)
|
|
await session.flush()
|
|
|
|
|
|
async def get_ticket(
|
|
session: AsyncSession,
|
|
ticket_id: int,
|
|
*,
|
|
include_internal: bool = False,
|
|
) -> tuple[Optional[SupportTicket], list[SupportTicketMessage]]:
|
|
stmt = (
|
|
select(SupportTicket)
|
|
.where(SupportTicket.ticket_id == ticket_id)
|
|
.options(selectinload(SupportTicket.user))
|
|
)
|
|
result = await session.execute(stmt)
|
|
ticket = result.scalar_one_or_none()
|
|
if not ticket:
|
|
return None, []
|
|
|
|
msg_stmt = select(SupportTicketMessage).where(SupportTicketMessage.ticket_id == ticket_id)
|
|
if not include_internal:
|
|
msg_stmt = msg_stmt.where(SupportTicketMessage.is_internal_note.is_(False))
|
|
msg_stmt = msg_stmt.order_by(
|
|
SupportTicketMessage.created_at.asc(),
|
|
SupportTicketMessage.message_id.asc(),
|
|
)
|
|
msg_result = await session.execute(msg_stmt)
|
|
return ticket, list(msg_result.scalars().all())
|
|
|
|
|
|
async def list_user_tickets(
|
|
session: AsyncSession,
|
|
user_id: int,
|
|
*,
|
|
limit: int,
|
|
offset: int,
|
|
status_filter: Optional[str] = None,
|
|
) -> list[SupportTicket]:
|
|
stmt = select(SupportTicket).where(SupportTicket.user_id == user_id)
|
|
status_cond = _status_condition(status_filter)
|
|
if status_cond is not None:
|
|
stmt = stmt.where(status_cond)
|
|
stmt = (
|
|
stmt.order_by(desc(SupportTicket.last_message_at), desc(SupportTicket.ticket_id))
|
|
.limit(limit)
|
|
.offset(offset)
|
|
)
|
|
result = await session.execute(stmt)
|
|
return list(result.scalars().all())
|
|
|
|
|
|
async def list_admin_tickets(
|
|
session: AsyncSession,
|
|
*,
|
|
status: Optional[str] = None,
|
|
priority: Optional[str] = None,
|
|
category: Optional[str] = None,
|
|
assigned_admin_id: Optional[int] = None,
|
|
search: Optional[str] = None,
|
|
sort: str = "updated_desc",
|
|
limit: int,
|
|
offset: int,
|
|
) -> list[SupportTicket]:
|
|
stmt = select(SupportTicket).join(User, User.user_id == SupportTicket.user_id)
|
|
status_cond = _status_condition(status)
|
|
if status_cond is not None:
|
|
stmt = stmt.where(status_cond)
|
|
if priority:
|
|
stmt = stmt.where(SupportTicket.priority == priority)
|
|
if category:
|
|
stmt = stmt.where(SupportTicket.category == category)
|
|
if assigned_admin_id is not None:
|
|
stmt = stmt.where(SupportTicket.assigned_admin_id == assigned_admin_id)
|
|
if search:
|
|
pattern = f"%{search.strip().lower()}%"
|
|
stmt = stmt.where(
|
|
or_(
|
|
func.lower(SupportTicket.subject).like(pattern),
|
|
func.lower(User.username).like(pattern),
|
|
func.lower(User.first_name).like(pattern),
|
|
func.lower(User.email).like(pattern),
|
|
)
|
|
)
|
|
priority_rank = case(
|
|
(SupportTicket.priority == "urgent", 4),
|
|
(SupportTicket.priority == "high", 3),
|
|
(SupportTicket.priority == "normal", 2),
|
|
(SupportTicket.priority == "low", 1),
|
|
else_=0,
|
|
)
|
|
sort_key = (sort or "updated_desc").strip().lower()
|
|
sort_map = {
|
|
"updated_desc": (SupportTicket.last_message_at.desc().nullslast(),),
|
|
"updated_asc": (SupportTicket.last_message_at.asc().nullslast(),),
|
|
"created_desc": (SupportTicket.created_at.desc().nullslast(),),
|
|
"created_asc": (SupportTicket.created_at.asc().nullslast(),),
|
|
"importance_desc": (
|
|
priority_rank.desc(),
|
|
SupportTicket.last_message_at.desc().nullslast(),
|
|
),
|
|
"importance_asc": (
|
|
priority_rank.asc(),
|
|
SupportTicket.last_message_at.desc().nullslast(),
|
|
),
|
|
}
|
|
order_by = sort_map.get(sort_key, sort_map["updated_desc"])
|
|
stmt = stmt.options(selectinload(SupportTicket.user)).order_by(
|
|
*order_by,
|
|
desc(SupportTicket.ticket_id),
|
|
)
|
|
stmt = stmt.limit(limit).offset(offset)
|
|
result = await session.execute(stmt)
|
|
return list(result.scalars().unique().all())
|
|
|
|
|
|
async def user_ticket_counts(session: AsyncSession, user_id: int) -> dict:
|
|
stmt = (
|
|
select(SupportTicket.status, func.count())
|
|
.where(SupportTicket.user_id == user_id)
|
|
.group_by(SupportTicket.status)
|
|
)
|
|
result = await session.execute(stmt)
|
|
by_status = {str(status): int(count or 0) for status, count in result.all()}
|
|
active = sum(by_status.get(status, 0) for status in ACTIVE_STATUSES)
|
|
closed = sum(by_status.get(status, 0) for status in CLOSED_STATUSES)
|
|
return {
|
|
**by_status,
|
|
"active": active,
|
|
"closed": closed,
|
|
"total": active + closed,
|
|
}
|
|
|
|
|
|
async def mark_read(session: AsyncSession, ticket_id: int, role: str) -> None:
|
|
now = datetime.now(timezone.utc)
|
|
if role == "user":
|
|
await session.execute(
|
|
update(SupportTicket)
|
|
.where(SupportTicket.ticket_id == ticket_id)
|
|
.values(unread_user_count=0, updated_at=now)
|
|
)
|
|
await session.execute(
|
|
update(SupportTicketMessage)
|
|
.where(
|
|
and_(
|
|
SupportTicketMessage.ticket_id == ticket_id,
|
|
SupportTicketMessage.author_role == "admin",
|
|
SupportTicketMessage.is_internal_note.is_(False),
|
|
SupportTicketMessage.read_by_user_at.is_(None),
|
|
)
|
|
)
|
|
.values(read_by_user_at=now)
|
|
)
|
|
elif role == "admin":
|
|
await session.execute(
|
|
update(SupportTicket)
|
|
.where(SupportTicket.ticket_id == ticket_id)
|
|
.values(unread_admin_count=0, updated_at=now)
|
|
)
|
|
await session.execute(
|
|
update(SupportTicketMessage)
|
|
.where(
|
|
and_(
|
|
SupportTicketMessage.ticket_id == ticket_id,
|
|
SupportTicketMessage.author_role == "user",
|
|
SupportTicketMessage.read_by_admin_at.is_(None),
|
|
)
|
|
)
|
|
.values(read_by_admin_at=now)
|
|
)
|
|
await session.flush()
|
|
|
|
|
|
async def update_ticket(
|
|
session: AsyncSession,
|
|
ticket_id: int,
|
|
*,
|
|
status: Optional[str] = None,
|
|
priority: Optional[str] = None,
|
|
category: Optional[str] = None,
|
|
assigned_admin_id: object = _UNSET,
|
|
closed_by_admin_id: Optional[int] = None,
|
|
) -> Optional[SupportTicket]:
|
|
ticket = await session.get(SupportTicket, ticket_id)
|
|
if not ticket:
|
|
return None
|
|
now = datetime.now(timezone.utc)
|
|
if status is not None:
|
|
ticket.status = status
|
|
if status == "closed":
|
|
ticket.closed_at = now
|
|
ticket.closed_by_admin_id = closed_by_admin_id
|
|
elif status != "closed":
|
|
ticket.closed_at = None
|
|
ticket.closed_by_admin_id = None
|
|
if priority is not None:
|
|
ticket.priority = priority
|
|
if category is not None:
|
|
ticket.category = category
|
|
if assigned_admin_id is not _UNSET:
|
|
ticket.assigned_admin_id = assigned_admin_id
|
|
ticket.updated_at = now
|
|
await session.flush()
|
|
await session.refresh(ticket)
|
|
return ticket
|
|
|
|
|
|
async def count_user_unread(session: AsyncSession, user_id: int) -> int:
|
|
stmt = select(func.coalesce(func.sum(SupportTicket.unread_user_count), 0)).where(
|
|
SupportTicket.user_id == user_id
|
|
)
|
|
result = await session.execute(stmt)
|
|
return int(result.scalar_one() or 0)
|
|
|
|
|
|
async def admin_stats(session: AsyncSession) -> dict:
|
|
status_result = await session.execute(
|
|
select(SupportTicket.status, func.count()).group_by(SupportTicket.status)
|
|
)
|
|
by_status = {str(status): int(count or 0) for status, count in status_result.all()}
|
|
unread_result = await session.execute(
|
|
select(func.coalesce(func.sum(SupportTicket.unread_admin_count), 0))
|
|
)
|
|
active = sum(by_status.get(status, 0) for status in ACTIVE_STATUSES)
|
|
closed = sum(by_status.get(status, 0) for status in CLOSED_STATUSES)
|
|
return {
|
|
**by_status,
|
|
"active": active,
|
|
"closed": closed,
|
|
"total": active + closed,
|
|
"open": by_status.get("open", 0),
|
|
"awaiting_admin": by_status.get("awaiting_admin", 0),
|
|
"awaiting_user": by_status.get("awaiting_user", 0),
|
|
"total_unread_admin": int(unread_result.scalar_one() or 0),
|
|
}
|
|
|
|
|
|
async def count_recent_tickets_for_user(
|
|
session: AsyncSession,
|
|
user_id: int,
|
|
window_seconds: int,
|
|
) -> int:
|
|
cutoff = datetime.now(timezone.utc) - timedelta(seconds=max(1, int(window_seconds)))
|
|
stmt = (
|
|
select(func.count())
|
|
.select_from(SupportTicket)
|
|
.where(SupportTicket.user_id == user_id, SupportTicket.created_at >= cutoff)
|
|
)
|
|
result = await session.execute(stmt)
|
|
return int(result.scalar_one() or 0)
|