From 7fa0a800d8dff6f16601ac56fc86a51b47553d8b Mon Sep 17 00:00:00 2001 From: "gorbenko.pavel" Date: Wed, 5 Aug 2026 12:28:58 +0500 Subject: [PATCH] =?UTF-8?q?=D0=BD=D0=BE=D0=B2=D0=B0=D1=8F=20=D1=81=D1=82?= =?UTF-8?q?=D0=B0=D1=82=D1=83=D1=81=D0=BD=D0=B0=D1=8F=20=D0=BC=D0=BE=D0=B4?= =?UTF-8?q?=D0=B5=D0=BB=D1=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../features/myRequests/RequestsTableView.tsx | 105 ++-- .../features/myRequests/myRequests.service.ts | 497 ++++++++++++------ .../RecruitingHire/approval/provisioning.json | 2 +- .../WorkplaceSetup/approval/provisioning.json | 2 +- .../shared/approval/approvalList.service.ts | 43 +- .../approval/approvalSubmission.service.ts | 9 +- .../approval/approverDecision.service.ts | 64 ++- .../shared/approval/models/statuses.ts | 9 + 8 files changed, 515 insertions(+), 216 deletions(-) diff --git a/src/webparts/requestPortal/features/myRequests/RequestsTableView.tsx b/src/webparts/requestPortal/features/myRequests/RequestsTableView.tsx index 16417b9..aaf9c0e 100644 --- a/src/webparts/requestPortal/features/myRequests/RequestsTableView.tsx +++ b/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<{ ); -// Раздел с таблицей заявок: поиск по названию + постраничный вывод. +// Раздел с таблицей заявок: поиск по всем полям + вывод постранично. // -// '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 = ({ context, kind, onOpen }) => { const [types, setTypes] = React.useState(undefined); const [rows, setRows] = React.useState(undefined); @@ -203,44 +219,63 @@ export const RequestsTableView: React.FC = ({ 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 => { + 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 = ({ context, setQuery(e.target.value)} /> diff --git a/src/webparts/requestPortal/features/myRequests/myRequests.service.ts b/src/webparts/requestPortal/features/myRequests/myRequests.service.ts index 3ac786c..96b6815 100644 --- a/src/webparts/requestPortal/features/myRequests/myRequests.service.ts +++ b/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 !!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 { + 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 { + 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>; - 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> = []; + for await (const p of approvalList.items + .filter(`ApproverId eq ${approver.Id}`) + .select('Id', 'TicketId', 'Status') + .top(2000)) { + allRows.push(...(p as Array>)); + } + + 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(); - 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> = []; - 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>; + .select('Id', 'Title', 'Status', 'Created') + .top(ticketIds.length)()) as Array>; - 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 { + if (rows.length === 0) return; + + const typeById = new Map(); + types.forEach((t) => typeById.set(t.id, t)); + + const idsByType = new Map(); + rows.forEach((r) => { + const ids = idsByType.get(r.requestTypeId) || []; + ids.push(r.id); + idsByType.set(r.requestTypeId, ids); + }); + + const byKey = new Map(); + 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>; + 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 { - 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 => { - 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>; - - 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>) + .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> { const idsByType = new Map(); - 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>; + .top(ids.length)()) as Array>; 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 { + 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 { + 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(); + 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( diff --git a/src/webparts/requestPortal/forms/RecruitingHire/approval/provisioning.json b/src/webparts/requestPortal/forms/RecruitingHire/approval/provisioning.json index 3b0092d..207b2dd 100644 --- a/src/webparts/requestPortal/forms/RecruitingHire/approval/provisioning.json +++ b/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" }, diff --git a/src/webparts/requestPortal/forms/WorkplaceSetup/approval/provisioning.json b/src/webparts/requestPortal/forms/WorkplaceSetup/approval/provisioning.json index 46810c2..70dd5ce 100644 --- a/src/webparts/requestPortal/forms/WorkplaceSetup/approval/provisioning.json +++ b/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" }, diff --git a/src/webparts/requestPortal/shared/approval/approvalList.service.ts b/src/webparts/requestPortal/shared/approval/approvalList.service.ts index 78c9b36..e63845f 100644 --- a/src/webparts/requestPortal/shared/approval/approvalList.service.ts +++ b/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 { - 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 { + await this.list().items.getById(rowId).update({ [FIELDS.status]: status }); + } + // Удаляет все строки согласования по заявке (при возврате/повторной отправке). public async deleteForRequest(requestId: number): Promise { const rows = await this.getForRequest(requestId); diff --git a/src/webparts/requestPortal/shared/approval/approvalSubmission.service.ts b/src/webparts/requestPortal/shared/approval/approvalSubmission.service.ts index 574eedb..ac45415 100644 --- a/src/webparts/requestPortal/shared/approval/approvalSubmission.service.ts +++ b/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 ); diff --git a/src/webparts/requestPortal/shared/approval/approverDecision.service.ts b/src/webparts/requestPortal/shared/approval/approverDecision.service.ts index 2f0f22b..af8c85f 100644 --- a/src/webparts/requestPortal/shared/approval/approverDecision.service.ts +++ b/src/webparts/requestPortal/shared/approval/approverDecision.service.ts @@ -17,6 +17,8 @@ const ROW_STATUS: Record = { 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 { 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 { 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 { + 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(); + 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) фаза согласования: отклонение/возврат → соответствующий статус; // не все согласовали → «На согласовании». diff --git a/src/webparts/requestPortal/shared/approval/models/statuses.ts b/src/webparts/requestPortal/shared/approval/models/statuses.ts index ef2e4cf..dbafdc1 100644 --- a/src/webparts/requestPortal/shared/approval/models/statuses.ts +++ b/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,