feat: Add frontend integration for watson search API

Backend:
- Created REST API endpoint /api/v1/search/
- Added SearchResultSerializer and SearchResponseSerializer
- Implemented search_api_view with model formatters (employee, department, post, request, chat, message, event)
- Registered search endpoint in api/v1/urls.py
- Added permission check for requests (HR can see all, users only their own)

Frontend:
- Added SearchResponse, SearchResult, SearchModelType types
- Added apiClient.search() method in lib/api.ts
- Completely rewrote search/page.tsx:
  * Single API call instead of 6 parallel requests
  * Cleaner UI with icons for each result type
  * Real-time search with loading states
  * Meta information display (email, phone, status, etc.)
  * Better performance and UX

Benefits:
- Frontend: 220 lines → 178 lines (19% reduction)
- 1 API request instead of 6 (83% less network calls)
- Server-side full-text search via watson (better relevance)
- Unified search results with metadata

Testing:
- API endpoint verified at /api/v1/search/?q=test
- Returns JSON with query, results, counts, total
- Requires authentication (IsAuthenticated decorator)

backend/api/v1/search/__init__.py

@@ -0,0 +1,2 @@
+# backend/api/v1/search/__init__.py
+"""API для глобального поиска через django-watson."""

backend/api/v1/search/serializers.py

@@ -0,0 +1,41 @@
+# backend/api/v1/search/serializers.py
+"""
+Сериализаторы для API поиска через django-watson.
+"""
+from __future__ import annotations
+
+from rest_framework import serializers
+from typing import Any
+
+
+class SearchResultSerializer(serializers.Serializer):
+    """Сериализатор для результата поиска watson."""
+    
+    model_name = serializers.CharField(
+        help_text="Тип модели: post, employee, department, request, chat, message, event"
+    )
+    object_id = serializers.IntegerField(help_text="ID объекта")
+    title = serializers.CharField(help_text="Заголовок/имя объекта", allow_blank=True)
+    description = serializers.CharField(
+        help_text="Описание/превью контента",
+        allow_blank=True,
+        required=False
+    )
+    url = serializers.CharField(help_text="Ссылка на объект", allow_blank=True)
+    meta = serializers.DictField(
+        help_text="Дополнительные метаданные",
+        required=False,
+        allow_null=True
+    )
+
+
+class SearchResponseSerializer(serializers.Serializer):
+    """Сериализатор для ответа API поиска."""
+    
+    query = serializers.CharField(help_text="Поисковый запрос")
+    results = SearchResultSerializer(many=True)
+    counts = serializers.DictField(
+        help_text="Количество результатов по типам",
+        child=serializers.IntegerField()
+    )
+    total = serializers.IntegerField(help_text="Общее количество результатов")

backend/api/v1/search/views.py

@@ -0,0 +1,262 @@
+# backend/api/v1/search/views.py
+"""
+API views для глобального поиска через django-watson.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+from collections import Counter
+
+from rest_framework import status
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import IsAuthenticated
+from rest_framework.request import Request as DRFRequest
+from rest_framework.response import Response
+from django.utils.html import escape
+from watson.search import search as watson_search
+
+from .serializers import SearchResponseSerializer
+
+
+def _get_model_name(obj: Any) -> str:
+    """Определяет тип модели для результата поиска."""
+    model = type(obj)
+    model_name = model.__name__.lower()
+    
+    mapping = {
+        "post": "post",
+        "employee": "employee",
+        "department": "department",
+        "request": "request",
+        "chat": "chat",
+        "message": "message",
+        "calendarevent": "event",
+    }
+    
+    return mapping.get(model_name, model_name)
+
+
+def _format_employee(obj: Any) -> Dict[str, Any]:
+    """Форматирует сотрудника для API."""
+    return {
+        "model_name": "employee",
+        "object_id": obj.pk,
+        "title": f"{obj.last_name} {obj.first_name} {obj.patronymic or ''}".strip(),
+        "description": getattr(obj.position, "name", "") if hasattr(obj, "position") else "",
+        "url": f"/employees/{obj.pk}/",
+        "meta": {
+            "email": obj.email,
+            "phone": obj.phone_number or "",
+        }
+    }
+
+
+def _format_department(obj: Any) -> Dict[str, Any]:
+    """Форматирует отдел для API."""
+    return {
+        "model_name": "department",
+        "object_id": obj.pk,
+        "title": obj.name,
+        "description": obj.description or "",
+        "url": f"/departments/{obj.pk}/",
+        "meta": {
+            "head": str(obj.head) if hasattr(obj, "head") and obj.head else None
+        }
+    }
+
+
+def _format_post(obj: Any) -> Dict[str, Any]:
+    """Форматирует пост для API."""
+    return {
+        "model_name": "post",
+        "object_id": obj.pk,
+        "title": obj.title,
+        "description": obj.body[:200] + "..." if len(obj.body) > 200 else obj.body,
+        "url": f"/feed/{obj.pk}/",
+        "meta": {
+            "author": str(obj.author) if hasattr(obj, "author") else None,
+            "created_at": obj.created_at.isoformat() if hasattr(obj, "created_at") else None,
+        }
+    }
+
+
+def _format_request(obj: Any) -> Dict[str, Any]:
+    """Форматирует заявление для API."""
+    return {
+        "model_name": "request",
+        "object_id": obj.pk,
+        "title": obj.title or f"{obj.get_type_display()} - {obj.employee}",
+        "description": obj.comment[:200] + "..." if obj.comment and len(obj.comment) > 200 else (obj.comment or ""),
+        "url": f"/requests/{obj.pk}/",
+        "meta": {
+            "status": obj.status,
+            "type": obj.type,
+            "employee": str(obj.employee) if hasattr(obj, "employee") else None,
+        }
+    }
+
+
+def _format_chat(obj: Any) -> Dict[str, Any]:
+    """Форматирует чат для API."""
+    return {
+        "model_name": "chat",
+        "object_id": obj.pk,
+        "title": obj.name or f"Чат #{obj.pk}",
+        "description": obj.description or "",
+        "url": f"/messages?chat={obj.pk}",
+        "meta": {
+            "type": obj.type if hasattr(obj, "type") else None,
+        }
+    }
+
+
+def _format_message(obj: Any) -> Dict[str, Any]:
+    """Форматирует сообщение для API."""
+    return {
+        "model_name": "message",
+        "object_id": obj.pk,
+        "title": f"Сообщение от {obj.author}" if hasattr(obj, "author") else f"Сообщение #{obj.pk}",
+        "description": obj.content[:200] + "..." if len(obj.content) > 200 else obj.content,
+        "url": f"/messages?chat={obj.chat.pk if hasattr(obj, 'chat') else ''}#msg-{obj.pk}",
+        "meta": {
+            "author": str(obj.author) if hasattr(obj, "author") else None,
+            "chat": str(obj.chat) if hasattr(obj, "chat") else None,
+        }
+    }
+
+
+def _format_event(obj: Any) -> Dict[str, Any]:
+    """Форматирует календарное событие для API."""
+    return {
+        "model_name": "event",
+        "object_id": obj.pk,
+        "title": obj.title,
+        "description": obj.description or "",
+        "url": f"/calendar?event={obj.pk}",
+        "meta": {
+            "start_date": obj.start_date.isoformat() if hasattr(obj, "start_date") else None,
+        }
+    }
+
+
+def _format_result(obj: Any, model_name: str) -> Dict[str, Any]:
+    """Форматирует результат поиска в зависимости от типа модели."""
+    formatters = {
+        "employee": _format_employee,
+        "department": _format_department,
+        "post": _format_post,
+        "request": _format_request,
+        "chat": _format_chat,
+        "message": _format_message,
+        "event": _format_event,
+    }
+    
+    formatter = formatters.get(model_name)
+    if formatter:
+        return formatter(obj)
+    
+    # Фоллбэк для неизвестных типов
+    return {
+        "model_name": model_name,
+        "object_id": obj.pk,
+        "title": str(obj),
+        "description": "",
+        "url": "#",
+        "meta": {}
+    }
+
+
+def _is_hr(user: Any) -> bool:
+    """Проверяет права на просмотр всех заявлений."""
+    return user.has_perm("requests_app.can_view_all_requests") or user.has_perm(
+        "requests_app.can_process_requests"
+    )
+
+
+@api_view(["GET"])
+@permission_classes([IsAuthenticated])
+def search_api_view(request: DRFRequest) -> Response:
+    """
+    API для глобального поиска через django-watson.
+    
+    Query Parameters:
+        - q (str): Поисковый запрос
+        - limit (int): Максимальное количество результатов на тип (default: 10)
+    
+    Returns:
+        {
+            "query": "поисковый запрос",
+            "results": [
+                {
+                    "model_name": "post|employee|department|request|chat|message|event",
+                    "object_id": 123,
+                    "title": "Заголовок",
+                    "description": "Описание",
+                    "url": "/path/to/object/",
+                    "meta": {...}
+                },
+                ...
+            ],
+            "counts": {
+                "post": 5,
+                "employee": 3,
+                ...
+            },
+            "total": 15
+        }
+    """
+    raw_q = request.query_params.get("q", "") or ""
+    query = escape(raw_q.strip())
+    limit = int(request.query_params.get("limit", 10))
+    
+    if not query:
+        return Response(
+            {
+                "query": "",
+                "results": [],
+                "counts": {},
+                "total": 0
+            },
+            status=status.HTTP_200_OK
+        )
+    
+    # Выполняем поиск через watson
+    search_results = watson_search(query)
+    
+    # Группируем и форматируем результаты
+    results = []
+    model_counts: Dict[str, int] = {}
+    
+    for search_result in search_results:
+        obj = search_result.object
+        model_name = _get_model_name(obj)
+        
+        # Фильтрация заявлений по правам доступа
+        if model_name == "request":
+            is_hr = _is_hr(request.user)
+            if not is_hr and hasattr(obj, 'employee') and obj.employee != request.user:  # type: ignore[attr-defined]
+                continue  # Пропускаем чужие заявления
+        
+        # Подсчитываем
+        model_counts[model_name] = model_counts.get(model_name, 0) + 1
+        
+        # Ограничиваем количество на тип
+        if model_counts[model_name] <= limit:
+            formatted = _format_result(obj, model_name)
+            results.append(formatted)
+    
+    # Готовим ответ
+    response_data = {
+        "query": query,
+        "results": results,
+        "counts": model_counts,
+        "total": sum(model_counts.values())
+    }
+    
+    # Валидируем через сериализатор (опционально, для проверки структуры)
+    serializer = SearchResponseSerializer(data=response_data)
+    if serializer.is_valid():
+        return Response(serializer.validated_data, status=status.HTTP_200_OK)
+    
+    # Если валидация не прошла, все равно возвращаем результат (для отладки)
+    return Response(response_data, status=status.HTTP_200_OK)

backend/api/v1/urls.py

@@ -27,6 +27,7 @@ from .employees.views import (
 )
 from .feed.views import CommentViewSet, PostViewSet
 from .requests_app.views import RequestViewSet
+from .search.views import search_api_view
 
 app_name = "v1"
 
@@ -83,6 +84,8 @@ urlpatterns = [
     path("notifications/", include("api.v1.notifications.urls")),
     # Procurement API
     path("procurement/", include("api.v1.procurement.urls")),
+    # Search API
+    path("search/", search_api_view, name="search"),
     # Router URLs (включая все ViewSets)
     path("", include(router.urls)),
 ]

frontend/src/app/search/page.tsx

@@ -1,47 +1,49 @@
 "use client";
 
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useState } from "react";
 import Link from "next/link";
 import { useSearchParams } from "next/navigation";
 import { AppShell } from "../../components/AppShell";
 import { apiClient } from "@/lib/api";
-import type { Chat, Department, Document, Post, Request, User } from "@/types/api";
-import { Search } from "lucide-react";
+import type { SearchResponse, SearchResult, SearchModelType } from "@/types/api";
+import { Search, User, Building, FileText, MessageSquare, MessageCircle, Calendar, Inbox } from "lucide-react";
 
-type SearchState = {
-  employees: User[];
-  departments: Department[];
-  documents: Document[];
-  requests: Request[];
-  chats: Chat[];
-  posts: Post[];
+// Иконки для разных типов результатов
+const modelIcons: Record<SearchModelType, React.ComponentType<{ size?: number; className?: string }>> = {
+  employee: User,
+  department: Building,
+  post: Inbox,
+  document: FileText,
+  request: FileText,
+  chat: MessageSquare,
+  message: MessageCircle,
+  event: Calendar,
 };
 
-const emptyState: SearchState = {
-  employees: [],
-  departments: [],
-  documents: [],
-  requests: [],
-  chats: [],
-  posts: [],
+// Названия категорий на русском
+const modelNames: Record<SearchModelType, string> = {
+  employee: "Сотрудники",
+  department: "Отделы",
+  post: "Посты",
+  document: "Документы",
+  request: "Заявления",
+  chat: "Чаты",
+  message: "Сообщения",
+  event: "События",
 };
 
-function contains(value: string | undefined, query: string): boolean {
-  return (value || "").toLowerCase().includes(query);
-}
-
 export default function SearchPage() {
   const searchParams = useSearchParams();
   const queryRaw = searchParams.get("q") || "";
-  const query = queryRaw.trim().toLowerCase();
+  const query = queryRaw.trim();
 
-  const [results, setResults] = useState<SearchState>(emptyState);
+  const [searchResponse, setSearchResponse] = useState<SearchResponse | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
   useEffect(() => {
     if (!query) {
-      setResults(emptyState);
+      setSearchResponse(null);
       setError(null);
       setLoading(false);
       return;
@@ -54,36 +56,11 @@ export default function SearchPage() {
         setLoading(true);
         setError(null);
 
-        const [employees, departments, documents, requests, chats, posts] = await Promise.all([
-          apiClient.getEmployees({ search: queryRaw, limit: 20 }),
-          apiClient.getDepartments({ search: queryRaw, limit: 20 }),
-          apiClient.getDocuments({ search: queryRaw, limit: 20 }),
-          apiClient.getRequests({ search: queryRaw, limit: 20 }),
-          apiClient.getChats({ search: queryRaw, limit: 20 }),
-          apiClient.getPosts({ search: queryRaw, limit: 20 }),
-        ]);
+        const response: SearchResponse = await apiClient.search(queryRaw, 10);
 
         if (cancelled) return;
 
-        const filtered: SearchState = {
-          employees: (employees.results || []).filter((u) =>
-            contains(`${u.last_name} ${u.first_name} ${u.patronymic || ""}`, query) ||
-            contains(u.email, query)
-          ),
-          departments: (departments.results || []).filter((d) =>
-            contains(d.name, query) || contains(d.description, query)
-          ),
-          documents: (documents.results || []).filter((d) =>
-            contains(d.title, query) || contains(d.description, query) || contains(d.document_type, query)
-          ),
-          requests: (requests.results || []).filter((r) =>
-            contains(r.title, query) || contains(r.description, query) || contains(r.request_type, query)
-          ),
-          chats: (chats.results || []).filter((c) => contains(c.name, query) || contains(c.last_message?.content, query)),
-          posts: (posts.results || []).filter((p) => contains(p.content, query)),
-        };
-
-        setResults(filtered);
+        setSearchResponse(response);
       } catch (err) {
         if (!cancelled) {
           console.error("Ошибка поиска:", err);
@@ -103,16 +80,16 @@ export default function SearchPage() {
     };
   }, [query, queryRaw]);
 
-  const total = useMemo(
-    () =>
-      results.employees.length +
-      results.departments.length +
-      results.documents.length +
-      results.requests.length +
-      results.chats.length +
-      results.posts.length,
-    [results]
-  );
+  // Группируем результаты по типам
+  const resultsByType: Partial<Record<SearchModelType, SearchResult[]>> = {};
+  if (searchResponse) {
+    searchResponse.results.forEach((result) => {
+      if (!resultsByType[result.model_name]) {
+        resultsByType[result.model_name] = [];
+      }
+      resultsByType[result.model_name]!.push(result);
+    });
+  }
 
   return (
     <AppShell>
@@ -120,97 +97,82 @@ export default function SearchPage() {
         <div className="mb-4 flex items-center gap-2">
           <Search size={16} className="text-gray-400" />
           <p className="text-sm text-gray-600">
-            {query ? `Результаты по запросу: ${queryRaw}` : "Введите запрос в поиске сверху"}
+            {query ? `Результаты по запросу: "${queryRaw}"` : "Введите запрос в поиске сверху"}
           </p>
         </div>
 
+        {query && searchResponse && (
+          <div className="mb-4 text-sm text-gray-500">
+            Найдено результатов: <span className="font-semibold">{searchResponse.total}</span>
+          </div>
+        )}
+
         {loading ? (
-          <div className="rounded-xl bg-gray-50 p-6 text-center text-sm text-gray-500">Идёт поиск...</div>
+          <div className="rounded-xl bg-gray-50 p-6 text-center text-sm text-gray-500">
+            <div className="inline-block h-5 w-5 animate-spin rounded-full border-2 border-gray-300 border-t-blue-600"></div>
+            <p className="mt-2">Поиск...</p>
+          </div>
         ) : error ? (
           <div className="rounded-xl bg-red-50 p-6 text-center text-sm text-red-800">{error}</div>
         ) : !query ? (
-          <div className="rounded-xl bg-gray-50 p-6 text-center text-sm text-gray-500">Начните вводить запрос в строке поиска</div>
-        ) : total === 0 ? (
-          <div className="rounded-xl bg-gray-50 p-6 text-center text-sm text-gray-500">Ничего не найдено</div>
+          <div className="rounded-xl bg-gray-50 p-6 text-center text-sm text-gray-500">
+            Начните вводить запрос в строке поиска
+          </div>
+        ) : searchResponse?.total === 0 ? (
+          <div className="rounded-xl bg-gray-50 p-6 text-center text-sm text-gray-500">
+            Ничего не найдено по запросу "{queryRaw}"
+          </div>
         ) : (
-          <div className="space-y-4">
-            {results.employees.length > 0 ? (
-              <div>
-                <p className="mb-2 text-xs font-semibold uppercase tracking-wide text-gray-500">Сотрудники</p>
-                <div className="space-y-2">
-                  {results.employees.map((u) => (
-                    <Link key={u.id} href="/employees" className="block rounded-lg border border-gray-100 px-3 py-2 text-sm hover:bg-gray-50">
-                      {`${u.last_name} ${u.first_name}`.trim()} {u.email ? `• ${u.email}` : ""}
-                    </Link>
-                  ))}
-                </div>
-              </div>
-            ) : null}
+          <div className="space-y-6">
+            {(Object.keys(resultsByType) as SearchModelType[]).map((modelType) => {
+              const results = resultsByType[modelType]!;
+              const Icon = modelIcons[modelType];
+              const categoryName = modelNames[modelType];
 
-            {results.departments.length > 0 ? (
-              <div>
-                <p className="mb-2 text-xs font-semibold uppercase tracking-wide text-gray-500">Отделы</p>
-                <div className="space-y-2">
-                  {results.departments.map((d) => (
-                    <Link key={d.id} href="/departments" className="block rounded-lg border border-gray-100 px-3 py-2 text-sm hover:bg-gray-50">
-                      {d.name}
-                    </Link>
-                  ))}
+              return (
+                <div key={modelType}>
+                  <div className="mb-3 flex items-center gap-2">
+                    <Icon size={16} className="text-gray-400" />
+                    <p className="text-xs font-semibold uppercase tracking-wide text-gray-500">
+                      {categoryName} <span className="font-normal">({results.length})</span>
+                    </p>
+                  </div>
+                  <div className="space-y-2">
+                    {results.map((result) => (
+                      <Link
+                        key={`${result.model_name}-${result.object_id}`}
+                        href={result.url}
+                        className="block rounded-lg border border-gray-200 p-3 transition-all hover:border-blue-300 hover:bg-blue-50/50 hover:shadow-sm"
+                      >
+                        <div className="flex items-start justify-between gap-2">
+                          <div className="flex-1 min-w-0">
+                            <p className="text-sm font-medium text-gray-900 truncate">{result.title}</p>
+                            {result.description && (
+                              <p className="mt-1 text-xs text-gray-500 line-clamp-2">{result.description}</p>
+                            )}
+                            {result.meta && Object.keys(result.meta).length > 0 && (
+                              <div className="mt-2 flex flex-wrap gap-2">
+                                {Object.entries(result.meta).map(([key, value]) => {
+                                  if (!value || key === 'id') return null;
+                                  return (
+                                    <span
+                                      key={key}
+                                      className="inline-flex items-center rounded-full bg-gray-100 px-2 py-0.5 text-xs text-gray-600"
+                                    >
+                                      {String(value)}
+                                    </span>
+                                  );
+                                })}
+                              </div>
+                            )}
+                          </div>
+                        </div>
+                      </Link>
+                    ))}
+                  </div>
                 </div>
-              </div>
-            ) : null}
-
-            {results.requests.length > 0 ? (
-              <div>
-                <p className="mb-2 text-xs font-semibold uppercase tracking-wide text-gray-500">Заявления</p>
-                <div className="space-y-2">
-                  {results.requests.map((r) => (
-                    <Link key={r.id} href="/requests" className="block rounded-lg border border-gray-100 px-3 py-2 text-sm hover:bg-gray-50">
-                      {r.title}
-                    </Link>
-                  ))}
-                </div>
-              </div>
-            ) : null}
-
-            {results.documents.length > 0 ? (
-              <div>
-                <p className="mb-2 text-xs font-semibold uppercase tracking-wide text-gray-500">Документы</p>
-                <div className="space-y-2">
-                  {results.documents.map((d) => (
-                    <Link key={d.id} href="/documents" className="block rounded-lg border border-gray-100 px-3 py-2 text-sm hover:bg-gray-50">
-                      {d.title}
-                    </Link>
-                  ))}
-                </div>
-              </div>
-            ) : null}
-
-            {results.chats.length > 0 ? (
-              <div>
-                <p className="mb-2 text-xs font-semibold uppercase tracking-wide text-gray-500">Чаты</p>
-                <div className="space-y-2">
-                  {results.chats.map((c) => (
-                    <Link key={c.id} href={`/messages/${c.id}`} className="block rounded-lg border border-gray-100 px-3 py-2 text-sm hover:bg-gray-50">
-                      {c.name || `Чат #${c.id}`}
-                    </Link>
-                  ))}
-                </div>
-              </div>
-            ) : null}
-
-            {results.posts.length > 0 ? (
-              <div>
-                <p className="mb-2 text-xs font-semibold uppercase tracking-wide text-gray-500">Посты</p>
-                <div className="space-y-2">
-                  {results.posts.map((p) => (
-                    <Link key={p.id} href="/" className="block rounded-lg border border-gray-100 px-3 py-2 text-sm hover:bg-gray-50">
-                      {p.content?.slice(0, 120) ?? "Без текста"}
-                    </Link>
-                  ))}
-                </div>
-              </div>
-            ) : null}
+              );
+            })}
           </div>
         )}
       </section>

frontend/src/lib/api.ts

@@ -230,6 +230,16 @@ class ApiClient {
         return this.request('/api/v1/employees/me/');
     }
 
+    // Глобальный поиск (django-watson)
+    async search(query: string, limit?: number): Promise<any> {
+        const queryParams = new URLSearchParams();
+        queryParams.append('q', query);
+        if (limit) queryParams.append('limit', limit.toString());
+
+        const url = `/api/v1/search/?${queryParams.toString()}`;
+        return this.request(url);
+    }
+
     // Сотрудники
     async getEmployees(params?: { search?: string; department?: string; page?: number; limit?: number }): Promise<any> {
         const queryParams = new URLSearchParams();

frontend/src/types/api.ts

@@ -279,3 +279,22 @@ export interface RegisterData {
   whatsapp?: string;
   wechat?: string;
 }
+
+// Search types (django-watson)
+export type SearchModelType = 'post' | 'employee' | 'department' | 'request' | 'chat' | 'message' | 'event';
+
+export interface SearchResult {
+  model_name: SearchModelType;
+  object_id: number;
+  title: string;
+  description?: string;
+  url: string;
+  meta?: Record<string, any>;
+}
+
+export interface SearchResponse {
+  query: string;
+  results: SearchResult[];
+  counts: Record<SearchModelType, number>;
+  total: number;
+}