src/webparts/requestPortal/features/myRequests/RequestsTableView.tsx

@@ -1,6 +1,13 @@
 import * as React from 'react';
 import type { WebPartContext } from '@microsoft/sp-webpart-base';
-import { getLinkedTypes, getOwnRequests, getPendingApproval } from './myRequests.service';
+import {
+  filterPendingByQuery,
+  getLinkedTypes,
+  getOwnRequests,
+  getPendingApproval,
+  getPendingApprovalIndex,
+  hydratePendingAuthors,
+} from './myRequests.service';
 import { IMyRequest } from './models/IMyRequest';
 import { REQUEST_STATUS, IRequestType } from '../../shared/approval';
 import { onRequestsChanged } from '../../shared/requestEvents';
@@ -166,15 +173,24 @@ const Table: React.FC<{
   </div>
 );
 
-// Раздел с таблицей заявок: поиск по названию + постраничный вывод.
+// Раздел с таблицей заявок: поиск по всем полям + вывод постранично.
 //
-// 'approvals' грузится целиком (алгоритм «чья сейчас очередь» требует видеть
-// весь маршрут заявки), поиск и пагинация — на клиенте.
-// 'own' идёт постранично через обычный REST (см. myRequests.service), поиск —
-// серверным OData-фильтром по Title.
+// 'own' — Search сразу с пагинацией (RowLimit/StartRow): автор = текущий
+// пользователь + текст запроса по всем полям.
+//
+// 'approvals' без поиска — обычный REST, отфильтрованный по ApproverId(+Status),
+// страница нарезается на СЕРВЕРЕ (getPendingApproval сам берёт нужный срез
+// индекса и дочитывает автора только для него).
+// 'approvals' с поиском — область расширяется до «где пользователь вообще есть
+// в маршруте» (getPendingApprovalIndex, ПОЛНЫЙ список без автора — постранично
+// его тут не взять, т.к. фильтрация текстом идёт уже после), затем текстовый
+// фильтр через Search (filterPendingByQuery), и только после фильтрации —
+// нарезка на страницы и дочитывание автора (hydratePendingAuthors) — тоже
+// только для видимой страницы, а не для всего отфильтрованного набора.
 //
 // Оба варианта перечитываются по событию rp-requests-changed
 // (shared/requestEvents) — после создания заявки и после решения согласующего.
+// Поиск идёт по индексу, поэтому свежая правка может проявиться не мгновенно.
 export const RequestsTableView: React.FC<IRequestsTableViewProps> = ({ context, kind, onOpen }) => {
   const [types, setTypes] = React.useState<IRequestType[] | undefined>(undefined);
   const [rows, setRows] = React.useState<IMyRequest[] | undefined>(undefined);
@@ -203,44 +219,63 @@ export const RequestsTableView: React.FC<IRequestsTableViewProps> = ({ context,
     if (types === undefined) return;
     let cancelled = false;
 
-    const load = (): void => {
-      const request =
-        kind === 'own'
-          ? getOwnRequests(context, types, query, page).then((r) => ({ rows: r.rows, total: r.totalRows }))
-          : getPendingApproval(context).then((r) => {
-              console.table(r.debug);
-              return { rows: r.rows, total: r.rows.length };
-            });
-
-      request
-        .then((result) => {
+    const load = async (): Promise<void> => {
+      try {
+        if (kind === 'own') {
+          const r = await getOwnRequests(context, types, query, page);
           if (cancelled) return;
-          setRows(result.rows);
-          setTotalRows(result.total);
+          setRows(r.rows);
+          setTotalRows(r.totalRows);
           setError('');
-        })
-        .catch((e) => {
-          if (!cancelled) setError((e as Error).message);
-        });
+          return;
+        }
+
+        const hasQuery = query.trim().length > 0;
+
+        if (!hasQuery) {
+          // Без поиска — страница уже нарезана и дочитана сервером.
+          const r = await getPendingApproval(context, 'myTurn', page);
+          if (cancelled) return;
+          console.table(r.debug);
+          setRows(r.rows);
+          setTotalRows(r.totalRows);
+          setError('');
+          return;
+        }
+
+        // С поиском — сначала полный список «где я есть в маршруте» (без
+        // автора), фильтруем текстом, и только потом режем на страницы и
+        // дочитываем автора — только для видимой страницы.
+        const idx = await getPendingApprovalIndex(context, 'involved');
+        if (cancelled) return;
+        console.table(idx.debug);
+        const filtered = await filterPendingByQuery(context, idx.types, idx.rows, query);
+        if (cancelled) return;
+        const pageRows = filtered.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE);
+        await hydratePendingAuthors(context, idx.types, pageRows);
+        if (cancelled) return;
+        setRows(pageRows);
+        setTotalRows(filtered.length);
+        setError('');
+      } catch (e) {
+        if (!cancelled) setError((e as Error).message);
+      }
     };
 
-    load();
-    const unsubscribe = onRequestsChanged(load);
+    load().catch(() => undefined); // ошибки уже обработаны внутри load через setError
+    const unsubscribe = onRequestsChanged(() => {
+      load().catch(() => undefined);
+    });
     return () => {
       cancelled = true;
       unsubscribe();
     };
   }, [context, types, kind, query, page]);
 
-  // 'approvals' приходит целиком — фильтруем и нарезаем страницы на клиенте.
-  const q = query.trim().toLowerCase();
-  let visible = rows || [];
-  let total = totalRows;
-  if (kind === 'approvals' && rows) {
-    const filtered = q ? rows.filter((r) => r.title.toLowerCase().indexOf(q) !== -1) : rows;
-    total = filtered.length;
-    visible = filtered.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE);
-  }
+  // Обе ветки теперь отдают уже нарезанную страницу — просто показываем как есть.
+  const q = query.trim();
+  const total = totalRows;
+  const visible = rows || [];
   const totalPages = Math.max(1, Math.ceil(total / PAGE_SIZE));
 
   const heading = kind === 'approvals' ? 'Ждут вашего решения' : 'Мои заявки';
@@ -255,7 +290,7 @@ export const RequestsTableView: React.FC<IRequestsTableViewProps> = ({ context,
         <input
           type="search"
           className={styles.search}
-          placeholder="Поиск по названию…"
+          placeholder="Поиск по заявкам…"
           value={query}
           onChange={(e) => setQuery(e.target.value)}
         />

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

@@ -3,6 +3,7 @@ import '@pnp/sp/webs';
 import '@pnp/sp/lists';
 import '@pnp/sp/items';
 import '@pnp/sp/site-users/web';
+import '@pnp/sp/search';
 import { WebPartContext } from '@microsoft/sp-webpart-base';
 import { getRequestTypes, IRequestType, REQUEST_STATUS } from '../../shared/approval';
 import { IMyRequest } from './models/IMyRequest';
@@ -12,12 +13,6 @@ import { IMyRequestsTypeDebug } from './models/IMyRequestsDebug';
 // (конвенция именования; см. forms/*/provisioning.json и forms/*/approval/provisioning.json).
 const DATA_LIST_SUFFIX = /\s*—\s*данные\s*$/;
 
-interface IApprovalStep {
-  status: string;
-  order?: number;
-  approverEmail: string;
-}
-
 export function currentUserEmail(context: WebPartContext): string {
   return (context.pageContext.user.email || '').toLowerCase();
 }
@@ -28,32 +23,114 @@ export async function getLinkedTypes(context: WebPartContext): Promise<IRequestT
   return types.filter((t) => !!t.listId && !!t.siteUrl);
 }
 
+// Что показывать в разделе «На согласовании»:
+//  'myTurn'   — только заявки, где очередь дошла до текущего пользователя
+//               (обычный режим, когда поиск не задан);
+//  'involved' — все заявки, где он вообще есть в маршруте (уже согласовал,
+//               ждёт своей очереди и т.п.) — так поиск ищет по всему, в чём
+//               пользователь участвует или будет участвовать.
+export type ApprovalScope = 'myTurn' | 'involved';
+
 // ---------------------------------------------------------------------------
-// «Ждёт вашего решения» — требует видеть ВЕСЬ маршрут заявки, чтобы понять,
-// чья сейчас очередь, поэтому идёт обычным REST-запросом (не через Search),
-// целиком за один раз. Пагинация по этому результату — на стороне панели
-// (клиентская нарезка по страницам), т.к. сам список обычно небольшой
-// (сколько заявок сейчас реально ждут решения ОДНОГО согласующего).
-export async function getPendingApproval(
-  context: WebPartContext
-): Promise<{ rows: IMyRequest[]; debug: IMyRequestsTypeDebug[] }> {
+// «На согласовании» — раньше сюда приходилось читать ВЕСЬ список согласования
+// (иначе на клиенте нечем было посчитать «чья очередь»). Теперь очередь
+// проставляется при создании/решении (см. approvalList.service.ts/createSteps,
+// approverDecision.service.ts/decide) — «чья сейчас очередь» это просто
+// значение колонки Status, поэтому здесь достаточно ОДНОГО отфильтрованного
+// запроса: ApproverId (+ Status для 'myTurn'). Список согласования больше НЕ
+// сканируется целиком, независимо от его размера.
+//
+// Заявку (Title/Status/Created) читаем сразу через expand по Lookup-полю
+// Ticket — отдельный запрос к списку данных нужен только за Author
+// (двухуровневый expand Ticket/Author у SharePoint REST ненадёжен), и то —
+// ТОЛЬКО для строк текущей страницы (см. hydrateAuthors ниже), а не для всего
+// найденного среза. Полноценный $skip/$top здесь не сделать: SharePoint REST
+// не умеет сортировать по полю через expand (Ticket/Created — поле не этого
+// списка), поэтому «свежие сверху» через несколько сайтов/типов можно получить
+// только слиянием и сортировкой в памяти. Экономим на самом дорогом шаге —
+// не дочитываем Author там, где он не попадёт на экран.
+export interface IPendingApprovalPage {
+  rows: IMyRequest[];
+  totalRows: number;
+  debug: IMyRequestsTypeDebug[];
+}
+
+const PENDING_PAGE_SIZE = 20;
+
+// Общая часть: собрать полный (не постраничный) индекс совпадающих заявок по
+// всем типам — без автора, БЕЗ дочитывания. Используется и обычным режимом
+// (без поиска — просто нарезаем страницу), и режимом с текстовым поиском (там
+// нужен ПОЛНЫЙ набор, иначе фильтрация Search дала бы неверный итог/страницы —
+// см. filterPendingByQuery и вызывающую сторону в RequestsTableView).
+async function buildPendingIndex(
+  context: WebPartContext,
+  scope: ApprovalScope
+): Promise<{ types: IRequestType[]; index: IMyRequest[]; debug: IMyRequestsTypeDebug[] }> {
   const types = await getLinkedTypes(context);
   const tokenEmail = currentUserEmail(context);
 
   const perType = await Promise.all(
-    types.map((t) => getApprovalPendingForType(context, t, tokenEmail))
+    types.map((t) => indexApprovalsForType(context, t, tokenEmail, scope))
   );
 
-  return {
-    rows: perType.reduce((all, r) => all.concat(r.rows), [] as IMyRequest[]),
-    debug: perType.map((r) => r.debug),
-  };
+  // Свежие сверху — типы объединяются в один список, сортировать нужно после слияния.
+  const index = perType
+    .reduce((all, r) => all.concat(r.rows), [] as IMyRequest[])
+    .sort((a, b) => b.created.localeCompare(a.created));
+
+  return { types, index, debug: perType.map((r) => r.debug) };
 }
 
-async function getApprovalPendingForType(
+// Без текстового поиска: страница нарезается ЗДЕСЬ (сервер решает, какие 20
+// заявок отдать), автор дочитывается только для них.
+export async function getPendingApproval(
+  context: WebPartContext,
+  scope: ApprovalScope = 'myTurn',
+  page: number = 1
+): Promise<IPendingApprovalPage> {
+  const { types, index, debug } = await buildPendingIndex(context, scope);
+
+  const pageRows = index.slice((page - 1) * PENDING_PAGE_SIZE, page * PENDING_PAGE_SIZE);
+  console.log(
+    `[Текущие заявки] «На согласовании» (scope=${scope}): всего найдено ${index.length}, страница ${page} — ${pageRows.length} строк, дочитываем автора для них`
+  );
+  await hydrateAuthors(context, types, pageRows);
+
+  return { rows: pageRows, totalRows: index.length, debug };
+}
+
+// С текстовым поиском: полный индекс (без автора) — фильтрует его вызывающая
+// сторона через filterPendingByQuery, а страницу и автора берёт из уже
+// отфильтрованного результата (см. hydratePendingAuthors).
+export async function getPendingApprovalIndex(
+  context: WebPartContext,
+  scope: ApprovalScope
+): Promise<{ rows: IMyRequest[]; types: IRequestType[]; debug: IMyRequestsTypeDebug[] }> {
+  const { types, index, debug } = await buildPendingIndex(context, scope);
+  return { rows: index, types, debug };
+}
+
+// Публичная обёртка над hydrateAuthors — для дочитывания автора по уже
+// отфильтрованной и нарезанной на страницу выборке (см. getPendingApprovalIndex).
+export async function hydratePendingAuthors(
+  context: WebPartContext,
+  types: IRequestType[],
+  rows: IMyRequest[]
+): Promise<void> {
+  await hydrateAuthors(context, types, rows);
+}
+
+// Лёгкий индекс совпадающих заявок для одного типа: строки согласования по
+// ApproverId → Title/Status/Created заявки отдельным запросом к списку ДАННЫХ
+// (НЕ через expand по Lookup-полю Ticket — SharePoint REST не отдаёт так
+// произвольные поля связанного элемента, только через Person-поля вроде
+// Author; попытка `expand('Ticket').select('Ticket/Status', ...)` падает с 400).
+// Author дочитывается позже (hydrateAuthors), только для строк итоговой страницы.
+async function indexApprovalsForType(
   context: WebPartContext,
   type: IRequestType,
-  tokenEmail: string
+  tokenEmail: string,
+  scope: ApprovalScope
 ): Promise<{ rows: IMyRequest[]; debug: IMyRequestsTypeDebug }> {
   const debug: IMyRequestsTypeDebug = {
     requestTypeId: type.id,
@@ -64,6 +141,8 @@ async function getApprovalPendingForType(
   };
 
   try {
+    if (!tokenEmail) return { rows: [], debug };
+
     const sp = spfi(type.siteUrl as string).using(SPFx(context));
     const list = sp.web.getList(type.listId as string);
 
@@ -77,63 +156,56 @@ async function getApprovalPendingForType(
     debug.approvalListTitle = approvalListTitle;
     const approvalList = sp.web.lists.getByTitle(approvalListTitle);
 
-    // Phase не смотрим вообще — работаем только по Status.
-    const stepRows = (await approvalList.items
-      .select('Id', 'StepOrder', 'Status', 'TicketId', 'Approver/EMail')
-      .expand('Approver')
-      .top(2000)()) as Array<Record<string, unknown>>;
-    console.log(
-      `[Текущие заявки] «${type.name}»: список согласования «${approvalListTitle}», элементов в списке: ${stepRows.length}, ваш email из токена: «${tokenEmail}»`
-    );
-    console.table(
-      stepRows.map((r) => ({
-        Id: r.Id,
-        TicketId: r.TicketId,
-        StepOrder: r.StepOrder,
-        Status: r.Status,
-        'Approver/EMail': (r.Approver as { EMail?: string } | undefined)?.EMail,
-      }))
-    );
+    // Approver/EMail eq '...' в $filter по Person-полю ненадёжен в SharePoint
+    // REST — резолвим email в числовой Id пользователя (как и везде в проекте,
+    // см. ensureUser) и фильтруем по ApproverId.
+    //
+    // Status в $filter НЕ используем: подтверждено на практике — фильтр
+    // `Status eq 'На согласовании'` (кириллица в $filter) молча возвращает 0
+    // строк, даже когда без него те же строки находятся с этим же значением
+    // Status. Поэтому фильтруем только по ApproverId (числовое значение,
+    // проблем нет), а Status сравниваем в JS после получения строк.
+    const claimsLogin = tokenEmail.indexOf('|') >= 0 ? tokenEmail : `i:0#.f|membership|${tokenEmail}`;
+    const approver = await sp.web.ensureUser(claimsLogin);
 
+    const allRows: Array<Record<string, unknown>> = [];
+    for await (const p of approvalList.items
+      .filter(`ApproverId eq ${approver.Id}`)
+      .select('Id', 'TicketId', 'Status')
+      .top(2000)) {
+      allRows.push(...(p as Array<Record<string, unknown>>));
+    }
+
+    const stepRows =
+      scope === 'myTurn' ? allRows.filter((r) => r.Status === REQUEST_STATUS.onApproval) : allRows;
+
+    console.log(
+      `[Текущие заявки] «${type.name}»: список согласования «${approvalListTitle}», approver.Id=${approver.Id}, scope=${scope}, строк по ApproverId: ${allRows.length}, после фильтра по статусу: ${stepRows.length}`
+    );
+    console.table(stepRows.map((r) => ({ Id: r.Id, TicketId: r.TicketId, Status: r.Status })));
     debug.approvalRowCount = stepRows.length;
 
-    const byTicket = new Map<number, IApprovalStep[]>();
-    stepRows.forEach((r) => {
-      const ticketId = r.TicketId as number | undefined;
-      if (!ticketId) return;
-      const approver = r.Approver as { EMail?: string } | undefined;
-      const steps = byTicket.get(ticketId) || [];
-      steps.push({
-        status: (r.Status as string) || '',
-        order: typeof r.StepOrder === 'number' ? (r.StepOrder as number) : undefined,
-        approverEmail: (approver?.EMail || '').toLowerCase(),
-      });
-      byTicket.set(ticketId, steps);
-    });
+    // Дедуп по TicketId: при scope='involved' у одной заявки может найтись
+    // несколько ваших строк (напр. вы согласующий и делегат) — заявка одна.
+    const ticketIds = Array.from(
+      new Set(stepRows.map((r) => r.TicketId as number | undefined).filter((id): id is number => !!id))
+    );
+    if (ticketIds.length === 0) {
+      debug.approvalPendingTickets = 0;
+      return { rows: [], debug };
+    }
 
-    const myTicketIds: number[] = [];
-    const byTicketDebug: Array<Record<string, unknown>> = [];
-    byTicket.forEach((steps, ticketId) => {
-      const mine = isMyTurn(steps, tokenEmail);
-      byTicketDebug.push({ TicketId: ticketId, isMyTurn: mine, steps: JSON.stringify(steps) });
-      if (mine) myTicketIds.push(ticketId);
-    });
-    console.table(byTicketDebug);
-
-    debug.approvalPendingTickets = myTicketIds.length;
-    if (myTicketIds.length === 0) return { rows: [], debug };
-
-    const ticketFilter = myTicketIds.map((id) => `Id eq ${id}`).join(' or ');
+    // Заголовок/статус/дата заявки — отдельным запросом к списку ДАННЫХ (см.
+    // комментарий у функции: через Lookup-expand это не отдаётся).
+    const ticketFilter = ticketIds.map((id) => `Id eq ${id}`).join(' or ');
     const ticketRows = (await list.items
       .filter(ticketFilter)
-      .select('Id', 'Title', 'Status', 'Created', 'Author/EMail', 'Author/Title')
-      .expand('Author')
-      .top(2000)()) as Array<Record<string, unknown>>;
+      .select('Id', 'Title', 'Status', 'Created')
+      .top(ticketIds.length)()) as Array<Record<string, unknown>>;
 
-    const rows = ticketRows.map((r) => {
-      const author = r.Author as { EMail?: string; Title?: string } | undefined;
-      return toMyRequest(r, author, type, 'approval');
-    });
+    const rows = ticketRows.map((r) => toMyRequest(r, undefined, type, 'approval'));
+
+    debug.approvalPendingTickets = rows.length;
     return { rows, debug };
   } catch (e) {
     debug.approvalError = (e as Error).message;
@@ -145,115 +217,126 @@ async function getApprovalPendingForType(
   }
 }
 
-// Сейчас ли очередь пользователя с данным email среди строк маршрута одной заявки.
-// Маршрут остановлен (где-то есть Отклонено/Возвращена) — не его очередь, заявка
-// не активна. Иначе «текущие» строки — это ещё не решённые (Status = На согласовании)
-// без указанного StepOrder (параллельно, все активны сразу) плюс, если есть строки
-// с указанным StepOrder, ещё не решённая с минимальным StepOrder (последовательно).
-function isMyTurn(steps: IApprovalStep[], tokenEmail: string): boolean {
-  if (!tokenEmail) return false;
-  const stopped = steps.some(
-    (s) => s.status === REQUEST_STATUS.rejected || s.status === REQUEST_STATUS.returned
+// Дочитывает Author/EMail + Author/Title в списке ДАННЫХ каждого типа —
+// только по переданным строкам (обычно уже нарезанная страница из ≤20), не по
+// всему найденному срезу. Мутирует переданные объекты (проставляет authorEmail/authorName).
+async function hydrateAuthors(
+  context: WebPartContext,
+  types: IRequestType[],
+  rows: IMyRequest[]
+): Promise<void> {
+  if (rows.length === 0) return;
+
+  const typeById = new Map<number, IRequestType>();
+  types.forEach((t) => typeById.set(t.id, t));
+
+  const idsByType = new Map<number, number[]>();
+  rows.forEach((r) => {
+    const ids = idsByType.get(r.requestTypeId) || [];
+    ids.push(r.id);
+    idsByType.set(r.requestTypeId, ids);
+  });
+
+  const byKey = new Map<string, { EMail?: string; Title?: string }>();
+  await Promise.all(
+    Array.from(idsByType.entries()).map(async ([requestTypeId, ids]) => {
+      const type = typeById.get(requestTypeId);
+      if (!type) return;
+      try {
+        const sp = spfi(type.siteUrl as string).using(SPFx(context));
+        const authorRows = (await sp.web
+          .getList(type.listId as string)
+          .items.filter(ids.map((id) => `Id eq ${id}`).join(' or '))
+          .select('Id', 'Author/EMail', 'Author/Title')
+          .expand('Author')
+          .top(ids.length)()) as Array<Record<string, unknown>>;
+        authorRows.forEach((r) => {
+          byKey.set(
+            `${requestTypeId}-${r.Id as number}`,
+            (r.Author as { EMail?: string; Title?: string }) || {}
+          );
+        });
+      } catch (e) {
+        console.error(`[Текущие заявки] Не удалось дочитать автора для «${type.name}»:`, (e as Error).message);
+      }
+    })
   );
-  if (stopped) return false;
 
-  const pending = steps.filter((s) => s.status === REQUEST_STATUS.onApproval);
-  const noOrder = pending.filter((s) => s.order === undefined);
-  const ordered = pending.filter((s): s is IApprovalStep & { order: number } => s.order !== undefined);
-
-  const current = [...noOrder];
-  if (ordered.length > 0) {
-    const minOrder = Math.min(...ordered.map((s) => s.order));
-    current.push(...ordered.filter((s) => s.order === minOrder));
-  }
-
-  return current.some((s) => s.approverEmail === tokenEmail);
+  rows.forEach((r) => {
+    const a = byKey.get(`${r.requestTypeId}-${r.id}`);
+    r.authorEmail = a?.EMail || '';
+    r.authorName = a?.Title || '';
+  });
 }
 
 // ---------------------------------------------------------------------------
-// «Созданы вами» — обычный REST по спискам данных (НЕ Search): данные всегда
-// актуальны, только что созданная заявка видна сразу (у поискового индекса
-// была бы задержка переиндексации).
+// Поиск через SharePoint Search REST API (search/query, KQL).
 //
-// Пагинация «сшивает» несколько списков в один нумерованный список: сначала по
-// каждому типу берём только лёгкие поля (Id + Created) всех заявок автора,
-// сортируем объединённый набор по дате создания и лишь для нужной страницы
-// дочитываем полные поля. Так на экран не тянется всё содержимое заявок,
-// но общее число страниц известно точно.
+// Текст запроса идёт свободным термом — поиск по ВСЕМ проиндексированным полям
+// элемента, а не только по названию. Плата за это — результаты берутся из
+// поискового индекса, который переиндексируется с задержкой: только что
+// созданная или изменённая заявка может найтись не сразу.
 export interface IOwnRequestsPage {
   rows: IMyRequest[];
   totalRows: number;
 }
 
 const PAGE_SIZE = 20;
-// Столько «лёгких» строк (Id + Created) максимум читаем из одного списка, чтобы
-// посчитать общее число страниц. Хватает с большим запасом; если у кого-то
-// заявок окажется больше — в консоль уйдёт предупреждение.
-const INDEX_LIMIT = 5000;
+// Сколько заявок максимум перечисляем в KQL при поиске среди уже отобранных
+// (см. filterPendingByQuery) — иначе строка запроса станет неподъёмной.
+const KQL_ID_LIMIT = 300;
 
-// В OData-строке одинарная кавычка экранируется удвоением.
-function escapeOData(text: string): string {
-  return text.replace(/'/g, "''");
+function siteOrigin(siteUrl: string): string {
+  const match = /^https?:\/\/[^/]+/.exec(siteUrl);
+  return match ? match[0] : siteUrl;
 }
 
-interface IOwnIndexEntry {
-  id: number;
-  created: string;
-  type: IRequestType;
+function listAbsUrl(type: IRequestType): string {
+  return `${siteOrigin(type.siteUrl as string)}${type.listId}`;
 }
 
-export async function getOwnRequests(
-  context: WebPartContext,
-  types: IRequestType[],
-  query: string,
-  page: number
-): Promise<IOwnRequestsPage> {
-  if (types.length === 0) return { rows: [], totalRows: 0 };
+// KQL не терпит спецсимволов в свободном терме — оставляем буквы (лат./кир.),
+// цифры и пробелы. (без \p{L} — целевой ES-таргет проекта его не поддерживает)
+function sanitizeForKql(text: string): string {
+  return text
+    .replace(/[^a-zA-Zа-яА-ЯёЁ0-9\s]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
 
-  const q = query.trim();
+// Свободный терм по всем полям: каждое слово — префиксный поиск, все слова
+// обязательны (AND). Пустая строка → undefined (условие не добавляем).
+function freeTextClause(query: string): string | undefined {
+  const q = sanitizeForKql(query);
+  if (!q) return undefined;
+  return `(${q.split(' ').map((word) => `${word}*`).join(' AND ')})`;
+}
 
-  // 1) Лёгкий индекс по каждому типу: только Id + Created заявок автора.
-  const perType = await Promise.all(
-    types.map(async (type): Promise<IOwnIndexEntry[]> => {
-      try {
-        const sp = spfi(type.siteUrl as string).using(SPFx(context));
-        const me = await sp.web.currentUser.select('Id')();
-        const filters = [`AuthorId eq ${me.Id}`];
-        if (q) filters.push(`substringof('${escapeOData(q)}',Title)`);
-
-        const rows = (await sp.web
-          .getList(type.listId as string)
-          .items.filter(filters.join(' and '))
-          .select('Id', 'Created')
-          .orderBy('Created', false)
-          .top(INDEX_LIMIT)()) as Array<Record<string, unknown>>;
-
-        if (rows.length === INDEX_LIMIT) {
-          console.warn(
-            `[Текущие заявки] «${type.name}»: индекс своих заявок обрезан на ${INDEX_LIMIT} — часть страниц не видна`
-          );
-        }
-        return rows.map((r) => ({ id: r.Id as number, created: (r.Created as string) || '', type }));
-      } catch (e) {
-        console.error(`[Текущие заявки] «${type.name}»: не удалось прочитать свои заявки:`, (e as Error).message);
-        return [];
-      }
+// Ответ Search → пары (Id элемента, его тип по префиксу Path).
+function hitsToEntries(
+  results: { PrimarySearchResults: unknown[] },
+  types: IRequestType[]
+): Array<{ id: number; type: IRequestType }> {
+  const urls = types.map((t) => ({ type: t, url: listAbsUrl(t).toLowerCase() }));
+  return (results.PrimarySearchResults as Array<Record<string, unknown>>)
+    .map((r) => ({ id: Number(r.ListItemID), path: String(r.Path || '').toLowerCase() }))
+    .filter((h) => !isNaN(h.id) && h.id > 0)
+    .map((h) => {
+      const matched = urls.filter((u) => h.path.indexOf(u.url) === 0)[0];
+      return matched ? { id: h.id, type: matched.type } : undefined;
     })
-  );
+    .filter((e): e is { id: number; type: IRequestType } => !!e);
+}
 
-  // 2) Общий список всех типов, свежие сверху.
-  const index = perType
-    .reduce((all, rows) => all.concat(rows), [] as IOwnIndexEntry[])
-    .sort((a, b) => b.created.localeCompare(a.created));
-
-  const pageEntries = index.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE);
-  if (pageEntries.length === 0) {
-    return { rows: [], totalRows: index.length };
-  }
-
-  // 3) Полные поля — только для заявок текущей страницы, по своему списку на тип.
+// Дочитать поля заявок по найденным Id (Search отдаёт не все колонки, и для
+// кастомных полей нет гарантии, что они проиндексированы как managed property).
+async function loadByIds(
+  context: WebPartContext,
+  entries: Array<{ id: number; type: IRequestType }>,
+  kind: 'own' | 'approval'
+): Promise<Map<string, IMyRequest>> {
   const idsByType = new Map<IRequestType, number[]>();
-  pageEntries.forEach((e) => {
+  entries.forEach((e) => {
     const ids = idsByType.get(e.type) || [];
     ids.push(e.id);
     idsByType.set(e.type, ids);
@@ -268,20 +351,108 @@ export async function getOwnRequests(
         .items.filter(ids.map((id) => `Id eq ${id}`).join(' or '))
         .select('Id', 'Title', 'Status', 'Created', 'Author/EMail', 'Author/Title')
         .expand('Author')
-        .top(PAGE_SIZE)()) as Array<Record<string, unknown>>;
+        .top(ids.length)()) as Array<Record<string, unknown>>;
       rows.forEach((r) => {
         const author = r.Author as { EMail?: string; Title?: string } | undefined;
-        byKey.set(`${type.id}-${r.Id as number}`, toMyRequest(r, author, type, 'own'));
+        byKey.set(`${type.id}-${r.Id as number}`, toMyRequest(r, author, type, kind));
       });
     })
   );
+  return byKey;
+}
 
-  // Порядок страницы задаёт индекс (по дате), а не порядок ответов REST.
-  const rows = pageEntries
+// «Мои заявки»: Search по спискам данных всех типов сразу — автор = текущий
+// пользователь, текст запроса по всем полям. Пагинация серверная
+// (RowLimit/StartRow), поэтому таблица не тянет весь архив заявок.
+export async function getOwnRequests(
+  context: WebPartContext,
+  types: IRequestType[],
+  query: string,
+  page: number
+): Promise<IOwnRequestsPage> {
+  if (types.length === 0) return { rows: [], totalRows: 0 };
+
+  const sp = spfi(types[0].siteUrl as string).using(SPFx(context));
+  const claimsLogin = `i:0#.f|membership|${currentUserEmail(context)}`;
+
+  const clauses = [
+    `(${types.map((t) => `Path:"${listAbsUrl(t)}*"`).join(' OR ')})`,
+    `AuthorOWSUSER:"${claimsLogin}"`,
+  ];
+  const text = freeTextClause(query);
+  if (text) clauses.push(text);
+  const kql = clauses.join(' AND ');
+
+  const results = await sp.search({
+    Querytext: kql,
+    RowLimit: PAGE_SIZE,
+    StartRow: (page - 1) * PAGE_SIZE,
+    SelectProperties: ['ListItemID', 'Title', 'Path'],
+    TrimDuplicates: false,
+    // Свежие сверху (по умолчанию Search сортирует по релевантности, не по дате).
+    SortList: [{ Property: 'Created', Direction: 1 }],
+  });
+
+  console.log(`[Текущие заявки] Search «Мои заявки»: KQL = ${kql}, всего найдено: ${results.TotalRows}`);
+  console.table(results.PrimarySearchResults);
+
+  const entries = hitsToEntries(results, types);
+  if (entries.length === 0) return { rows: [], totalRows: results.TotalRows || 0 };
+
+  const byKey = await loadByIds(context, entries, 'own');
+  // Порядок задаёт релевантность поиска, а не порядок ответов REST.
+  const rows = entries
     .map((e) => byKey.get(`${e.type.id}-${e.id}`))
     .filter((r): r is IMyRequest => !!r);
 
-  return { rows, totalRows: index.length };
+  return { rows, totalRows: results.TotalRows || 0 };
+}
+
+// «На согласовании»: список заявок уже отобран по строкам согласования
+// (getPendingApproval — там же определяется, чья сейчас очередь). Здесь среди
+// НИХ ищем по тексту через Search: KQL ограничивается ListItemID найденных
+// заявок, текст идёт свободным термом по всем полям.
+export async function filterPendingByQuery(
+  context: WebPartContext,
+  types: IRequestType[],
+  rows: IMyRequest[],
+  query: string
+): Promise<IMyRequest[]> {
+  const text = freeTextClause(query);
+  if (!text || rows.length === 0) return rows;
+
+  if (rows.length > KQL_ID_LIMIT) {
+    console.warn(
+      `[Текущие заявки] Поиск среди ждущих решения ограничен ${KQL_ID_LIMIT} заявками из ${rows.length}`
+    );
+  }
+  const scope = rows.slice(0, KQL_ID_LIMIT);
+
+  const byType = new Map<number, IRequestType>();
+  types.forEach((t) => byType.set(t.id, t));
+  const scopeTypes = types.filter((t) => scope.some((r) => r.requestTypeId === t.id));
+  if (scopeTypes.length === 0) return [];
+
+  const sp = spfi(scopeTypes[0].siteUrl as string).using(SPFx(context));
+  const kql = [
+    `(${scopeTypes.map((t) => `Path:"${listAbsUrl(t)}*"`).join(' OR ')})`,
+    `(${scope.map((r) => `ListItemID:${r.id}`).join(' OR ')})`,
+    text,
+  ].join(' AND ');
+
+  const results = await sp.search({
+    Querytext: kql,
+    RowLimit: KQL_ID_LIMIT,
+    SelectProperties: ['ListItemID', 'Title', 'Path'],
+    TrimDuplicates: false,
+  });
+
+  console.log(`[Текущие заявки] Search «На согласовании»: KQL = ${kql}, найдено: ${results.TotalRows}`);
+  console.table(results.PrimarySearchResults);
+
+  // ListItemID уникален только внутри своего списка — сверяем пару тип+Id.
+  const found = new Set(hitsToEntries(results, scopeTypes).map((e) => `${e.type.id}-${e.id}`));
+  return scope.filter((r) => found.has(`${r.requestTypeId}-${r.id}`));
 }
 
 function toMyRequest(

src/webparts/requestPortal/forms/RecruitingHire/approval/provisioning.json

@@ -2,7 +2,7 @@
   "dataListTitle": "Прием на работу — согласование",
   "columns": [
     { "internalName": "Approver", "title": "Согласующий", "type": "User", "userSelectionMode": "PeopleOnly" },
-    { "internalName": "Status", "title": "Статус", "type": "Choice", "choices": ["Черновик", "На согласовании", "Согласовано", "Отклонено", "Возвращена на доработку", "Выполнение", "Закрыта"] },
+    { "internalName": "Status", "title": "Статус", "type": "Choice", "choices": ["Черновик", "На согласовании", "Ждёт очереди", "Согласовано", "Отклонено", "Возвращена на доработку", "Выполнение", "Закрыта"] },
     { "internalName": "Ticket", "title": "Заявка", "type": "Lookup", "lookupList": "Прием на работу — данные", "lookupShowField": "Title" },
     { "internalName": "Date", "title": "Дата", "type": "DateTime" },
     { "internalName": "Comment", "title": "Комментарий", "type": "Note" },

src/webparts/requestPortal/forms/WorkplaceSetup/approval/provisioning.json

@@ -2,7 +2,7 @@
   "dataListTitle": "Организация рабочего места — согласование",
   "columns": [
     { "internalName": "Approver", "title": "Согласующий", "type": "User", "userSelectionMode": "PeopleOnly" },
-    { "internalName": "Status", "title": "Статус", "type": "Choice", "choices": ["Черновик", "На согласовании", "Согласовано", "Отклонено", "Возвращена на доработку", "Выполнение", "Закрыта"] },
+    { "internalName": "Status", "title": "Статус", "type": "Choice", "choices": ["Черновик", "На согласовании", "Ждёт очереди", "Согласовано", "Отклонено", "Возвращена на доработку", "Выполнение", "Закрыта"] },
     { "internalName": "Ticket", "title": "Заявка", "type": "Lookup", "lookupList": "Организация рабочего места — данные", "lookupShowField": "Title" },
     { "internalName": "Date", "title": "Дата", "type": "DateTime" },
     { "internalName": "Comment", "title": "Комментарий", "type": "Note" },

src/webparts/requestPortal/shared/approval/approvalList.service.ts

@@ -8,7 +8,7 @@ import '@pnp/sp/profiles';
 import { IApprovalRow } from './models/IApprovalRow';
 import { IMatrixRow } from './models/IMatrixRow';
 import { ISiteUser } from './models/ISiteUser';
-import { APPROVAL_PHASE } from './models/statuses';
+import { APPROVAL_PHASE, REQUEST_STATUS } from './models/statuses';
 
 // Внутренние имена колонок списка согласования (создаются провижинингом).
 const FIELDS = {
@@ -28,6 +28,12 @@ export interface IApproverToWrite {
   email: string;
   position: string;
   allowReassign: boolean;
+  /** Порядок (StepOrder). Не задан — берётся позиция в массиве (orderStart + индекс).
+   * Несколько согласующих с ОДИНАКОВЫМ order — параллельный шаг: все становятся
+   * «На согласовании» одновременно (см. createSteps). Сейчас редактор матрицы
+   * (ApprovalMatrix/useMatrixEditor) всегда даёт уникальный order по позиции —
+   * это поле для параллельных шагов, приходящих из внешнего маршрута напрямую. */
+  order?: number;
 }
 
 // Все запросы к списку «<форма> — согласование». listTitle задаётся формой.
@@ -38,9 +44,18 @@ export class ApprovalListService {
     return getSP().web.lists.getByTitle(this.listTitle);
   }
 
-  // Пишет по строке на каждого участника фазы с указанным статусом.
-  // Порядок (Order) = orderStart + позиция в массиве (фазы идут подряд в одном списке:
-  // сначала согласующие 1..N, затем исполнители N+1..N+M).
+  // Пишет по строке на каждого участника фазы. Порядок (Order) = a.order, если
+  // задан, иначе orderStart + позиция в массиве (фазы идут подряд в одном
+  // списке: сначала согласующие 1..N, затем исполнители N+1..N+M).
+  //
+  // Статус строки решается здесь, а не читается заново при каждом открытии
+  // заявки: строки с НАИМЕНЬШИМ order в этой партии получают переданный status
+  // (обычно «На согласовании» — их очередь СЕЙЧАС; если несколько согласующих
+  // делят один и тот же order — это параллельный шаг, активны все сразу),
+  // остальные — «Ждёт очереди». Так «чья сейчас очередь» — это просто значение
+  // колонки Status, без пересчёта порядка на клиенте (см.
+  // approverDecision.service.ts/decide, который двигает очередь дальше при
+  // каждом решении — той же логикой «наименьший order среди нерешённых»).
   public async createSteps(
     requestId: number,
     approvers: IApproverToWrite[],
@@ -48,16 +63,20 @@ export class ApprovalListService {
     phase: string = APPROVAL_PHASE.approval,
     orderStart: number = 1
   ): Promise<void> {
-    for (let i = 0; i < approvers.length; i++) {
-      const a = approvers[i];
-      if (!a.email) continue;
+    const withOrder = approvers
+      .map((a, i) => ({ a, order: a.order ?? orderStart + i }))
+      .filter((x) => !!x.a.email);
+    const minOrder = withOrder.length > 0 ? Math.min(...withOrder.map((x) => x.order)) : 0;
+
+    for (const { a, order } of withOrder) {
       const approverId = await this.resolveUserId(a.email);
+      const rowStatus = order === minOrder ? status : REQUEST_STATUS.waitingInQueue;
       await this.list().items.add({
         Title: a.position || a.email,
         [`${FIELDS.approver}Id`]: approverId,
-        [FIELDS.status]: status,
+        [FIELDS.status]: rowStatus,
         [`${FIELDS.ticket}Id`]: requestId,
-        [FIELDS.order]: orderStart + i,
+        [FIELDS.order]: order,
         [FIELDS.allowReassign]: a.allowReassign,
         [FIELDS.phase]: phase,
       });
@@ -187,6 +206,12 @@ export class ApprovalListService {
       });
   }
 
+  // Только статус строки, без даты/комментария — продвижение очереди
+  // («На согласовании» ⇄ «Ждёт очереди»), а не решение согласующего.
+  public async setStatus(rowId: number, status: string): Promise<void> {
+    await this.list().items.getById(rowId).update({ [FIELDS.status]: status });
+  }
+
   // Удаляет все строки согласования по заявке (при возврате/повторной отправке).
   public async deleteForRequest(requestId: number): Promise<void> {
     const rows = await this.getForRequest(requestId);

src/webparts/requestPortal/shared/approval/approvalSubmission.service.ts

@@ -3,7 +3,7 @@ import { resolveRoute } from './approvalRoute.service';
 import { ApprovalListService, IApproverToWrite } from './approvalList.service';
 import { IMatrixRow } from './models/IMatrixRow';
 import { ApprovalStatus } from './models/IApprovalRouteApi';
-import { APPROVAL_PHASE } from './models/statuses';
+import { APPROVAL_PHASE, REQUEST_STATUS } from './models/statuses';
 
 // Планируемый маршрут для НОВОЙ заявки: resolve по email инициатора → строки матрицы.
 // status выбирает фазу: 'Approval' (согласующие, по умолчанию) или 'Execution'
@@ -50,6 +50,11 @@ export async function writeApprovers(
 // (Order N+1..N+M) в один список. Исполнители пишутся сразу при отправке —
 // стороне согласующего внешний API уже не нужен, переход в фазу исполнения
 // делает computeRequestStatus, когда все согласующие одобрили.
+//
+// Исполнители стартуют ВСЕ как «Ждёт очереди» (не передаём им status — фаза
+// исполнения ещё не наступила, до неё нет ничьей текущей очереди). Первого
+// исполнителя переключит на «На согласовании» approverDecision.service.ts/decide,
+// когда фаза согласования будет пройдена целиком.
 export async function writeRoute(
   approval: ApprovalListService,
   requestId: number,
@@ -62,7 +67,7 @@ export async function writeRoute(
   await approval.createSteps(
     requestId,
     executors,
-    status,
+    REQUEST_STATUS.waitingInQueue,
     APPROVAL_PHASE.execution,
     approvers.length + 1
   );

src/webparts/requestPortal/shared/approval/approverDecision.service.ts

@@ -17,6 +17,8 @@ const ROW_STATUS: Record<ApproverDecision, string> = {
   reject: REQUEST_STATUS.rejected,
 };
 
+const TERMINAL_STATUSES: string[] = [REQUEST_STATUS.approved, REQUEST_STATUS.rejected, REQUEST_STATUS.returned];
+
 // Действия согласующего: определение его строки, применение решения,
 // делегирование и пересчёт статуса заявки в контентном списке.
 //
@@ -30,12 +32,14 @@ export class ApproverService {
   ) {}
 
   // Ожидающая строка текущего пользователя, если сейчас его очередь; иначе undefined.
-  // Последовательное согласование: активна первая строка со статусом «На согласовании».
+  // Очередь уже проставлена на запись (см. createSteps/advanceQueue) — активна
+  // ровно одна строка со статусом «На согласовании» на фазу, искать «первую по
+  // порядку» не нужно.
   public async getPendingRowForCurrentUser(requestId: number): Promise<IApprovalRow | undefined> {
     const rows = await this.approval.getForRequest(requestId);
     const userId = await this.approval.getCurrentUserId();
-    const firstPending = rows.filter((r) => r.status === REQUEST_STATUS.onApproval)[0];
-    if (firstPending && firstPending.approverId === userId) return firstPending;
+    const current = rows.filter((r) => r.status === REQUEST_STATUS.onApproval)[0];
+    if (current && current.approverId === userId) return current;
     return undefined;
   }
 
@@ -54,6 +58,8 @@ export class ApproverService {
     const newOrder = (prevOrder + current.order) / 2;
     const position = await this.approval.getJobTitle(user.loginName);
     // Делегат наследует фазу той строки, вместо которой согласует (согласование/исполнение).
+    // Пишем его сразу как «На согласовании» — advanceQueue ниже сам переведёт
+    // строку currentRowId (у неё теперь больше не наименьший Order) в «Ждёт очереди».
     await this.approval.addApproverRow(
       requestId,
       { email: user.email, position, allowReassign: false },
@@ -61,9 +67,13 @@ export class ApproverService {
       REQUEST_STATUS.onApproval,
       current.phase
     );
+    await this.advanceQueue(requestId);
+    emitRequestsChanged();
   }
 
-  // Применяет решение: обновляет строку и пересчитывает статус заявки.
+  // Применяет решение: обновляет строку, продвигает очередь (на следующего
+  // согласующего внутри фазы либо на первого исполнителя, если фаза согласования
+  // только что завершилась целиком) и пересчитывает статус заявки.
   // Возвращает новый статус заявки.
   public async decide(
     requestId: number,
@@ -72,13 +82,57 @@ export class ApproverService {
     comment: string
   ): Promise<string> {
     await this.approval.setDecision(rowId, ROW_STATUS[decision], comment);
-    const rows = await this.approval.getForRequest(requestId);
+    const rows = await this.advanceQueue(requestId);
     const requestStatus = this.computeRequestStatus(rows);
     await this.updateRequestStatus(requestId, requestStatus);
     emitRequestsChanged();
     return requestStatus;
   }
 
+  // Пересчитывает и записывает «чья сейчас очередь» по обеим фазам маршрута:
+  // ровно у одной ещё не решённой строки на фазу становится «На согласовании»
+  // (наименьший StepOrder среди нерешённых), у остальных — «Ждёт очереди».
+  // Фаза исполнения активна, только когда фаза согласования пройдена целиком
+  // (без Отклонено/Возвращена) — иначе там тоже сплошное «Ждёт очереди».
+  // Возвращает строки МАРШРУТА в том виде, в каком они были ДО применения этих
+  // обновлений (для computeRequestStatus — ему важны только терминальные
+  // статусы approved/rejected/returned, на которые эта функция не влияет).
+  private async advanceQueue(requestId: number): Promise<IApprovalRow[]> {
+    const rows = await this.approval.getForRequest(requestId);
+    const approvalRows = rows.filter((r) => r.phase !== APPROVAL_PHASE.execution);
+    const execRows = rows.filter((r) => r.phase === APPROVAL_PHASE.execution);
+
+    const approvalStopped = approvalRows.some(
+      (r) => r.status === REQUEST_STATUS.rejected || r.status === REQUEST_STATUS.returned
+    );
+    const approvalDone =
+      !approvalStopped &&
+      (approvalRows.length === 0 || approvalRows.every((r) => r.status === REQUEST_STATUS.approved));
+
+    const updates = new Map<number, string>();
+    const applyPhase = (phaseRows: IApprovalRow[], eligible: boolean): void => {
+      const undecided = phaseRows.filter((r) => TERMINAL_STATUSES.indexOf(r.status) === -1);
+      if (undecided.length === 0) return;
+      if (!eligible) {
+        undecided.forEach((r) => {
+          if (r.status !== REQUEST_STATUS.waitingInQueue) updates.set(r.id, REQUEST_STATUS.waitingInQueue);
+        });
+        return;
+      }
+      const minOrder = Math.min(...undecided.map((r) => r.order));
+      undecided.forEach((r) => {
+        const desired = r.order === minOrder ? REQUEST_STATUS.onApproval : REQUEST_STATUS.waitingInQueue;
+        if (r.status !== desired) updates.set(r.id, desired);
+      });
+    };
+
+    applyPhase(approvalRows, !approvalStopped);
+    applyPhase(execRows, approvalDone);
+
+    await Promise.all(Array.from(updates.entries()).map(([id, status]) => this.approval.setStatus(id, status)));
+    return rows;
+  }
+
   // Статус заявки из строк маршрута с учётом фазы:
   //  1) фаза согласования: отклонение/возврат → соответствующий статус;
   //     не все согласовали → «На согласовании».

src/webparts/requestPortal/shared/approval/models/statuses.ts

@@ -11,6 +11,14 @@ export const REQUEST_STATUS = {
   returned: 'Возвращена на доработку',
   execution: 'Выполнение',
   closed: 'Закрыта',
+  // Строка маршрута, до которой очередь ещё не дошла. Применяется ТОЛЬКО к
+  // строкам списка «— согласование» (не к заявке в контентном списке):
+  // при создании маршрута и при каждом решении согласующего (см.
+  // approvalList.service.ts/createSteps, approverDecision.service.ts/decide)
+  // ровно у одной строки на фазу выставляется onApproval («её очередь сейчас»),
+  // у всех остальных недорешённых строк — waitingInQueue. Это позволяет читать
+  // «чья сейчас очередь» прямым фильтром по Status, без пересчёта на клиенте.
+  waitingInQueue: 'Ждёт очереди',
 } as const;
 
 // Статусы, при которых заявку ещё можно править (форма редактируема).
@@ -31,6 +39,7 @@ export function isEditableStatus(status: string | undefined): boolean {
 export const REQUEST_STATUS_CHOICES: string[] = [
   REQUEST_STATUS.draft,
   REQUEST_STATUS.onApproval,
+  REQUEST_STATUS.waitingInQueue,
   REQUEST_STATUS.approved,
   REQUEST_STATUS.rejected,
   REQUEST_STATUS.returned,