Переработка списков (#5)

Co-authored-by: gorbenko.pavel <gorbenko.pavel@tansu.kz>
Reviewed-on: http://git.tnsu.kz/timur.gorodetskiy/request-portal/pulls/5

src/webparts/requestPortal/features/myRequests/myRequests.service.ts

@@ -38,9 +38,20 @@ const OWN_REST_TOP = 200;
 // ApproverOWSUSER в схеме поиска не находилось (разбирались 2026-08-06).
 // Суффикс — тип исходного поля: OWSUSER для Person/Group.
 const MP_APPROVER = 'TansuSiteApproverOWSUSER';
-// Статус строки маршрута — Choice-поле, отсюда суффикс OWSCHCS (подтверждено
-// отладочным перебором 2026-08-06; у Person-полей он OWSUSER, см. MP_APPROVER).
-const MP_STATUS = 'RequestStatusOWSCHCS';
+// Статус СТРОКИ МАРШРУТА (колонка ApprovalStatus списка «— согласование») —
+// Choice-поле, отсюда суффикс OWSCHCS (подтверждено отладочным перебором
+// 2026-08-06; у Person-полей он OWSUSER, см. MP_APPROVER). Колонку не путать с
+// RequestStatus списка ДАННЫХ — это статус ЗАЯВКИ целиком.
+//
+// Для статуса ЗАЯВКИ (список ДАННЫХ) отдельной managed property здесь
+// НАМЕРЕННО нет: имя для произвольной Choice-колонки в схеме поиска либо надо
+// знать точно, либо угадывать по конвенции — угадали неверно (или колонка
+// после переименования Status → RequestStatus ещё не переиндексирована), и
+// фильтр по статусу молча возвращал 0 заявок. Поэтому статус заявки
+// фильтруется НЕ в KQL, а в памяти после дочитывания реальных полей через REST
+// (см. getOwnRequestsByStatus) — Search там ищет только по надёжному
+// AuthorOWSUSER, статус ни при чём.
+const MP_STATUS = 'ApprovalStatusOWSCHCS';
 
 export function currentUserEmail(context: WebPartContext): string {
   return (context.pageContext.user.email || '').toLowerCase();
@@ -60,16 +71,41 @@ export async function getLinkedTypes(context: WebPartContext): Promise<IRequestT
 //               пользователь участвует или будет участвовать.
 export type ApprovalScope = 'myTurn' | 'involved';
 
+// Очереди и истории, построенные на СТРОКАХ МАРШРУТА текущего пользователя.
+// Отличаются только набором статусов его строки — сам механизм (найти свои
+// строки → взять их заявки) общий, поэтому статусы вынесены в параметр, а не
+// зашиты в indexApprovalsForType.
+//
+//   approvals/execution — очереди действий: ход за пользователем прямо сейчас.
+//     Раньше обе выдавались одним разделом «На согласовании» (фильтр включал
+//     оба статуса сразу); теперь это РАЗНЫЕ разделы и пересечения между ними
+//     нет — заявка ровно в одном из них.
+//   approved/rejected/executed — история уже принятых им решений
+//     (подвкладки «Моих заявок»).
+export type ApprovalQueueKind = 'approvals' | 'execution' | 'approved' | 'rejected' | 'executed';
+
+const QUEUE_STATUSES: Record<ApprovalQueueKind, string[]> = {
+  approvals: [REQUEST_STATUS.onApproval],
+  execution: [REQUEST_STATUS.onExecution],
+  approved: [REQUEST_STATUS.approved],
+  rejected: [REQUEST_STATUS.rejected],
+  executed: [REQUEST_STATUS.executed],
+};
+
+// Статусы строки, означающие «ход за пользователем» — для счётчиков в меню
+// (обе очереди считаются за один проход, см. getMyTurnCounts).
+const MY_TURN_STATUSES: string[] = [REQUEST_STATUS.onApproval, REQUEST_STATUS.onExecution];
+
 // ---------------------------------------------------------------------------
 // «На согласовании» — раньше сюда приходилось читать ВЕСЬ список согласования
 // (иначе на клиенте нечем было посчитать «чья очередь»). Теперь очередь
 // проставляется при создании/решении (см. approvalList.service.ts/createSteps,
 // approverDecision.service.ts/decide) — «чья сейчас очередь» это просто
-// значение колонки Status, поэтому здесь достаточно ОДНОГО отфильтрованного
-// запроса: ApproverId (+ Status для 'myTurn'). Список согласования больше НЕ
-// сканируется целиком, независимо от его размера.
+// значение колонки ApprovalStatus, поэтому здесь достаточно ОДНОГО
+// отфильтрованного запроса: ApproverId (+ ApprovalStatus для 'myTurn').
+// Список согласования больше НЕ сканируется целиком, независимо от его размера.
 //
-// Заявку (Title/Status/Created) читаем сразу через expand по Lookup-полю
+// Заявку (Title/RequestStatus/Created) читаем сразу через expand по Lookup-полю
 // Ticket — отдельный запрос к списку данных нужен только за Author
 // (двухуровневый expand Ticket/Author у SharePoint REST ненадёжен), и то —
 // ТОЛЬКО для строк текущей страницы (см. hydrateAuthors ниже), а не для всего
@@ -93,13 +129,14 @@ const PENDING_PAGE_SIZE = 20;
 // см. filterPendingByQuery и вызывающую сторону в RequestsTableView).
 async function buildPendingIndex(
   context: WebPartContext,
-  scope: ApprovalScope
+  scope: ApprovalScope,
+  statuses: string[]
 ): Promise<{ types: IRequestType[]; index: IMyRequest[]; debug: IMyRequestsTypeDebug[] }> {
   const types = await getLinkedTypes(context);
   const tokenEmail = currentUserEmail(context);
 
   const perType = await Promise.all(
-    types.map((t) => indexApprovalsForType(context, t, tokenEmail, scope))
+    types.map((t) => indexApprovalsForType(context, t, tokenEmail, scope, statuses))
   );
 
   // Свежие сверху — типы объединяются в один список, сортировать нужно после слияния.
@@ -112,12 +149,12 @@ async function buildPendingIndex(
 
 // Без текстового поиска: страница нарезается ЗДЕСЬ (сервер решает, какие 20
 // заявок отдать), автор дочитывается только для них.
-export async function getPendingApproval(
+export async function getApprovalQueue(
   context: WebPartContext,
-  scope: ApprovalScope = 'myTurn',
+  kind: ApprovalQueueKind,
   page: number = 1
 ): Promise<IPendingApprovalPage> {
-  const { types, index, debug } = await buildPendingIndex(context, scope);
+  const { types, index, debug } = await buildPendingIndex(context, 'myTurn', QUEUE_STATUSES[kind]);
 
   const pageRows = index.slice((page - 1) * PENDING_PAGE_SIZE, page * PENDING_PAGE_SIZE);
   await hydrateAuthors(context, types, pageRows);
@@ -128,14 +165,59 @@ export async function getPendingApproval(
 // С текстовым поиском: полный индекс (без автора) — фильтрует его вызывающая
 // сторона через filterPendingByQuery, а страницу и автора берёт из уже
 // отфильтрованного результата (см. hydratePendingAuthors).
+//
+// Область поиска — та же, что и у самой вкладки (статусы очереди уходят в KQL):
+// раньше при вводе текста «На согласовании» расширялась до «где я вообще есть в
+// маршруте», но теперь для сквозного поиска есть отдельный раздел «Поиск», а
+// внутри вкладки предсказуемее искать по тому же набору, который в ней виден.
+export async function getApprovalQueueIndex(
+  context: WebPartContext,
+  kind: ApprovalQueueKind
+): Promise<{ rows: IMyRequest[]; types: IRequestType[]; debug: IMyRequestsTypeDebug[] }> {
+  const { types, index, debug } = await buildPendingIndex(context, 'involved', QUEUE_STATUSES[kind]);
+  return { rows: index, types, debug };
+}
+
+// Полный индекс «где я вообще есть в маршруте», без отбора по статусу — нужен
+// только разделу «Поиск» (см. searchMyRequests).
 export async function getPendingApprovalIndex(
   context: WebPartContext,
   scope: ApprovalScope
 ): Promise<{ rows: IMyRequest[]; types: IRequestType[]; debug: IMyRequestsTypeDebug[] }> {
-  const { types, index, debug } = await buildPendingIndex(context, scope);
+  const { types, index, debug } = await buildPendingIndex(context, scope, []);
   return { rows: index, types, debug };
 }
 
+/** Счётчики очередей для бокового меню. */
+export interface INavCounts {
+  approvals: number;
+  execution: number;
+  rework: number;
+}
+
+// «На согласовании» и «На исполнении» считаются за ОДИН проход: разделять их по
+// отдельным запросам значило бы дважды просканировать одни и те же списки
+// согласования. Статус своей строки приходит в myStepStatus (см.
+// indexApprovalsForType), по нему и разносим.
+//
+// «Доработка» живёт в других списках (данные, по автору), поэтому считается
+// своим запросом — но параллельно, и ровно тем же вызовом, что наполняет саму
+// вкладку: иначе счётчик и список могли бы разойтись.
+export async function getNavCounts(context: WebPartContext): Promise<INavCounts> {
+  const types = await getLinkedTypes(context);
+
+  const [turn, rework] = await Promise.all([
+    buildPendingIndex(context, 'myTurn', MY_TURN_STATUSES),
+    getOwnRequestsByStatus(context, types, REQUEST_STATUS.returned, 1),
+  ]);
+
+  return {
+    approvals: turn.index.filter((r) => r.myStepStatus === REQUEST_STATUS.onApproval).length,
+    execution: turn.index.filter((r) => r.myStepStatus === REQUEST_STATUS.onExecution).length,
+    rework: rework.totalRows,
+  };
+}
+
 // Публичная обёртка над hydrateAuthors — для дочитывания автора по уже
 // отфильтрованной и нарезанной на страницу выборке (см. getPendingApprovalIndex).
 export async function hydratePendingAuthors(
@@ -147,7 +229,7 @@ export async function hydratePendingAuthors(
 }
 
 // Лёгкий индекс совпадающих заявок для одного типа: строки согласования по
-// ApproverId → Title/Status/Created заявки отдельным запросом к списку ДАННЫХ
+// ApproverId → Title/RequestStatus/Created заявки отдельным запросом к списку ДАННЫХ
 // (НЕ через expand по Lookup-полю Ticket — SharePoint REST не отдаёт так
 // произвольные поля связанного элемента, только через Person-поля вроде
 // Author; попытка `expand('Ticket').select('Ticket/Status', ...)` падает с 400).
@@ -156,7 +238,8 @@ async function indexApprovalsForType(
   context: WebPartContext,
   type: IRequestType,
   tokenEmail: string,
-  scope: ApprovalScope
+  scope: ApprovalScope,
+  statuses: string[]
 ): Promise<{ rows: IMyRequest[]; debug: IMyRequestsTypeDebug }> {
   const debug: IMyRequestsTypeDebug = {
     requestTypeId: type.id,
@@ -186,8 +269,8 @@ async function indexApprovalsForType(
     // SharePoint REST — резолвим email в числовой Id пользователя (как и везде в
     // проекте, см. ensureUser) и фильтруем по TansuSiteApproverId.
     //
-    // RequestStatus в $filter НЕ используем: подтверждено на практике — фильтр
-    // вида `RequestStatus eq 'На согласовании'` (кириллица в $filter) молча
+    // ApprovalStatus в $filter НЕ используем: подтверждено на практике — фильтр
+    // вида `ApprovalStatus eq 'На согласовании'` (кириллица в $filter) молча
     // возвращает 0 строк, даже когда без него те же строки находятся с этим же
     // значением статуса. Поэтому фильтруем только по TansuSiteApproverId
     // (числовое значение, проблем нет), а статус сравниваем в JS после
@@ -208,23 +291,18 @@ async function indexApprovalsForType(
       const cutoffIso = new Date(Date.now() - RECENT_MS).toISOString();
       const recentRows = (await approvalList.items
         .filter(`TansuSiteApproverId eq ${approver.Id} and Modified ge '${cutoffIso}'`)
-        .select('Id', 'TicketId', 'RequestStatus')
+        .select('Id', 'TicketId', 'ApprovalStatus')
         .top(2000)()) as Array<Record<string, unknown>>;
 
-      // Статусы уходят в KQL: сервер сразу отдаёт только активные строки,
+      // Статусы уходят в KQL: сервер сразу отдаёт только нужные строки,
       // а не всё, где пользователь есть в маршруте.
-      const searchRows = await getInvolvedRowsViaSearch(context, type, approvalList, [
-        REQUEST_STATUS.onApproval,
-        REQUEST_STATUS.onExecution,
-      ]);
+      const searchRows = await getInvolvedRowsViaSearch(context, type, approvalList, statuses);
       const seenIds = new Set(recentRows.map((r) => r.Id));
       const allRows = recentRows.concat(searchRows.filter((r) => !seenIds.has(r.Id)));
 
-      stepRows = allRows.filter(
-        (r) =>
-          r.RequestStatus === REQUEST_STATUS.onApproval ||
-          r.RequestStatus === REQUEST_STATUS.onExecution
-      );
+      // REST-довесок берётся по Modified без учёта статуса (кириллица в $filter
+      // ненадёжна, см. выше) — отбор по статусу делаем здесь, на клиенте.
+      stepRows = allRows.filter((r) => statuses.indexOf(r.ApprovalStatus as string) !== -1);
     } else {
       // 'involved' — используется ТОЛЬКО для текстового поиска (см.
       // getPendingApprovalIndex/searchMyRequests) — здесь важна не мгновенная
@@ -233,7 +311,7 @@ async function indexApprovalsForType(
       // давал неустойчивый результат (заявка то находилась, то нет, в
       // зависимости от того, успел ли Search её проиндексировать к моменту
       // REST-окна).
-      stepRows = await getInvolvedRowsViaSearch(context, type, approvalList);
+      stepRows = await getInvolvedRowsViaSearch(context, type, approvalList, statuses);
     }
 
     debug.approvalRowCount = stepRows.length;
@@ -243,6 +321,18 @@ async function indexApprovalsForType(
     const ticketIds = Array.from(
       new Set(stepRows.map((r) => r.TicketId as number | undefined).filter((id): id is number => !!id))
     );
+
+    // Статус СВОЕЙ строки по заявке — нужен, чтобы разнести заявки по очередям
+    // одним проходом (см. getMyTurnCounts). Если строк по заявке несколько,
+    // берём первую подошедшую: все они уже отобраны по statuses, а очередь у
+    // заявки на практике одна.
+    const stepStatusByTicket = new Map<number, string>();
+    stepRows.forEach((r) => {
+      const ticketId = r.TicketId as number | undefined;
+      if (ticketId && !stepStatusByTicket.has(ticketId)) {
+        stepStatusByTicket.set(ticketId, (r.ApprovalStatus as string) || '');
+      }
+    });
     if (ticketIds.length === 0) {
       debug.approvalPendingTickets = 0;
       return { rows: [], debug };
@@ -253,10 +343,13 @@ async function indexApprovalsForType(
     const ticketFilter = ticketIds.map((id) => `Id eq ${id}`).join(' or ');
     const ticketRows = (await list.items
       .filter(ticketFilter)
-      .select('Id', 'Title', 'Status', 'Created')
+      .select('Id', 'Title', 'RequestStatus', 'Created')
       .top(ticketIds.length)()) as Array<Record<string, unknown>>;
 
-    const rows = ticketRows.map((r) => toMyRequest(r, undefined, type, 'approval'));
+    const rows = ticketRows.map((r) => ({
+      ...toMyRequest(r, undefined, type, 'approval'),
+      myStepStatus: stepStatusByTicket.get(r.Id as number),
+    }));
 
     debug.approvalPendingTickets = rows.length;
     return { rows, debug };
@@ -339,7 +432,7 @@ async function getInvolvedRowsViaSearch(
 
     return (await approvalList.items
       .filter(ids.map((id) => `Id eq ${id}`).join(' or '))
-      .select('Id', 'TicketId', 'RequestStatus')
+      .select('Id', 'TicketId', 'ApprovalStatus')
       .top(ids.length)()) as Array<Record<string, unknown>>;
   } catch (e) {
     console.error(
@@ -482,7 +575,7 @@ async function loadByIds(
       const rows = (await sp.web
         .getList(type.listId as string)
         .items.filter(ids.map((id) => `Id eq ${id}`).join(' or '))
-        .select('Id', 'Title', 'Status', 'Created', 'Author/EMail', 'Author/Title')
+        .select('Id', 'Title', 'RequestStatus', 'Created', 'Author/EMail', 'Author/Title')
         .expand('Author')
         .top(ids.length)()) as Array<Record<string, unknown>>;
       rows.forEach((r) => {
@@ -494,23 +587,20 @@ async function loadByIds(
   return byKey;
 }
 
-// Свежие (созданные за последние RECENT_MS) заявки автора — обычным REST-ом,
-// в обход Search (индекс мог их ещё не подхватить). Без текстового запроса —
-// матчить название не нужно, отдаём как есть.
-async function getFreshOwnRowsForType(context: WebPartContext, type: IRequestType): Promise<IMyRequest[]> {
+// Последние OWN_REST_TOP заявок автора одного типа обычным REST-ом, в обход
+// Search — сырьё для довеска по свежести (см. getFreshOwnRowsForType).
+// Фильтруем только по AuthorId: статус в $filter не используем, потому что
+// кириллица в сравнении там уже подводила (см. indexApprovalsForType) — отбор
+// по статусу делает вызывающая сторона.
+async function getOwnRowsForType(context: WebPartContext, type: IRequestType): Promise<IMyRequest[]> {
   try {
     const sp = spForSite(type.siteUrl as string, context);
     const me = await sp.web.currentUser.select('Id')();
-    const cutoff = new Date(Date.now() - RECENT_MS).toISOString();
 
-    // Фильтруем только по AuthorId, а «свежая или черновик» решаем в JS: статус
-    // в $filter не используем, потому что кириллица в сравнении там уже подводила
-    // (см. indexApprovalsForType). Берём последние OWN_REST_TOP заявок автора —
-    // это его собственные записи, их немного, и запрос ограничен по объёму.
     const rows = (await sp.web
       .getList(type.listId as string)
       .items.filter(`AuthorId eq ${me.Id}`)
-      .select('Id', 'Title', 'Status', 'Created', 'Author/EMail', 'Author/Title')
+      .select('Id', 'Title', 'RequestStatus', 'Created', 'Author/EMail', 'Author/Title')
       .expand('Author')
       .orderBy('Created', false)
       .top(OWN_REST_TOP)()) as Array<Record<string, unknown>>;
@@ -521,17 +611,57 @@ async function getFreshOwnRowsForType(context: WebPartContext, type: IRequestTyp
       );
     }
 
-    // Черновик берём ЛЮБОГО возраста: он живёт только у автора, правится часто и
-    // именно по нему индекс Search отстаёт заметнее всего, а увидеть свой
-    // черновик в «Моих заявках» пользователь ожидает сразу.
-    return rows
-      .filter((r) => {
-        const created = (r.Created as string) || '';
-        return r.Status === REQUEST_STATUS.draft || created >= cutoff;
-      })
-      .map((r) => toMyRequest(r, r.Author as { EMail?: string; Title?: string } | undefined, type, 'own'));
+    return rows.map((r) =>
+      toMyRequest(r, r.Author as { EMail?: string; Title?: string } | undefined, type, 'own')
+    );
   } catch (e) {
-    console.error(`[Текущие заявки] «${type.name}»: не удалось дочитать свежие заявки:`, (e as Error).message);
+    console.error(`[Текущие заявки] «${type.name}»: не удалось прочитать свои заявки:`, (e as Error).message);
+    return [];
+  }
+}
+
+// Свежие (созданные за последние RECENT_MS) заявки автора — довесок к Search,
+// индекс мог их ещё не подхватить.
+async function getFreshOwnRowsForType(context: WebPartContext, type: IRequestType): Promise<IMyRequest[]> {
+  const cutoff = new Date(Date.now() - RECENT_MS).toISOString();
+
+  // Черновик берём ЛЮБОГО возраста: он живёт только у автора, правится часто и
+  // именно по нему индекс Search отстаёт заметнее всего, а увидеть свой
+  // черновик в «Моих заявках» пользователь ожидает сразу.
+  return (await getOwnRowsForType(context, type)).filter(
+    (r) => r.status === REQUEST_STATUS.draft || r.created >= cutoff
+  );
+}
+
+// Заявки автора, изменённые за последние RECENT_MS, — довесок к Search для
+// getOwnRequestsByStatus. В отличие от getFreshOwnRowsForType (которая ловит
+// НОВЫЕ заявки по дате СОЗДАНИЯ), здесь важна дата ИЗМЕНЕНИЯ: заявку могли
+// вернуть на доработку неделю спустя после создания — по Created такую не
+// найти, а Modified у неё обновится ровно в момент решения согласующего
+// (см. approverDecision.service.ts/decide). Filter по Modified — обычная дата,
+// не Choice-колонка, кириллицы в значении нет, поэтому $filter здесь надёжен
+// (в отличие от статуса, см. getOwnRequestsByStatus).
+async function getRecentlyChangedOwnRowsForType(context: WebPartContext, type: IRequestType): Promise<IMyRequest[]> {
+  try {
+    const sp = spForSite(type.siteUrl as string, context);
+    const me = await sp.web.currentUser.select('Id')();
+    const cutoffIso = new Date(Date.now() - RECENT_MS).toISOString();
+
+    const rows = (await sp.web
+      .getList(type.listId as string)
+      .items.filter(`AuthorId eq ${me.Id} and Modified ge '${cutoffIso}'`)
+      .select('Id', 'Title', 'RequestStatus', 'Created', 'Author/EMail', 'Author/Title')
+      .expand('Author')
+      .top(OWN_REST_TOP)()) as Array<Record<string, unknown>>;
+
+    return rows.map((r) =>
+      toMyRequest(r, r.Author as { EMail?: string; Title?: string } | undefined, type, 'own')
+    );
+  } catch (e) {
+    console.error(
+      `[Текущие заявки] «${type.name}»: не удалось прочитать недавно изменённые заявки:`,
+      (e as Error).message
+    );
     return [];
   }
 }
@@ -601,12 +731,153 @@ export async function searchOwnRequests(
   });
 
 
+  const totalRows = results.TotalRows || 0;
   const entries = hitsToEntries(results, types);
   const byKey = entries.length > 0 ? await loadByIds(context, entries, 'own') : new Map<string, IMyRequest>();
   // Порядок задаёт релевантность поиска, а не порядок ответов REST.
   const rows = entries.map((e) => byKey.get(`${e.type.id}-${e.id}`)).filter((r): r is IMyRequest => !!r);
 
-  return { rows, totalRows: results.TotalRows || 0 };
+  return { rows, totalRows };
+}
+
+// Свои заявки с конкретным статусом ЗАЯВКИ (не строки маршрута) — «Доработка»
+// и фильтр по статусу на вкладке «Инициированные».
+//
+// Статус НЕ уходит в KQL: единственная надёжная managed property здесь —
+// AuthorOWSUSER (стандартное поле автора), а для произвольной Choice-колонки
+// имя managed property надо либо знать из схемы поиска, либо угадывать по
+// конвенции — угадали неверно (или она ещё не переиндексирована после
+// переименования колонки Status → RequestStatus), из-за чего фильтр по
+// статусу молча возвращал 0. Поэтому здесь Search ищет ТОЛЬКО по автору
+// (+ опционально текст) — это находит ВСЕ заявки автора вплоть до
+// KQL_ID_LIMIT, — а отбор по статусу и постраничность делаются в памяти по
+// уже дочитанным через REST реальным полям (см. searchOwnAll/loadByIds).
+// Тот же принцип, что и в filterPendingByQuery: Search сужает набор по
+// надёжному полю, остальное — на клиенте.
+export async function getOwnRequestsByStatus(
+  context: WebPartContext,
+  types: IRequestType[],
+  status: string,
+  page: number,
+  query: string = ''
+): Promise<IOwnRequestsPage> {
+  const all = await searchOwnAll(context, types, query);
+  const searchFiltered = all.filter((r) => r.status === status);
+
+  // Довесок по недавним изменениям — только на первой странице и только без
+  // текстового поиска (см. getOwnRequests: тот же принцип — довесок относится
+  // к «показать всё, свежее по дате», а не к результату полнотекстового поиска).
+  let merged = searchFiltered;
+  if (page === 1 && !query.trim()) {
+    const freshRows = (await Promise.all(types.map((t) => getRecentlyChangedOwnRowsForType(context, t))))
+      .reduce((acc, r) => acc.concat(r), [] as IMyRequest[])
+      .filter((r) => r.status === status);
+
+    const seen = new Set(searchFiltered.map((r) => `${r.requestTypeId}-${r.id}`));
+    const onlyFresh = freshRows.filter((r) => !seen.has(`${r.requestTypeId}-${r.id}`));
+    merged = onlyFresh.concat(searchFiltered);
+  }
+
+  const sorted = merged.sort((a, b) => b.created.localeCompare(a.created));
+  return {
+    rows: sorted.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE),
+    totalRows: sorted.length,
+  };
+}
+
+// Список согласования по типу заявки: Title списка данных → Title списка
+// согласования по конвенции имён (та же логика, что в indexApprovalsForType).
+// undefined — список заведён не по конвенции, маршрута для него не найти.
+async function approvalListFor(
+  context: WebPartContext,
+  type: IRequestType
+): Promise<IList | undefined> {
+  const sp = spForSite(type.siteUrl as string, context);
+  const info = (await sp.web.getList(type.listId as string).select('Title')()) as { Title?: string };
+  const dataTitle = info.Title || '';
+  if (!DATA_LIST_SUFFIX.test(dataTitle)) return undefined;
+  return sp.web.lists.getByTitle(`${dataTitle.replace(DATA_LIST_SUFFIX, '')} — согласование`);
+}
+
+// Сколько строк маршрута максимум забираем за раз при дочитывании комментариев:
+// на странице ≤20 заявок, у каждой обычно единицы шагов — запас многократный.
+const DECISION_COMMENT_ROW_LIMIT = 2000;
+
+/**
+ * Проставляет decisionComment — комментарий согласующего к его решению по
+ * заявке: причину возврата на доработку либо отклонения (что именно искать,
+ * задаёт decisionStatus). Комментарий хранится в СТРОКЕ МАРШРУТА (колонка
+ * Comment списка «— согласование»), а не в самой заявке, поэтому его нельзя
+ * получить тем же запросом, что и список: нужен отдельный проход по спискам
+ * согласования.
+ *
+ * Одного статуса достаточно, чтобы найти нужную строку, и для «своих
+ * возвращённых» (вернул кто-то другой), и для «отклонённых мной»: и возврат, и
+ * отклонение останавливают маршрут, поэтому такая строка по заявке одна.
+ *
+ * Вызывается ТОЛЬКО там, где причина показывается (см. RequestsTableView) —
+ * счётчику в меню, например, она не нужна, и лишние запросы ему ни к чему.
+ * Мутирует переданные строки — как и hydrateAuthors рядом.
+ */
+export async function hydrateDecisionComments(
+  context: WebPartContext,
+  types: IRequestType[],
+  rows: IMyRequest[],
+  decisionStatus: string
+): Promise<void> {
+  if (rows.length === 0) return;
+
+  const typeById = new Map<number, IRequestType>();
+  types.forEach((t) => typeById.set(t.id, t));
+
+  const rowsByType = new Map<number, IMyRequest[]>();
+  rows.forEach((r) => {
+    const list = rowsByType.get(r.requestTypeId) || [];
+    list.push(r);
+    rowsByType.set(r.requestTypeId, list);
+  });
+
+  await Promise.all(
+    Array.from(rowsByType.entries()).map(async ([requestTypeId, typeRows]) => {
+      const type = typeById.get(requestTypeId);
+      if (!type) return;
+      try {
+        const approvalList = await approvalListFor(context, type);
+        if (!approvalList) return;
+
+        // Фильтруем только по TicketId (числовое поле), статус сравниваем в JS:
+        // кириллица в $filter по Choice-колонке молча возвращает 0 строк —
+        // ровно та же причина, что и в indexApprovalsForType.
+        const stepRows = (await approvalList.items
+          .filter(typeRows.map((r) => `TicketId eq ${r.id}`).join(' or '))
+          .select('TicketId', 'ApprovalStatus', 'Comment')
+          .top(DECISION_COMMENT_ROW_LIMIT)()) as Array<Record<string, unknown>>;
+
+        const commentByTicket = new Map<number, string>();
+        stepRows.forEach((r) => {
+          if (r.ApprovalStatus !== decisionStatus) return;
+          const ticketId = r.TicketId as number | undefined;
+          const comment = ((r.Comment as string) || '').trim();
+          // Такая строка по заявке одна (и возврат, и отклонение останавливают
+          // маршрут, а при переотправке он переписывается целиком — см.
+          // writeRoute), но если их вдруг несколько, берём первую НЕПУСТУЮ,
+          // а не последнюю пустую.
+          if (ticketId && comment && !commentByTicket.has(ticketId)) {
+            commentByTicket.set(ticketId, comment);
+          }
+        });
+
+        typeRows.forEach((r) => {
+          r.decisionComment = commentByTicket.get(r.id);
+        });
+      } catch (e) {
+        console.error(
+          `[Текущие заявки] «${type.name}»: не удалось прочитать комментарий к решению:`,
+          (e as Error).message
+        );
+      }
+    })
+  );
 }
 
 // «На согласовании»: список заявок уже отобран по строкам согласования
@@ -672,7 +943,7 @@ export interface ISearchPage {
 
 // Как searchOwnRequests, но без $skip/$top — сразу весь найденный срез (до
 // KQL_ID_LIMIT). Только Search, без REST-подстраховки на свежесть.
-async function searchOwnAll(
+export async function searchOwnAll(
   context: WebPartContext,
   types: IRequestType[],
   query: string
@@ -702,11 +973,25 @@ async function searchOwnAll(
   return entries.map((e) => byKey.get(`${e.type.id}-${e.id}`)).filter((r): r is IMyRequest => !!r);
 }
 
+/**
+ * ВЕСЬ результат поиска (без нарезки на страницы) — постраничность делает
+ * вызывающая сторона.
+ *
+ * Именно так, а не «страницу за вызов»: набор всё равно собирается целиком
+ * (двумя источниками + слияние + сортировка), и раньше 95% этой работы
+ * выбрасывалось ради 20 строк — а при переходе на следующую страницу весь поиск
+ * запускался заново. Теперь SearchView кеширует список по ЗАПРОСУ, и листание
+ * страниц не стоит ни одного запроса.
+ *
+ * Автор здесь НЕ дочитывается: у строк 'approval' он требует отдельного запроса,
+ * и делать его на весь набор (до KQL_ID_LIMIT) значило бы собирать $filter из
+ * сотен Id — SharePoint такой длины URL не переварит. Автора дочитывает
+ * вызывающая сторона для видимой страницы (hydratePendingAuthors).
+ */
 export async function searchMyRequests(
   context: WebPartContext,
   types: IRequestType[],
-  query: string,
-  page: number
+  query: string
 ): Promise<ISearchPage> {
   const q = query.trim();
   if (!q) return { rows: [], totalRows: 0 };
@@ -724,17 +1009,7 @@ export async function searchMyRequests(
   const involvedOnly = involvedFiltered.filter((r) => !ownKeys.has(`${r.requestTypeId}-${r.id}`));
 
   const merged = ownRows.concat(involvedOnly).sort((a, b) => b.created.localeCompare(a.created));
-  const totalRows = merged.length;
-  const pageRows = merged.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE);
-
-  // Автор нужен для 'approval'-строк текущей страницы — 'own' уже пришли с
-  // автором (loadByIds сам дочитывает Author).
-  const needAuthor = pageRows.filter((r) => r.kind === 'approval');
-  if (needAuthor.length > 0) {
-    await hydratePendingAuthors(context, involvedIdx.types, needAuthor);
-  }
-
-  return { rows: pageRows, totalRows };
+  return { rows: merged, totalRows: merged.length };
 }
 
 function toMyRequest(
@@ -746,7 +1021,7 @@ function toMyRequest(
   return {
     id: r.Id as number,
     title: (r.Title as string) || '',
-    status: (r.Status as string) || '',
+    status: (r.RequestStatus as string) || '',
     authorEmail: author?.EMail || '',
     authorName: author?.Title || '',
     created: (r.Created as string) || '',