Search requests (#2)
Co-authored-by: gorbenko.pavel <gorbenko.pavel@tansu.kz> Reviewed-on: http://git.tnsu.kz/timur.gorodetskiy/request-portal/pulls/2 Co-authored-by: timur.gorodetskiy <timur.gorodetskiy@tnsu.kz> Co-committed-by: timur.gorodetskiy <timur.gorodetskiy@tnsu.kz>
This commit was merged in pull request #2.
This commit is contained in:
@@ -1,8 +1,10 @@
|
||||
import { spfi, SPFx } from '@pnp/sp';
|
||||
import { spForSite } from '../../shared/pnp/pnpjs';
|
||||
import '@pnp/sp/webs';
|
||||
import '@pnp/sp/lists';
|
||||
import { IList } from '@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,11 +14,28 @@ 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;
|
||||
}
|
||||
// Свежие заявки/строки (созданы или изменены недавно) поисковый индекс может
|
||||
// ещё не проиндексировать — такие добираем обычным REST-ом напрямую, в обход
|
||||
// Search, и подмешиваем к результату (см. indexApprovalsForType/myTurn,
|
||||
// getFreshOwnRowsForType). Используется ТОЛЬКО в паре с Search (гибрид для
|
||||
// таблиц без текстового запроса — там, где важны и масштаб, и мгновенная
|
||||
// свежесть); при поиске по тексту эта подстраховка не применяется (см. RequestsTableView).
|
||||
const RECENT_MS = 10 * 60 * 1000;
|
||||
|
||||
// Сколько строк согласования максимум забираем из Search за один запрос
|
||||
// (см. getInvolvedRowsViaSearch). Постраничного перебора здесь нет: набор
|
||||
// целиком уходит в слияние и сортировку по дате заявки, поэтому при превышении
|
||||
// лимита пишем предупреждение в лог, а не молча обрезаем.
|
||||
const SEARCH_ROW_LIMIT = 500;
|
||||
|
||||
// Managed properties списка согласования. Имена включают группу колонок сайта
|
||||
// (TansuSite) — SharePoint генерирует их так, поэтому «ожидаемого»
|
||||
// ApproverOWSUSER в схеме поиска не находилось (разбирались 2026-08-06).
|
||||
// Суффикс — тип исходного поля: OWSUSER для Person/Group.
|
||||
const MP_APPROVER = 'TansuSiteApproverOWSUSER';
|
||||
// Статус строки маршрута — Choice-поле, отсюда суффикс OWSCHCS (подтверждено
|
||||
// отладочным перебором 2026-08-06; у Person-полей он OWSUSER, см. MP_APPROVER).
|
||||
const MP_STATUS = 'RequestStatusOWSCHCS';
|
||||
|
||||
export function currentUserEmail(context: WebPartContext): string {
|
||||
return (context.pageContext.user.email || '').toLowerCase();
|
||||
@@ -28,32 +47,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,7 +165,9 @@ async function getApprovalPendingForType(
|
||||
};
|
||||
|
||||
try {
|
||||
const sp = spfi(type.siteUrl as string).using(SPFx(context));
|
||||
if (!tokenEmail) return { rows: [], debug };
|
||||
|
||||
const sp = spForSite(type.siteUrl as string, context);
|
||||
const list = sp.web.getList(type.listId as string);
|
||||
|
||||
const dataListInfo = await list.select('Title')();
|
||||
@@ -77,63 +180,91 @@ 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,
|
||||
}))
|
||||
);
|
||||
// TansuSiteApprover/EMail eq '...' в $filter по Person-полю ненадёжен в
|
||||
// SharePoint REST — резолвим email в числовой Id пользователя (как и везде в
|
||||
// проекте, см. ensureUser) и фильтруем по TansuSiteApproverId.
|
||||
//
|
||||
// RequestStatus в $filter НЕ используем: подтверждено на практике — фильтр
|
||||
// вида `RequestStatus eq 'На согласовании'` (кириллица в $filter) молча
|
||||
// возвращает 0 строк, даже когда без него те же строки находятся с этим же
|
||||
// значением статуса. Поэтому фильтруем только по TansuSiteApproverId
|
||||
// (числовое значение, проблем нет), а статус сравниваем в JS после
|
||||
// получения строк.
|
||||
const claimsLogin = tokenEmail.indexOf('|') >= 0 ? tokenEmail : `i:0#.f|membership|${tokenEmail}`;
|
||||
const approver = await sp.web.ensureUser(claimsLogin);
|
||||
|
||||
let stepRows: Array<Record<string, unknown>>;
|
||||
|
||||
if (scope === 'myTurn') {
|
||||
// 'myTurn' — гибрид для масштаба (список согласования может быть очень
|
||||
// большим): Search находит кандидатов, не сканируя список целиком, плюс
|
||||
// REST по «последним N минутам» (Modified) добирает то, что Search мог ещё
|
||||
// не проиндексировать. Status в обоих случаях берётся СВЕЖИМ через REST по
|
||||
// найденным Id (не из индекса Search) — именно это делает
|
||||
// getInvolvedRowsViaSearch, поэтому решение «моя очередь сейчас» всегда
|
||||
// точное, даже когда список кандидатов пришёл из Search.
|
||||
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')
|
||||
.top(2000)()) as Array<Record<string, unknown>>;
|
||||
|
||||
// Статусы уходят в KQL: сервер сразу отдаёт только активные строки,
|
||||
// а не всё, где пользователь есть в маршруте.
|
||||
const searchRows = await getInvolvedRowsViaSearch(context, type, approvalList, [
|
||||
REQUEST_STATUS.onApproval,
|
||||
REQUEST_STATUS.onExecution,
|
||||
]);
|
||||
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
|
||||
);
|
||||
console.log(
|
||||
`[Текущие заявки] «${type.name}»: список согласования «${approvalListTitle}», approver.Id=${approver.Id}, scope=myTurn — свежих (REST, < 10 мин): ${recentRows.length}, через Search: ${searchRows.length}, после фильтра по статусу: ${stepRows.length}`
|
||||
);
|
||||
} else {
|
||||
// 'involved' — используется ТОЛЬКО для текстового поиска (см.
|
||||
// getPendingApprovalIndex/searchMyRequests) — здесь важна не мгновенная
|
||||
// свежесть, а полнота по всему архиву, поэтому только Search, без
|
||||
// REST-подстраховки на «последние N минут»: гибрид REST+Search при поиске
|
||||
// давал неустойчивый результат (заявка то находилась, то нет, в
|
||||
// зависимости от того, успел ли Search её проиндексировать к моменту
|
||||
// REST-окна).
|
||||
stepRows = await getInvolvedRowsViaSearch(context, type, approvalList);
|
||||
|
||||
console.log(
|
||||
`[Текущие заявки] «${type.name}»: список согласования «${approvalListTitle}», approver.Id=${approver.Id}, scope=involved (Search) — найдено: ${stepRows.length}`
|
||||
);
|
||||
}
|
||||
|
||||
console.table(stepRows.map((r) => ({ Id: r.Id, TicketId: r.TicketId, RequestStatus: r.RequestStatus })));
|
||||
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 +276,210 @@ 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
|
||||
);
|
||||
if (stopped) return false;
|
||||
// Строки согласования текущего пользователя через Search, чтобы не сканировать
|
||||
// список целиком (он растёт с каждой заявкой).
|
||||
//
|
||||
// Фильтр по согласующему — managed property MP_APPROVER. Имя нестандартное
|
||||
// (с префиксом группы колонок сайта), см. комментарий к константе: «ожидаемого»
|
||||
// ApproverOWSUSER в схеме поиска нет вовсе, из-за чего запросы по нему долго
|
||||
// возвращали 0.
|
||||
//
|
||||
// statuses задаёт фильтр по статусу строки прямо в KQL — нужен для режима
|
||||
// «чья сейчас очередь» (без текстового поиска), чтобы страницу резал СЕРВЕР:
|
||||
// без него в выдачу попали бы все строки, где пользователь вообще есть в
|
||||
// маршруте, и после отбрасывания неактивных в странице появлялись бы дыры.
|
||||
// Пустой массив — не фильтровать (режим текстового поиска: там важна полнота).
|
||||
//
|
||||
// Search используется ТОЛЬКО чтобы сузить набор Id — TicketId и Status берём
|
||||
// свежими через REST по этим Id, а не из индекса (индекс мог устареть, а на
|
||||
// устаревшем статусе решение «моя очередь» строить нельзя).
|
||||
async function getInvolvedRowsViaSearch(
|
||||
context: WebPartContext,
|
||||
type: IRequestType,
|
||||
approvalList: IList,
|
||||
statuses: string[] = []
|
||||
): Promise<Array<Record<string, unknown>>> {
|
||||
try {
|
||||
const email = currentUserEmail(context);
|
||||
if (!email) {
|
||||
console.warn(
|
||||
`[Текущие заявки] «${type.name}»: у текущего пользователя нет email — Search по согласующему невозможен`
|
||||
);
|
||||
return [];
|
||||
}
|
||||
const claimsLogin = `i:0#.f|membership|${email}`;
|
||||
|
||||
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 rootFolder = (await approvalList
|
||||
.select('RootFolder/ServerRelativeUrl')
|
||||
.expand('RootFolder')()) as { RootFolder?: { ServerRelativeUrl?: string } };
|
||||
const relUrl = rootFolder.RootFolder?.ServerRelativeUrl;
|
||||
if (!relUrl) return [];
|
||||
const approvalListAbsUrl = `${siteOrigin(type.siteUrl as string)}${relUrl}`;
|
||||
|
||||
const current = [...noOrder];
|
||||
if (ordered.length > 0) {
|
||||
const minOrder = Math.min(...ordered.map((s) => s.order));
|
||||
current.push(...ordered.filter((s) => s.order === minOrder));
|
||||
const sp = spForSite(type.siteUrl as string, context);
|
||||
const pathClause = `Path:"${approvalListAbsUrl}*"`;
|
||||
const clauses = [pathClause, `${MP_APPROVER}:"${claimsLogin}"`];
|
||||
if (statuses.length > 0) {
|
||||
clauses.push(`(${statuses.map((s) => `${MP_STATUS}:"${s}"`).join(' OR ')})`);
|
||||
}
|
||||
const kql = clauses.join(' AND ');
|
||||
|
||||
const results = await sp.search({
|
||||
Querytext: kql,
|
||||
RowLimit: SEARCH_ROW_LIMIT,
|
||||
SelectProperties: ['ListItemID'],
|
||||
TrimDuplicates: false,
|
||||
});
|
||||
|
||||
const total = results.TotalRows || 0;
|
||||
const ids = (results.PrimarySearchResults as Array<Record<string, unknown>>)
|
||||
.map((r) => Number(r.ListItemID))
|
||||
.filter((id) => !isNaN(id) && id > 0);
|
||||
|
||||
console.log(
|
||||
`[Текущие заявки] Search «${type.name}» (involved): KQL = ${kql}, найдено: ${total}, годных Id: ${ids.length}`
|
||||
);
|
||||
|
||||
if (total > SEARCH_ROW_LIMIT) {
|
||||
console.warn(
|
||||
`[Текущие заявки] «${type.name}»: Search вернул ${total} строк, взяли первые ${SEARCH_ROW_LIMIT} — остальные не попадут в выборку`
|
||||
);
|
||||
}
|
||||
if (ids.length === 0) return [];
|
||||
|
||||
return (await approvalList.items
|
||||
.filter(ids.map((id) => `Id eq ${id}`).join(' or '))
|
||||
.select('Id', 'TicketId', 'RequestStatus')
|
||||
.top(ids.length)()) as Array<Record<string, unknown>>;
|
||||
} catch (e) {
|
||||
console.error(
|
||||
`[Текущие заявки] «${type.name}»: Search по списку согласования не сработал:`,
|
||||
(e as Error).message
|
||||
);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
return current.some((s) => s.approverEmail === tokenEmail);
|
||||
// Дочитывает 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 = spForSite(type.siteUrl as string, 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);
|
||||
}
|
||||
})
|
||||
);
|
||||
|
||||
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);
|
||||
@@ -262,26 +488,256 @@ export async function getOwnRequests(
|
||||
const byKey = new Map<string, IMyRequest>();
|
||||
await Promise.all(
|
||||
Array.from(idsByType.entries()).map(async ([type, ids]) => {
|
||||
const sp = spfi(type.siteUrl as string).using(SPFx(context));
|
||||
const sp = spForSite(type.siteUrl as string, context);
|
||||
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')
|
||||
.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
|
||||
.map((e) => byKey.get(`${e.type.id}-${e.id}`))
|
||||
.filter((r): r is IMyRequest => !!r);
|
||||
// Свежие (созданные за последние RECENT_MS) заявки автора — обычным REST-ом,
|
||||
// в обход Search (индекс мог их ещё не подхватить). Без текстового запроса —
|
||||
// матчить название не нужно, отдаём как есть.
|
||||
async function getFreshOwnRowsForType(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();
|
||||
|
||||
return { rows, totalRows: index.length };
|
||||
const rows = (await sp.web
|
||||
.getList(type.listId as string)
|
||||
.items.filter(`AuthorId eq ${me.Id} and Created ge '${cutoff}'`)
|
||||
.select('Id', 'Title', 'Status', 'Created', 'Author/EMail', 'Author/Title')
|
||||
.expand('Author')
|
||||
.top(50)()) 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 [];
|
||||
}
|
||||
}
|
||||
|
||||
// «Мои заявки» БЕЗ поиска — гибрид для масштаба: Search с серверной пагинацией
|
||||
// (RowLimit/StartRow) находит страницу без сканирования всего архива, REST по
|
||||
// «последним N минутам» добирает то, что Search мог не успеть проиндексировать
|
||||
// (см. RECENT_MS). Довесок применяется только на первой странице — свежее по
|
||||
// дате там и оказалось бы, будь оно проиндексировано.
|
||||
export async function getOwnRequests(
|
||||
context: WebPartContext,
|
||||
types: IRequestType[],
|
||||
page: number
|
||||
): Promise<IOwnRequestsPage> {
|
||||
if (types.length === 0) return { rows: [], totalRows: 0 };
|
||||
|
||||
const searchPage = await searchOwnRequests(context, types, '', page);
|
||||
|
||||
if (page !== 1) return searchPage;
|
||||
|
||||
const freshRows = (await Promise.all(types.map((t) => getFreshOwnRowsForType(context, t)))).reduce(
|
||||
(all, r) => all.concat(r),
|
||||
[] as IMyRequest[]
|
||||
);
|
||||
|
||||
const searchKeys = new Set(searchPage.rows.map((r) => `${r.requestTypeId}-${r.id}`));
|
||||
const onlyFresh = freshRows.filter((r) => !searchKeys.has(`${r.requestTypeId}-${r.id}`));
|
||||
|
||||
if (onlyFresh.length > 0) {
|
||||
console.log(
|
||||
`[Текущие заявки] «Мои заявки»: довесили ${onlyFresh.length} свежих заявок (< 10 мин), которых Search ещё не нашёл`
|
||||
);
|
||||
}
|
||||
|
||||
const merged = onlyFresh
|
||||
.concat(searchPage.rows)
|
||||
.sort((a, b) => b.created.localeCompare(a.created))
|
||||
.slice(0, PAGE_SIZE);
|
||||
|
||||
return { rows: merged, totalRows: searchPage.totalRows + onlyFresh.length };
|
||||
}
|
||||
|
||||
// «Мои заявки» С поиском — только Search, без REST-подстраховки на свежесть:
|
||||
// только что созданная заявка может найтись не сразу (задержка индексации), но
|
||||
// зато результат предсказуем — не зависит от 10-минутного REST-окна.
|
||||
export async function searchOwnRequests(
|
||||
context: WebPartContext,
|
||||
types: IRequestType[],
|
||||
query: string,
|
||||
page: number
|
||||
): Promise<IOwnRequestsPage> {
|
||||
if (types.length === 0) return { rows: [], totalRows: 0 };
|
||||
|
||||
const sp = spForSite(types[0].siteUrl as string, 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);
|
||||
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 };
|
||||
}
|
||||
|
||||
// «На согласовании»: список заявок уже отобран по строкам согласования
|
||||
// (getPendingApprovalIndex — там же определяется, чья сейчас очередь,
|
||||
// обычным REST). Здесь среди НИХ фильтруем по тексту — только через Search
|
||||
// (KQL ограничивается ListItemID этих заявок, текст идёт свободным термом по
|
||||
// всем полям), без клиентского REST-матчинга по свежести.
|
||||
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 candidates = rows.slice(0, KQL_ID_LIMIT);
|
||||
|
||||
const scopeTypes = types.filter((t) => candidates.some((r) => r.requestTypeId === t.id));
|
||||
if (scopeTypes.length === 0) return [];
|
||||
|
||||
const sp = spForSite(scopeTypes[0].siteUrl as string, context);
|
||||
const kql = [
|
||||
`(${scopeTypes.map((t) => `Path:"${listAbsUrl(t)}*"`).join(' OR ')})`,
|
||||
`(${candidates.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 candidates.filter((r) => found.has(`${r.requestTypeId}-${r.id}`));
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Вкладка «Поиск»: ищет сразу по двум категориям — «Мои заявки» (я автор) и
|
||||
// «где я участвовал как согласующий» (involved, независимо от того, дошла ли
|
||||
// уже очередь) — и показывает их одним списком, с колонками Автор и Статус
|
||||
// одновременно (в отличие от «Мои заявки»/«На согласовании», где по смыслу
|
||||
// раздела одно из двух не нужно).
|
||||
//
|
||||
// Пагинация — клиентская поверх объединённого результата: «Мои заявки» уже
|
||||
// умеет по-настоящему постранично через Search, но «где участвовал» — нет
|
||||
// (см. filterPendingByQuery — там честного $skip/$top не сделать), так что
|
||||
// единой серверной пагинации на двух источниках сразу не построить. Для
|
||||
// сценария «искал что-то один раз» это приемлемо.
|
||||
export interface ISearchPage {
|
||||
rows: IMyRequest[];
|
||||
totalRows: number;
|
||||
}
|
||||
|
||||
// Как searchOwnRequests, но без $skip/$top — сразу весь найденный срез (до
|
||||
// KQL_ID_LIMIT). Только Search, без REST-подстраховки на свежесть.
|
||||
async function searchOwnAll(
|
||||
context: WebPartContext,
|
||||
types: IRequestType[],
|
||||
query: string
|
||||
): Promise<IMyRequest[]> {
|
||||
if (types.length === 0) return [];
|
||||
|
||||
const sp = spForSite(types[0].siteUrl as string, 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: KQL_ID_LIMIT,
|
||||
SelectProperties: ['ListItemID', 'Title', 'Path'],
|
||||
TrimDuplicates: false,
|
||||
});
|
||||
|
||||
console.log(`[Текущие заявки] Search «Поиск» (мои заявки): KQL = ${kql}, найдено: ${results.TotalRows}`);
|
||||
console.table(results.PrimarySearchResults);
|
||||
|
||||
const entries = hitsToEntries(results, types);
|
||||
const byKey = entries.length > 0 ? await loadByIds(context, entries, 'own') : new Map<string, IMyRequest>();
|
||||
return entries.map((e) => byKey.get(`${e.type.id}-${e.id}`)).filter((r): r is IMyRequest => !!r);
|
||||
}
|
||||
|
||||
export async function searchMyRequests(
|
||||
context: WebPartContext,
|
||||
types: IRequestType[],
|
||||
query: string,
|
||||
page: number
|
||||
): Promise<ISearchPage> {
|
||||
const q = query.trim();
|
||||
if (!q) return { rows: [], totalRows: 0 };
|
||||
|
||||
const [ownRows, involvedIdx] = await Promise.all([
|
||||
searchOwnAll(context, types, q),
|
||||
getPendingApprovalIndex(context, 'involved'),
|
||||
]);
|
||||
|
||||
const involvedFiltered = await filterPendingByQuery(context, involvedIdx.types, involvedIdx.rows, q);
|
||||
|
||||
// Заявка может оказаться и своей, и involved одновременно (сам себе
|
||||
// согласующий) — оставляем как 'own', не дублируем строку.
|
||||
const ownKeys = new Set(ownRows.map((r) => `${r.requestTypeId}-${r.id}`));
|
||||
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 };
|
||||
}
|
||||
|
||||
function toMyRequest(
|
||||
|
||||
Reference in New Issue
Block a user