Watch
1
0
Fork
You've already forked arc
0
forked from hesabix/arc
arc/hesabixAPI/adapters/api/v1/support/operator.py

689 lines
28 KiB
Python
Executable file

from typing import List
from fastapi import APIRouter, Depends, HTTPException, status, Request, Body
from sqlalchemy.orm import Session
from adapters.db.session import get_db
from adapters.db.repositories.support.ticket_repository import TicketRepository
from adapters.db.repositories.support.message_repository import MessageRepository
from adapters.db.models.support.ticket import Ticket
from adapters.api.v1.schemas import QueryInfo, PaginatedResponse, SuccessResponse
from adapters.api.v1.support.schemas import (
CreateMessageRequest,
UpdateStatusRequest,
UpdatePriorityRequest,
AssignTicketRequest,
BulkAssignRequest,
BulkUpdateStatusRequest,
TicketResponse,
MessageResponse
)
from app.core.auth_dependency import get_current_user, AuthContext
from app.core.permissions import require_app_permission
from app.core.responses import success_response, format_datetime_fields, ApiError
from app.services.notification_service import NotificationService
from app.services.support.ticket_access_service import TicketAccessService
from app.services.support.ticket_lifecycle_service import TicketLifecycleService
from app.services.support.ticket_event_service import TicketEventService
from app.services.support.support_attachment_service import SupportAttachmentService
from adapters.api.v1.support.message_helpers import serialize_message, serialize_messages
from adapters.api.v1.support.ticket_serialize import ticket_to_dict, ticket_response_dict
from app.services.support.ticket_engagement_service import mark_operator_read
from adapters.db.repositories.support.attachment_repository import AttachmentRepository
from app.services.support.notification_helpers import (
support_notification_context,
support_operator_notification_context,
resolve_announcement_navigation,
)
import logging
router = APIRouter()
@router.post("/tickets/search", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def search_operator_tickets(
request: Request,
query_info: QueryInfo = Body(...),
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""جستجو در تمام تیکت‌ها برای اپراتور"""
ticket_repo = TicketRepository(db)
# تنظیم فیلدهای قابل جستجو
if not query_info.search_fields:
query_info.search_fields = ["title", "description", "user_email", "user_name"]
tickets, total = ticket_repo.get_operator_tickets(query_info)
ticket_dicts = [ticket_to_dict(ticket, db) for ticket in tickets]
paginated_data = PaginatedResponse.create(
items=ticket_dicts,
total=total,
page=(query_info.skip // query_info.take) + 1,
limit=query_info.take
)
# Format datetime fields based on calendar type
formatted_data = format_datetime_fields(paginated_data.dict(), request)
return success_response(formatted_data, request)
@router.get("/operators", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def list_support_operators(
request: Request,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""لیست اپراتورهای پشتیبانی برای تخصیص"""
from adapters.db.repositories.user_repo import UserRepository
user_repo = UserRepository(db)
operators = user_repo.get_support_operators()
items = [
{
"id": op.id,
"first_name": op.first_name,
"last_name": op.last_name,
"email": op.email,
}
for op in operators
]
return success_response(items, request)
@router.get("/tickets/{ticket_id}/events", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def get_operator_ticket_events(
request: Request,
ticket_id: int,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""دریافت تاریخچه رویدادهای تیکت برای اپراتور"""
access = TicketAccessService(db)
access.get_operator_ticket(ticket_id)
events = TicketEventService(db).list_for_ticket(ticket_id)
items = [
{
"id": e.id,
"ticket_id": e.ticket_id,
"actor_id": e.actor_id,
"event_type": e.event_type,
"old_value": e.old_value,
"new_value": e.new_value,
"created_at": e.created_at,
}
for e in events
]
formatted_data = format_datetime_fields(items, request)
return success_response(formatted_data, request)
@router.get("/tickets/{ticket_id}", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def get_operator_ticket(
request: Request,
ticket_id: int,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""مشاهده تیکت برای اپراتور"""
ticket_repo = TicketRepository(db)
ticket = ticket_repo.get_operator_ticket_with_details(ticket_id)
if not ticket:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="تیکت یافت نشد"
)
# Format datetime fields based on calendar type
ticket_data = ticket_response_dict(ticket, db)
formatted_data = format_datetime_fields(ticket_data, request)
return success_response(formatted_data, request)
@router.post("/tickets/{ticket_id}/read", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def mark_ticket_read_operator(
request: Request,
ticket_id: int,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""علامت‌گذاری تیکت به‌عنوان خوانده‌شده توسط اپراتور"""
access = TicketAccessService(db)
ticket = access.get_operator_ticket(ticket_id)
mark_operator_read(db, ticket)
data = ticket_to_dict(ticket, db)
return success_response(format_datetime_fields(data, request), request)
@router.put("/tickets/{ticket_id}/status", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def update_ticket_status(
request: Request,
ticket_id: int,
status_request: UpdateStatusRequest,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""تغییر وضعیت تیکت"""
ticket_repo = TicketRepository(db)
lifecycle = TicketLifecycleService(db)
old_ticket = ticket_repo.get_operator_ticket_with_details(ticket_id)
if not old_ticket:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="تیکت یافت نشد"
)
old_status_id = old_ticket.status_id
old_status_name = old_ticket.status.name if old_ticket.status else "نامشخص"
ticket_with_details = lifecycle.update_status(
ticket_id=ticket_id,
status_id=status_request.status_id,
actor_id=current_user.get_user_id(),
assigned_operator_id=status_request.assigned_operator_id or current_user.get_user_id(),
)
new_status_name = ticket_with_details.status.name if ticket_with_details.status else "نامشخص"
if old_status_id != status_request.status_id and ticket_with_details.user_id:
try:
notification_service = NotificationService(db)
operator_name = f"{current_user.user.first_name or ''} {current_user.user.last_name or ''}".strip() or "اپراتور پشتیبانی"
context = support_notification_context({
"subject": f"وضعیت تیکت #{ticket_id} تغییر کرد",
"message": f"وضعیت تیکت شما (#{ticket_id}: {ticket_with_details.title}) از '{old_status_name}' به '{new_status_name}' تغییر کرد.",
"ticket_id": ticket_id,
"ticket_title": ticket_with_details.title,
"operator_name": operator_name,
"old_status": old_status_name,
"new_status": new_status_name,
"user_id": ticket_with_details.user_id
}, ticket_id)
notification_service.send(
user_id=ticket_with_details.user_id,
event_key="support.ticket_status_changed",
context=context,
preferred_channels=["inapp", "email", "telegram"],
broadcast_mode=False
)
except Exception as e:
logger = logging.getLogger(__name__)
logger.error(f"خطا در ارسال ناتیفیکیشن برای تغییر وضعیت تیکت {ticket_id}: {e}")
# Format datetime fields based on calendar type
ticket_data = ticket_response_dict(ticket_with_details, db)
formatted_data = format_datetime_fields(ticket_data, request)
return success_response(formatted_data, request)
@router.put("/tickets/{ticket_id}/priority", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def update_ticket_priority(
request: Request,
ticket_id: int,
priority_request: UpdatePriorityRequest,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db),
):
"""تغییر اولویت تیکت"""
lifecycle = TicketLifecycleService(db)
ticket_with_details = lifecycle.update_priority(
ticket_id, priority_request.priority_id, current_user.get_user_id()
)
ticket_data = ticket_response_dict(ticket_with_details, db)
formatted_data = format_datetime_fields(ticket_data, request)
return success_response(formatted_data, request)
@router.post("/tickets/{ticket_id}/assign", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def assign_ticket(
request: Request,
ticket_id: int,
assign_request: AssignTicketRequest,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""تخصیص تیکت به اپراتور"""
from adapters.db.repositories.user_repo import UserRepository
ticket_repo = TicketRepository(db)
user_repo = UserRepository(db)
lifecycle = TicketLifecycleService(db)
if assign_request.operator_id:
if not user_repo.is_support_operator(assign_request.operator_id):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="کاربر مشخص شده یک اپراتور پشتیبانی نیست"
)
ticket = ticket_repo.get_operator_ticket_with_details(ticket_id)
if not ticket:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail="تیکت یافت نشد"
)
old_operator_id = ticket.assigned_operator_id
new_operator_id = assign_request.operator_id
ticket_with_details = lifecycle.assign(
ticket_id, assign_request.operator_id, current_user.get_user_id()
)
try:
from app.services.support.support_broadcast import broadcast_ticket_updated
broadcast_ticket_updated(
db,
ticket_with_details,
changes={"assigned_operator_id": assign_request.operator_id},
)
except Exception:
pass
if new_operator_id and new_operator_id != old_operator_id:
try:
notification_service = NotificationService(db)
operator = user_repo.get_by_id(new_operator_id)
operator_name = f"{operator.first_name or ''} {operator.last_name or ''}".strip() if operator else "اپراتور پشتیبانی"
context = support_operator_notification_context({
"subject": f"تیکت جدید به شما تخصیص داده شد: #{ticket_id}",
"message": f"تیکت #{ticket_id}: {ticket_with_details.title} به شما تخصیص داده شد.",
"ticket_title": ticket_with_details.title,
"operator_name": operator_name,
"user_id": ticket_with_details.user_id,
}, ticket_id)
notification_service.send(
user_id=new_operator_id,
event_key="support.ticket_assigned",
context=context,
preferred_channels=["inapp", "email", "telegram"],
broadcast_mode=False
)
except Exception as e:
logger = logging.getLogger(__name__)
logger.error(f"خطا در ارسال ناتیفیکیشن برای تخصیص تیکت {ticket_id}: {e}")
# Format datetime fields based on calendar type
ticket_data = ticket_response_dict(ticket_with_details, db)
formatted_data = format_datetime_fields(ticket_data, request)
return success_response(formatted_data, request)
@router.post("/tickets/{ticket_id}/messages", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def send_operator_message(
request: Request,
ticket_id: int,
message_request: CreateMessageRequest,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""ارسال پیام اپراتور به تیکت"""
access = TicketAccessService(db)
message_repo = MessageRepository(db)
ticket_repo = TicketRepository(db)
ticket = access.get_operator_ticket(ticket_id)
if ticket.assigned_operator_id and ticket.assigned_operator_id != current_user.get_user_id():
logger = logging.getLogger(__name__)
logger.info(f"اپراتور {current_user.get_user_id()} به تیکت {ticket_id} که به اپراتور {ticket.assigned_operator_id} تخصیص شده پاسخ می‌دهد")
content = (message_request.content or "").strip()
if not content and not message_request.attachment_ids:
raise ApiError("EMPTY_MESSAGE", "متن پیام یا پیوست الزامی است", http_status=400)
if not content:
content = "📎 پیوست فایل"
message = message_repo.create_message(
ticket_id=ticket_id,
sender_id=current_user.get_user_id(),
sender_type="operator",
content=content,
is_internal=message_request.is_internal
)
attachment_service = SupportAttachmentService(db)
if message_request.attachment_ids:
attachment_service.attach_to_message(ticket_id, message.id, message_request.attachment_ids)
if not ticket.assigned_operator_id:
ticket_repo.assign_ticket(ticket_id, current_user.get_user_id())
db.commit()
# ارسال ناتیفیکیشن به کاربر (فقط برای پیام‌های غیرداخلی)
if not message_request.is_internal and ticket.user_id:
try:
from app.services.support.support_sla_service import SupportSlaService
SupportSlaService(db).mark_first_response(ticket)
notification_service = NotificationService(db)
operator_name = f"{current_user.user.first_name or ''} {current_user.user.last_name or ''}".strip() or "اپراتور پشتیبانی"
message_preview = content[:200] + ("..." if len(content) > 200 else "")
context = support_notification_context({
"subject": f"پاسخ جدید به تیکت #{ticket_id}",
"message": f"اپراتور {operator_name} به تیکت شما پاسخ داد:\n\n{message_preview}",
"ticket_id": ticket_id,
"ticket_title": ticket.title,
"operator_name": operator_name,
"message_preview": message_preview
}, ticket_id)
notification_service.send(
user_id=ticket.user_id,
event_key="support.operator_reply",
context=context,
preferred_channels=["inapp", "email", "telegram", "sms"],
broadcast_mode=False
)
except Exception as e:
# در صورت خطا، لاگ می‌کنیم اما فرآیند اصلی ادامه می‌یابد
logger = logging.getLogger(__name__)
logger.error(f"خطا در ارسال ناتیفیکیشن برای پاسخ اپراتور به تیکت {ticket_id}: {e}")
if not message_request.is_internal:
try:
from app.services.support.support_broadcast import broadcast_message_created
broadcast_message_created(
db,
ticket,
sender_type="operator",
message_id=message.id,
preview=content,
)
except Exception:
pass
attachment_repo = AttachmentRepository(db)
message_data = serialize_message(message, attachment_repo)
formatted_data = format_datetime_fields(message_data, request)
return success_response(formatted_data, request)
@router.post("/tickets/{ticket_id}/messages/search", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def search_operator_ticket_messages(
request: Request,
ticket_id: int,
query_info: QueryInfo = Body(...),
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""جستجو در پیام‌های تیکت برای اپراتور"""
access = TicketAccessService(db)
message_repo = MessageRepository(db)
access.get_operator_ticket(ticket_id)
if not query_info.search_fields:
query_info.search_fields = ["content"]
messages, total = message_repo.get_ticket_messages(ticket_id, query_info)
attachment_repo = AttachmentRepository(db)
message_dicts = serialize_messages(messages, attachment_repo)
paginated_data = PaginatedResponse.create(
items=message_dicts,
total=total,
page=(query_info.skip // query_info.take) + 1,
limit=query_info.take
)
# Format datetime fields based on calendar type
formatted_data = format_datetime_fields(paginated_data.dict(), request)
return success_response(formatted_data, request)
@router.post("/tickets/bulk-assign", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def bulk_assign_tickets(
request: Request,
bulk_request: BulkAssignRequest,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""تخصیص گروهی تیکت‌ها به اپراتور"""
from adapters.db.repositories.user_repo import UserRepository
ticket_repo = TicketRepository(db)
user_repo = UserRepository(db)
# بررسی اینکه operator_id واقعاً یک اپراتور است
if not user_repo.is_support_operator(bulk_request.operator_id):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="کاربر مشخص شده یک اپراتور پشتیبانی نیست"
)
# بررسی وجود تیکت‌ها
existing_tickets = ticket_repo.db.query(Ticket).filter(Ticket.id.in_(bulk_request.ticket_ids)).count()
if existing_tickets != len(bulk_request.ticket_ids):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=f"برخی از تیکت‌ها یافت نشدند. {existing_tickets} از {len(bulk_request.ticket_ids)} تیکت موجود است"
)
# تخصیص گروهی
updated_count = ticket_repo.bulk_assign_tickets(bulk_request.ticket_ids, bulk_request.operator_id)
# ارسال ناتیفیکیشن به اپراتور
if updated_count > 0:
try:
notification_service = NotificationService(db)
operator = user_repo.get_by_id(bulk_request.operator_id)
operator_name = f"{operator.first_name or ''} {operator.last_name or ''}".strip() if operator else "اپراتور پشتیبانی"
context = {
"subject": f"{updated_count} تیکت به شما تخصیص داده شد",
"message": f"{updated_count} تیکت به شما تخصیص داده شد.",
"operator_name": operator_name,
"ticket_count": updated_count,
}
context.update(resolve_announcement_navigation("support.tickets_bulk_assigned", context))
notification_service.send(
user_id=bulk_request.operator_id,
event_key="support.tickets_bulk_assigned",
context=context,
preferred_channels=["inapp", "email", "telegram"],
broadcast_mode=False
)
except Exception as e:
logger = logging.getLogger(__name__)
logger.error(f"خطا در ارسال ناتیفیکیشن برای تخصیص گروهی تیکت‌ها: {e}")
return success_response(
{
"message": f"{updated_count} تیکت با موفقیت تخصیص داده شد",
"updated_count": updated_count,
"ticket_ids": bulk_request.ticket_ids
},
request
)
@router.post("/tickets/bulk-update-status", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def bulk_update_ticket_status(
request: Request,
bulk_request: BulkUpdateStatusRequest,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""تغییر وضعیت گروهی تیکت‌ها"""
ticket_repo = TicketRepository(db)
# بررسی وجود تیکت‌ها
existing_tickets = ticket_repo.db.query(Ticket).filter(Ticket.id.in_(bulk_request.ticket_ids)).count()
if existing_tickets != len(bulk_request.ticket_ids):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail=f"برخی از تیکت‌ها یافت نشدند. {existing_tickets} از {len(bulk_request.ticket_ids)} تیکت موجود است"
)
# تغییر وضعیت گروهی
updated_count = ticket_repo.bulk_update_status(
bulk_request.ticket_ids,
bulk_request.status_id,
bulk_request.assigned_operator_id or current_user.get_user_id()
)
# ارسال ناتیفیکیشن به کاربران صاحب تیکت‌ها
if updated_count > 0:
try:
notification_service = NotificationService(db)
tickets = ticket_repo.db.query(Ticket).filter(Ticket.id.in_(bulk_request.ticket_ids)).all()
# دریافت نام وضعیت جدید
from adapters.db.models.support.status import Status
new_status = db.query(Status).filter(Status.id == bulk_request.status_id).first()
new_status_name = new_status.name if new_status else "نامشخص"
operator_name = f"{current_user.user.first_name or ''} {current_user.user.last_name or ''}".strip() or "اپراتور پشتیبانی"
# ارسال ناتیفیکیشن به هر کاربر
user_ids = list(set([t.user_id for t in tickets if t.user_id]))
for user_id in user_ids:
user_tickets = [t for t in tickets if t.user_id == user_id]
context = {
"subject": f"وضعیت {len(user_tickets)} تیکت شما تغییر کرد",
"message": f"وضعیت {len(user_tickets)} تیکت شما به '{new_status_name}' تغییر کرد.",
"operator_name": operator_name,
"new_status": new_status_name,
"ticket_count": len(user_tickets),
}
if len(user_tickets) == 1:
context = support_notification_context(context, user_tickets[0].id)
else:
context.update(resolve_announcement_navigation("support.tickets_bulk_status_changed", context))
notification_service.send(
user_id=user_id,
event_key="support.tickets_bulk_status_changed",
context=context,
preferred_channels=["inapp", "email", "telegram"],
broadcast_mode=False
)
except Exception as e:
logger = logging.getLogger(__name__)
logger.error(f"خطا در ارسال ناتیفیکیشن برای تغییر وضعیت گروهی تیکت‌ها: {e}")
return success_response(
{
"message": f"وضعیت {updated_count} تیکت با موفقیت تغییر کرد",
"updated_count": updated_count,
"ticket_ids": bulk_request.ticket_ids
},
request
)
@router.delete("/tickets/{ticket_id}", response_model=SuccessResponse)
@require_app_permission("superadmin")
async def delete_ticket(
request: Request,
ticket_id: int,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db)
):
"""حذف تیکت (فقط برای مدیر سیستم)"""
ticket_repo = TicketRepository(db)
# حذف تیکت
deleted = ticket_repo.delete_ticket(ticket_id)
if not deleted:
translator = getattr(request.state, "translator", None)
raise ApiError(
code="RESOURCE_NOT_FOUND",
message="تیکت یافت نشد یا قبلاً حذف شده است",
http_status=status.HTTP_404_NOT_FOUND,
translator=translator
)
return success_response(
{"message": "تیکت با موفقیت حذف شد", "ticket_id": ticket_id},
request
)
@router.get("/dashboard/stats", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def operator_dashboard_stats(
request: Request,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db),
):
from app.services.support.support_dashboard_service import SupportDashboardService
stats = SupportDashboardService(db).get_stats(current_user.get_user_id())
return success_response(stats, request)
@router.get("/dashboard/overdue", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def operator_dashboard_overdue(
request: Request,
limit: int = 20,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db),
):
from app.services.support.support_dashboard_service import SupportDashboardService
items = SupportDashboardService(db).get_overdue_tickets(limit=limit)
formatted = format_datetime_fields(items, request)
return success_response(formatted, request)
@router.get("/dashboard/activity", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def operator_dashboard_activity(
request: Request,
days: int = 7,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db),
):
from app.services.support.support_dashboard_service import SupportDashboardService
items = SupportDashboardService(db).get_activity(days=days)
return success_response(items, request)
@router.get("/users/{user_id}/tickets", response_model=SuccessResponse)
@require_app_permission("support_operator")
async def operator_user_ticket_history(
request: Request,
user_id: int,
take: int = 5,
current_user: AuthContext = Depends(get_current_user),
db: Session = Depends(get_db),
):
from app.services.support.support_dashboard_service import SupportDashboardService
items = SupportDashboardService(db).get_user_ticket_history(user_id, take=take)
formatted = format_datetime_fields(items, request)
return success_response(formatted, request)