forked from hesabix/arc
689 lines
28 KiB
Python
Executable file
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)
|