Compare commits

..
24 Commits
Author SHA1 Message Date
tremble7681 caed1c340e fix(mechanic): вернуть выдачу резины и запчастей — слить origin/main (пропали после деплоя 05.10 из feat/driver-pwa без складских экранов)
Разрешение конфликтов: ремонты/хуки — наша ветка (в проде с 05.10),
склад/меню/маршруты — origin/main; меню — эмодзи-стиль владельца + все
плитки; в repairsCreate добавлены PartCatalogItem/searchParts для складских
экранов.
2026-10-08 18:54:06 +10:00
tremble7681 782f079cc7 Merge remote-tracking branch 'origin/main' into feat/driver-pwa
# Conflicts:
#	mechanic-pwa/frontend/src/App.tsx
#	mechanic-pwa/frontend/src/api/repairsCreate.ts
#	mechanic-pwa/frontend/src/api/repairsFeed.ts
#	mechanic-pwa/frontend/src/pages/ActionMenu.tsx
#	mechanic-pwa/frontend/src/pages/repairs/CreateRepairPage.tsx
#	mechanic-pwa/frontend/src/pages/repairs/EditRepairPage.tsx
#	mechanic-pwa/frontend/src/pages/repairs/RepairDetailPage.tsx
#	mechanic-pwa/frontend/src/pages/repairs/RepairsFeedPage.tsx
2026-10-08 18:50:38 +10:00
tremble7681 16c932d0b1 feat(bonuses): экран «Бонусы» возвращён — только участникам, остальным закрыто
Поэтапное внедрение вышло на старт: программы запущены, водители
подключаются адресно. Вход на главной и витрина — только у водителей
с включёнными программами (programs_enabled); неучастнику — заглушка.
Внутри — карточки только его программ (уровень = программа «Стаж»),
цели уже фильтрует бэкенд по адресности. Revert экрана (f6bc3da)
откатан, экран доработан под адресность.
2026-10-06 20:59:57 +10:00
tremble7681 7034c6aaae Reapply "feat(bonuses): экран «Бонусы» — уровень, серии, цели, история"
This reverts commit f6bc3da47b.
2026-10-06 20:51:29 +10:00
tremble7681 205e6d6d10 fix(inspections): фото больше не теряются — сжатие + персистентная очередь (6929)
Причина потерь: камера отдаёт 3–8 МБ, по LTE PUT длится дольше осмотра,
механик закрывал PWA — fetch убивался, фото пропадало (1010 шт за полгода).
- сжатие до 1600px JPEG q0.82 перед отправкой (~10x быстрее)
- очередь на IndexedDB: сериально, 5 попыток с бэкоффом, доигрывается
  после перезапуска приложения; фолбэк в память без IDB
- «Завершить осмотр» заблокирован, пока грузятся фото (N в кнопке)
- слот: «В очереди/Загружаю…», при отказе — «Повторить»
- карточка осмотра: failed-фото не показываем пустышками, бейдж
  «не загрузилось фото: N»; слот с failed предлагает снять заново
2026-10-06 00:36:07 +10:00
tremble7681andClaude Fable 5.1 8a587db154 fix(menu): вернуть цветные эмодзи в плитках меню — по просьбе владельца
Монохромные иконки lucide из a78f0e9 откатили: владелец хочет цветные плитки
разделов. Это осознанное исключение из правила «иконки только из паков»,
зафиксировано в комментарии к типу ActionTile. Новая плитка «Выдача запчастей»
получила свою эмодзи в том же ряду.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-24 12:16:34 +10:00
tremble7681andClaude Fable 5.1 a78f0e9632 feat(warehouse): экран «Выдача запчастей» на машину и журнал выдач (задача 5763)
Механик выбирает машину по госномеру, набирает детали из складского каталога
(тот же PartsPickerModal, что в ремонте), пишет комментарий — детали
списываются сразу, без карточки ремонта. Ключ идемпотентности живёт пока
открыта форма. Журнал показывает выдачи и списания в ремонт рядом.

Плитка в меню видна всем, кто вошёл в приложение (гейт require_mechanic на
сервере). Заодно плитки меню переведены с эмодзи на иконки lucide по правилу
проекта, а выбор машины вынесен в общий CarPicker (используется и резиной).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
2026-09-24 12:03:53 +10:00
tremble7681andClaude Fable 5 b3e5d05849 feat(tyres): доступ к выдаче резины по праву склада, не только админам
Плитка «Выдача резины» и маршруты /wh/tyres* открываются по признаку
warehouse:tyres из /me (или is_admin) — новый гейт RequireTyres вместо
RequireAdmin. Приёмка/инвентаризация остаются админскими. Бэкенд: право
warehouse.tyres в crm2.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-09-09 16:11:17 +10:00
tremble7681andClaude Opus 5 8deddf2630 feat(tyres): на машине с комплектом — выбор «доложить» или «заменить»
Раньше экран требовал закрыть старый комплект (вернули / списали / не найден),
даже когда старые колёса остаются на машине и добавляется одно новое. Теперь
развилка: доложить — комплект тот же, колёса прибавляются; заменить — прежний
порядок с закрытием.

В шапке комплекта видно, сколько и когда доложили. Подпись кнопки следует
выбору: «Доложить 1 покрышку» вместо «Выдать комплект».

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-14 12:48:53 +10:00
tremble7681andClaude Opus 5 771558a551 feat(tyres): резину можно выдавать поштучно — 1, 2, 3 или 4 покрышки
Задача 4684. Выбор был 2/4/5 и не покрывал самый частый несезонный случай:
порезали боковину, поймали грыжу — в замену уходит одно-два колеса, а не
комплект. Теперь 1-4.

Подпись кнопки перестала врать: «Выдать комплект» осталась только для четырёх,
на меньшем количестве — «Выдать 1 покрышку» / «Выдать 2 покрышки».

Вариант «5» (комплект с запаской) убран: задача перечисляет 1-4, а выдач за
время жизни раздела не было ни одной — защищать нечего. Вернуть — одна строка.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-14 12:24:44 +10:00
tremble7681 2a58c5ca94 feat(tyres): по умолчанию только подходящая резина, «Показать все» разворачивает
Кладовщик у подъёмника выбирал размер из девятнадцати позиций глазами. Теперь
экран показывает только подходящее выбранной машине (по подтверждённой
применимости), с счётчиком и кнопкой-переключателем на полный список.

Если по модели применимость не отмечена, фильтровать нечем — показываются все
размеры и объясняется, почему: прятать правильную резину по незнанию хуже, чем
показать лишнюю.

Плашка на строке различает «подходит» (применимость) и «штатный» (справочник
размеров), и предвыбор позиции теперь учитывает оба признака.
2026-08-13 20:10:39 +10:00
tremble7681 064b02e735 feat(tyres): экран сезонной выдачи резины, справочник размеров и журнал
Осенью через кладовщика проходит весь парк, поэтому экран построен вокруг
скорости: выбрал машину — приложение подсказало штатный размер модели, показало
остаток и контейнер, три кнопки состояния, выдал. Контекст приходит одним
запросом: телефон у подъёмника работает по слабой связи, и три round-trip'а на
каждую машину заметны на четырёхстах машинах.

Пока не сказано, что случилось с предыдущим комплектом (вернули / списали / не
найден), кнопка выдачи заблокирована. Сервер это тоже проверяет — здесь просто
не даём дойти до отказа.

Ключ идемпотентности живёт, пока открыта форма: ретрай после обрыва связи должен
попасть в ту же выдачу, а не создать вторую с четырьмя лишними покрышками.

Справочник размеров подсказывает те размеры, что реально лежат на складе:
набирать «225/65/17» с телефона долго и легко ошибиться. Модели отсортированы по
числу машин — самые ходовые заполняются первыми.

Разделы админские, как приёмка и инвентаризация.
2026-08-13 08:41:28 +10:00
tremble7681andClaude Opus 5 39176d2694 feat(инвентаризация): находку можно поправить и убрать до проведения
Механик ошибся в количестве при пересчёте — раньше единственным выходом было
бросить инвентаризацию и начать заново. Теперь строку находки можно исправить
или удалить, пока пересчёт в черновике.

Правка идёт через тот же фасад склада, что и остальные складские действия
приложения, — отдельного пути в обход правил остатков не появилось.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-08 06:53:29 +10:00
tremble7681andClaude Opus 5 58c9a2ca1e feat(repairs): пробег видно прямо в списке ремонтов
Задача CRM 4386: «набрал номер авто, смотрю историю ремонтов по машине,
а пробеги не вижу сразу, нужно проваливаться в ремонт».

Пробег бэкенд отдавал в строке ленты и раньше — лента его просто не забирала.
Теперь он стоит справа на строке механика: так пробеги выстраиваются в колонку
и историю одной машины можно читать сверху вниз, не открывая каждый ремонт.

Показываем ровно тот пробег, что зафиксирован в самом ремонте. Он и есть
старлайновский: форма создания подставляет его из последнего снимка StarLine,
механик только подтверждает (если сервис недоступен — вводит руками).
Подставлять в историю ТЕКУЩИЙ пробег из StarLine нельзя: у ремонта полугодовой
давности он показал бы сегодняшнее число.

Когда пробега нет — не пишем ничего. У ремонтов из импортированного архива он
есть в 2% случаев, и подпись «пробег не записан» в каждой второй строке была бы
шумом. У ремонтов, заведённых в приложении, пробег заполнен в 72% случаев.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 23:31:50 +10:00
tremble7681andClaude Opus 5 3cc9ffb3e6 feat(warehouse): итоги проведённой инвентаризации вместо тупика
Владелец: «чтобы по клику по инвентаризации я видел не просто информацию о том,
что я не могу её поменять, а итоги. Какие позиции найдены, какие списаны».

Клик по проведённой сессии открывал тот же экран обхода со списком,
отфильтрованным на «только непосчитанные». У проведённой посчитано всё, поэтому
список оказывался пуст, а сверху висел баннер «правки закрыты»: экран показывал
ровно то, чего не просили, и прятал всё остальное.

Теперь отдельный экран итогов: шапка (зона, кто и когда провёл, счётчики,
недостача и излишек в штуках и рублях) и список группами — не нашли, не хватает,
излишек, находки; «сошлось» и «не дошли» свёрнуты числом, чтобы не листать мимо
совпавших строк. Только просмотр.

Числа на этом экране решают, поэтому отдельно закрыто:

- «Всё сошлось — расхождений не было» показывалось при любом числе
  НЕПОСЧИТАННЫХ позиций. Механик обошёл одну из ста, провёл — и сверху документа
  зелёным «зона чистая». Теперь это отдельное предупреждение: расхождений среди
  посчитанного нет, но обойдено не всё.
- Шапка считается по тем же строкам, из которых собираются секции, а не берётся
  готовым агрегатом с бэкенда — сходимость по построению, а не по совпадению
  определений. «Недостача» и «Излишек и находки» названы так, чтобы не совпадать
  с именем секции ниже: одноимённость заставляла сверять и не сходиться в разы.
- Позиции без цены партии больше не выпадают из денег молча — помечены в строке,
  и в шапке сказано, что реальная сумма больше.
- «Обошли X из Y» больше не включает находки: раньше они завышали долю
  обойдённого и противоречили чипу «не дошли» в той же шапке.

Идущая инвентаризация не тронута: ввод количества, «Сходится», «Нет», находки и
проведение работают как раньше.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 23:13:14 +10:00
tremble7681andClaude Opus 5 5a65f8f1ca feat(repairs): поле поиска прямо в ленте ремонтов
Владелец: «не хочу ещё один раздел, хочу чтобы в списке ремонтов просто
появилось поле поиска». Поле встроено в шапку существующего экрана /repairs,
нового раздела и роута нет.

Поиск СЕРВЕРНЫЙ, и это принципиально. Лента грузится курсором по 20 строк:
фильтрация «по уже загруженному» на старте видела бы последние 20 ремонтов
парка и честно отвечала «ничего не найдено» на машину, которая была в ремонте
позавчера. Отсутствие поиска хотя бы не врёт. Вторая ловушка того же варианта:
маркер бесконечной прокрутки стоит сразу под списком, и схлопнутый фильтром
список подтянул бы его в кадр — лента начала бы молча выкачивать всю таблицу
по 20 строк за запрос.

- q уходит на КАЖДОЙ странице и входит в ключ кэша: смена запроса создаёт свой
  список со своим курсором, поэтому курсор нефильтрованной ленты физически не
  может подмешать чужие ремонты во вторую страницу найденного.
- Во время набора на экране остаётся прошлая выдача (приглушённой), а не
  пульсирующие скелетоны на каждое нажатие клавиши.
- «Обновить» перезапрашивает одну страницу вместо всех загруженных: у
  бесконечного запроса refetch тянет их последовательно, и на слабой сети это
  десять round-trip'ов подряд с десятью шансами словить ошибку.
  При этом во время обновления догрузка молчит — иначе схлопывание ленты
  подтягивает маркер в кадр, fetchNextPage отменяет летящий запрос обновления,
  и новые ремонты сверху не появляются, сколько ни жми.
- «Ничего не нашли по этому запросу» отличается от пустой ленты, а сбой сети —
  от ответа сервера с ошибкой: совет «проверьте сеть» на 500-ку отправляет
  механика перезагружать вайфай, когда чинить у него нечего.

Строка ремонта, дневные разделители, месячный итог и поведение ленты без
поиска не менялись.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-07 22:04:02 +10:00
tremble7681andClaude Opus 5 b7302c23d6 feat(inspection): кнопка «Продолжить осмотр» на автозакрытом
Бэкенд раз в час закрывает осмотры, которые несколько часов никто не трогает,
— иначе снятые фото не попадают в отчёты. Редактирование в приложении завязано
на статус, поэтому механик, вернувшийся с перерыва, упирался бы в
заблокированную карточку и заводил осмотр заново.

На автозакрытом (meta.auto_completed) показываем плашку с объяснением и кнопку:
статус возвращается в in_progress, редактор открывается снова.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-08-01 12:51:35 +10:00
tremble7681andClaude Opus 4.8 bbaef9bc7d fix(repairs): количество запчасти можно поменять — «залипшая единица» (4123)
Поле количества приводилось к минимуму на КАЖДЫЙ onChange
(`Math.max(1, Number(v))`), поэтому стирание единицы мгновенно возвращало
её обратно: набрать «4 свечи» было нельзя — цифра дописывалась и выходило
«14». Ровно этот же баг однажды чинили в цене работы (3b7b2ae), там ""
уже разрешено как промежуточное состояние стейта.

- общий QtyStepper: "" остаётся в стейте, пока печатают; приведение — на
  blur и ещё раз на отправке (пустое = 1 шт: строка есть, значит деталь
  ставили);
- тап по полю выделяет число — набор поверх заменяет, а не дописывает;
- кнопки −/+: 4 свечи набираются одним пальцем в перчатках, мобильная
  цифровая клавиатура для этого слишком долгая;
- то же в форме правки ремонта — там я повторил ту же ошибку при переводе
  запчастей на складской каталог;
- регрессионные тесты на стирание/blur/степпер: баг повторился второй раз
  на том же паттерне, пусть дальше ловится сам.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-30 16:16:43 +10:00
tremble7681andClaude Opus 4.8 4c1df109ca wh: карточка проведённого прихода в разделе «Приёмка» (чтение)
Строка в «Последних приходах» стала кликабельной, после проведения
накладной открывается сразу она — видно, что именно получилось.

Показываем снимки на момент приёмки (имя, артикул), а не текущие значения
каталога: накладная — исторический документ, переименование номенклатуры
не должно её переписывать. Единственное «сегодняшнее» поле — сколько от
партии ещё лежит на складе: лежит целиком / осталось N / разошлось.

Правки нет намеренно: проведённый приход уже стал партиями и движениями,
и «поправить» его значило бы разъехаться с журналом — сторно делается в
CRM, где видны последствия. В карточке это сказано текстом, чтобы не
выглядело как недоделка.

Заодно после проведения инвалидируются списки черновиков и приходов —
иначе при возврате в раздел они показывались из кэша устаревшими.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-30 15:29:39 +10:00
tremble7681andClaude Opus 4.8 26c0261784 wh: разделы «Приёмка» и «Инвентаризация» в PWA (админам, мобильная вёрстка)
Приёмка. Главное действие — снять накладную/чек камерой; несколько листов
уходят одним документом. Кадр ужимается до 2200 px на клиенте: сервер всё
равно приводит к этому размеру, а на мобильном интернете в гараже разница
в секундах загрузки заметная. Распознанное проверяется рядом с фото
документа — строки правятся на месте, поставщик выбирается или заводится
прямо с накладной. «Провести» приходует товар в выбранную зону.

Инвентаризация. Запуск спрашивает зону: весь склад одной сессией — это
сотни строк, которые никто не обойдёт за раз. На обходе по умолчанию видны
только непосчитанные, посчитанная сразу уходит из списка. Пустое поле —
«ещё не считали», ноль вводится кнопкой «Нет» (это уже недостача). Находки
подбираются из складского каталога общим пикером. Внизу постоянно висят
недостача и излишек в штуках и рублях.

Доступ: плитки в меню и маршруты закрыты RequireAdmin (тот же гейт на
сервере — клиентская проверка нужна, чтобы прямая ссылка не открывала
экран с ошибкой вместо «вам сюда нельзя»).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-30 15:23:06 +10:00
tremble7681andClaude Opus 4.8 2c02d15a10 repairs(pwa): восстановлены детали/правка/лента с деньгами + слияние со складом
Прод mechanic-pwa собирался с ветки feat/driver-pwa, а main отставал на 18
коммитов (24.05→10.06). Сборка от 29.07 ушла в прод с main — из приложения
пропали разделы. Вернул содержимое ветки и заново наложил работу 29.07.

Возвращено:
- лента: сумма за месяц, разделители по дням с итогом дня, цена в строке,
  бейдж «с улицы»;
- карточка ремонта /repairs/:id (ссылка из ленты вела в никуда);
- правка ремонта /repairs/:id/edit (окно 1 час);
- ремонт «с улицы» /repairs/new-external;
- блок «Механики» — делёж оплаты 1/N;
- vitest-харнесс и вынесенные в lib/ тестируемые хелперы.

Поверх наложено (работа 29.07): несколько замен масла за заезд, запчасти из
складского каталога вместо свободного текста.

Дополнительно:
- пикер деталей вынесен в общий PartsPickerModal (создание + правка). Без
  этого правка ремонта отправляла детали без part_id и сверка склада
  возвращала всё списанное на остаток;
- форма правки знает про 1:N масла — раньше схлопнула бы вторую запись;
- карточка ремонта показывает артикул детали и все замены масла.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-30 11:53:02 +10:00
tremble7681andClaude Opus 4.8 226b1ca6c1 repairs: детали из складского каталога вместо свободного текста
Блок «Запчасти» — модалка-пикер по складскому каталогу (searchParts):
поиск по названию/артикулу, остаток и пометка «подходит», тумблер
«Показать все» (снимает фильтр применимости). Выбор шлёт part_id —
бэкенд списывает деталь со склада. Свободный ввод убран.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-29 19:16:26 +10:00
tremble7681andClaude Opus 4.8 ce4b50109a repairs: несколько замен масла за заезд (двигатель + коробка)
Блок «Замена масла» теперь мульти: чекбоксы Двигатель / Коробка (можно оба),
общий одометр (одна замена — один пробег). Отправляем список oil_changes
(1:N), стикер прикрепляем к первой выбранной. Тип 'transmission' объединяет
АКПП/вариатор/робот — интервал по модели в отчёте СТО.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-29 13:37:38 +10:00
tremble7681andClaude Opus 4.8 3c27b794dd repairs: тип масла в блоке замены (двигатель/вариатор/АКПП)
Для отчётов СТО по замене масла (задача 4078) нужно различать двигатель и
трансмиссию. В блоке «Замена масла» добавлен выбор типа oil_type
(engine|cvt|akpp) и он уходит в payload create. Для вариатора/АКПП поле
«следующая через (км)» скрыто — интервал задаётся по модели в отчёте СТО.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-29 13:12:08 +10:00
38 changed files with 5600 additions and 37 deletions

No files matched your search

@@ -6,6 +6,9 @@ import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { useEffect, type ReactNode } from "react"; import { useEffect, type ReactNode } from "react";
vi.mock("@/api/driver", () => ({ vi.mock("@/api/driver", () => ({
// Карточка бонусов на главной: null -> карточка спрятана, тестам баланса
// она не мешает.
getBonuses: vi.fn(async () => null),
getNotifications: vi.fn(async () => ({ getNotifications: vi.fn(async () => ({
items: [ items: [
{ id: 5, kind: "fine", title: "Новый штраф", body: "Постановление от 13.08.2026.", { id: 5, kind: "fine", title: "Новый штраф", body: "Постановление от 13.08.2026.",
+63
View File
@@ -237,6 +237,69 @@ export const unsubscribePush = async (endpoint: string) =>
/** Пробное уведомление себе. Доступно только при просмотре сотрудником. */ /** Пробное уведомление себе. Доступно только при просмотре сотрудником. */
export const sendTestPush = async () => api.post("driver/push/test").json(); export const sendTestPush = async () => api.post("driver/push/test").json();
// ── Бонусы (система лояльности) ──────────────────────────────────────────────
export const BonusesSchema = z.object({
level: z.object({
code: z.string(),
title: z.string(),
subtitle: z.string(),
days: z.number(),
next: z.object({ title: z.string(), days_left: z.number() }).nullable(),
series_start: z.string().nullable().default(null),
}),
week: z.object({
monday: z.string(),
orders: z.object({
yandex: z.number(),
maxim: z.number(),
total: z.number(),
tier_amount: z.number().default(0),
next_tier: z.object({ minimum: z.number(), amount: z.number() }).nullable().default(null),
}),
}),
payment_streak: z.object({
weeks: z.number(), weekly_amount: z.number(), monthly_cap: z.number(),
}),
clean: z.object({
days: z.number(),
next: z.object({ days: z.number(), amount: z.number() }).nullable().default(null),
}),
discount: z.object({
active: z.boolean(),
per_day: z.number(),
series: z.number(),
max_series: z.number(),
threshold: z.number(),
this_week_best: z.number(),
ends_at: z.string().nullable().default(null),
}),
sums: z.object({ pending: z.number(), earned: z.number(), this_month: z.number() }),
referral: z.object({
code: z.string(),
connect_amount: z.number(),
days_amount: z.number(),
work_days: z.number(),
invited: z.array(z.object({
driver_id: z.number(), days: z.number(), connected: z.boolean(),
})).default([]),
}),
goals: z.array(z.object({
kind: z.string(), text: z.string(), left: z.number(),
})).default([]),
accruals: z.array(z.object({
id: z.number(), program: z.string(), kind: z.string(), amount: z.number(),
title: z.string(), status: z.string(), date: z.string().nullable().default(null),
})).default([]),
// Что реально работает у водителя (глобально И адресно). Пусто/все false —
// водитель в бонусной программе не участвует: экран и вход закрыты.
programs_enabled: z.record(z.string(), z.boolean()).default({}),
});
export type Bonuses = z.infer<typeof BonusesSchema>;
export const getBonuses = async () =>
BonusesSchema.parse(await api.get("driver/bonuses").json());
// ── Вход по номеру через МТС ID ────────────────────────────────────────────── // ── Вход по номеру через МТС ID ──────────────────────────────────────────────
// Оператор подтверждает владение номером sim-push'ем, а если push не дошёл — // Оператор подтверждает владение номером sim-push'ем, а если push не дошёл —
// СМС с кодом. Ответ от МТС приезжает нам колбэком СНАРУЖИ, поэтому приложение // СМС с кодом. Ответ от МТС приезжает нам колбэком СНАРУЖИ, поэтому приложение
@@ -9,6 +9,22 @@ vi.mock("@/api/driver", () => ({
// Колокольчик в шапке главного экрана спрашивает счётчик непрочитанного. // Колокольчик в шапке главного экрана спрашивает счётчик непрочитанного.
getNotifications: vi.fn(async () => ({ items: [], unread: 0 })), getNotifications: vi.fn(async () => ({ items: [], unread: 0 })),
markNotificationsRead: vi.fn(async () => ({ marked: 0 })), markNotificationsRead: vi.fn(async () => ({ marked: 0 })),
// Карточка бонусов на главной: та же форма, что отдаёт /driver/bonuses.
getBonuses: vi.fn(async () => ({
level: { code: "rhythm", title: "В ритме", subtitle: "Третья неделя", days: 18,
next: { title: "Первый месяц", days_left: 12 }, series_start: null },
week: { monday: "2026-08-10", orders: { yandex: 90, maxim: 37, total: 127,
tier_amount: 1200, next_tier: { minimum: 140, amount: 1500 } } },
payment_streak: { weeks: 3, weekly_amount: 500, monthly_cap: 3500 },
clean: { days: 18, next: { days: 30, amount: 1000 } },
discount: { active: true, per_day: 500, series: 2, max_series: 3, threshold: 70,
this_week_best: 90, ends_at: "2026-08-16" },
sums: { pending: 700, earned: 4300, this_month: 4300 },
referral: { code: "PP-2630", connect_amount: 2000, days_amount: 8000, work_days: 21,
invited: [{ driver_id: 9001, days: 9, connected: true }] },
goals: [{ kind: "orders", text: "Ещё 13 заказов до 1 500 ₽ за неделю", left: 13 }],
accruals: [],
})),
getBalance: vi.fn(async () => ({ getBalance: vi.fn(async () => ({
accounts: [ accounts: [
{ bucket: "Долг аренда", balance: -3050, payable: true }, { bucket: "Долг аренда", balance: -3050, payable: true },
+42 -3
View File
@@ -1,8 +1,9 @@
import { useState } from "react"; import { useState } from "react";
import { useQuery } from "@tanstack/react-query"; import { useQuery } from "@tanstack/react-query";
import { useNavigate, useSearchParams } from "react-router-dom"; import { useNavigate, useSearchParams } from "react-router-dom";
import { ArrowUp, ChevronRight, LogOut } from "lucide-react"; import { ArrowUp, ChevronRight, Gift, LogOut } from "lucide-react";
import { getBalance, type StatementKind } from "@/api/driver"; import { getBalance, getBonuses, type StatementKind } from "@/api/driver";
import { anyProgramEnabled } from "@/pages/BonusesPage";
import { formatMoney, isoDaysAgo, isoToday } from "@/lib/format"; import { formatMoney, isoDaysAgo, isoToday } from "@/lib/format";
import { paymentActivityWithin } from "@/lib/paymentWatch"; import { paymentActivityWithin } from "@/lib/paymentWatch";
import { useAuth } from "@/store/auth"; import { useAuth } from "@/store/auth";
@@ -49,6 +50,15 @@ export function BalancePage() {
refetchInterval: (q) => balancePollMs(q.state.data), refetchInterval: (q) => balancePollMs(q.state.data),
}); });
const [sheet, setSheet] = useState(false); const [sheet, setSheet] = useState(false);
// Витрина бонусов на главной: если бонусная подсистема недоступна — карточку
// молча прячем, главный экран не должен падать из-за неё. Тот же ключ кэша,
// что у /bonuses: переход туда не бьёт в API второй раз.
const bonuses = useQuery({
queryKey: ["bonuses"],
queryFn: getBonuses,
retry: 0,
staleTime: 60_000,
});
// Фильтр выписки живёт в адресе (?kind=&from=&to=), а не в памяти экрана: // Фильтр выписки живёт в адресе (?kind=&from=&to=), а не в памяти экрана:
// вернувшись «Назад» из карточки штрафа, водитель видит тот же список штрафов, // вернувшись «Назад» из карточки штрафа, водитель видит тот же список штрафов,
// а не «Все операции», и F5 его не сбрасывает. Меняем заменой записи — выбор // а не «Все операции», и F5 его не сбрасывает. Меняем заменой записи — выбор
@@ -144,11 +154,40 @@ export function BalancePage() {
)} )}
</div> </div>
<button className="btn-primary flex items-center justify-center gap-2 mb-5" <button className="btn-primary flex items-center justify-center gap-2 mb-3"
onClick={() => setSheet(true)}> onClick={() => setSheet(true)}>
<ArrowUp size={18} /> Пополнить <ArrowUp size={18} /> Пополнить
</button> </button>
{/* ── Бонусы ──────────────────────────────────────────────
Вход только участникам: программа поэтапная, водителей включают
адресно (карточка водителя в CRM). Не участвует — закрыто. */}
{bonuses.data && anyProgramEnabled(bonuses.data) && (
<button
className="card w-full flex items-center gap-3 p-4 mb-5 text-left"
onClick={() => nav("/bonuses")}
>
<div className="w-10 h-10 rounded-full bg-accent-soft flex items-center justify-center shrink-0">
<Gift size={20} className="text-accent" />
</div>
<div className="min-w-0 flex-1">
<div className="text-sm font-semibold">Бонусы</div>
<div className="text-muted text-xs truncate">
{bonuses.data.programs_enabled.tenure
? `${bonuses.data.level.title} · ${bonuses.data.level.days} дн.`
: "ваши бонусы"}
{bonuses.data.goals[0] ? ` · ${bonuses.data.goals[0].text}` : ""}
</div>
</div>
<div className="text-right shrink-0">
<b className="text-pos text-sm whitespace-nowrap">
{formatMoney(bonuses.data.sums.earned)}
</b>
<ChevronRight size={16} className="text-muted ml-1 inline" />
</div>
</button>
)}
{/* ── За что списано ─────────────────────────────────────── */} {/* ── За что списано ─────────────────────────────────────── */}
<Statement from={from} to={to} kind={kind} <Statement from={from} to={to} kind={kind}
onFrom={(v) => setFilter("from", v)} onTo={(v) => setFilter("to", v)} onKind={setKind} /> onFrom={(v) => setFilter("from", v)} onTo={(v) => setFilter("to", v)} onKind={setKind} />
@@ -0,0 +1,127 @@
import { describe, it, expect, vi } from "vitest";
import { render, screen } from "@testing-library/react";
import { MemoryRouter, Route, Routes, useLocation } from "react-router-dom";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
// Экран из презентации владельца: уровень «В ритме», 18/21 день, 127/140
// заказов, скидка активна второй неделей, в истории — подтверждённый бонус.
vi.mock("@/api/driver", () => ({
getBonuses: vi.fn(async () => ({
level: { code: "rhythm", title: "В ритме", subtitle: "Третья неделя", days: 18,
next: { title: "Первый месяц", days_left: 12 }, series_start: null },
week: { monday: "2026-08-10", orders: { yandex: 90, maxim: 37, total: 127,
tier_amount: 1200, next_tier: { minimum: 140, amount: 1500 } } },
payment_streak: { weeks: 3, weekly_amount: 500, monthly_cap: 3500 },
clean: { days: 18, next: { days: 30, amount: 1000 } },
discount: { active: true, per_day: 500, series: 2, max_series: 3, threshold: 70,
this_week_best: 90, ends_at: "2026-08-16" },
sums: { pending: 700, earned: 4300, this_month: 4300 },
referral: { code: "PP-2630", connect_amount: 2000, days_amount: 8000, work_days: 21,
invited: [{ driver_id: 9001, days: 9, connected: true }] },
goals: [
{ kind: "orders", text: "Ещё 13 заказов до 1 500 ₽ за неделю", left: 13 },
{ kind: "level", text: "До уровня «Первый месяц» — 12 дн.", left: 12 },
],
accruals: [
{ id: 1, program: "orders", kind: "money", amount: 1200,
title: "127 заказов за неделю", status: "approved", date: "2026-08-16" },
{ id: 2, program: "payment", kind: "money", amount: 500,
title: "Неделя без просрочки аренды", status: "pending", date: "2026-08-16" },
],
// Участник всех программ: экран и карточки открыты.
programs_enabled: { orders: true, payment: true, discount: true,
clean: true, tenure: true, friend: true },
})),
}));
import { BonusesPage } from "./BonusesPage";
function Search() {
return <p data-testid="search">{useLocation().search}</p>;
}
function wrap(url = "/bonuses") {
const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } });
return render(
<QueryClientProvider client={qc}>
<MemoryRouter initialEntries={[url]}>
<Search />
<Routes>
<Route path="/bonuses" element={<BonusesPage />} />
<Route path="/" element={<p>главная</p>} />
</Routes>
</MemoryRouter>
</QueryClientProvider>
);
}
describe("экран бонусов", () => {
it("уровень, заработанное и путь до следующего уровня", async () => {
wrap();
expect(await screen.findByText("В ритме")).toBeInTheDocument();
expect(screen.getByText("18 дн. в парке")).toBeInTheDocument();
expect(screen.getByText(/до «Первый месяц» — 12 дн./)).toBeInTheDocument();
expect(screen.getByText("4 300 ₽")).toBeInTheDocument(); // заработано
expect(screen.getByText(/700 ₽ ждёт подтверждения/)).toBeInTheDocument();
});
it("заказы недели: сколько есть и сколько до следующего тира", async () => {
wrap();
expect(await screen.findByText("127")).toBeInTheDocument();
expect(screen.getByText("Яндекс 90 · Максим 37")).toBeInTheDocument();
// Тир 120–139 уже набран — показываем его сумму и путь до максимума.
expect(screen.getByText("Тир набран: 1 200 ₽ за неделю")).toBeInTheDocument();
});
it("активная скидка показывается зелёной картой с серией", async () => {
wrap();
expect(await screen.findByText("−500 ₽ в сутки")).toBeInTheDocument();
expect(screen.getByText(/серия 2 из 3/)).toBeInTheDocument();
});
it("серии оплат и «без нарушений» с вехой", async () => {
wrap();
expect(await screen.findByText("3 нед. подряд")).toBeInTheDocument();
expect(screen.getByText(/ещё 12 дн. — и 1 000 ₽/)).toBeInTheDocument();
});
it("код друга и ближайшие цели", async () => {
wrap();
expect(await screen.findByText("PP-2630")).toBeInTheDocument();
expect(screen.getByText("Ещё 13 заказов до 1 500 ₽ за неделю")).toBeInTheDocument();
expect(screen.getByText(/друзей привёл: 1/)).toBeInTheDocument();
});
it("история начислений с разницей «начислено / ждёт»", async () => {
wrap();
expect(await screen.findByText("127 заказов за неделю")).toBeInTheDocument();
expect(screen.getByText("начислено")).toBeInTheDocument();
expect(screen.getByText("ждёт подтверждения")).toBeInTheDocument();
});
it("ошибка загрузки предлагает повторить, а не белый экран", async () => {
const { getBonuses } = await import("@/api/driver");
vi.mocked(getBonuses).mockRejectedValueOnce(new Error("boom"));
wrap();
expect(await screen.findByRole("button", { name: /Попробовать снова/ })).toBeInTheDocument();
});
it("клик по карточке на главной — отдельный маршрут /bonuses", async () => {
// Сам маршрут описан в routes.tsx и покрыт сторожем routes.test.tsx
// («Назад» на каждом экране); здесь проверяем только сам экран.
wrap();
expect(screen.getByTestId("search").textContent).toBe("");
expect(screen.queryByText("главная")).not.toBeInTheDocument();
});
});
describe("экран бонусов: адресность", () => {
it("неучастнику закрыто — вежливая заглушка вместо витрины", async () => {
const { getBonuses } = await import("@/api/driver");
vi.mocked(getBonuses).mockResolvedValueOnce({
...await getBonuses(), programs_enabled: {},
} as never);
wrap();
expect(await screen.findByText(/Вы пока не участвуете/)).toBeInTheDocument();
});
});
@@ -0,0 +1,334 @@
import { useQuery } from "@tanstack/react-query";
import {
BarChart3, CalendarCheck, ChevronRight, Flame, Gift, ShieldCheck, Target,
Trophy, Users,
} from "lucide-react";
import { getBonuses, type Bonuses } from "@/api/driver";
import { Spinner } from "@/components/Spinner";
import { formatDate, formatMoney } from "@/lib/format";
/** Полоса прогресса: тонкая, с мягкими краями — как «до следующей цели». */
function Bar({ value, max, tone = "accent" }: { value: number; max: number; tone?: "accent" | "pos" }) {
const pct = max > 0 ? Math.min(100, Math.round((value / max) * 100)) : 0;
return (
<div className="h-2 rounded-full bg-line-soft overflow-hidden mt-2">
<div
className={`h-full rounded-full ${tone === "pos" ? "bg-pos" : "bg-accent"}`}
style={{ width: `${pct}%` }}
/>
</div>
);
}
function ProgramIcon({ program }: { program: string }) {
const cls = "w-5 h-5 text-accent shrink-0";
switch (program) {
case "orders": return <BarChart3 className={cls} />;
case "discount": return <Flame className={cls} />;
case "payment": return <CalendarCheck className={cls} />;
case "clean": return <ShieldCheck className={cls} />;
case "tenure": return <Trophy className={cls} />;
case "friend": return <Users className={cls} />;
default: return <Gift className={cls} />;
}
}
function Card({ children, tone = "plain" }: { children: React.ReactNode; tone?: "plain" | "pos" }) {
return (
<div
className={`card p-4 ${tone === "pos" ? "border-pos/40 bg-pos/5" : ""}`}
>
{children}
</div>
);
}
const CardTitle = ({ icon, children }: { icon: React.ReactNode; children: React.ReactNode }) => (
<div className="flex items-center gap-2 text-ink-soft text-sm font-medium">
{icon}
<span>{children}</span>
</div>
);
const STATUS_LABEL: Record<string, { text: string; cls: string }> = {
pending: { text: "ждёт подтверждения", cls: "text-muted" },
approved: { text: "начислено", cls: "text-pos font-medium" },
posted: { text: "начислено", cls: "text-pos font-medium" },
};
/** Участвует ли хоть в одной программе (вход на главную закрыт неучастникам). */
export function anyProgramEnabled(b: Bonuses | undefined | null): boolean {
const m = b?.programs_enabled;
return !!m && Object.values(m).some(Boolean);
}
/**
* Бонусы — витрина системы лояльности: уровень, серии, прогресс до следующей
* суммы и история начислений. Числа считаются тем же движком, что и в CRM,
* поэтому с менеджером всегда одинаковые (docs/bonus-rules.md на бэкенде).
*
* Экран живёт только у участников: бонусная программа поэтапная, водителя
* включают адресно (карточка водителя в CRM). Не участвует — закрыто.
*/
export function BonusesPage() {
const { data, error, refetch } = useQuery({
queryKey: ["bonuses"],
queryFn: getBonuses,
staleTime: 60_000,
});
if (error) {
return (
<div>
<h1 className="text-lg font-bold mb-3">Бонусы</h1>
<div className="card p-4 text-sm">
<p className="text-ink-soft">Не удалось загрузить бонусы. Проверьте связь.</p>
<button className="btn-primary mt-3 w-full" onClick={() => void refetch()}>
Попробовать снова
</button>
</div>
</div>
);
}
if (!data) {
return (
<div>
<h1 className="text-lg font-bold mb-3">Бонусы</h1>
<Spinner />
</div>
);
}
if (!anyProgramEnabled(data)) {
return (
<div className="space-y-3">
<h1 className="text-lg font-bold">Бонусы</h1>
<div className="card p-4 text-sm text-ink-soft">
Вы пока не участвуете в бонусной программе парка. Когда менеджер включит
вам бонусы — здесь появятся уровень, серии и заработанное.
</div>
</div>
);
}
return <BonusesBody b={data} />;
}
function BonusesBody({ b }: { b: Bonuses }) {
const o = b.week.orders;
const weekFrom = formatDate(b.week.monday);
const on = {
orders: b.programs_enabled.orders === true,
discount: b.programs_enabled.discount === true,
payment: b.programs_enabled.payment === true,
clean: b.programs_enabled.clean === true,
tenure: b.programs_enabled.tenure === true,
friend: b.programs_enabled.friend === true,
};
const cards = [on.orders, on.discount, on.payment, on.clean, on.friend].filter(Boolean).length;
return (
<div className="space-y-3">
<h1 className="text-lg font-bold">Бонусы</h1>
{/* Уровень + заработанное — первое, ради чего экран открывают.
Уровень — часть программы «Стаж»: не участвует — не показываем. */}
{(on.tenure || cards > 0 || b.sums.earned > 0 || b.sums.pending > 0) && (
<div className="card p-4">
<div className="flex items-start justify-between gap-3">
{on.tenure ? (
<div className="flex items-center gap-3">
<div className="w-11 h-11 rounded-full bg-accent-soft flex items-center justify-center shrink-0">
<Trophy className="w-6 h-6 text-accent" />
</div>
<div>
<div className="text-xl font-bold leading-tight">{b.level.title}</div>
<div className="text-muted text-sm">{b.level.subtitle}</div>
</div>
</div>
) : (
<div className="flex items-center gap-3">
<div className="w-11 h-11 rounded-full bg-accent-soft flex items-center justify-center shrink-0">
<Gift className="w-6 h-6 text-accent" />
</div>
<div>
<div className="text-xl font-bold leading-tight">Бонусы парка</div>
<div className="text-muted text-sm">программы, в которых вы участвуете</div>
</div>
</div>
)}
<div className="text-right shrink-0">
<div className="text-xl font-bold text-pos">{formatMoney(b.sums.earned)}</div>
<div className="text-muted text-xs">заработано</div>
</div>
</div>
{on.tenure && (
<div className="mt-4">
<div className="flex justify-between text-sm">
<span className="text-ink-soft">{b.level.days} дн. в парке</span>
{b.level.next && (
<span className="text-muted">
до «{b.level.next.title}» — {b.level.next.days_left} дн.
</span>
)}
</div>
<Bar value={b.level.days % 30 || 30} max={30} />
</div>
)}
{b.sums.pending > 0 && (
<div className="mt-2 text-xs text-muted">
Ещё {formatMoney(b.sums.pending)} ждёт подтверждения менеджера
</div>
)}
</div>
)}
{/* Ближайшие цели — «ещё 13 заказов и…» (памятка из презентации) */}
{b.goals.length > 0 && (
<div className="card p-4">
<CardTitle icon={<Target className="w-5 h-5 text-accent" />}>До ближайших целей</CardTitle>
<ul className="mt-2 space-y-1.5 text-sm">
{b.goals.map((g, i) => (
<li key={i} className="flex items-start gap-2">
<ChevronRight className="w-4 h-4 text-muted mt-0.5 shrink-0" />
<span>{g.text}</span>
</li>
))}
</ul>
</div>
)}
{/* Заказы за неделю */}
{on.orders && (
<Card>
<CardTitle icon={<BarChart3 className="w-5 h-5 text-accent" />}>
Заказы за неделю (с {weekFrom})
</CardTitle>
<div className="flex items-baseline justify-between mt-1">
<div className="text-2xl font-bold tabular-nums">{o.total}</div>
<div className="text-muted text-sm">Яндекс {o.yandex} · Максим {o.maxim}</div>
</div>
<Bar value={o.total} max={o.next_tier?.minimum ?? 140} />
<div className="mt-2 text-sm text-ink-soft">
{o.tier_amount > 0
? `Тир набран: ${formatMoney(o.tier_amount)} за неделю`
: o.next_tier
? `Ещё ${o.next_tier.minimum - o.total} заказов — и ${formatMoney(o.next_tier.amount)}`
: "Максимальный тир недели"}
</div>
</Card>
)}
{/* Скидка 70+ */}
{on.discount && (b.discount.active ? (
<Card tone="pos">
<CardTitle icon={<Flame className="w-5 h-5 text-pos" />}>Скидка на аренду активна</CardTitle>
<div className="text-2xl font-bold text-pos mt-1">
−{formatMoney(b.discount.per_day)} в сутки
</div>
<div className="mt-1 text-sm text-ink-soft">
до {formatDate(b.discount.ends_at)} · серия {b.discount.series} из {b.discount.max_series}
</div>
<div className="mt-1 text-xs text-muted">
Продли: {b.discount.threshold}+ заказов в одном агрегаторе на этой неделе
</div>
</Card>
) : (
<Card>
<CardTitle icon={<Flame className="w-5 h-5 text-accent" />}>
Скидка за {b.discount.threshold}+ заказов
</CardTitle>
<div className="flex items-baseline justify-between mt-1">
<div className="text-2xl font-bold tabular-nums">{b.discount.this_week_best}</div>
<div className="text-muted text-sm">из {b.discount.threshold} в одном агрегаторе</div>
</div>
<Bar value={b.discount.this_week_best} max={b.discount.threshold} />
<div className="mt-2 text-sm text-ink-soft">
Дальше — −{formatMoney(b.discount.per_day)} с аренды каждый день следующей недели
</div>
</Card>
))}
{/* Оплата вовремя */}
{on.payment && (
<Card>
<CardTitle icon={<CalendarCheck className="w-5 h-5 text-accent" />}>Оплата вовремя</CardTitle>
<div className="text-2xl font-bold mt-1">{b.payment_streak.weeks} нед. подряд</div>
<div className="mt-1 text-sm text-ink-soft">
+{formatMoney(b.payment_streak.weekly_amount)} за каждую неделю без просрочки
</div>
</Card>
)}
{/* Без нарушений */}
{on.clean && (
<Card>
<CardTitle icon={<ShieldCheck className="w-5 h-5 text-accent" />}>Без нарушений</CardTitle>
<div className="text-2xl font-bold mt-1">{b.clean.days} дн.</div>
{b.clean.next && (
<>
<Bar value={b.clean.days} max={b.clean.next.days} tone="pos" />
<div className="mt-2 text-sm text-ink-soft">
ещё {b.clean.next.days - b.clean.days} дн. — и {formatMoney(b.clean.next.amount)}
</div>
</>
)}
</Card>
)}
{/* Приведи друга */}
{on.friend && (
<Card>
<CardTitle icon={<Users className="w-5 h-5 text-accent" />}>Приведи друга</CardTitle>
<div className="flex items-baseline justify-between mt-1">
<div>
<div className="text-muted text-xs">твой код</div>
<div className="text-2xl font-bold tracking-wide">{b.referral.code}</div>
</div>
<div className="text-right text-sm text-ink-soft">
до {formatMoney(b.referral.connect_amount + b.referral.days_amount)}
<div className="text-muted text-xs">
{b.referral.invited.length > 0
? `друзей привёл: ${b.referral.invited.length}`
: `за друга, который проработает ${b.referral.work_days} дн.`}
</div>
</div>
</div>
<div className="mt-2 text-xs text-muted">
Назови код менеджеру при подключении друга — бонус придёт сюда
</div>
</Card>
)}
{/* История начислений */}
<div className="card p-0 overflow-hidden">
<div className="px-4 pt-4 pb-2 text-sm font-medium text-ink-soft">История начислений</div>
{b.accruals.length === 0 && (
<div className="px-4 pb-4 text-muted text-sm">
Пока пусто: начисления появляются после первой закрытой недели
</div>
)}
<ul>
{b.accruals.map((a) => {
const st = STATUS_LABEL[a.status] ?? { text: a.status, cls: "text-muted" };
return (
<li key={a.id} className="flex items-center gap-3 px-4 py-3 border-t border-line">
<ProgramIcon program={a.program} />
<div className="min-w-0 flex-1">
<div className="text-sm">{a.title}</div>
<div className={`text-xs ${st.cls}`}>{st.text}</div>
</div>
<div className="text-sm font-semibold tabular-nums whitespace-nowrap">
{formatMoney(a.amount)}
</div>
</li>
);
})}
</ul>
</div>
</div>
);
}
+4
View File
@@ -13,6 +13,7 @@ import { DebugPage } from "@/pages/DebugPage";
import { MockPayPage } from "@/pages/MockPayPage"; import { MockPayPage } from "@/pages/MockPayPage";
import { FineDetailPage } from "@/pages/FineDetailPage"; import { FineDetailPage } from "@/pages/FineDetailPage";
import { NotificationsPage } from "@/pages/NotificationsPage"; import { NotificationsPage } from "@/pages/NotificationsPage";
import { BonusesPage } from "@/pages/BonusesPage";
/** Что известно при выборе родителя: параметры пути, строка запроса, вход. */ /** Что известно при выборе родителя: параметры пути, строка запроса, вход. */
export interface ParentCtx { export interface ParentCtx {
@@ -52,6 +53,9 @@ export const ROUTES: AppRoute[] = [
// туда и возвращаем; без входа возвращаться некуда, кроме экрана входа. // туда и возвращаем; без входа возвращаться некуда, кроме экрана входа.
{ path: "/dev", element: <DevLoginPage />, parent: ({ signedIn }) => (signedIn ? "/" : "/login") }, { path: "/dev", element: <DevLoginPage />, parent: ({ signedIn }) => (signedIn ? "/" : "/login") },
{ path: "/notifications", element: <NotificationsPage />, guard: "auth", parent: "/" }, { path: "/notifications", element: <NotificationsPage />, guard: "auth", parent: "/" },
// Бонусы открывают карточкой с главной и пушем «Бонус начислен» — оба
// случая возвращаются на главную.
{ path: "/bonuses", element: <BonusesPage />, guard: "auth", parent: "/" },
{ path: "/topup", element: <TopupPage />, guard: "auth", parent: "/" }, { path: "/topup", element: <TopupPage />, guard: "auth", parent: "/" },
{ path: "/pay/:orderId", element: <PaymentPage />, guard: "auth", parent: "/" }, { path: "/pay/:orderId", element: <PaymentPage />, guard: "auth", parent: "/" },
{ path: "/mock-pay/:orderId", element: <MockPayPage />, guard: "auth", parent: "/" }, { path: "/mock-pay/:orderId", element: <MockPayPage />, guard: "auth", parent: "/" },
+55
View File
@@ -1,5 +1,7 @@
import { Routes, Route, Navigate } from "react-router-dom"; import { Routes, Route, Navigate } from "react-router-dom";
import { useQuery } from "@tanstack/react-query";
import { useAuth } from "@/store/auth"; import { useAuth } from "@/store/auth";
import { getMe } from "@/api/me";
import { useMeSync } from "@/hooks/useMeSync"; import { useMeSync } from "@/hooks/useMeSync";
import Login from "@/pages/Login"; import Login from "@/pages/Login";
import ActionMenu from "@/pages/ActionMenu"; import ActionMenu from "@/pages/ActionMenu";
@@ -14,6 +16,16 @@ import EditRepairPage from "@/pages/repairs/EditRepairPage";
import CarSelectPage from "@/pages/repairs/CarSelectPage"; import CarSelectPage from "@/pages/repairs/CarSelectPage";
import CreateRepairPage from "@/pages/repairs/CreateRepairPage"; import CreateRepairPage from "@/pages/repairs/CreateRepairPage";
import RepairHistoryPage from "@/pages/repairs/RepairHistoryPage"; import RepairHistoryPage from "@/pages/repairs/RepairHistoryPage";
import ReceivingPage from "@/pages/warehouse/ReceivingPage";
import ReceivingDraftPage from "@/pages/warehouse/ReceivingDraftPage";
import ReceiptDetailPage from "@/pages/warehouse/ReceiptDetailPage";
import StocktakePage from "@/pages/warehouse/StocktakePage";
import TyresPage from "@/pages/warehouse/TyresPage";
import TyreSizesPage from "@/pages/warehouse/TyreSizesPage";
import TyreJournalPage from "@/pages/warehouse/TyreJournalPage";
import PartsIssuePage from "@/pages/warehouse/PartsIssuePage";
import PartsIssueJournalPage from "@/pages/warehouse/PartsIssueJournalPage";
import StocktakeSessionPage from "@/pages/warehouse/StocktakeSessionPage";
function RequireAuth({ children }: { children: React.ReactNode }) { function RequireAuth({ children }: { children: React.ReactNode }) {
const token = useAuth((s) => s.token); const token = useAuth((s) => s.token);
@@ -21,6 +33,36 @@ function RequireAuth({ children }: { children: React.ReactNode }) {
return <>{children}</>; return <>{children}</>;
} }
/**
* Складские разделы пока только админам. Сервер и так отдаёт 403, но без
* клиентской проверки прямой ссылкой можно было бы открыть пустой экран с
* ошибкой — это читается как поломка, а не как «вам сюда нельзя».
*/
function RequireAdmin({ children }: { children: React.ReactNode }) {
const token = useAuth((s) => s.token);
const meQuery = useQuery({ queryKey: ["me"], queryFn: getMe, staleTime: 60_000, enabled: !!token });
if (!token) return <Navigate to="/login" replace />;
if (meQuery.isLoading) return null;
if (!meQuery.data?.is_admin) return <Navigate to="/" replace />;
return <>{children}</>;
}
/**
* Выдача резины — по складскому праву (warehouse:tyres в /me), не только
* админам. Приёмка и инвентаризация остаются под RequireAdmin.
*/
function RequireTyres({ children }: { children: React.ReactNode }) {
const token = useAuth((s) => s.token);
const meQuery = useQuery({ queryKey: ["me"], queryFn: getMe, staleTime: 60_000, enabled: !!token });
if (!token) return <Navigate to="/login" replace />;
if (meQuery.isLoading) return null;
const me = meQuery.data;
if (!me?.is_admin && !me?.permissions?.includes("warehouse:tyres")) {
return <Navigate to="/" replace />;
}
return <>{children}</>;
}
export default function App() { export default function App() {
// У35: фоновая сверка прав механика раз в 5 минут — выкидывает на /login // У35: фоновая сверка прав механика раз в 5 минут — выкидывает на /login
// с сообщением «Доступ отозван», если админ снял can_login_pwa или вывел // с сообщением «Доступ отозван», если админ снял can_login_pwa или вывел
@@ -49,6 +91,19 @@ export default function App() {
<Route path="/repairs/history/:carId" element={<RequireAuth><RepairHistoryPage /></RequireAuth>} /> <Route path="/repairs/history/:carId" element={<RequireAuth><RepairHistoryPage /></RequireAuth>} />
<Route path="/repairs/:id" element={<RequireAuth><RepairDetailPage /></RequireAuth>} /> <Route path="/repairs/:id" element={<RequireAuth><RepairDetailPage /></RequireAuth>} />
<Route path="/repairs/:id/edit" element={<RequireAuth><EditRepairPage /></RequireAuth>} /> <Route path="/repairs/:id/edit" element={<RequireAuth><EditRepairPage /></RequireAuth>} />
{/* Склад — приёмка и инвентаризация с телефона (пока только админы). */}
<Route path="/wh/receiving" element={<RequireAdmin><ReceivingPage /></RequireAdmin>} />
<Route path="/wh/receiving/:id" element={<RequireAdmin><ReceivingDraftPage /></RequireAdmin>} />
<Route path="/wh/receipts/:id" element={<RequireAdmin><ReceiptDetailPage /></RequireAdmin>} />
<Route path="/wh/stocktake" element={<RequireAdmin><StocktakePage /></RequireAdmin>} />
<Route path="/wh/stocktake/:id" element={<RequireAdmin><StocktakeSessionPage /></RequireAdmin>} />
{/* Сезонная выдача резины — по складскому праву (не только админам). */}
<Route path="/wh/tyres" element={<RequireTyres><TyresPage /></RequireTyres>} />
<Route path="/wh/tyres/sizes" element={<RequireTyres><TyreSizesPage /></RequireTyres>} />
<Route path="/wh/tyres/journal" element={<RequireTyres><TyreJournalPage /></RequireTyres>} />
{/* Выдача запчастей (5763) — всем, кто вошёл в PWA: гейт на сервере require_mechanic. */}
<Route path="/wh/issues" element={<RequireAuth><PartsIssuePage /></RequireAuth>} />
<Route path="/wh/issues/journal" element={<RequireAuth><PartsIssueJournalPage /></RequireAuth>} />
<Route path="*" element={<Navigate to="/" replace />} /> <Route path="*" element={<Navigate to="/" replace />} />
</Routes> </Routes>
); );
+2 -1
View File
@@ -48,10 +48,11 @@ export async function requestUploadUrl(
* PUT the file directly to MinIO via the presigned URL. * PUT the file directly to MinIO via the presigned URL.
* Content-Type header MUST match the value the URL was signed with * Content-Type header MUST match the value the URL was signed with
* (we pass the same `args.content_type` to requestUploadUrl). * (we pass the same `args.content_type` to requestUploadUrl).
* Принимает Blob: очередь загрузки кладёт сюда сжатый blob, а не File.
*/ */
export async function uploadToS3( export async function uploadToS3(
presigned: PresignedUploadResponse, presigned: PresignedUploadResponse,
file: File, file: Blob,
contentType: string contentType: string
): Promise<void> { ): Promise<void> {
const r = await fetch(presigned.presigned_url, { const r = await fetch(presigned.presigned_url, {
@@ -29,6 +29,18 @@ export interface PartSuggestion {
name: string; name: string;
} }
/** Каталожная позиция склада для выдачи запчастей (поиск с остатками). */
export interface PartCatalogItem {
id: number;
name: string;
article: string | null;
brand: string | null;
unit: string;
in_stock: number; // суммарный остаток (может быть < 0)
price_hint: number | string | null;
fits: boolean; // подходит этой машине
}
export interface PresignResponse { export interface PresignResponse {
photo_uuid: string; photo_uuid: string;
extension: string; extension: string;
@@ -126,6 +138,20 @@ export async function searchWorks(q: string): Promise<MechWork[]> {
return api.get(`works${qs}`).json<MechWork[]>(); return api.get(`works${qs}`).json<MechWork[]>();
} }
export async function searchParts(
q: string,
carId: number | null,
showAll = false,
): Promise<PartCatalogItem[]> {
const params = new URLSearchParams();
// Без машины (ремонт «с улицы») применимость считать не по чему —
// бэкенд отдаст каталог целиком.
if (carId) params.set("car_id", String(carId));
if (q.trim()) params.set("q", q.trim());
if (showAll) params.set("all", "true");
return api.get(`parts/search?${params.toString()}`).json<PartCatalogItem[]>();
}
export async function suggestParts(q: string): Promise<PartSuggestion[]> { export async function suggestParts(q: string): Promise<PartSuggestion[]> {
return api return api
.get(`parts/suggest?q=${encodeURIComponent(q)}`) .get(`parts/suggest?q=${encodeURIComponent(q)}`)
+566
View File
@@ -0,0 +1,566 @@
/**
* Склад в PWA — приёмка и инвентаризация (эндпоинты /v1/mechanic/wh/*).
*
* Разделы админские: сервер отдаёт 403 всем остальным, поэтому клиент
* дополнительно прячет плитки по me.is_admin — чтобы механик не упирался в
* ошибку там, куда ему не надо.
*/
import { HTTPError } from "ky";
import { api } from "./client";
/**
* Текст отказа, который сервер написал для человека.
*
* ky кладёт в Error.message служебное «Request failed with status code 409», а
* понятную причину бэкенд пишет в detail («Удалить находку нельзя: деталь
* выдали после пересчёта»). Механику у стеллажа нужна именно она: по номеру
* статуса он не поймёт, что делать дальше, и повторит то же действие.
*
* Запасной текст обязателен: тело читается один раз (при повторном вызове поток
* уже пуст), у прокси-ошибок его может не быть вовсе, а валидационный 422 от
* pydantic кладёт в detail список объектов — человеку он ничего не говорит.
* Не-HTTP ошибка (связь отвалилась, таймаут) тоже уходит в запасной: у ky там
* английское «Failed to fetch».
*/
export async function apiErrorText(e: unknown, fallback: string): Promise<string> {
if (!(e instanceof HTTPError)) return fallback;
try {
const { detail } = (await e.response.json()) as { detail?: unknown };
if (typeof detail === "string" && detail.trim()) return detail.trim();
} catch {
// тело не JSON или уже прочитано — остаётся запасной текст
}
return fallback;
}
// ── Справочники ────────────────────────────────────────────────────────────
export interface WhRef {
id: number;
code: string;
name: string;
}
export async function getPlaces(): Promise<WhRef[]> {
return api.get("wh/places").json<WhRef[]>();
}
export async function getSuppliers(): Promise<WhRef[]> {
return api.get("wh/suppliers").json<WhRef[]>();
}
// ── Приёмка ────────────────────────────────────────────────────────────────
export interface DraftLine {
id: number;
brand: string | null;
article: string | null;
name: string;
qty: number;
unit_price: number | string;
matched_part_id: number | null;
matched_part_name: string | null;
thumb_url: string | null;
}
export interface Draft {
id: number;
source: string;
ext_order_id: string;
supplier_id: number | null;
supplier_name: string | null;
legal_entity: string | null;
order_date: string | null;
total_price: number | string | null;
status: string;
receipt_id: number | null;
created_at: string;
photo_urls: string[];
lines: DraftLine[];
}
export interface DraftListResponse {
items: Draft[];
total: number;
}
/** Фото накладной/чека → распознавание → черновик (приход НЕ создаётся). */
export async function scanInvoice(files: Blob[]): Promise<Draft> {
const fd = new FormData();
files.forEach((f, i) => fd.append("files", f, `page${i + 1}.jpg`));
// Распознавание идёт на vision-модели и занимает десятки секунд —
// клиентский таймаут по умолчанию (30 с) её не дожидается.
return api.post("wh/receiving/scan", { body: fd, timeout: 240_000 }).json<Draft>();
}
export async function getDrafts(status = "pending"): Promise<DraftListResponse> {
return api.get(`wh/receiving/drafts?status=${status}`).json<DraftListResponse>();
}
export async function getDraft(id: number): Promise<Draft> {
return api.get(`wh/receiving/drafts/${id}`).json<Draft>();
}
export interface DraftPatch {
supplier_id?: number | null;
order_date?: string | null;
doc_number?: string | null;
comment?: string | null;
}
export async function patchDraft(id: number, body: DraftPatch): Promise<Draft> {
return api.patch(`wh/receiving/drafts/${id}`, { json: body }).json<Draft>();
}
export async function createDraftSupplier(
id: number,
body: { name: string; legal_entity?: string | null },
): Promise<Draft> {
return api.post(`wh/receiving/drafts/${id}/supplier`, { json: body }).json<Draft>();
}
export interface DraftLinePatch {
article?: string | null;
name?: string | null;
qty?: number;
unit_price?: number;
matched_part_id?: number | null;
}
export async function addDraftLine(id: number, body: DraftLinePatch): Promise<Draft> {
return api.post(`wh/receiving/drafts/${id}/lines`, { json: body }).json<Draft>();
}
export async function patchDraftLine(
id: number,
lineId: number,
body: DraftLinePatch,
): Promise<Draft> {
return api.patch(`wh/receiving/drafts/${id}/lines/${lineId}`, { json: body }).json<Draft>();
}
export async function deleteDraftLine(id: number, lineId: number): Promise<Draft> {
return api.delete(`wh/receiving/drafts/${id}/lines/${lineId}`).json<Draft>();
}
export interface PostDraftResult {
ok: boolean;
receipt_id: number;
lines: number;
}
export async function postDraft(
id: number,
body: { place_id: number | null; doc_date?: string | null; exclude_line_ids?: number[] },
): Promise<PostDraftResult> {
return api.post(`wh/receiving/drafts/${id}/post`, { json: body }).json<PostDraftResult>();
}
export async function rejectDraft(id: number): Promise<{ ok: boolean }> {
return api.post(`wh/receiving/drafts/${id}/reject`).json<{ ok: boolean }>();
}
export interface ReceiptPreviewLine {
part_id: number;
name: string;
article: string | null;
qty: number;
thumb_url: string | null;
}
export interface Receipt {
id: number;
supplier_name: string | null;
doc_number: string | null;
doc_date: string;
total_amount: number | string;
lines_count: number;
posted_by_name: string | null;
preview_lines: ReceiptPreviewLine[];
}
export interface ReceiptListResponse {
items: Receipt[];
total: number;
total_sum: number | string;
month_total: number | string;
month_label: string;
}
export async function getReceipts(limit = 30): Promise<ReceiptListResponse> {
return api.get(`wh/receipts?limit=${limit}`).json<ReceiptListResponse>();
}
export interface ReceiptLine {
batch_id: number;
part_id: number;
/** Снимок имени на момент прихода — накладная исторический документ. */
part_name: string;
article: string | null;
qty: number;
/** Сколько от этой партии ещё лежит на складе (может быть < 0). */
qty_remaining: number;
unit_price: number | string;
amount: number | string;
place_code: string | null;
thumb_url: string | null;
}
export interface ReceiptDetail extends Receipt {
supplier_id: number;
comment: string | null;
created_at: string | null;
lines: ReceiptLine[];
}
export async function getReceipt(id: number): Promise<ReceiptDetail> {
return api.get(`wh/receipts/${id}`).json<ReceiptDetail>();
}
// ── Инвентаризация ─────────────────────────────────────────────────────────
export interface Stocktake {
id: number;
/** Статусов ровно два — сужаем до union, чтобы «проведена» проверялась типом. */
status: "draft" | "done";
place_id: number | null;
place_code: string | null;
author_name: string | null;
started_at: string;
finished_at: string | null;
comment: string | null;
lines_total: number;
lines_counted: number;
shortage_qty: number;
shortage_amount: number | string;
surplus_qty: number;
surplus_amount: number | string;
}
export interface StocktakeLine {
id: number;
/**
* null = находка, но ТОЛЬКО до проведения: apply создаёт находке партию и
* прописывает её id сюда. На проведённой сессии находку узнаём иначе —
* см. isFind() в pages/warehouse/stocktakeSummary.ts.
*/
batch_id: number | null;
part_id: number;
part_name: string;
article: string | null;
place_id: number | null;
place_code: string | null;
qty_expected: number;
qty_counted: number | null;
unit_price: number | string | null;
condition: "new" | "used";
seasons_left: number | null;
resolution: "not_counted" | "match" | "shortage" | "surplus";
delta: number;
delta_amount: number | string;
comment: string | null;
/** Код причины расхождения (курируемый список, зеркалит stock_reasons.py). */
reason_code: string | null;
}
export interface StocktakeDetail extends Stocktake {
lines: StocktakeLine[];
}
export interface StocktakeListResponse {
items: Stocktake[];
total: number;
}
export async function getStocktakes(): Promise<StocktakeListResponse> {
return api.get("wh/stocktakes").json<StocktakeListResponse>();
}
export async function getStocktake(id: number): Promise<StocktakeDetail> {
return api.get(`wh/stocktakes/${id}`).json<StocktakeDetail>();
}
export async function createStocktake(body: {
place_id: number | null;
comment?: string | null;
}): Promise<StocktakeDetail> {
return api.post("wh/stocktakes", { json: body }).json<StocktakeDetail>();
}
export async function countLine(
stocktakeId: number,
lineId: number,
body: { qty_counted: number | null; comment?: string | null },
): Promise<StocktakeLine> {
return api
.patch(`wh/stocktakes/${stocktakeId}/lines/${lineId}`, { json: body })
.json<StocktakeLine>();
}
export async function addFind(
stocktakeId: number,
body: { part_id: number; qty: number; place_id?: number | null; comment?: string | null },
): Promise<StocktakeLine> {
return api.post(`wh/stocktakes/${stocktakeId}/finds`, { json: body }).json<StocktakeLine>();
}
/**
* Поправить находку в черновике.
*
* Отдельная ручка, а не countLine: сервер пишет в аудит «было → стало» и не
* даёт свести количество к нулю — от находки отказываются удалением строки,
* иначе она остаётся в документе пустышкой «числилось 0 — столько и нашли».
* Поля опциональны: шлём только то, что правим.
*/
export async function patchFind(
stocktakeId: number,
lineId: number,
body: {
qty?: number;
unit_price?: number;
condition?: "new" | "used";
seasons_left?: number | null;
comment?: string | null;
reason_code?: string | null;
},
): Promise<StocktakeLine> {
return api
.patch(`wh/stocktakes/${stocktakeId}/finds/${lineId}`, { json: body })
.json<StocktakeLine>();
}
/**
* Убрать строку из черновика. Сервер разрешает только находку: обычную строку
* не заводил человек — она означает «эту позицию надо обойти», и её удаление
* молча вычеркнуло бы позицию из пересчёта.
*/
export async function deleteStocktakeLine(
stocktakeId: number,
lineId: number,
): Promise<{ ok: boolean }> {
return api
.delete(`wh/stocktakes/${stocktakeId}/lines/${lineId}`)
.json<{ ok: boolean }>();
}
export async function applyStocktake(id: number): Promise<StocktakeDetail> {
return api.post(`wh/stocktakes/${id}/apply`).json<StocktakeDetail>();
}
export async function deleteStocktake(id: number): Promise<{ ok: boolean }> {
return api.delete(`wh/stocktakes/${id}`).json<{ ok: boolean }>();
}
// ── Сезонная выдача резины ─────────────────────────────────────────────────
//
// Комплект живёт на машине от осени до следующей осени, поэтому выдача — не
// разовое списание, а документ со статусом. Закрыть предыдущий комплект
// (вернули / списали / не найден) обязательно, иначе сервер отвечает 409.
/** Три градации состояния. На сервере это «сколько сезонов осталось»: 2/1/0. */
export type TyreGrade = "good" | "season" | "worn";
export const TYRE_GRADE_LABEL: Record<TyreGrade, string> = {
good: "Хорошая",
season: "На сезон",
worn: "Под списание",
};
export interface TyreStockRow {
part_id: number;
name: string;
size: string | null;
condition: string;
qty: number;
by_grade: Partial<Record<TyreGrade, number>>;
places: string[];
suggested: boolean;
/** Подтверждённая применимость к выбранной машине. */
fits: boolean;
}
/** Докладка в выданный комплект — ещё колесо на ту же машину. */
export interface TyreAddition {
id: number;
part_id: number;
part_name: string | null;
qty: number;
grade: TyreGrade | null;
created_at: string;
created_by: string | null;
comment: string | null;
}
export interface TyreSet {
id: number;
car_id: number | null;
car_number: string | null;
driver_id: number | null;
driver_fio: string | null;
part_id: number;
part_name: string | null;
size: string | null;
season: string;
qty: number;
place_name: string | null;
issued_at: string;
issued_by: string | null;
grade_out: TyreGrade | null;
status: "on_car" | "returned" | "scrapped" | "lost";
closed_at: string | null;
closed_by: string | null;
grade_in: TyreGrade | null;
close_comment: string | null;
comment: string | null;
/** Докладки. `qty` выше их уже включает: это все колёса на машине. */
additions?: TyreAddition[];
}
export interface TyreContext {
car_id: number;
car_number: string | null;
brand: string | null;
model: string | null;
driver_id: number | null;
driver_fio: string | null;
suggested_size: string | null;
open_set: TyreSet | null;
stock: TyreStockRow[];
/** Известно ли, что подходит машине. false — фильтровать нечем, показываем всё. */
fit_known: boolean;
}
export interface TyreClose {
action: "returned" | "scrapped" | "lost";
grade?: TyreGrade;
place_id?: number | null;
comment?: string | null;
}
export async function getTyreContext(carId: number): Promise<TyreContext> {
return api.get(`wh/tyres/context?car_id=${carId}`).json<TyreContext>();
}
export async function issueTyres(
body: {
car_id: number;
part_id: number;
qty: number;
grade: TyreGrade;
season?: "winter" | "summer";
place_id?: number | null;
comment?: string | null;
close?: TyreClose | null;
/** Доложить в открытый комплект вместо выдачи нового (тогда close не нужен). */
add_to_open?: boolean;
},
idempotencyKey: string,
): Promise<TyreSet> {
// Ключ идемпотентности обязателен: телефон у подъёмника теряет связь и
// ретраит, а повтор — это ещё четыре покрышки со склада.
return api
.post("wh/tyres/issue", { json: body, headers: { "Idempotency-Key": idempotencyKey } })
.json<TyreSet>();
}
export interface TyreSetsResponse {
items: TyreSet[];
total: number;
on_car: number;
}
export async function getTyreSets(params?: { status?: string; limit?: number }): Promise<TyreSetsResponse> {
const qs = new URLSearchParams();
if (params?.status) qs.set("status", params.status);
if (params?.limit) qs.set("limit", String(params.limit));
const s = qs.toString();
return api.get(`wh/tyres/sets${s ? `?${s}` : ""}`).json<TyreSetsResponse>();
}
export interface TyreSizeRow {
brand: string | null;
model: string | null;
tyre_size: string | null;
cars_count: number;
}
export async function getTyreSizes(): Promise<TyreSizeRow[]> {
return api.get("wh/tyres/sizes").json<TyreSizeRow[]>();
}
export async function setTyreSize(body: {
brand: string;
model: string;
tyre_size: string | null;
}): Promise<TyreSizeRow> {
return api.put("wh/tyres/sizes", { json: body }).json<TyreSizeRow>();
}
/** Вся резина в наличии — подсказка размеров в справочнике. */
export async function getTyreStock(): Promise<TyreStockRow[]> {
return api.get("wh/tyres/stock").json<TyreStockRow[]>();
}
// ── Выдача запчастей на машину (задача 5763) ──────────────────────────────
//
// Отдельно от списания в ремонт: механик ставит деталь на машину, а карточки
// ремонта под это может и не быть. Строки — по номенклатуре, партию выбирает
// склад; недостача уходит в минус, как у ремонта и резины.
export interface PartsIssueLineIn {
part_id: number;
qty: number;
}
export interface PartsIssueLine {
batch_id: number;
part_id: number;
part_name: string;
qty: number;
unit_price: number | string;
amount: number | string;
}
export interface PartsIssue {
id: number;
repair_id: number | null;
car_id: number | null;
car_number: string | null;
car_brand: string | null;
car_model: string | null;
comment: string | null;
user_id: number | null;
user_name: string | null;
total_amount: number | string;
lines: PartsIssueLine[];
created_at: string;
}
export interface PartsIssueListResponse {
items: PartsIssue[];
total: number;
}
/** Выдать детали на машину. Ключ идемпотентности живёт, пока открыта форма:
* ретрай после обрыва связи попадает в ту же выдачу, а не создаёт вторую. */
export async function issueParts(
body: { car_id: number; lines: PartsIssueLineIn[]; comment?: string | null },
idempotencyKey: string,
): Promise<PartsIssue> {
return api
.post("wh/issues", { json: body, headers: { "Idempotency-Key": idempotencyKey } })
.json<PartsIssue>();
}
export async function getPartsIssues(params?: {
car_id?: number;
without_repair?: boolean;
limit?: number;
}): Promise<PartsIssueListResponse> {
const qs = new URLSearchParams();
if (params?.car_id) qs.set("car_id", String(params.car_id));
if (params?.without_repair) qs.set("without_repair", "true");
if (params?.limit) qs.set("limit", String(params.limit));
const s = qs.toString();
return api.get(`wh/issues${s ? `?${s}` : ""}`).json<PartsIssueListResponse>();
}
@@ -1,7 +1,13 @@
import { useState } from "react"; import { useMemo, useState } from "react";
import { CameraCapture } from "./CameraCapture"; import { CameraCapture } from "./CameraCapture";
import { AuthImg } from "@/components/AuthImg"; import { AuthImg } from "@/components/AuthImg";
import { uploadPhoto } from "@/api/photos"; import { compressImage } from "@/lib/imageCompress";
import {
enqueuePhoto,
retryItem,
usePhotoQueue,
useSlotUploaded,
} from "@/lib/photoQueue";
import { toast } from "sonner"; import { toast } from "sonner";
interface Props { interface Props {
@@ -22,19 +28,33 @@ export function PhotoSlot({
onUploaded, onUploaded,
}: Props) { }: Props) {
const [photoId, setPhotoId] = useState<number | undefined>(initialPhotoId); const [photoId, setPhotoId] = useState<number | undefined>(initialPhotoId);
const [uploading, setUploading] = useState(false); const queue = usePhotoQueue();
// Последний элемент очереди этого слота (могут быть при пересъёмке).
const mine = useMemo(
() =>
[...queue]
.reverse()
.find(
(i) => i.inspectionId === inspectionId && i.side === side && i.slotIndex === slotIndex,
),
[queue, inspectionId, side, slotIndex],
);
// Фото доехало фоновым насосом — показываем превью.
useSlotUploaded(inspectionId, side, slotIndex, (id) => {
setPhotoId(id);
onUploaded?.(id);
});
async function handleCapture(file: File) { async function handleCapture(file: File) {
setUploading(true);
try { try {
const result = await uploadPhoto(inspectionId, side, slotIndex, file); // Сжимаем до ~1600px: по LTE оригинал в 3–8 МБ грузится дольше,
setPhotoId(result.id); // чем живёт осмотр, — терялись целые серии (задача 6929).
onUploaded?.(result.id); const compressed = await compressImage(file);
toast.success(`${label}: загружено`); await enqueuePhoto({ inspectionId, side, slotIndex, blob: compressed });
} catch { } catch {
toast.error(`${label}: ошибка загрузки`); toast.error(`${label}: не удалось поставить фото в очередь`);
} finally {
setUploading(false);
} }
} }
@@ -52,8 +72,23 @@ export function PhotoSlot({
onCapture={handleCapture} onCapture={handleCapture}
buttonLabel={photoId ? "Заменить" : "Снять"} buttonLabel={photoId ? "Заменить" : "Снять"}
/> />
{uploading && ( {mine?.status === "failed" ? (
<div className="text-xs text-muted-foreground">Загружаю…</div> <div className="text-xs text-destructive space-y-1">
<div>Не загрузилось ({mine.attempts} попыток)</div>
<button
type="button"
className="underline"
onClick={() => void retryItem(mine.id)}
>
Повторить
</button>
</div>
) : (
mine && (
<div className="text-xs text-muted-foreground">
{mine.status === "uploading" ? "Загружаю…" : "В очереди на загрузку…"}
</div>
)
)} )}
</div> </div>
); );
@@ -0,0 +1,133 @@
/**
* Пикер детали из складского каталога — общий для формы создания и формы
* правки ремонта (по образцу WorksPickerModal: состояние поиска живёт внутри,
* наружу отдаётся только выбранная позиция).
*
* Свободного ввода нет намеренно: деталь ремонта — это реальная складская
* позиция, которая списывается с остатка. Нет в каталоге → сначала карточка
* на складе.
*
* По умолчанию показываем только то, что подходит этой машине ИЛИ вообще не
* привязано к марке; «Показать все» снимает фильтр (страховка, пока
* применимость не набита). У ремонта «с улицы» машины парка нет — carId=null,
* и бэкенд отдаёт каталог целиком.
*/
import { useEffect, useState } from "react";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import { searchParts, type PartCatalogItem } from "@/api/repairsCreate";
interface Props {
open: boolean;
carId: number | null;
onPick: (item: PartCatalogItem) => void;
onClose: () => void;
}
export default function PartsPickerModal({ open, carId, onPick, onClose }: Props) {
const [q, setQ] = useState("");
const [showAll, setShowAll] = useState(false);
const [results, setResults] = useState<PartCatalogItem[]>([]);
const [loading, setLoading] = useState(false);
const load = async (query: string, all: boolean) => {
setLoading(true);
try {
setResults(await searchParts(query, carId, all));
} catch {
setResults([]);
} finally {
setLoading(false);
}
};
// Открытие = свежий поиск с чистого листа: прошлый запрос механика к этому
// моменту уже неактуален, а его остатки на экране читаются как «не нашлось».
useEffect(() => {
if (!open) return;
setQ("");
setShowAll(false);
void load("", false);
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [open, carId]);
if (!open) return null;
const toggleShowAll = () => {
const next = !showAll;
setShowAll(next);
void load(q, next);
};
return (
<div className="fixed inset-0 z-50 bg-background/95 flex flex-col">
<header className="border-b p-3 flex items-center gap-2">
<Button variant="ghost" size="sm" onClick={onClose}>
Отмена
</Button>
<Input
autoFocus
placeholder="Поиск детали — название или артикул…"
value={q}
onChange={(e) => {
setQ(e.target.value);
void load(e.target.value, showAll);
}}
/>
</header>
{carId != null && (
<div className="border-b px-3 py-2 flex items-center justify-between">
<span className="text-xs text-muted-foreground">
{showAll ? "Все детали каталога" : "Подходящие этой машине"}
</span>
<button
type="button"
onClick={toggleShowAll}
className="text-xs font-medium text-primary underline-offset-2 hover:underline"
>
{showAll ? "← Только подходящие" : "Показать все →"}
</button>
</div>
)}
<main className="flex-1 overflow-y-auto">
<ul className="divide-y">
{results.map((p) => (
<li key={p.id}>
<button
type="button"
onClick={() => onPick(p)}
className="w-full text-left p-3 hover:bg-accent/40 flex items-center justify-between gap-3"
>
<span className="flex-1 min-w-0">
<span className="block truncate">
{p.fits && <span className="text-primary mr-1">✓</span>}
{p.name}
</span>
<span className="block text-xs text-muted-foreground truncate">
{p.article ? `арт. ${p.article}` : "без артикула"}
{p.brand ? ` · ${p.brand}` : ""}
</span>
</span>
<span
className={`text-sm whitespace-nowrap ${
p.in_stock < 0 ? "text-destructive" : "text-muted-foreground"
}`}
>
{p.in_stock === 0 ? "нет" : `${p.in_stock} шт`}
</span>
</button>
</li>
))}
{!loading && results.length === 0 && (
<li className="p-6 text-center text-sm text-muted-foreground">
{q
? "Ничего не найдено. Если детали нет в каталоге — заведите карточку на складе."
: "Нет подходящих деталей. Нажмите «Показать все» или заведите карточку на складе."}
</li>
)}
{loading && <li className="p-6 text-center text-sm text-muted-foreground">Загрузка…</li>}
</ul>
</main>
</div>
);
}
@@ -0,0 +1,67 @@
import { useState } from "react";
import { render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { vi } from "vitest";
import QtyStepper from "@/components/repairs/QtyStepper";
/** Обёртка с реальным стейтом — баг был именно в связке ввод↔стейт. */
function Harness({ start = 1 }: { start?: number | "" }) {
const [qty, setQty] = useState<number | "">(start);
return (
<>
<QtyStepper value={qty} onChange={setQty} />
<span data-testid="out">{qty === "" ? "empty" : qty}</span>
</>
);
}
test("количество можно стереть и набрать заново (жалоба «4 свечи»)", async () => {
const user = userEvent.setup();
render(<Harness start={1} />);
const input = screen.getByRole("spinbutton");
await user.clear(input);
// Ключевой момент: пустое поле ОСТАЁТСЯ пустым. Раньше сюда мгновенно
// возвращалась единица, и «4» превращалось в «14».
expect(screen.getByTestId("out")).toHaveTextContent("empty");
await user.type(input, "4");
expect(screen.getByTestId("out")).toHaveTextContent("4");
});
test("пустое поле на blur превращается в 1, а не в 0", async () => {
const user = userEvent.setup();
render(<Harness start={3} />);
const input = screen.getByRole("spinbutton");
await user.clear(input);
await user.tab();
expect(screen.getByTestId("out")).toHaveTextContent("1");
});
test("кнопки −/+ меняют количество и не уводят ниже минимума", async () => {
const user = userEvent.setup();
render(<Harness start={1} />);
const minus = screen.getByLabelText("Меньше");
const plus = screen.getByLabelText("Больше");
expect(minus).toBeDisabled(); // на единице уменьшать нечего
await user.click(plus);
await user.click(plus);
await user.click(plus);
expect(screen.getByTestId("out")).toHaveTextContent("4");
await user.click(minus);
expect(screen.getByTestId("out")).toHaveTextContent("3");
});
test("тап по полю выделяет значение — цифра заменяет его, а не дописывается", async () => {
const user = userEvent.setup();
const onChange = vi.fn();
render(<QtyStepper value={1} onChange={onChange} />);
await user.type(screen.getByRole("spinbutton"), "2");
// 2, а не 12: без select-on-focus набор поверх единицы давал бы «12»,
// и это ровно тот сорт сюрприза, на который жаловались механики.
expect(onChange).toHaveBeenCalledWith(2);
// Число, а не строка — иначе qty уехал бы в payload строкой.
expect(typeof onChange.mock.calls[0][0]).toBe("number");
});
@@ -0,0 +1,66 @@
/**
* Количество детали в ремонте: −/+ и поле ввода.
*
* Почему не просто <input type="number">. Пустое поле обязано ОСТАВАТЬСЯ
* пустым, пока человек печатает. Если на каждый onChange приводить значение
* к минимуму (`Math.max(1, Number(v))`), то стирание единицы мгновенно
* возвращает единицу — и набрать «4» становится невозможно: цифра
* дописывается к ней («14»). Ровно на это пожаловались механики, и ровно так
* же однажды залипал ноль в цене работы.
*
* Поэтому "" — легальное промежуточное состояние стейта, а к разумному
* значению приводим на blur (и ещё раз на отправке формы).
*
* Кнопки −/+ здесь не украшение: 4 свечи набираются в перчатках одним
* пальцем, а мобильная цифровая клавиатура для этого слишком долгая.
*/
import { Minus, Plus } from "lucide-react";
import { Input } from "@/components/ui/input";
interface Props {
value: number | "";
onChange: (next: number | "") => void;
min?: number;
disabled?: boolean;
}
export default function QtyStepper({ value, onChange, min = 1, disabled }: Props) {
const current = value === "" ? min : value;
return (
<div className="flex items-center gap-1">
<button
type="button"
disabled={disabled || current <= min}
onClick={() => onChange(Math.max(min, current - 1))}
aria-label="Меньше"
className="h-9 w-9 rounded-md border flex items-center justify-center disabled:opacity-40 active:bg-accent"
>
<Minus className="h-4 w-4" />
</button>
<Input
type="number"
inputMode="numeric"
min={min}
value={value}
disabled={disabled}
onChange={(e) => onChange(e.target.value === "" ? "" : Number(e.target.value))}
onFocus={(e) => e.currentTarget.select()}
onBlur={() => {
const n = value === "" ? min : Math.floor(Number(value));
onChange(Number.isFinite(n) && n >= min ? n : min);
}}
className="w-14 text-center"
/>
<button
type="button"
disabled={disabled}
onClick={() => onChange(current + 1)}
aria-label="Больше"
className="h-9 w-9 rounded-md border flex items-center justify-center disabled:opacity-40 active:bg-accent"
>
<Plus className="h-4 w-4" />
</button>
</div>
);
}
@@ -0,0 +1,74 @@
/**
* Выбор машины парка по госномеру — общий для складских экранов PWA
* (выдача резины, выдача запчастей).
*
* Поиск с задержкой 200 мс: у подъёмника номер набирают по буквам, и запрос
* на каждую букву по слабой связи только замедлит список. Пока новый ответ не
* пришёл, на экране остаётся прошлый список — без мигания «Загрузка…» на
* каждую букву.
*/
import { useEffect, useState } from "react";
import { keepPreviousData, useQuery } from "@tanstack/react-query";
import { Search } from "lucide-react";
import { Input } from "@/components/ui/input";
import { searchCars } from "@/api/repairsCreate";
function useDebounced<T>(value: T, ms: number): T {
const [debounced, setDebounced] = useState(value);
useEffect(() => {
const t = setTimeout(() => setDebounced(value), ms);
return () => clearTimeout(t);
}, [value, ms]);
return debounced;
}
export default function CarPicker({ onPick }: { onPick: (carId: number) => void }) {
const [q, setQ] = useState("");
const debouncedQ = useDebounced(q, 200);
const carsQuery = useQuery({
queryKey: ["cars-search", debouncedQ],
queryFn: () => searchCars(debouncedQ),
placeholderData: keepPreviousData,
staleTime: 30_000,
});
const cars = carsQuery.data ?? [];
const loading = carsQuery.isLoading;
return (
<>
<div className="px-3 py-3 border-b">
<div className="relative">
<Search className="absolute left-2.5 top-1/2 -translate-y-1/2 h-4 w-4 text-muted-foreground" />
<Input
autoFocus
placeholder="Госномер…"
value={q}
onChange={(e) => setQ(e.target.value)}
className="pl-8"
/>
</div>
</div>
<main className="flex-1 divide-y">
{loading && <p className="p-4 text-sm text-muted-foreground">Загрузка…</p>}
{!loading && cars.length === 0 && (
<p className="p-4 text-sm text-muted-foreground">
{carsQuery.isError ? "Не удалось загрузить список машин" : "Ничего не нашлось"}
</p>
)}
{cars.map((c) => (
<button
key={c.id}
onClick={() => onPick(c.id)}
className="w-full text-left p-3 active:bg-muted flex items-baseline gap-3"
>
<span className="font-mono font-semibold">{c.plate ?? "—"}</span>
<span className="text-sm text-muted-foreground">
{[c.brand, c.model].filter(Boolean).join(" ")}
</span>
</button>
))}
</main>
</>
);
}
@@ -0,0 +1,19 @@
import { describe, expect, it } from "vitest";
import { scaleFor } from "@/lib/imageCompress";
describe("scaleFor", () => {
it("ужимает по длинной стороне", () => {
expect(scaleFor(4000, 3000)).toBeCloseTo(0.4);
expect(scaleFor(3000, 1000)).toBeCloseTo(1600 / 3000);
expect(scaleFor(900, 4000)).toBeCloseTo(0.4);
});
it("меньше лимита — не масштабирует", () => {
expect(scaleFor(1000, 800)).toBe(1);
expect(scaleFor(1600, 900)).toBe(1);
});
it("нулевые размеры — единица (не делить на ноль)", () => {
expect(scaleFor(0, 0)).toBe(1);
});
});
@@ -0,0 +1,61 @@
/**
* Сжатие фото перед отправкой на сервер (задача 6929: «теряются фото осмотров»).
*
* Камера отдаёт JPEG по 3–8 МБ; по LTE такой файл грузится десятки секунд,
* механик завершал осмотр и закрывал PWA раньше, чем заканчивалась загрузка —
* фото терялись молча. Сжимаем до 1600px по длинной стороне (≈300–500 КБ):
* для карточки осмотра и сравнения повреждений этого достаточно с запасом,
* а грузится в ~10 раз быстрее.
*
* Если декодировать не удалось (экзотический формат/нет canvas) — отдаём
* оригинал: медленная загрузка лучше потерянного фото.
*/
const MAX_EDGE_PX = 1600;
const JPEG_QUALITY = 0.82;
/** Уже компактный файл не пережимаем — только время теряем. */
const SKIP_IF_SMALLER_BYTES = 400_000;
/** Во сколько раз уместить картинку в maxEdge (чистая функция — для тестов). */
export function scaleFor(width: number, height: number, maxEdge = MAX_EDGE_PX): number {
const longest = Math.max(width, height);
if (longest <= 0) return 1;
return Math.min(1, maxEdge / longest);
}
function decode(file: File): Promise<HTMLImageElement> {
return new Promise((resolve, reject) => {
const url = URL.createObjectURL(file);
const img = new Image();
img.onload = () => {
URL.revokeObjectURL(url);
resolve(img);
};
img.onerror = () => {
URL.revokeObjectURL(url);
reject(new Error("image decode failed"));
};
img.src = url;
});
}
export async function compressImage(file: File): Promise<File> {
if (file.size <= SKIP_IF_SMALLER_BYTES) return file;
try {
const img = await decode(file);
const scale = scaleFor(img.naturalWidth, img.naturalHeight);
if (scale >= 1) return file;
const canvas = document.createElement("canvas");
canvas.width = Math.round(img.naturalWidth * scale);
canvas.height = Math.round(img.naturalHeight * scale);
const ctx = canvas.getContext("2d");
if (!ctx) return file;
ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
const blob = await new Promise<Blob | null>((resolve) =>
canvas.toBlob(resolve, "image/jpeg", JPEG_QUALITY),
);
if (!blob || blob.size >= file.size) return file;
return new File([blob], "photo.jpg", { type: "image/jpeg" });
} catch {
return file;
}
}
@@ -0,0 +1,43 @@
/**
* Ужать снимок перед отправкой на распознавание.
*
* Телефон отдаёт кадр на 4000+ px и 3–5 МБ, а сервер всё равно приводит
* накладную к 2200 px по длинной стороне — значит всё, что выше, это чистые
* секунды загрузки на мобильном интернете в гараже. Ужимаем на клиенте до
* того же предела: качество распознавания не меняется, отправка ускоряется
* в разы.
*
* 2200 — именно то, на чём работает vision-модель (см. invoice_ocr.py).
* Мельче нельзя: текст накладной и так на грани читаемости.
*/
const MAX_EDGE = 2200;
const QUALITY = 0.9;
export async function downscaleImage(file: File, maxEdge = MAX_EDGE): Promise<Blob> {
// Если что-то в цепочке не поддержано (старый WebView) — шлём оригинал:
// медленно, но рабочее лучше, чем ошибка.
try {
const bitmap = await createImageBitmap(file);
const scale = Math.min(1, maxEdge / Math.max(bitmap.width, bitmap.height));
if (scale >= 1) {
bitmap.close();
return file;
}
const canvas = document.createElement("canvas");
canvas.width = Math.round(bitmap.width * scale);
canvas.height = Math.round(bitmap.height * scale);
const ctx = canvas.getContext("2d");
if (!ctx) {
bitmap.close();
return file;
}
ctx.drawImage(bitmap, 0, 0, canvas.width, canvas.height);
bitmap.close();
const blob = await new Promise<Blob | null>((resolve) =>
canvas.toBlob(resolve, "image/jpeg", QUALITY),
);
return blob ?? file;
} catch {
return file;
}
}
@@ -0,0 +1,87 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
// Очередь должна жить без сети: мокаем транспорт целиком.
vi.mock("@/api/photos", () => ({
requestUploadUrl: vi.fn(async () => ({
photo_id: 7,
presigned_url: "https://s3/put",
storage_key: "mechanic/inspections/1/x.jpg",
})),
uploadToS3: vi.fn(async () => undefined),
confirmPhoto: vi.fn(async () => ({ id: 7, status: "ready" })),
}));
import { confirmPhoto, requestUploadUrl, uploadToS3 } from "@/api/photos";
import {
_resetForTests,
_setSleepForTests,
enqueuePhoto,
getSnapshot,
onUploaded,
retryItem,
} from "@/lib/photoQueue";
import type { UploadedEvent } from "@/lib/photoQueue";
const BLOB = new Blob(["bytes"], { type: "image/jpeg" });
beforeEach(() => {
vi.clearAllMocks();
// Явно восстанавливаем «успешный» транспорт: mockRejectedValue из
// отдельных кейсов персистентен и без этого протекает в следующие тесты.
vi.mocked(requestUploadUrl).mockImplementation(async () => ({
photo_id: 7,
presigned_url: "https://s3/put",
storage_key: "mechanic/inspections/1/x.jpg",
}));
vi.mocked(uploadToS3).mockImplementation(async () => undefined);
vi.mocked(confirmPhoto).mockImplementation(async () => ({ id: 7, status: "ready" }));
_resetForTests();
// Бэкофф между повторами не ждём по-настоящему.
_setSleepForTests(async () => undefined);
});
describe("photoQueue", () => {
it("успешная загрузка очищает очередь и стреляет событием слота", async () => {
const events: UploadedEvent[] = [];
onUploaded((e) => events.push(e));
await enqueuePhoto({ inspectionId: 1, side: "front", slotIndex: 0, blob: BLOB });
await vi.waitFor(() => expect(getSnapshot()).toHaveLength(0));
expect(requestUploadUrl).toHaveBeenCalledTimes(1);
expect(confirmPhoto).toHaveBeenCalledWith(1, 7, { actual_size: BLOB.size });
expect(events).toEqual([
{ inspectionId: 1, side: "front", slotIndex: 0, photoId: 7 },
]);
});
it("сбой сети — 5 попыток, потом failed (фото не теряем молча)", async () => {
vi.mocked(uploadToS3).mockRejectedValue(new Error("network down"));
await enqueuePhoto({ inspectionId: 2, side: "rear", slotIndex: 0, blob: BLOB });
await vi.waitFor(() => expect(getSnapshot()[0]?.status).toBe("failed"));
expect(uploadToS3).toHaveBeenCalledTimes(5);
expect(getSnapshot()[0]?.attempts).toBe(5);
});
it("retryItem сбрасывает счётчик и доигрывает успешно", async () => {
vi.mocked(uploadToS3).mockRejectedValueOnce(new Error("flaky"));
await enqueuePhoto({ inspectionId: 3, side: "left", slotIndex: 0, blob: BLOB });
await vi.waitFor(() => expect(getSnapshot()).toHaveLength(0));
expect(uploadToS3).toHaveBeenCalledTimes(2); // 1 неудача + успешный повтор
});
it("после исчерпания попыток retry поднимает фото заново", async () => {
vi.mocked(uploadToS3).mockRejectedValue(new Error("down"));
await enqueuePhoto({ inspectionId: 4, side: "vin", slotIndex: 0, blob: BLOB });
await vi.waitFor(() => expect(getSnapshot()[0]?.status).toBe("failed"));
vi.mocked(uploadToS3).mockResolvedValue(undefined);
await retryItem(getSnapshot()[0]!.id);
await vi.waitFor(() => expect(getSnapshot()).toHaveLength(0));
});
});
+270
View File
@@ -0,0 +1,270 @@
/**
* Персистентная очередь загрузки фото осмотра (задача 6929).
*
* Раньше фото грузилось inline в момент снимка, и если механик закрывал
* PWA до конца PUT — фото терялось навсегда (в БД висела строка 'pending',
* а объекта в хранилище не было). Теперь снимок (уже сжатый) кладётся в
* очередь на IndexedDB и уходит фоном: строго по одному, с повторами.
* Очередь переживает закрытие приложения и доигрывается при следующем
* запуске; «Завершить осмотр» блокируется, пока есть недогруженные фото.
*
* Если IndexedDB недоступен (приватный режим) — очередь живёт в памяти:
* хуже, чем персистентно, но лучше, чем терять фото сразу.
*/
import { useEffect } from "react";
import { useSyncExternalStore } from "react";
import { confirmPhoto, requestUploadUrl, uploadToS3 } from "@/api/photos";
export interface QueuedPhoto {
id: string;
inspectionId: number;
side: string;
slotIndex: number;
blob: Blob;
attempts: number;
createdAt: number;
status: "queued" | "uploading" | "failed";
}
export interface UploadedEvent {
inspectionId: number;
side: string;
slotIndex: number;
photoId: number;
}
const DB_NAME = "pp-mechanic-photoq";
const STORE = "photos";
const MAX_ATTEMPTS = 5;
const RETRY_BASE_MS = 4000;
// ── Хранилище: IndexedDB с фолбэком в память ───────────────────────────────
let idb: IDBDatabase | null | undefined; // undefined = ещё не пробовали открыть
function openIdb(): Promise<IDBDatabase | null> {
return new Promise((resolve) => {
if (typeof indexedDB === "undefined") return resolve(null);
try {
const req = indexedDB.open(DB_NAME, 1);
req.onupgradeneeded = () => {
const db = req.result;
if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE, { keyPath: "id" });
};
req.onsuccess = () => resolve(req.result);
req.onerror = () => resolve(null);
} catch {
resolve(null);
}
});
}
function idbPut(item: QueuedPhoto): Promise<void> {
return new Promise((resolve) => {
if (!idb) return resolve();
try {
const tx = idb.transaction(STORE, "readwrite");
// Blob кладётся в IndexedDB как есть (structured clone умеет Blob).
tx.objectStore(STORE).put(item);
tx.oncomplete = () => resolve();
tx.onerror = () => resolve();
} catch {
resolve();
}
});
}
function idbDelete(id: string): Promise<void> {
return new Promise((resolve) => {
if (!idb) return resolve();
try {
const tx = idb.transaction(STORE, "readwrite");
tx.objectStore(STORE).delete(id);
tx.oncomplete = () => resolve();
tx.onerror = () => resolve();
} catch {
resolve();
}
});
}
// ── Состояние в памяти + подписка для React ────────────────────────────────
let items: QueuedPhoto[] = [];
let snapshot: QueuedPhoto[] = items;
const listeners = new Set<() => void>();
const uploadedHandlers = new Set<(e: UploadedEvent) => void>();
function commit(): void {
snapshot = [...items];
for (const l of listeners) l();
}
export function subscribe(cb: () => void): () => void {
listeners.add(cb);
return () => listeners.delete(cb);
}
export function getSnapshot(): QueuedPhoto[] {
return snapshot;
}
/** Реактивный доступ к очереди (useSyncExternalStore). */
export function usePhotoQueue(): QueuedPhoto[] {
return useSyncExternalStore(subscribe, getSnapshot);
}
export function onUploaded(cb: (e: UploadedEvent) => void): () => void {
uploadedHandlers.add(cb);
return () => uploadedHandlers.delete(cb);
}
/** Хук: дождаться загрузки фото конкретного слота (для превью в PhotoSlot). */
export function useSlotUploaded(
inspectionId: number,
side: string,
slotIndex: number,
cb: (photoId: number) => void,
): void {
useEffect(
() =>
onUploaded((e) => {
if (e.inspectionId === inspectionId && e.side === side && e.slotIndex === slotIndex) {
cb(e.photoId);
}
}),
// cb намеренно не в зависимостях: слот живёт всей жизнью страницы,
// а колбэк — стабильно замкнут над setState.
// eslint-disable-next-line react-hooks/exhaustive-deps
[inspectionId, side, slotIndex],
);
}
/** Сколько фото этого осмотра ещё не долетело (ошибки не считаем). */
export function pendingCountFor(inspectionId: number): number {
return items.filter((i) => i.inspectionId === inspectionId && i.status !== "failed").length;
}
// ── Насос: сериальная догрузка с повторами ─────────────────────────────────
let sleepImpl: (ms: number) => Promise<void> = (ms) => new Promise((r) => setTimeout(r, ms));
/** Тесты подменяют сон, чтобы не ждать бэкоффы по-настоящему. */
export function _setSleepForTests(fn: (ms: number) => Promise<void>): void {
sleepImpl = fn;
}
let draining = false;
async function uploadOne(item: QueuedPhoto): Promise<number> {
const contentType = item.blob.type || "image/jpeg";
const presign = await requestUploadUrl(item.inspectionId, {
side: item.side,
slot_index: item.slotIndex,
content_type: contentType,
size: item.blob.size,
});
await uploadToS3(presign, item.blob, contentType);
await confirmPhoto(item.inspectionId, presign.photo_id, {
actual_size: item.blob.size,
});
return presign.photo_id;
}
export async function drainQueue(): Promise<void> {
if (draining) return;
draining = true;
try {
for (;;) {
const item = items.find((i) => i.status === "queued");
if (!item) break;
item.status = "uploading";
commit();
try {
const photoId = await uploadOne(item);
items = items.filter((i) => i.id !== item.id);
commit();
await idbDelete(item.id);
for (const h of uploadedHandlers) {
h({ inspectionId: item.inspectionId, side: item.side, slotIndex: item.slotIndex, photoId });
}
} catch {
item.attempts += 1;
item.status = item.attempts >= MAX_ATTEMPTS ? "failed" : "queued";
commit();
await idbPut(item);
if (item.status === "queued") await sleepImpl(RETRY_BASE_MS * item.attempts);
}
}
} finally {
draining = false;
}
}
// ── Публичное API ──────────────────────────────────────────────────────────
export async function enqueuePhoto(args: {
inspectionId: number;
side: string;
slotIndex: number;
blob: Blob;
}): Promise<void> {
const item: QueuedPhoto = {
id: crypto.randomUUID(),
attempts: 0,
createdAt: Date.now(),
status: "queued",
...args,
};
items.push(item);
commit();
await idbPut(item);
void drainQueue();
}
/** Повторить сломанное фото (кнопка «Повторить» в слоте). */
export async function retryItem(id: string): Promise<void> {
const item = items.find((i) => i.id === id);
if (!item) return;
item.attempts = 0;
item.status = "queued";
commit();
await idbPut(item);
void drainQueue();
}
let initialized = false;
/** Разовая инициализация при старте приложения: поднять IDB и доиграть хвосты. */
export async function initPhotoQueue(): Promise<void> {
if (initialized) return;
initialized = true;
if (idb === undefined) idb = await openIdb();
if (idb) {
const stored = await new Promise<QueuedPhoto[]>((resolve) => {
try {
const tx = idb!.transaction(STORE, "readonly");
const req = tx.objectStore(STORE).getAll();
req.onsuccess = () => resolve((req.result as QueuedPhoto[]) ?? []);
req.onerror = () => resolve([]);
} catch {
resolve([]);
}
});
// «uploading» из прошлого запуска = загрузка оборвалась закрытием приложения.
for (const s of stored) {
if (s.status === "uploading") s.status = "queued";
items.push(s);
}
commit();
}
if (items.length > 0) void drainQueue();
}
/** Только для тестов: очистить состояние модуля между кейсами. */
export function _resetForTests(): void {
items = [];
commit();
draining = false;
initialized = false;
}
+4
View File
@@ -4,12 +4,16 @@ import { BrowserRouter } from "react-router-dom";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query"; import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { Toaster } from "sonner"; import { Toaster } from "sonner";
import App from "./App"; import App from "./App";
import { initPhotoQueue } from "@/lib/photoQueue";
import "./index.css"; import "./index.css";
const queryClient = new QueryClient({ const queryClient = new QueryClient({
defaultOptions: { queries: { retry: 1, staleTime: 30_000 } }, defaultOptions: { queries: { retry: 1, staleTime: 30_000 } },
}); });
// Доиграть фото осмотров, не долетевшие в прошлом запуске (задача 6929).
void initPhotoQueue();
ReactDOM.createRoot(document.getElementById("root")!).render( ReactDOM.createRoot(document.getElementById("root")!).render(
<React.StrictMode> <React.StrictMode>
<QueryClientProvider client={queryClient}> <QueryClientProvider client={queryClient}>
+52 -13
View File
@@ -1,7 +1,5 @@
import type { ComponentType } from "react";
import { useNavigate } from "react-router-dom"; import { useNavigate } from "react-router-dom";
import { useQuery } from "@tanstack/react-query"; import { useQuery } from "@tanstack/react-query";
import { ClipboardCheck, History, Wrench } from "lucide-react";
import { getMe } from "@/api/me"; import { getMe } from "@/api/me";
import { logout } from "@/api/auth"; import { logout } from "@/api/auth";
import { Card } from "@/components/ui/card"; import { Card } from "@/components/ui/card";
@@ -11,8 +9,10 @@ interface ActionTile {
key: string; key: string;
title: string; title: string;
description: string; description: string;
// Иконка из lucide-react (пак всего PWA); эмодзи в интерфейсе не используем. // Эмодзи, а не иконка из пака — осознанное исключение из правила проекта:
icon: ComponentType<{ className?: string }>; // владелец хочет цветные плитки в меню (24.09.2026), монохромные lucide
// откатили по его просьбе.
emoji: string;
onClick: () => void; onClick: () => void;
disabled?: boolean; disabled?: boolean;
comingSoon?: boolean; comingSoon?: boolean;
@@ -27,23 +27,65 @@ export default function ActionMenu() {
key: "inspect", key: "inspect",
title: "Осмотр", title: "Осмотр",
description: "Создать или продолжить осмотр машины", description: "Создать или продолжить осмотр машины",
icon: ClipboardCheck, emoji: "🔍",
onClick: () => navigate("/vehicles?action=inspect"), onClick: () => navigate("/vehicles?action=inspect"),
}, },
{ {
key: "repair", key: "repair",
title: "Ремонт", title: "Ремонт",
description: "Лента ремонтов парка + создать новый", description: "Лента ремонтов парка + создать новый",
icon: Wrench, emoji: "🔧",
onClick: () => navigate("/repairs"), onClick: () => navigate("/repairs"),
}, },
{ {
key: "repair-history", key: "repair-history",
title: "История ремонта", title: "История ремонта",
description: "Что чинили на машине — поиск по госномеру", description: "Что чинили на машине — поиск по госномеру",
icon: History, emoji: "📜",
onClick: () => navigate("/repairs/history"), onClick: () => navigate("/repairs/history"),
}, },
// Выдача запчастей на машину без ремонта (задача 5763) — всему отделу
// авторемонта, то есть каждому, кто вошёл в приложение.
{
key: "issues",
title: "Выдача запчастей",
description: "Списать детали со склада на машину — без карточки ремонта",
emoji: "🔩",
onClick: () => navigate("/wh/issues"),
},
// Приёмка и инвентаризация правят остатки и деньги — пока только админам
// (тот же гейт стоит на сервере, здесь просто не показываем лишнего).
...(meQuery.data?.is_admin
? [
{
key: "receiving",
title: "Приёмка",
description: "Снять накладную камерой и оприходовать товар",
emoji: "📦",
onClick: () => navigate("/wh/receiving"),
},
{
key: "stocktake",
title: "Инвентаризация",
description: "Пересчитать зону склада и провести расхождения",
emoji: "📋",
onClick: () => navigate("/wh/stocktake"),
},
]
: []),
// Выдача резины — по складскому праву (не только админам): признак
// warehouse:tyres приходит в /me, если у механика есть право склада.
...(meQuery.data?.is_admin || meQuery.data?.permissions?.includes("warehouse:tyres")
? [
{
key: "tyres",
title: "Выдача резины",
description: "Сезонная переобувка: выдать комплект и закрыть старый",
emoji: "🛞",
onClick: () => navigate("/wh/tyres"),
},
]
: []),
]; ];
return ( return (
@@ -72,9 +114,7 @@ export default function ActionMenu() {
Что делаем? Что делаем?
</h2> </h2>
<div className="grid grid-cols-1 sm:grid-cols-2 gap-3"> <div className="grid grid-cols-1 sm:grid-cols-2 gap-3">
{tiles.map((t) => { {tiles.map((t) => (
const Icon = t.icon;
return (
<Card <Card
key={t.key} key={t.key}
onClick={t.disabled ? undefined : t.onClick} onClick={t.disabled ? undefined : t.onClick}
@@ -86,7 +126,7 @@ export default function ActionMenu() {
} }
> >
<div className="flex items-start gap-3"> <div className="flex items-start gap-3">
<Icon className="h-8 w-8 shrink-0 text-muted-foreground" /> <div className="text-3xl leading-none">{t.emoji}</div>
<div className="flex-1 min-w-0"> <div className="flex-1 min-w-0">
<div className="flex items-center gap-2"> <div className="flex items-center gap-2">
<h3 className="font-semibold text-base">{t.title}</h3> <h3 className="font-semibold text-base">{t.title}</h3>
@@ -102,8 +142,7 @@ export default function ActionMenu() {
</div> </div>
</div> </div>
</Card> </Card>
); ))}
})}
</div> </div>
</main> </main>
</div> </div>
@@ -10,6 +10,8 @@ import {
type MarkerSummary, type MarkerSummary,
} from "@/api/inspections"; } from "@/api/inspections";
import { uploadPhoto, uploadPhotoAnnotation } from "@/api/photos"; import { uploadPhoto, uploadPhotoAnnotation } from "@/api/photos";
import { compressImage } from "@/lib/imageCompress";
import { usePhotoQueue } from "@/lib/photoQueue";
import { PhotoSlot } from "@/components/camera/PhotoSlot"; import { PhotoSlot } from "@/components/camera/PhotoSlot";
import { CameraCapture } from "@/components/camera/CameraCapture"; import { CameraCapture } from "@/components/camera/CameraCapture";
import { VendorVehicleScheme } from "@/components/vehicle-scheme/VendorVehicleScheme"; import { VendorVehicleScheme } from "@/components/vehicle-scheme/VendorVehicleScheme";
@@ -113,6 +115,13 @@ export default function InspectionEditor() {
// draft отличается от сохранённого (см. notesDirty ниже). // draft отличается от сохранённого (см. notesDirty ниже).
const [notesDraft, setNotesDraft] = useState<string>(""); const [notesDraft, setNotesDraft] = useState<string>("");
// Очередь догрузки фото (задача 6929): завершать осмотр можно только
// когда все снимки доехали — раньше закрытие приложения убивало загрузку.
const queue = usePhotoQueue();
const uploadingCount = queue.filter(
(i) => i.inspectionId === insId && i.status !== "failed",
).length;
useEffect(() => { loadZoneLabels().then(setZoneLabels); }, []); useEffect(() => { loadZoneLabels().then(setZoneLabels); }, []);
const { data: ins, isLoading, isError } = useQuery({ const { data: ins, isLoading, isError } = useQuery({
@@ -161,9 +170,18 @@ export default function InspectionEditor() {
if (isError || !ins) if (isError || !ins)
return <div className="p-8 text-destructive">Осмотр не найден.</div>; return <div className="p-8 text-destructive">Осмотр не найден.</div>;
// Photos lookup by side+slot for initialPhotoId // Photos lookup by side+slot for initialPhotoId. Потерянные (failed) фото
// не подставляем — слот должен предлагать снять заново; при нескольких
// строках на слот (пересъёмка после сбоя) предпочитаем готовую.
const photosBySide = new Map<string, typeof ins.photos[0]>(); const photosBySide = new Map<string, typeof ins.photos[0]>();
for (const p of ins.photos) photosBySide.set(`${p.side}-${p.slot_index}`, p); for (const p of ins.photos) {
if (p.status === "failed") continue;
const key = `${p.side}-${p.slot_index}`;
const cur = photosBySide.get(key);
if (!cur || (cur.status !== "ready" && p.status === "ready")) {
photosBySide.set(key, p);
}
}
// Photos lookup by id — нужен для marker thumb (annotated vs original) // Photos lookup by id — нужен для marker thumb (annotated vs original)
const photosById = new Map<number, typeof ins.photos[0]>(); const photosById = new Map<number, typeof ins.photos[0]>();
for (const p of ins.photos) photosById.set(p.id, p); for (const p of ins.photos) photosById.set(p.id, p);
@@ -341,7 +359,7 @@ export default function InspectionEditor() {
setFlow({ kind: "idle" }); setFlow({ kind: "idle" });
return; return;
} }
const result = await uploadPhoto(insId, "free", 0, flow.photoFile); const result = await uploadPhoto(insId, "free", 0, await compressImage(flow.photoFile));
if (annotated) { if (annotated) {
try { try {
await uploadPhotoAnnotation(insId, result.id, annotated); await uploadPhotoAnnotation(insId, result.id, annotated);
@@ -497,9 +515,13 @@ export default function InspectionEditor() {
<Button <Button
className="w-full" className="w-full"
onClick={() => finalize.mutate()} onClick={() => finalize.mutate()}
disabled={finalize.isPending} disabled={finalize.isPending || uploadingCount > 0}
> >
{finalize.isPending ? "Завершаем…" : "Завершить осмотр"} {uploadingCount > 0
? `Догружаю фото (${uploadingCount})…`
: finalize.isPending
? "Завершаем…"
: "Завершить осмотр"}
</Button> </Button>
)} )}
</div> </div>
@@ -14,6 +14,7 @@ import { AuthImg } from "@/components/AuthImg";
import { ttImageUrl } from "@/api/vehicles"; import { ttImageUrl } from "@/api/vehicles";
import { VendorVehicleScheme } from "@/components/vehicle-scheme/VendorVehicleScheme"; import { VendorVehicleScheme } from "@/components/vehicle-scheme/VendorVehicleScheme";
import { Card } from "@/components/ui/card"; import { Card } from "@/components/ui/card";
import { Button } from "@/components/ui/button";
import { loadZoneLabels } from "@/data/zoneLabels"; import { loadZoneLabels } from "@/data/zoneLabels";
const STATUS_LABELS: Record<string, string> = { const STATUS_LABELS: Record<string, string> = {
@@ -138,6 +139,19 @@ export default function InspectionReview() {
onError: () => toast.error("Не удалось сохранить заметку"), onError: () => toast.error("Не удалось сохранить заметку"),
}); });
// Осмотр закрыт не механиком, а автоматикой — вернуть в работу и дать
// доснять. Без этой кнопки механик, вернувшийся через три часа, упирается в
// заблокированную карточку и вынужден заводить осмотр заново.
const reopenMutation = useMutation({
mutationFn: () => patchInspection(insId, { status: "in_progress" }),
onSuccess: (updated) => {
queryClient.setQueryData(["inspection", insId], updated);
queryClient.invalidateQueries({ queryKey: ["vehicle"] });
navigate(`/inspections/${insId}/edit`);
},
onError: () => toast.error("Не удалось вернуть осмотр в работу"),
});
if (isLoading) return <div className="p-8 text-muted-foreground">Загружаю…</div>; if (isLoading) return <div className="p-8 text-muted-foreground">Загружаю…</div>;
if (isError || !ins) if (isError || !ins)
return <div className="p-8 text-destructive">Осмотр не найден.</div>; return <div className="p-8 text-destructive">Осмотр не найден.</div>;
@@ -152,6 +166,10 @@ export default function InspectionReview() {
// фото повреждений) + tt_image_id из маркеров (carry-over из Element). Без // фото повреждений) + tt_image_id из маркеров (carry-over из Element). Без
// tt_image_id counter недоучитывал импортированные дефекты — видно на // tt_image_id counter недоучитывал импортированные дефекты — видно на
// осмотрах, где почти все маркеры пришли из вендора. // осмотрах, где почти все маркеры пришли из вендора.
// «failed» — фото, чья загрузка оборвалась (объекта в хранилище нет):
// в сетке не показываем и в счётчик не считаем, количество выводим отдельно.
const visiblePhotos = ins.photos.filter((p: PhotoSummary) => p.status !== "failed");
const failedPhotoCount = ins.photos.length - visiblePhotos.length;
const markerPhotoIds = ins.markers const markerPhotoIds = ins.markers
.map((m: MarkerSummary) => m.photo_id) .map((m: MarkerSummary) => m.photo_id)
.filter((id): id is number => id != null); .filter((id): id is number => id != null);
@@ -159,7 +177,7 @@ export default function InspectionReview() {
.map((m: MarkerSummary) => m.tt_image_id) .map((m: MarkerSummary) => m.tt_image_id)
.filter((id): id is string => !!id); .filter((id): id is string => !!id);
const uniquePhotoIds = Array.from( const uniquePhotoIds = Array.from(
new Set([...ins.photos.map((p: PhotoSummary) => p.id), ...markerPhotoIds]) new Set([...visiblePhotos.map((p: PhotoSummary) => p.id), ...markerPhotoIds])
); );
const uniqueTtIds = Array.from(new Set(markerTtIds)); const uniqueTtIds = Array.from(new Set(markerTtIds));
const totalPhotoCount = uniquePhotoIds.length + uniqueTtIds.length; const totalPhotoCount = uniquePhotoIds.length + uniqueTtIds.length;
@@ -231,8 +249,35 @@ export default function InspectionReview() {
{ins.mileage.toLocaleString("ru-RU")} км {ins.mileage.toLocaleString("ru-RU")} км
</div> </div>
)} )}
{failedPhotoCount > 0 && (
<div className="text-destructive">
<span className="font-semibold">Не загрузилось фото: </span>
{failedPhotoCount} — загрузка оборвалась при осмотре
</div>
)}
</Card> </Card>
{ins.meta?.auto_completed === true && (
<Card className="p-4 space-y-3 border-amber-500/40 bg-amber-500/10">
<div className="text-sm">
<div className="font-semibold">Закрыт автоматически</div>
<p className="mt-1 text-muted-foreground leading-relaxed">
Осмотр несколько часов никто не открывал, поэтому система завершила
его сама — чтобы фотографии не пропали из отчётов. Если работа не
доделана, верните осмотр в работу и продолжите.
</p>
</div>
<Button
variant="outline"
className="w-full"
onClick={() => reopenMutation.mutate()}
disabled={reopenMutation.isPending}
>
{reopenMutation.isPending ? "Открываю…" : "Продолжить осмотр"}
</Button>
</Card>
)}
<Card className="p-4 space-y-2"> <Card className="p-4 space-y-2">
<h2 className="text-sm font-semibold text-muted-foreground"> <h2 className="text-sm font-semibold text-muted-foreground">
Заметки механика Заметки механика
@@ -291,7 +336,7 @@ export default function InspectionReview() {
<div className="text-sm text-muted-foreground">Нет фото.</div> <div className="text-sm text-muted-foreground">Нет фото.</div>
) : ( ) : (
<div className="grid grid-cols-2 gap-2"> <div className="grid grid-cols-2 gap-2">
{ins.photos.map((p: PhotoSummary) => ( {visiblePhotos.map((p: PhotoSummary) => (
<Card <Card
key={p.id} key={p.id}
className="overflow-hidden cursor-pointer" className="overflow-hidden cursor-pointer"
@@ -0,0 +1,117 @@
/**
* Журнал выдач запчастей.
*
* Отвечает на вопрос «эту деталь на эту машину уже брали?» — поэтому по
* умолчанию показывает и выдачи на машину, и списания в ремонт: физически это
* одно и то же событие «деталь ушла со склада», а различаются они только тем,
* есть ли карточка ремонта. Переключатель оставляет только выдачи без ремонта.
*/
import { useState } from "react";
import { useNavigate } from "react-router-dom";
import { useQuery } from "@tanstack/react-query";
import { ChevronLeft } from "lucide-react";
import { Button } from "@/components/ui/button";
import { getPartsIssues, type PartsIssue } from "@/api/warehouse";
const FILTERS: { key: boolean; label: string }[] = [
{ key: false, label: "Все" },
{ key: true, label: "Без ремонта" },
];
function fmtDateTime(iso: string): string {
const d = new Date(iso);
return Number.isNaN(d.getTime())
? iso
: new Intl.DateTimeFormat("ru-RU", {
day: "2-digit",
month: "2-digit",
year: "numeric",
hour: "2-digit",
minute: "2-digit",
}).format(d);
}
export default function PartsIssueJournalPage() {
const navigate = useNavigate();
const [withoutRepair, setWithoutRepair] = useState(false);
const q = useQuery({
queryKey: ["parts-issues", withoutRepair],
queryFn: () => getPartsIssues({ without_repair: withoutRepair, limit: 100 }),
staleTime: 15_000,
});
const items = q.data?.items ?? [];
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center gap-2 p-3">
<Button variant="ghost" size="sm" className="-ml-2" onClick={() => navigate("/wh/issues")}>
<ChevronLeft className="h-5 w-5" />
</Button>
<div>
<h1 className="text-base font-semibold">Журнал выдач</h1>
<p className="text-xs text-muted-foreground">всего записей: {q.data?.total ?? 0}</p>
</div>
</div>
<div className="flex gap-2 px-3 pb-3">
{FILTERS.map((f) => (
<Button
key={String(f.key)}
variant={withoutRepair === f.key ? "default" : "outline"}
size="sm"
onClick={() => setWithoutRepair(f.key)}
>
{f.label}
</Button>
))}
</div>
</header>
<main className="flex-1 divide-y">
{q.isLoading && <p className="p-4 text-sm text-muted-foreground">Загрузка…</p>}
{!q.isLoading && items.length === 0 && (
<p className="p-4 text-sm text-muted-foreground">Выдач пока не было.</p>
)}
{items.map((it) => (
<IssueRow key={it.id} issue={it} />
))}
</main>
</div>
);
}
function IssueRow({ issue }: { issue: PartsIssue }) {
return (
<div className="p-3">
<div className="flex items-baseline justify-between gap-2">
<span className="flex items-baseline gap-2 min-w-0">
<span className="font-mono font-semibold">{issue.car_number ?? "—"}</span>
<span className="text-sm text-muted-foreground truncate">
{[issue.car_brand, issue.car_model].filter(Boolean).join(" ")}
</span>
</span>
<span className="text-xs text-muted-foreground whitespace-nowrap">
{fmtDateTime(issue.created_at)}
</span>
</div>
<ul className="mt-1 text-sm">
{issue.lines.map((ln, i) => (
<li key={`${ln.batch_id}-${i}`} className="flex justify-between gap-2">
<span className="truncate">{ln.part_name}</span>
<span className="text-muted-foreground whitespace-nowrap">{ln.qty} шт</span>
</li>
))}
</ul>
<p className="text-xs text-muted-foreground mt-1">
{[
issue.repair_id ? `ремонт #${issue.repair_id}` : "без ремонта",
issue.user_name,
issue.comment,
]
.filter(Boolean)
.join(" · ")}
</p>
</div>
);
}
@@ -0,0 +1,242 @@
/**
* Выдача запчастей на машину — экран механика (задача 5763).
*
* Сценарий: деталь ставится на машину, а карточки ремонта под это нет
* (расходник, мелочь, донор). Выбрал машину → набрал детали со склада →
* комментарий → выдал. Со склада списывается сразу; партию выбирает склад,
* недостача уходит в минус — как в ремонте и резине: механика у подъёмника
* из-за неоприходованного прихода не останавливаем.
*
* Доступ — у всех, кто входит в приложение (весь отдел авторемонта): так
* решил постановщик задачи.
*/
import { useMemo, useState } from "react";
import { useNavigate, useSearchParams } from "react-router-dom";
import { useQuery } from "@tanstack/react-query";
import { ChevronLeft, History, Plus, Trash2 } from "lucide-react";
import { toast } from "sonner";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import CarPicker from "@/components/warehouse/CarPicker";
import PartsPickerModal from "@/components/repairs/PartsPickerModal";
import QtyStepper from "@/components/repairs/QtyStepper";
import { getCarContext, type PartCatalogItem } from "@/api/repairsCreate";
import { apiErrorText, issueParts } from "@/api/warehouse";
interface Line {
part_id: number;
name: string;
article: string | null;
in_stock: number;
qty: number | "";
}
/** «Выдать 3 позиции» — по числу строк, а не штук: механик считает позициями. */
function issueLabel(n: number): string {
if (n === 0) return "Добавьте хотя бы одну деталь";
const mod10 = n % 10;
const mod100 = n % 100;
const noun =
mod10 === 1 && mod100 !== 11
? "позицию"
: mod10 >= 2 && mod10 <= 4 && (mod100 < 12 || mod100 > 14)
? "позиции"
: "позиций";
return `Выдать ${n} ${noun}`;
}
export default function PartsIssuePage() {
const navigate = useNavigate();
const [sp, setSp] = useSearchParams();
const carId = sp.get("car") ? Number(sp.get("car")) : null;
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center justify-between p-3">
<div className="flex items-center gap-2">
<Button
variant="ghost"
size="sm"
className="-ml-2"
onClick={() => (carId ? setSp({}, { replace: true }) : navigate("/"))}
>
<ChevronLeft className="h-5 w-5" />
</Button>
<h1 className="text-base font-semibold">Выдача запчастей</h1>
</div>
<Button variant="ghost" size="sm" onClick={() => navigate("/wh/issues/journal")}>
<History className="h-4 w-4 mr-1" />
Журнал
</Button>
</div>
</header>
{carId ? (
// key — чтобы смена машины давала чистую форму и новый ключ идемпотентности.
<IssueForm key={carId} carId={carId} onDone={() => setSp({}, { replace: true })} />
) : (
<CarPicker onPick={(id) => setSp({ car: String(id) }, { replace: true })} />
)}
</div>
);
}
function IssueForm({ carId, onDone }: { carId: number; onDone: () => void }) {
const ctxQuery = useQuery({
queryKey: ["car-ctx", carId],
queryFn: () => getCarContext(carId),
staleTime: 60_000,
});
const ctx = ctxQuery.data;
const [lines, setLines] = useState<Line[]>([]);
const [pickerOpen, setPickerOpen] = useState(false);
const [comment, setComment] = useState("");
const [saving, setSaving] = useState(false);
// Ключ идемпотентности живёт, пока форма открыта: ретрай после обрыва связи
// должен попасть в ТУ ЖЕ выдачу, а не создать вторую.
const [idemKey] = useState(() => crypto.randomUUID());
const addPart = (p: PartCatalogItem) => {
setLines((arr) => {
const existing = arr.find((l) => l.part_id === p.id);
// Та же деталь второй раз — плюс одна штука, а не вторая строка.
if (existing) {
return arr.map((l) =>
l.part_id === p.id ? { ...l, qty: (l.qty === "" ? 0 : l.qty) + 1 } : l,
);
}
return [...arr, { part_id: p.id, name: p.name, article: p.article, in_stock: p.in_stock, qty: 1 }];
});
setPickerOpen(false);
};
const setQty = (partId: number, qty: number | "") =>
setLines((arr) => arr.map((l) => (l.part_id === partId ? { ...l, qty } : l)));
const removeLine = (partId: number) =>
setLines((arr) => arr.filter((l) => l.part_id !== partId));
// Пустое поле количества — легальное состояние во время набора (см. QtyStepper);
// на отправке приводим к единице.
const normalized = useMemo(
() => lines.map((l) => ({ part_id: l.part_id, qty: l.qty === "" || l.qty < 1 ? 1 : l.qty })),
[lines],
);
const shortages = lines.filter((l) => {
const q = l.qty === "" ? 1 : l.qty;
return q > l.in_stock;
});
const submit = async () => {
if (normalized.length === 0) {
toast.error("Добавьте хотя бы одну деталь");
return;
}
setSaving(true);
try {
const issued = await issueParts(
{ car_id: carId, lines: normalized, comment: comment.trim() || null },
idemKey,
);
const total = issued.lines.reduce((s, ln) => s + ln.qty, 0);
toast.success(`Выдано ${total} шт · ${issued.car_number ?? ""}`.trim());
onDone();
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось выдать запчасти"));
setSaving(false);
}
};
if (ctxQuery.isLoading) {
return <main className="p-4 text-sm text-muted-foreground">Загрузка…</main>;
}
if (!ctx) {
return <main className="p-4 text-sm text-destructive">Не удалось загрузить машину</main>;
}
return (
<main className="flex-1 pb-28">
{/* Машина и арендатор */}
<section className="p-3 border-b">
<div className="flex items-baseline gap-3">
<span className="font-mono text-lg font-semibold">{ctx.plate ?? "—"}</span>
<span className="text-sm text-muted-foreground">
{[ctx.brand, ctx.model].filter(Boolean).join(" ")}
</span>
</div>
<p className="text-sm text-muted-foreground mt-0.5">
{ctx.driver_name ? `Водитель: ${ctx.driver_name}` : "Водитель не определён"}
</p>
</section>
{/* Что выдаём */}
<section className="p-3 border-b">
<div className="flex items-center justify-between mb-2">
<h2 className="text-sm font-semibold">Что выдаём</h2>
<Button variant="outline" size="sm" onClick={() => setPickerOpen(true)}>
<Plus className="h-3 w-3 mr-1" />
Добавить деталь
</Button>
</div>
{lines.length === 0 ? (
<p className="text-sm text-muted-foreground">
Детали выбираются со склада и списываются сразу при выдаче.
</p>
) : (
<ul className="space-y-2">
{lines.map((l) => (
<li key={l.part_id} className="flex items-center gap-2 text-sm">
<div className="flex-1 min-w-0">
<div className="truncate">{l.name}</div>
<div className="text-xs text-muted-foreground">
{l.article ? `арт. ${l.article} · ` : ""}
{l.in_stock > 0
? `на складе: ${l.in_stock}`
: l.in_stock < 0
? `на складе: ${l.in_stock}`
: "нет в наличии"}
</div>
</div>
<QtyStepper value={l.qty} onChange={(next) => setQty(l.part_id, next)} />
<Button variant="ghost" size="sm" onClick={() => removeLine(l.part_id)} aria-label="Убрать">
<Trash2 className="h-3 w-3" />
</Button>
</li>
))}
</ul>
)}
{shortages.length > 0 && (
<p className="text-sm text-amber-700 dark:text-amber-500 mt-2">
{shortages.length === 1
? `«${shortages[0].name}» — на складе меньше, чем выдаём. Склад уйдёт в минус, выдать можно.`
: `По ${shortages.length} позициям на складе меньше, чем выдаём. Склад уйдёт в минус, выдать можно.`}
</p>
)}
</section>
{/* Комментарий */}
<section className="p-3 border-b">
<Input
placeholder="Комментарий (необязательно) — что и зачем поставили"
value={comment}
onChange={(e) => setComment(e.target.value)}
/>
</section>
{/* Кнопка выдачи */}
<div className="fixed bottom-0 left-0 right-0 border-t bg-background p-3">
<Button className="w-full" disabled={saving || lines.length === 0} onClick={submit}>
{saving ? "Выдаём…" : issueLabel(lines.length)}
</Button>
</div>
<PartsPickerModal
open={pickerOpen}
carId={carId}
onPick={addPart}
onClose={() => setPickerOpen(false)}
/>
</main>
);
}
@@ -0,0 +1,134 @@
/**
* Карточка проведённого прихода — только чтение.
*
* Накладная — исторический документ: имена и артикулы показываем снимками
* на момент приёмки, а не текущими из каталога. Правки нет намеренно:
* проведённый приход уже стал партиями и движениями, и «поправить» его
* означало бы разъехаться с журналом. Ошиблись — удаление/сторно делается
* в CRM, где видно все последствия.
*
* Единственное, что берётся из «сегодня» — сколько от каждой партии ещё
* лежит на складе: по нему сразу видно, что уже разошлось.
*/
import { useNavigate, useParams } from "react-router-dom";
import { useQuery } from "@tanstack/react-query";
import { ChevronLeft } from "lucide-react";
import { Button } from "@/components/ui/button";
import { fmtMoney } from "@/lib/repairsFeed";
import { getReceipt } from "@/api/warehouse";
function fmtDate(iso: string | null): string {
if (!iso) return "—";
const d = new Date(iso);
if (Number.isNaN(d.getTime())) return iso;
return new Intl.DateTimeFormat("ru-RU", {
day: "2-digit", month: "long", year: "numeric",
}).format(d);
}
export default function ReceiptDetailPage() {
const { id } = useParams<{ id: string }>();
const navigate = useNavigate();
const query = useQuery({
queryKey: ["wh-receipt", Number(id)],
queryFn: () => getReceipt(Number(id)),
staleTime: 60_000,
});
const r = query.data;
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center justify-between p-3">
<Button variant="ghost" size="sm" onClick={() => navigate("/wh/receiving")} className="-ml-2">
<ChevronLeft className="h-5 w-5" />
<span className="ml-1">Назад</span>
</Button>
<h1 className="text-base font-semibold">Приход</h1>
<span className="w-16" />
</div>
</header>
<main className="flex-1 container max-w-2xl py-4 space-y-4">
{query.isLoading && <div className="h-24 rounded-lg bg-muted animate-pulse" />}
{query.isError && (
<div className="rounded-md border border-destructive bg-destructive/10 p-3 text-sm">
Не удалось загрузить приход.
</div>
)}
{r && (
<>
<section className="rounded-lg border bg-card p-3 space-y-1">
<div className="text-base font-semibold">{r.supplier_name || "Поставщик не указан"}</div>
<div className="text-sm text-muted-foreground">
{r.doc_number ? `Накладная ${r.doc_number} · ` : ""}
{fmtDate(r.doc_date)}
</div>
{r.posted_by_name && (
<div className="text-xs text-muted-foreground">Провёл: {r.posted_by_name}</div>
)}
{r.comment && <div className="text-xs text-muted-foreground italic">{r.comment}</div>}
<div className="pt-2 flex items-baseline justify-between border-t mt-2">
<span className="text-sm text-muted-foreground">
Позиций: {r.lines.length}
</span>
<span className="text-lg font-semibold tabular-nums">
{fmtMoney(Number(r.total_amount))} ₽
</span>
</div>
</section>
<section className="rounded-lg border bg-card overflow-hidden">
<div className="px-3 py-2 border-b bg-muted/40 text-sm font-semibold">Состав</div>
<ul className="divide-y">
{r.lines.map((ln) => (
<li key={ln.batch_id} className="p-3 flex items-start gap-3">
{ln.thumb_url ? (
<img
src={ln.thumb_url}
alt=""
loading="lazy"
className="h-10 w-10 rounded border object-cover flex-shrink-0"
/>
) : (
<div className="h-10 w-10 rounded border bg-muted flex-shrink-0" />
)}
<div className="flex-1 min-w-0">
<div className="text-sm truncate">{ln.part_name}</div>
<div className="text-xs text-muted-foreground truncate">
{ln.article ? `арт. ${ln.article}` : "без артикула"}
{ln.place_code ? ` · ${ln.place_code}` : ""}
</div>
<div className="text-xs text-muted-foreground mt-0.5">
{ln.qty} × {fmtMoney(Number(ln.unit_price))} ₽
{" · "}
<RemainHint qty={ln.qty} remaining={ln.qty_remaining} />
</div>
</div>
<div className="text-sm font-medium whitespace-nowrap tabular-nums">
{fmtMoney(Number(ln.amount))} ₽
</div>
</li>
))}
</ul>
</section>
<p className="text-xs text-muted-foreground px-1">
Приход уже проведён — правка и удаление только в CRM, чтобы не
разошлись остатки и журнал.
</p>
</>
)}
</main>
</div>
);
}
function RemainHint({ qty, remaining }: { qty: number; remaining: number }) {
if (remaining === qty) return <span>лежит целиком</span>;
if (remaining <= 0) return <span>разошлось полностью</span>;
return <span>осталось {remaining}</span>;
}
@@ -0,0 +1,380 @@
/**
* Проверка распознанной накладной перед проведением.
*
* Распознавание почти никогда не идеально: путается артикул, съезжает цена,
* поставщик может быть новым. Поэтому экран построен как сверка — фото
* документа сверху всегда под рукой, а каждая строка правится на месте.
*
* Приход создаётся только по кнопке «Провести»: до неё черновик ничего не
* меняет на складе, и его можно спокойно бросить.
*/
import { useEffect, useState } from "react";
import { useNavigate, useParams } from "react-router-dom";
import { useQuery, useQueryClient } from "@tanstack/react-query";
import { ChevronLeft, Loader2, Plus, Trash2, X } from "lucide-react";
import { toast } from "sonner";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import { Label } from "@/components/ui/label";
import { fmtMoney } from "@/lib/repairsFeed";
import {
addDraftLine,
createDraftSupplier,
deleteDraftLine,
getDraft,
getPlaces,
getSuppliers,
patchDraft,
patchDraftLine,
postDraft,
rejectDraft,
type Draft,
} from "@/api/warehouse";
function lineSum(qty: number, price: number | string): number {
return qty * Number(price || 0);
}
export default function ReceivingDraftPage() {
const { id } = useParams<{ id: string }>();
const draftId = Number(id);
const navigate = useNavigate();
const queryClient = useQueryClient();
const [draft, setDraft] = useState<Draft | null>(null);
const [loading, setLoading] = useState(true);
const [busy, setBusy] = useState(false);
const [placeId, setPlaceId] = useState<number | null>(null);
const [lightbox, setLightbox] = useState<string | null>(null);
const placesQuery = useQuery({ queryKey: ["wh-places"], queryFn: getPlaces, staleTime: 300_000 });
const suppliersQuery = useQuery({
queryKey: ["wh-suppliers"],
queryFn: getSuppliers,
staleTime: 300_000,
});
useEffect(() => {
if (!draftId) return;
setLoading(true);
getDraft(draftId)
.then(setDraft)
.catch((e: Error) => toast.error(e.message || "Не удалось загрузить черновик"))
.finally(() => setLoading(false));
}, [draftId]);
// Обёртка над правками: сервер всегда возвращает черновик целиком, поэтому
// локально ничего не пересчитываем — берём его ответ как истину.
const mutate = async (fn: () => Promise<Draft>) => {
setBusy(true);
try {
setDraft(await fn());
} catch (e) {
toast.error((e as Error).message || "Не удалось сохранить");
} finally {
setBusy(false);
}
};
const total = (draft?.lines ?? []).reduce((s, l) => s + lineSum(l.qty, l.unit_price), 0);
const unmatched = (draft?.lines ?? []).filter((l) => !l.matched_part_id).length;
const onPost = async () => {
if (!draft) return;
if (!draft.supplier_id) {
toast.error("Укажите поставщика — без него приход не провести");
return;
}
if (draft.lines.length === 0) {
toast.error("В накладной нет позиций");
return;
}
setBusy(true);
try {
const r = await postDraft(draft.id, { place_id: placeId, doc_date: draft.order_date });
toast.success(`Приход проведён · позиций ${r.lines}`);
// Списки на входе в раздел кэшируются — после проведения они устарели.
await queryClient.invalidateQueries({ queryKey: ["wh-drafts"] });
await queryClient.invalidateQueries({ queryKey: ["wh-receipts"] });
// Сразу показываем, что получилось, — карточкой прихода.
navigate(`/wh/receipts/${r.receipt_id}`, { replace: true });
} catch (e) {
toast.error((e as Error).message || "Не удалось провести приход");
setBusy(false);
}
};
const onReject = async () => {
if (!draft) return;
if (!window.confirm("Отклонить накладную? Остатки не изменятся, черновик уйдёт из списка.")) return;
setBusy(true);
try {
await rejectDraft(draft.id);
toast.success("Черновик отклонён");
navigate("/wh/receiving", { replace: true });
} catch (e) {
toast.error((e as Error).message || "Не удалось отклонить");
setBusy(false);
}
};
return (
<div className="min-h-screen bg-background flex flex-col pb-24">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center justify-between p-3">
<Button variant="ghost" size="sm" onClick={() => navigate("/wh/receiving")} className="-ml-2">
<ChevronLeft className="h-5 w-5" />
<span className="ml-1">Назад</span>
</Button>
<h1 className="text-base font-semibold">Проверка накладной</h1>
<span className="w-16" />
</div>
</header>
<main className="flex-1 container max-w-2xl py-4 space-y-5">
{loading && <div className="h-24 rounded-lg bg-muted animate-pulse" />}
{draft && (
<>
{/* Фото документа — сверять глазами по ходу правки */}
{draft.photo_urls.length > 0 && (
<div className="flex gap-2 overflow-x-auto pb-1">
{draft.photo_urls.map((u) => (
<button key={u} type="button" onClick={() => setLightbox(u)} className="flex-shrink-0">
<img
src={u}
alt="Накладная"
loading="lazy"
className="h-28 w-auto rounded-md border bg-muted object-cover"
/>
</button>
))}
</div>
)}
{/* Шапка документа */}
<section className="rounded-lg border bg-card p-3 space-y-3">
<div>
<Label className="text-xs">Поставщик</Label>
{draft.supplier_id ? (
<select
className="mt-1 w-full rounded-md border bg-background px-3 py-2 text-sm"
value={draft.supplier_id}
disabled={busy}
onChange={(e) => void mutate(() =>
patchDraft(draft.id, { supplier_id: Number(e.target.value) }))}
>
{(suppliersQuery.data ?? []).map((s) => (
<option key={s.id} value={s.id}>{s.name}</option>
))}
</select>
) : (
<div className="mt-1 space-y-2">
<div className="text-sm text-destructive">
Не определён{draft.legal_entity ? ` — в документе «${draft.legal_entity}»` : ""}
</div>
<div className="flex gap-2">
<select
className="flex-1 rounded-md border bg-background px-3 py-2 text-sm"
defaultValue=""
disabled={busy}
onChange={(e) => e.target.value && void mutate(() =>
patchDraft(draft.id, { supplier_id: Number(e.target.value) }))}
>
<option value="" disabled>Выбрать из списка…</option>
{(suppliersQuery.data ?? []).map((s) => (
<option key={s.id} value={s.id}>{s.name}</option>
))}
</select>
{draft.legal_entity && (
<Button
variant="outline"
disabled={busy}
onClick={() => void mutate(() =>
createDraftSupplier(draft.id, {
name: draft.legal_entity!, legal_entity: draft.legal_entity,
}))}
>
Завести
</Button>
)}
</div>
</div>
)}
</div>
<div className="grid grid-cols-2 gap-2">
<div>
<Label className="text-xs">Номер документа</Label>
<Input
defaultValue={draft.ext_order_id}
disabled={busy}
onBlur={(e) => e.target.value !== draft.ext_order_id &&
void mutate(() => patchDraft(draft.id, { doc_number: e.target.value }))}
/>
</div>
<div>
<Label className="text-xs">Дата</Label>
<Input
type="date"
defaultValue={draft.order_date ?? ""}
disabled={busy}
onChange={(e) => void mutate(() =>
patchDraft(draft.id, { order_date: e.target.value || null }))}
/>
</div>
</div>
<div>
<Label className="text-xs">Зона хранения (куда кладём)</Label>
<select
className="mt-1 w-full rounded-md border bg-background px-3 py-2 text-sm"
value={placeId ?? ""}
onChange={(e) => setPlaceId(e.target.value ? Number(e.target.value) : null)}
>
<option value="">Без зоны</option>
{(placesQuery.data ?? []).map((p) => (
<option key={p.id} value={p.id}>{p.code} — {p.name}</option>
))}
</select>
</div>
</section>
{/* Позиции */}
<section className="space-y-2">
<div className="flex items-baseline justify-between">
<h2 className="text-sm font-semibold">Позиции · {draft.lines.length}</h2>
{unmatched > 0 && (
<span className="text-xs text-amber-700">
новых карточек: {unmatched}
</span>
)}
</div>
{draft.lines.map((ln) => (
<div key={ln.id} className="rounded-lg border bg-card p-3 space-y-2">
<div className="flex items-start gap-2">
{ln.thumb_url && (
<img
src={ln.thumb_url}
alt=""
loading="lazy"
className="h-10 w-10 rounded border object-cover flex-shrink-0"
/>
)}
<Input
defaultValue={ln.name}
disabled={busy}
className="flex-1"
onBlur={(e) => e.target.value !== ln.name &&
void mutate(() => patchDraftLine(draft.id, ln.id, { name: e.target.value }))}
/>
<Button
variant="ghost"
size="sm"
disabled={busy}
onClick={() => void mutate(() => deleteDraftLine(draft.id, ln.id))}
>
<Trash2 className="h-4 w-4" />
</Button>
</div>
<div className="grid grid-cols-3 gap-2">
<div>
<Label className="text-[11px] text-muted-foreground">Артикул</Label>
<Input
defaultValue={ln.article ?? ""}
disabled={busy}
onBlur={(e) => (e.target.value || null) !== ln.article &&
void mutate(() => patchDraftLine(draft.id, ln.id, { article: e.target.value || null }))}
/>
</div>
<div>
<Label className="text-[11px] text-muted-foreground">Кол-во</Label>
<Input
type="number"
inputMode="numeric"
min={1}
defaultValue={ln.qty}
disabled={busy}
onBlur={(e) => Number(e.target.value) !== ln.qty &&
void mutate(() => patchDraftLine(draft.id, ln.id, {
qty: Math.max(1, Number(e.target.value) || 1),
}))}
/>
</div>
<div>
<Label className="text-[11px] text-muted-foreground">Цена</Label>
<Input
type="number"
inputMode="decimal"
min={0}
defaultValue={Number(ln.unit_price)}
disabled={busy}
onBlur={(e) => Number(e.target.value) !== Number(ln.unit_price) &&
void mutate(() => patchDraftLine(draft.id, ln.id, {
unit_price: Number(e.target.value) || 0,
}))}
/>
</div>
</div>
<div className="flex items-center justify-between text-xs">
<span className={ln.matched_part_id ? "text-muted-foreground" : "text-amber-700"}>
{ln.matched_part_id
? `на складе: ${ln.matched_part_name ?? "карточка найдена"}`
: "новая карточка — заведётся при проведении"}
</span>
<span className="font-medium">
{fmtMoney(lineSum(ln.qty, ln.unit_price))} ₽
</span>
</div>
</div>
))}
<button
type="button"
disabled={busy}
onClick={() => void mutate(() =>
addDraftLine(draft.id, { name: "Новая позиция", qty: 1, unit_price: 0 }))}
className="w-full border-2 border-dashed rounded-md py-2.5 text-sm hover:bg-accent/40 flex items-center justify-center gap-1.5"
>
<Plus className="h-4 w-4" /> Добавить позицию
</button>
</section>
<Button variant="ghost" onClick={onReject} disabled={busy} className="w-full text-destructive">
Отклонить накладную
</Button>
</>
)}
</main>
{/* Итого + проведение */}
{draft && (
<footer className="fixed bottom-0 left-0 right-0 border-t bg-background p-3 z-10">
<div className="container max-w-2xl flex items-center gap-3">
<div className="flex-1">
<div className="text-xs text-muted-foreground">Итого по накладной</div>
<div className="text-lg font-semibold tabular-nums">{fmtMoney(total)} ₽</div>
</div>
<Button onClick={onPost} disabled={busy || draft.lines.length === 0} className="flex-1">
{busy ? <Loader2 className="h-4 w-4 animate-spin" /> : "Провести"}
</Button>
</div>
</footer>
)}
{lightbox && (
<div className="fixed inset-0 z-50 bg-black/90 flex flex-col" onClick={() => setLightbox(null)}>
<div className="flex justify-end p-3">
<button className="text-white p-2" aria-label="Закрыть">
<X className="h-6 w-6" />
</button>
</div>
<div className="flex-1 flex items-center justify-center p-3">
<img src={lightbox} alt="Накладная" className="max-w-full max-h-full object-contain" />
</div>
</div>
)}
</div>
);
}
@@ -0,0 +1,193 @@
/**
* Приёмка товара — точка входа раздела.
*
* Главное действие вынесено наверх и занимает пол-экрана: снять накладную
* камерой. Всё остальное (черновики на проверке, последние приходы) — списки
* под ним. Приёмка делается стоя у коробок с телефоном в одной руке, поэтому
* кнопки крупные, а информации на строку минимум.
*/
import { useCallback, useRef, useState } from "react";
import { useNavigate } from "react-router-dom";
import { useQuery } from "@tanstack/react-query";
import { Camera, ChevronLeft, ChevronRight, FileText, Loader2, PackageCheck } from "lucide-react";
import { toast } from "sonner";
import { Button } from "@/components/ui/button";
import { downscaleImage } from "@/lib/imageDownscale";
import { fmtMoney } from "@/lib/repairsFeed";
import { getDrafts, getReceipts, scanInvoice } from "@/api/warehouse";
function fmtDate(iso: string | null): string {
if (!iso) return "—";
const d = new Date(iso);
if (Number.isNaN(d.getTime())) return iso;
return new Intl.DateTimeFormat("ru-RU", { day: "2-digit", month: "long" }).format(d);
}
export default function ReceivingPage() {
const navigate = useNavigate();
const [scanning, setScanning] = useState(false);
const fileRef = useRef<HTMLInputElement | null>(null);
const draftsQuery = useQuery({
queryKey: ["wh-drafts"],
queryFn: () => getDrafts("pending"),
staleTime: 15_000,
});
const receiptsQuery = useQuery({
queryKey: ["wh-receipts"],
queryFn: () => getReceipts(20),
staleTime: 60_000,
});
const onFiles = useCallback(
async (files: FileList | null) => {
if (!files || files.length === 0) return;
setScanning(true);
try {
// Накладная бывает на 2-3 листа — снимаем всё разом, распознаём как
// один документ (модель видит все страницы в одном запросе).
const prepared = await Promise.all(
Array.from(files).slice(0, 6).map((f) => downscaleImage(f)),
);
const draft = await scanInvoice(prepared);
toast.success(`Распознано позиций: ${draft.lines.length}`);
navigate(`/wh/receiving/${draft.id}`);
} catch (e) {
toast.error((e as Error).message || "Не удалось распознать накладную");
} finally {
setScanning(false);
if (fileRef.current) fileRef.current.value = "";
}
},
[navigate],
);
const drafts = draftsQuery.data?.items ?? [];
const receipts = receiptsQuery.data?.items ?? [];
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center justify-between p-3">
<Button variant="ghost" size="sm" onClick={() => navigate("/")} className="-ml-2">
<ChevronLeft className="h-5 w-5" />
<span className="ml-1">Назад</span>
</Button>
<h1 className="text-base font-semibold">Приёмка</h1>
<span className="w-16" />
</div>
</header>
<main className="flex-1 container max-w-2xl py-4 space-y-6">
{/* Главное действие */}
<label
className={`block rounded-xl border-2 border-dashed p-6 text-center ${
scanning ? "opacity-60 pointer-events-none" : "cursor-pointer hover:bg-accent/40"
}`}
>
<div className="flex flex-col items-center gap-2">
{scanning ? (
<Loader2 className="h-8 w-8 animate-spin text-muted-foreground" />
) : (
<Camera className="h-8 w-8 text-muted-foreground" />
)}
<div className="font-semibold">
{scanning ? "Распознаём накладную…" : "Снять накладную или чек"}
</div>
<div className="text-xs text-muted-foreground max-w-xs">
{scanning
? "Это занимает до минуты — не закрывайте экран"
: "Сфотографируйте документ целиком. Несколько листов — снимите подряд, они уйдут одним документом."}
</div>
</div>
<input
ref={fileRef}
type="file"
accept="image/*"
capture="environment"
multiple
className="hidden"
disabled={scanning}
onChange={(e) => void onFiles(e.target.files)}
/>
</label>
{/* Черновики на проверке */}
<section>
<h2 className="text-sm font-semibold text-muted-foreground mb-2">
На проверке{drafts.length > 0 ? ` · ${drafts.length}` : ""}
</h2>
{draftsQuery.isLoading ? (
<div className="h-16 rounded-lg bg-muted animate-pulse" />
) : drafts.length === 0 ? (
<div className="text-sm text-muted-foreground">
Нечего проверять — все накладные проведены.
</div>
) : (
<ul className="space-y-2">
{drafts.map((d) => (
<li key={d.id}>
<button
type="button"
onClick={() => navigate(`/wh/receiving/${d.id}`)}
className="w-full rounded-lg border bg-card p-3 text-left hover:bg-accent/40 flex items-center gap-3"
>
<FileText className="h-5 w-5 text-muted-foreground flex-shrink-0" />
<div className="flex-1 min-w-0">
<div className="font-medium truncate">
{d.supplier_name || d.legal_entity || "Поставщик не определён"}
</div>
<div className="text-xs text-muted-foreground truncate">
{d.ext_order_id} · {fmtDate(d.order_date)} · позиций {d.lines.length}
</div>
</div>
<div className="text-sm font-medium whitespace-nowrap">
{d.total_price != null ? `${fmtMoney(Number(d.total_price))} ₽` : ""}
</div>
<ChevronRight className="h-4 w-4 text-muted-foreground flex-shrink-0" />
</button>
</li>
))}
</ul>
)}
</section>
{/* Последние приходы */}
<section>
<h2 className="text-sm font-semibold text-muted-foreground mb-2">Последние приходы</h2>
{receiptsQuery.isLoading ? (
<div className="h-16 rounded-lg bg-muted animate-pulse" />
) : receipts.length === 0 ? (
<div className="text-sm text-muted-foreground">Приходов пока нет.</div>
) : (
<ul className="space-y-2">
{receipts.map((r) => (
<li key={r.id}>
<button
type="button"
onClick={() => navigate(`/wh/receipts/${r.id}`)}
className="w-full rounded-lg border bg-card p-3 text-left hover:bg-accent/40 flex items-center gap-3"
>
<PackageCheck className="h-5 w-5 text-muted-foreground flex-shrink-0" />
<div className="flex-1 min-w-0">
<div className="font-medium truncate">{r.supplier_name || "—"}</div>
<div className="text-xs text-muted-foreground truncate">
{r.doc_number ? `${r.doc_number} · ` : ""}
{fmtDate(r.doc_date)} · позиций {r.lines_count}
{r.posted_by_name ? ` · ${r.posted_by_name}` : ""}
</div>
</div>
<div className="text-sm font-medium whitespace-nowrap">
{fmtMoney(Number(r.total_amount))} ₽
</div>
<ChevronRight className="h-4 w-4 text-muted-foreground flex-shrink-0" />
</button>
</li>
))}
</ul>
)}
</section>
</main>
</div>
);
}
@@ -0,0 +1,196 @@
/**
* Инвентаризация — список сессий и запуск новой.
*
* Пересчёт делают по зонам (стеллаж за стеллажом), поэтому запуск сразу
* спрашивает зону: «весь склад одной сессией» — это несколько сотен строк,
* которые никто не обойдёт за раз.
*/
import { useState } from "react";
import { useNavigate } from "react-router-dom";
import { useQuery } from "@tanstack/react-query";
import { ChevronLeft, ChevronRight, ClipboardList, Plus } from "lucide-react";
import { toast } from "sonner";
import { Button } from "@/components/ui/button";
import { Label } from "@/components/ui/label";
import { fmtMoney } from "@/lib/repairsFeed";
import { createStocktake, getPlaces, getStocktakes, type Stocktake } from "@/api/warehouse";
function fmtDateTime(iso: string): string {
const d = new Date(iso);
if (Number.isNaN(d.getTime())) return iso;
return new Intl.DateTimeFormat("ru-RU", {
day: "2-digit", month: "long", hour: "2-digit", minute: "2-digit",
}).format(d);
}
export default function StocktakePage() {
const navigate = useNavigate();
const [creating, setCreating] = useState(false);
const [newOpen, setNewOpen] = useState(false);
const [placeId, setPlaceId] = useState<number | null>(null);
const listQuery = useQuery({
queryKey: ["wh-stocktakes"],
queryFn: getStocktakes,
staleTime: 15_000,
});
const placesQuery = useQuery({ queryKey: ["wh-places"], queryFn: getPlaces, staleTime: 300_000 });
const start = async () => {
setCreating(true);
try {
const st = await createStocktake({ place_id: placeId });
if (st.lines_total === 0) {
toast.message("В этой зоне нечего считать — сессия пустая");
}
navigate(`/wh/stocktake/${st.id}`);
} catch (e) {
toast.error((e as Error).message || "Не удалось начать инвентаризацию");
setCreating(false);
}
};
const items = listQuery.data?.items ?? [];
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center justify-between p-3">
<Button variant="ghost" size="sm" onClick={() => navigate("/")} className="-ml-2">
<ChevronLeft className="h-5 w-5" />
<span className="ml-1">Назад</span>
</Button>
<h1 className="text-base font-semibold">Инвентаризация</h1>
<Button variant="default" size="sm" onClick={() => setNewOpen(true)}>
<Plus className="h-4 w-4 mr-1" />
Начать
</Button>
</div>
</header>
<main className="flex-1 container max-w-2xl py-4 space-y-3">
{listQuery.isLoading && <div className="h-20 rounded-lg bg-muted animate-pulse" />}
{!listQuery.isLoading && items.length === 0 && (
<div className="text-center py-16 px-4 space-y-3">
<div className="inline-flex rounded-full bg-muted p-4">
<ClipboardList className="h-8 w-8 text-muted-foreground" />
</div>
<h2 className="text-base font-semibold">Пересчётов ещё не было</h2>
<p className="text-sm text-muted-foreground max-w-xs mx-auto">
Начните с одной зоны — приложение соберёт список того, что там числится.
</p>
<Button onClick={() => setNewOpen(true)}>
<Plus className="h-4 w-4 mr-1" /> Начать пересчёт
</Button>
</div>
)}
<ul className="space-y-2">
{items.map((st) => (
<li key={st.id}>
<button
type="button"
onClick={() => navigate(`/wh/stocktake/${st.id}`)}
className="w-full rounded-lg border bg-card p-3 text-left hover:bg-accent/40"
>
<div className="flex items-center gap-2">
<div className="flex-1 min-w-0">
<div className="font-medium truncate">
{st.place_code ? `Зона ${st.place_code}` : "Весь склад"}
<StatusChip status={st.status} />
</div>
<div className="text-xs text-muted-foreground truncate">
{fmtDateTime(st.started_at)}
{st.author_name ? ` · ${st.author_name}` : ""}
</div>
</div>
<ChevronRight className="h-4 w-4 text-muted-foreground flex-shrink-0" />
</div>
<Progress st={st} />
</button>
</li>
))}
</ul>
</main>
{/* Лист выбора зоны */}
{newOpen && (
<div className="fixed inset-0 z-50 bg-black/50 flex items-end" onClick={() => setNewOpen(false)}>
<div
className="bg-background w-full rounded-t-xl p-4 space-y-3"
onClick={(e) => e.stopPropagation()}
>
<h3 className="text-base font-semibold">Что пересчитываем</h3>
<div>
<Label className="text-xs">Зона хранения</Label>
<select
className="mt-1 w-full rounded-md border bg-background px-3 py-2 text-sm"
value={placeId ?? ""}
onChange={(e) => setPlaceId(e.target.value ? Number(e.target.value) : null)}
>
<option value="">Весь склад (долго)</option>
{(placesQuery.data ?? []).map((p) => (
<option key={p.id} value={p.id}>{p.code} — {p.name}</option>
))}
</select>
<p className="mt-1 text-xs text-muted-foreground">
Список соберётся из того, что числится в зоне. Найденное сверх списка
добавляется прямо во время обхода.
</p>
</div>
<div className="flex gap-2 pt-1">
<Button variant="outline" onClick={() => setNewOpen(false)} className="flex-1">
Отмена
</Button>
<Button onClick={start} disabled={creating} className="flex-1">
{creating ? "Готовим…" : "Начать"}
</Button>
</div>
</div>
</div>
)}
</div>
);
}
function StatusChip({ status }: { status: string }) {
const done = status !== "draft";
return (
<span
className={`ml-2 align-middle rounded px-1.5 py-0.5 text-[10px] font-semibold uppercase tracking-wide ${
done ? "bg-muted text-muted-foreground" : "bg-primary/10 text-primary"
}`}
>
{done ? "проведена" : "идёт"}
</span>
);
}
function Progress({ st }: { st: Stocktake }) {
const pct = st.lines_total > 0 ? Math.round((st.lines_counted / st.lines_total) * 100) : 0;
return (
<div className="mt-2 space-y-1">
<div className="h-1.5 rounded-full bg-muted overflow-hidden">
<div className="h-full bg-primary" style={{ width: `${pct}%` }} />
</div>
<div className="flex items-center justify-between text-xs text-muted-foreground">
<span>
посчитано {st.lines_counted} из {st.lines_total}
</span>
<span className="space-x-2">
{st.shortage_qty > 0 && (
<span className="text-destructive">
−{st.shortage_qty} ({fmtMoney(Number(st.shortage_amount))} ₽)
</span>
)}
{st.surplus_qty > 0 && (
<span className="text-emerald-700">
+{st.surplus_qty} ({fmtMoney(Number(st.surplus_amount))} ₽)
</span>
)}
</span>
</div>
</div>
);
}
@@ -0,0 +1,301 @@
/**
* Итоги проведённой инвентаризации — только просмотр.
*
* Проведённая сессия перестаёт быть рабочим списком и становится документом:
* расхождения уже ушли движениями в журнал склада, менять нечего. Раньше на
* этом месте показывался рабочий список с фильтром «только непосчитанные» —
* то есть ровно то, чего человек НЕ делал, а сам итог был скрыт.
*
* Вид держим в родстве с карточкой прихода (ReceiptDetailPage): шапка
* документа, секции-списки, объяснительная сноска внизу.
*
* Строки разложены по исходам, а не сплошняком: на пересчёте всего склада их
* бывают сотни, и «сошлось» с «не дошли» свёрнуты числом — открываются по
* желанию. Группы без строк не показываются вовсе.
*/
import { useMemo, useState } from "react";
import { AlertTriangle, CheckCircle2, ChevronDown, ChevronLeft, ChevronRight } from "lucide-react";
import { Button } from "@/components/ui/button";
import { fmtMoney } from "@/lib/repairsFeed";
import type { StocktakeDetail, StocktakeLine } from "@/api/warehouse";
import {
GROUPS,
buildSummary,
countPhrase,
lineAmount,
pluralPositions,
reasonLabel,
type GroupMeta,
type MoneyBlock,
} from "./stocktakeSummary";
function fmtDateTime(iso: string | null): string {
if (!iso) return "—";
const d = new Date(iso);
if (Number.isNaN(d.getTime())) return iso;
return new Intl.DateTimeFormat("ru-RU", {
day: "2-digit", month: "long", year: "numeric", hour: "2-digit", minute: "2-digit",
}).format(d);
}
export default function StocktakeResult({
st, onBack,
}: {
st: StocktakeDetail;
onBack: () => void;
}) {
const s = useMemo(() => buildSummary(st.lines), [st.lines]);
const groups = s.groups;
const notCounted = s.walked.left;
// Счётчики шапки: бэкенд отдаёт только «всего/посчитано», разбивку по
// исходам считаем сами.
const chips: { label: string; count: number }[] = [
{ label: "сошлось", count: groups.match.length },
{ label: "не нашли", count: groups.missing.length },
{ label: "не хватает", count: groups.shortage.length },
{ label: "излишек", count: groups.surplus.length },
{ label: "находок", count: groups.find.length },
{ label: "не дошли", count: notCounted },
].filter((c) => c.count > 0);
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center justify-between p-3">
<Button variant="ghost" size="sm" onClick={onBack} className="-ml-2">
<ChevronLeft className="h-5 w-5" />
<span className="ml-1">Назад</span>
</Button>
<h1 className="text-base font-semibold">Итоги пересчёта</h1>
<span className="w-16" />
</div>
</header>
<main className="flex-1 container max-w-2xl py-4 space-y-4">
<section className="rounded-lg border bg-card p-3 space-y-1">
<div className="text-base font-semibold">
{st.place_code ? `Зона ${st.place_code}` : "Весь склад"}
</div>
<div className="text-sm text-muted-foreground">
Завершён {fmtDateTime(st.finished_at ?? st.started_at)}
</div>
{/* author_name — кто ОТКРЫЛ сессию; отдельного «кто провёл» бэкенд не
отдаёт, поэтому и подписываем честно. */}
{st.author_name && (
<div className="text-xs text-muted-foreground">Пересчёт вёл: {st.author_name}</div>
)}
{st.comment && <div className="text-xs text-muted-foreground italic">{st.comment}</div>}
<div className="pt-2 border-t mt-2 space-y-2">
{/* Считаем по строкам, а не по lines_counted/lines_total: те включают
находки и завышают долю обойдённого, противореча чипу «не дошли». */}
<div className="text-sm">
Обошли <span className="tabular-nums">{s.walked.done}</span> из{" "}
<span className="tabular-nums">{s.walked.total}</span> {pluralPositions(s.walked.total)}
{s.finds > 0 && (
<span className="text-muted-foreground">
{" "}· сверх списка нашли <span className="tabular-nums">{s.finds}</span>
</span>
)}
</div>
{chips.length > 0 && (
<div className="flex flex-wrap gap-x-3 gap-y-1 text-xs text-muted-foreground">
{chips.map((c) => (
<span key={c.label}>
{c.label} <span className="font-semibold tabular-nums">{c.count}</span>
</span>
))}
</div>
)}
<MoneyRow label="Недостача" block={s.shortage} bad />
{/* Не просто «Излишек»: ниже есть секция с таким названием, а сюда
входят ещё и находки. Одноимённость заставляет сверять шапку
с секцией и не сходиться — ровно то, что уже лечили слева. */}
<MoneyRow label="Излишек и находки" block={s.surplus} />
<p className="text-xs text-muted-foreground">
Суммы — по закупочной цене партии.
</p>
{s.unpriced > 0 && (
<p className="text-xs text-destructive">
У {s.unpriced} {pluralPositions(s.unpriced)} с расхождением нет цены партии —
в суммы они не вошли, реальные деньги больше.
</p>
)}
</div>
</section>
{st.lines.length === 0 ? (
<div className="py-10 text-center text-sm text-muted-foreground">
В этой сессии не было ни одной позиции — считать было нечего.
</div>
) : (
<>
{s.headline && (
<div
className={`rounded-md border p-3 text-sm flex items-start gap-2 ${
s.headline.tone === "warn"
? "border-destructive/40 bg-destructive/5"
: "bg-muted/40"
}`}
>
{s.headline.tone === "warn" ? (
<AlertTriangle className="h-4 w-4 mt-0.5 flex-shrink-0 text-destructive" />
) : (
<CheckCircle2 className="h-4 w-4 mt-0.5 flex-shrink-0 text-muted-foreground" />
)}
<span>{s.headline.text}</span>
</div>
)}
{GROUPS.map((meta) =>
groups[meta.key].length > 0 ? (
<Group key={meta.key} meta={meta} lines={groups[meta.key]} />
) : null,
)}
{notCounted > 0 && (
<p className="text-xs text-muted-foreground px-1">
Непосчитанные позиции при проведении пропущены: остатки по ним
остались прежними, ничего не списывалось.
</p>
)}
</>
)}
<p className="text-xs text-muted-foreground px-1">
Инвентаризация проведена — расхождения уже стали движениями склада.
Правка только в CRM, чтобы не разошлись остатки и журнал.
</p>
</main>
</div>
);
}
/**
* Строка денег в шапке. Слагаемые подписаны названиями групп с этого же экрана
* — человек должен уметь сверить шапку с секциями ниже и сойтись.
*/
function MoneyRow({ label, block, bad }: { label: string; block: MoneyBlock; bad?: boolean }) {
const parts = block.parts.filter((p) => p.totals.qty > 0);
return (
<div className="space-y-0.5">
<div className="flex items-baseline justify-between gap-3 text-sm">
<span className="text-muted-foreground">{label}</span>
<span
className={`font-semibold tabular-nums ${bad && block.total.qty ? "text-destructive" : ""}`}
>
{block.total.qty} шт · {fmtMoney(block.total.amount)} ₽
</span>
</div>
{/* Расшифровку показываем не только когда слагаемых несколько, но и когда
единственное называется иначе, чем строка шапки. Иначе самый частый
случай — только находки, без обычного излишка — оставался без
объяснения: в шапке сумма есть, а секции с таким названием ниже нет. */}
{(parts.length > 1 ||
(parts.length === 1 && parts[0].title.toLowerCase() !== label.toLowerCase())) && (
<div className="text-xs text-muted-foreground text-right">
{parts
.map((p) => `${p.title.toLowerCase()} ${fmtMoney(p.totals.amount)} ₽`)
.join(" + ")}
</div>
)}
</div>
);
}
/** Сколько строк рисуем за раз — пересчёт всего склада это сотни позиций. */
const PAGE = 100;
function Group({ meta, lines }: { meta: GroupMeta; lines: StocktakeLine[] }) {
// Свёрнутая группа не рендерит строки вовсе — на пересчёте всего склада
// «сошлось» это сотни элементов, и открывать их без нужды незачем.
const [open, setOpen] = useState(!meta.collapsed);
const [limit, setLimit] = useState(PAGE);
const shown = lines.slice(0, limit);
const rest = lines.length - shown.length;
return (
<section className="rounded-lg border bg-card overflow-hidden">
<button
type="button"
onClick={() => setOpen((v) => !v)}
className={`w-full px-3 py-2 bg-muted/40 flex items-center gap-2 text-left ${open ? "border-b" : ""}`}
>
{open
? <ChevronDown className="h-4 w-4 text-muted-foreground flex-shrink-0" />
: <ChevronRight className="h-4 w-4 text-muted-foreground flex-shrink-0" />}
<span className="flex-1 min-w-0">
<span className="block text-sm font-semibold">
{meta.title} · <span className="tabular-nums">{lines.length}</span>
</span>
{meta.note && (
<span className="block text-xs font-normal text-muted-foreground">{meta.note}</span>
)}
</span>
</button>
{open && (
<>
<ul className="divide-y">
{shown.map((l) => <LineItem key={l.id} line={l} />)}
</ul>
{rest > 0 && (
<button
type="button"
onClick={() => setLimit((v) => v + PAGE)}
className="w-full border-t px-3 py-2 text-sm font-medium text-primary hover:bg-accent/40"
>
Показать ещё {Math.min(rest, PAGE)} из {rest}
</button>
)}
</>
)}
</section>
);
}
function LineItem({ line }: { line: StocktakeLine }) {
const reason = reasonLabel(line.reason_code, line.delta > 0);
const amount = lineAmount(line);
return (
<li className="p-3 flex items-start gap-3">
<div className="flex-1 min-w-0">
<div className="text-sm truncate">{line.part_name}</div>
<div className="text-xs text-muted-foreground truncate">
{line.article ? `арт. ${line.article}` : "без артикула"}
{line.place_code ? ` · ${line.place_code}` : ""}
{line.condition === "used"
? ` · Б/У${line.seasons_left ? `, ${line.seasons_left} сез.` : ""}`
: ""}
</div>
<div className="text-xs text-muted-foreground mt-0.5">{countPhrase(line)}</div>
{reason && (
<div className="text-xs text-muted-foreground mt-0.5">Причина: {reason}</div>
)}
{line.comment && (
<div className="text-xs text-muted-foreground italic mt-0.5">{line.comment}</div>
)}
</div>
{line.delta !== 0 && (
<div className="text-right whitespace-nowrap">
<div className={`text-sm font-semibold tabular-nums ${line.delta < 0 ? "text-destructive" : ""}`}>
{line.delta > 0 ? `+${line.delta}` : line.delta}
</div>
{/* Цена партии не проставлена — расхождение настоящее, а денег ноль.
Молча пропустить нельзя: шапку примут за полную картину. */}
{amount > 0 ? (
<div className="text-xs text-muted-foreground tabular-nums">{fmtMoney(amount)} ₽</div>
) : (
<div className="text-xs text-destructive">без цены</div>
)}
</div>
)}
</li>
);
}
@@ -0,0 +1,678 @@
/**
* Обход зоны: ввод факта по строкам + находки.
*
* Экран рассчитан на «иду вдоль стеллажа с телефоном»: по умолчанию показаны
* только непосчитанные строки, посчитанная сразу уходит из списка — видно,
* сколько ещё осталось обойти. Переключатель возвращает весь список, если
* надо что-то перепроверить.
*
* Пустое поле — это «ещё не считали», а не ноль. Ноль означает «дошёл и не
* нашёл» и превратится в недостачу, поэтому он вводится явной кнопкой.
*
* Находки живут ОТДЕЛЬНЫМ блоком, а не строками рабочего списка. Причина не
* косметическая: у находки количество проставлено с рождения, поэтому фильтр
* «только непосчитанные» прятал её сразу после добавления — со стороны это
* читалось как «нажал, и оно пропало». Вынести их из-под фильтра исключением
* значило бы держать в одном списке две разные сущности: обход («что надо
* проверить», и его-то и считает прогресс) и находки («что появилось сверх
* списка»). Отдельный блок сохраняет смысл фильтра и прогресса и ставит
* находку прямо под кнопкой, которой её добавили.
*
* Строка, в поле которой стоит курсор, из списка не исчезает, даже если её
* значение уже ушло на сервер. Иначе фильтр выдёргивает строку из-под пальца
* посреди набора — и в документе остаётся то, что успели напечатать. Отсюда
* focusedId на этом уровне: сам фильтр живёт здесь, а знает про фокус строка.
*
* Проведённая сессия сюда не доходит: она уже не рабочий список, а документ,
* и показывается экраном итогов (StocktakeResult). Адрес один на одну сущность
* — id до и после проведения тот же, поэтому разводим не роутом, а статусом:
* так работает и ссылка из списка, и переход сразу после «Провести».
*/
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { useNavigate, useParams } from "react-router-dom";
import { ChevronLeft, Loader2, Plus, RefreshCw, Trash2 } from "lucide-react";
import { toast } from "sonner";
import { useQuery } from "@tanstack/react-query";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import PartsPickerModal from "@/components/repairs/PartsPickerModal";
import QtyStepper from "@/components/repairs/QtyStepper";
import { fmtMoney } from "@/lib/repairsFeed";
import {
addFind,
apiErrorText,
applyStocktake,
countLine,
deleteStocktake,
deleteStocktakeLine,
getStocktake,
patchFind,
type StocktakeDetail,
type StocktakeLine,
} from "@/api/warehouse";
import type { PartCatalogItem } from "@/api/repairsCreate";
import StocktakeResult from "./StocktakeResult";
export default function StocktakeSessionPage() {
const { id } = useParams<{ id: string }>();
const stId = Number(id);
const navigate = useNavigate();
const [data, setData] = useState<StocktakeDetail | null>(null);
const [onlyPending, setOnlyPending] = useState(true);
const [busy, setBusy] = useState(false);
const [pickerOpen, setPickerOpen] = useState(false);
// Выбранная в пикере деталь ждёт количество: сколько нашли, спрашиваем ДО
// отправки — иначе коробка из восьми уходит в учёт одной штукой.
const [findDraft, setFindDraft] = useState<PartCatalogItem | null>(null);
// Строка, в поле которой сейчас курсор: её фильтр не трогает (см. шапку).
const [focusedId, setFocusedId] = useState<number | null>(null);
const query = useQuery({
queryKey: ["wh-stocktake", stId],
queryFn: () => getStocktake(stId),
staleTime: 5_000,
});
// Локальная копия — чтобы строка исчезала из списка сразу после ввода, не
// дожидаясь перезапроса всей сессии (их бывает несколько сотен).
const st = data ?? query.data ?? null;
const isDraft = st?.status === "draft";
// Обход и находки — разные списки (см. шапку файла). В черновике находка
// опознаётся по batch_id = null; после проведения признак затирается, но
// проведённая сессия сюда не доходит.
const { walk, finds } = useMemo(() => {
const walk: StocktakeLine[] = [];
const finds: StocktakeLine[] = [];
for (const l of st?.lines ?? []) (l.batch_id == null ? finds : walk).push(l);
return { walk, finds };
}, [st]);
// Посчитанная строка уходит из списка — но не та, в которой сейчас курсор:
// её значение могло уйти на сервер из-под пальца (погас экран), и исчезни
// она сейчас — механик дописывал бы вторую цифру в никуда.
const visible = useMemo(
() => (onlyPending ? walk.filter((l) => l.qty_counted == null || l.id === focusedId) : walk),
[walk, onlyPending, focusedId],
);
// Прогресс — про обход: находки в него не входят, иначе доля обойдённого
// растёт от того, что человек нашёл лишнего (так же считает экран итогов).
const counted = walk.filter((l) => l.qty_counted != null).length;
const totalLines = walk.length;
const totals = useMemo(() => {
let shortQty = 0, shortAmt = 0, surQty = 0, surAmt = 0;
for (const l of st?.lines ?? []) {
if (l.delta < 0) { shortQty += -l.delta; shortAmt += -Number(l.delta_amount || 0); }
if (l.delta > 0) { surQty += l.delta; surAmt += Number(l.delta_amount || 0); }
}
return { shortQty, shortAmt, surQty, surAmt };
}, [st]);
// Дальше — только черновик. Проведённую отдаём экрану итогов: править в ней
// нечего, а рабочий список с фильтром «только непосчитанные» показывал бы
// ровно то, чего человек НЕ делал.
if (st && !isDraft) {
return <StocktakeResult st={st} onBack={() => navigate("/wh/stocktake")} />;
}
const applyLine = (updated: StocktakeLine) =>
setData((cur) => {
const base = cur ?? query.data ?? null;
if (!base) return cur;
return { ...base, lines: base.lines.map((l) => (l.id === updated.id ? updated : l)) };
});
const dropLine = (lineId: number) =>
setData((cur) => {
const base = cur ?? query.data ?? null;
if (!base) return cur;
return { ...base, lines: base.lines.filter((l) => l.id !== lineId) };
});
// Сохранилось или нет — строка обязана знать: после отказа её поле должно
// вернуться к тому, что реально лежит в документе.
const setCount = async (line: StocktakeLine, value: number | null): Promise<boolean> => {
try {
applyLine(await countLine(stId, line.id, { qty_counted: value }));
return true;
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось сохранить"));
return false;
}
};
// Количество находки правим её собственной ручкой: она пишет в аудит
// «было → стало» — исправление должно быть видно, а не выглядеть так, будто
// находку сразу такой и вносили.
const setFindQty = async (line: StocktakeLine, qty: number): Promise<boolean> => {
try {
applyLine(await patchFind(stId, line.id, { qty }));
return true;
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось сохранить количество"));
return false;
}
};
const removeFind = async (line: StocktakeLine) => {
if (!window.confirm(`Убрать находку «${line.part_name}» из пересчёта?`)) return;
try {
await deleteStocktakeLine(stId, line.id);
dropLine(line.id);
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось убрать находку"));
}
};
const onFind = async (item: PartCatalogItem, qty: number) => {
setFindDraft(null);
try {
const line = await addFind(stId, { part_id: item.id, qty });
setData((cur) => {
const base = cur ?? query.data ?? null;
return base ? { ...base, lines: [...base.lines, line] } : cur;
});
toast.success(`Находка добавлена: ${item.name}, ${qty} шт`);
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось добавить находку"));
}
};
const onApply = async () => {
if (!st) return;
const notCounted = totalLines - counted;
const msg = notCounted > 0
? `Не посчитано строк: ${notCounted}. Они будут пропущены (останутся как есть). Провести?`
: "Провести инвентаризацию? Расхождения станут движениями склада.";
if (!window.confirm(msg)) return;
setBusy(true);
try {
setData(await applyStocktake(stId));
toast.success("Инвентаризация проведена");
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось провести"));
} finally {
setBusy(false);
}
};
const onDelete = async () => {
if (!window.confirm("Удалить инвентаризацию? Введённые данные пропадут.")) return;
setBusy(true);
try {
await deleteStocktake(stId);
navigate("/wh/stocktake", { replace: true });
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось удалить"));
setBusy(false);
}
};
const pct = totalLines > 0 ? Math.round((counted / totalLines) * 100) : 0;
return (
<div className="min-h-screen bg-background flex flex-col pb-28">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center justify-between p-3">
<Button variant="ghost" size="sm" onClick={() => navigate("/wh/stocktake")} className="-ml-2">
<ChevronLeft className="h-5 w-5" />
<span className="ml-1">Назад</span>
</Button>
<h1 className="text-base font-semibold">
{st?.place_code ? `Зона ${st.place_code}` : "Весь склад"}
</h1>
<span className="w-16" />
</div>
{st && (
<div className="px-3 pb-2 space-y-1">
<div className="h-1.5 rounded-full bg-muted overflow-hidden">
<div className="h-full bg-primary" style={{ width: `${pct}%` }} />
</div>
<div className="flex items-center justify-between text-xs text-muted-foreground">
<span>
посчитано {counted} из {totalLines}
{finds.length > 0 && ` · находок ${finds.length}`}
</span>
{isDraft && (
<button
type="button"
onClick={() => setOnlyPending((v) => !v)}
className="font-medium text-primary underline-offset-2 hover:underline"
>
{onlyPending ? "Показать все" : "Только непосчитанные"}
</button>
)}
</div>
</div>
)}
</header>
<main className="flex-1 container max-w-2xl py-3 space-y-2">
{query.isLoading && <div className="h-20 rounded-lg bg-muted animate-pulse" />}
{/* Обрыв связи — это не «пустая инвентаризация»: показываем отдельно,
иначе человек решит, что данные пропали. Повтор кнопкой: жеста
«потянуть экран» в приложении нет, без неё в дальнем углу склада
остаётся только перезапускать PWA. */}
{query.isError && !st && (
<div className="rounded-md border border-destructive bg-destructive/10 p-3 text-sm space-y-2">
<div>Не удалось загрузить инвентаризацию — проверьте связь.</div>
<Button
variant="outline"
size="sm"
onClick={() => void query.refetch()}
disabled={query.isFetching}
>
{query.isFetching
? <Loader2 className="h-4 w-4 mr-1 animate-spin" />
: <RefreshCw className="h-4 w-4 mr-1" />}
Повторить
</Button>
</div>
)}
{st && isDraft && (
<Button variant="outline" onClick={() => setPickerOpen(true)} className="w-full">
<Plus className="h-4 w-4 mr-1" />
Нашёл то, чего нет в списке
</Button>
)}
{/* Находки — сразу под кнопкой, которой их добавляют, и вне фильтра
обхода (см. шапку файла). */}
{st && isDraft && finds.length > 0 && (
<section className="space-y-2 pt-1">
<div className="flex items-baseline justify-between gap-2 px-1">
<h2 className="text-sm font-semibold">Находки · {finds.length}</h2>
<span className="text-xs text-muted-foreground">в учёте их не числилось</span>
</div>
<ul className="space-y-2">
{finds.map((l) => (
<FindRow
key={l.id}
line={l}
onQty={(qty) => setFindQty(l, qty)}
onRemove={() => void removeFind(l)}
/>
))}
</ul>
</section>
)}
{st && visible.length === 0 && (
<div className="py-12 text-center text-sm text-muted-foreground">
{onlyPending && totalLines > 0
? "Всё обошли. Проверьте итог внизу и проводите."
: "В этой зоне ничего не числится — добавьте находки, если что-то лежит."}
</div>
)}
<ul className="space-y-2">
{visible.map((l) => (
<LineRow
key={l.id}
line={l}
editable={!!isDraft}
onSet={(v) => setCount(l, v)}
onFocusChange={(f) => setFocusedId((cur) => (f ? l.id : cur === l.id ? null : cur))}
/>
))}
</ul>
{st && isDraft && (
<Button variant="ghost" onClick={onDelete} disabled={busy} className="w-full text-destructive">
Удалить инвентаризацию
</Button>
)}
</main>
{st && (
<footer className="fixed bottom-0 left-0 right-0 border-t bg-background p-3 z-10">
<div className="container max-w-2xl flex items-center gap-3">
<div className="flex-1 text-xs space-y-0.5">
<div className="text-muted-foreground">Расхождения</div>
<div className="flex gap-3">
<span className={totals.shortQty ? "text-destructive font-medium" : "text-muted-foreground"}>
недостача {totals.shortQty} · {fmtMoney(totals.shortAmt)} ₽
</span>
<span className={totals.surQty ? "font-medium" : "text-muted-foreground"}>
излишек {totals.surQty} · {fmtMoney(totals.surAmt)} ₽
</span>
</div>
</div>
{isDraft && (
// Одни находки — тоже повод провести: обход мог не дать ни одной
// посчитанной строки, а найденное уже надо оприходовать.
<Button onClick={onApply} disabled={busy || (counted === 0 && finds.length === 0)}>
{busy ? <Loader2 className="h-4 w-4 animate-spin" /> : "Провести"}
</Button>
)}
</div>
</footer>
)}
{/* Находка выбирается из общего каталога — машины тут нет, фильтр
применимости не при чём. */}
<PartsPickerModal
open={pickerOpen}
carId={null}
onPick={(item) => { setPickerOpen(false); setFindDraft(item); }}
onClose={() => setPickerOpen(false)}
/>
{findDraft && (
<FindQtyDialog
item={findDraft}
onCancel={() => setFindDraft(null)}
onConfirm={(qty) => void onFind(findDraft, qty)}
/>
)}
</div>
);
}
/**
* Сколько нашли — спрашиваем до отправки, отдельным шагом после выбора детали.
*
* Раньше находка уходила жёсткой единицей: механик нашёл коробку из восьми, в
* учёт попадала одна, и поправить было нечем. Ввод берём тот же, что у деталей
* в ремонте (QtyStepper): −/+ нажимаются в перчатках, а пустое поле остаётся
* пустым, пока набирают, — иначе «8» не набрать поверх единицы.
*/
function FindQtyDialog({
item, onCancel, onConfirm,
}: {
item: PartCatalogItem;
onCancel: () => void;
onConfirm: (qty: number) => void;
}) {
const [qty, setQty] = useState<number | "">(1);
const value = qty === "" ? 1 : qty;
return (
<div className="fixed inset-0 z-50 bg-background/95 flex items-center justify-center p-4">
<div className="w-full max-w-sm rounded-lg border bg-card p-4 space-y-4">
<div className="min-w-0">
<div className="text-xs text-muted-foreground">Нашли на полке</div>
<div className="text-sm font-medium">{item.name}</div>
<div className="text-xs text-muted-foreground truncate">
{item.article ? `арт. ${item.article}` : "без артикула"}
{item.brand ? ` · ${item.brand}` : ""}
</div>
</div>
<div className="flex items-center justify-between gap-3">
<span className="text-sm">Сколько штук</span>
<QtyStepper value={qty} onChange={setQty} />
</div>
<div className="flex gap-2">
<Button variant="outline" onClick={onCancel} className="flex-1">
Отмена
</Button>
<Button onClick={() => onConfirm(value)} className="flex-1">
Добавить
</Button>
</div>
</div>
</div>
);
}
/**
* Отправка набранного количества: один запрос на весь ввод, и ни одного —
* пока в поле стоит курсор.
*
* Здесь была пауза в 700 мс, и она портила склад. Промежуточное значение
* уходило на сервер, строка переставала быть непосчитанной, фильтр «только
* непосчитанные» убирал её из списка прямо посреди набора: механик вводил
* «12», в документе оставалась «1» — и это уходило в списание недостачи.
*
* Поэтому hold: пока с полем работают, набранное только удерживается, а на
* сервер уходит по завершению ввода (sendNow/flush на уходе с поля). Терять
* удержанное нельзя — ровно от этого автосохранение и делалось, — поэтому на
* время удержания висят слушатели «страницу прячут»: гашение экрана и
* сворачивание приложения дают ровно эти события. Размонтирование строки
* (ушли с экрана) отправляет удержанное тем же flush.
*
* schedule (пауза) остался для правок, у которых нет момента «ушёл с поля», —
* это кнопки −/+ у находки на мобильном: они фокус не берут, ждать нечего.
*
* Слушатели вешаем только пока есть несохранённое значение: на пересчёте всего
* склада строк сотни, и постоянный слушатель у каждой — лишний хвост на каждом
* сворачивании.
*/
function useDeferredSave<T>(commit: (value: T) => void | Promise<void>, delayMs = 700) {
const commitRef = useRef(commit);
const pending = useRef<{ value: T } | null>(null);
const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
const unlisten = useRef<(() => void) | null>(null);
useEffect(() => { commitRef.current = commit; });
const stopTimer = useCallback(() => {
if (timer.current) { clearTimeout(timer.current); timer.current = null; }
}, []);
const stopListen = useCallback(() => {
unlisten.current?.();
unlisten.current = null;
}, []);
const flush = useCallback(() => {
const p = pending.current;
pending.current = null;
stopTimer();
stopListen();
if (p) void commitRef.current(p.value);
}, [stopListen, stopTimer]);
/** Запомнить набранное и ждать — с подстраховкой на случай «экран погас». */
const hold = useCallback((value: T) => {
stopTimer();
pending.current = { value };
if (unlisten.current) return;
const onHidden = () => { if (document.visibilityState === "hidden") flush(); };
document.addEventListener("visibilitychange", onHidden);
window.addEventListener("pagehide", flush);
unlisten.current = () => {
document.removeEventListener("visibilitychange", onHidden);
window.removeEventListener("pagehide", flush);
};
}, [flush, stopTimer]);
const schedule = useCallback((value: T) => {
hold(value);
timer.current = setTimeout(flush, delayMs);
}, [delayMs, flush, hold]);
const sendNow = useCallback((value: T) => {
pending.current = { value };
flush();
}, [flush]);
const cancel = useCallback(() => {
pending.current = null;
stopTimer();
stopListen();
}, [stopListen, stopTimer]);
// Размонтирование (ушли с экрана, список перерисовался) — та же потеря.
useEffect(() => flush, [flush]);
return { hold, schedule, sendNow, flush, cancel };
}
/**
* Что набрано в поле: число, null — «ещё не считали» (пустое поле),
* undefined — мусор, отправлять нечего.
*/
function parseQty(raw: string): number | null | undefined {
const s = raw.trim();
if (s === "") return null;
const n = Math.floor(Number(s));
return Number.isFinite(n) && n >= 0 ? n : undefined;
}
function LineRow({
line, editable, onSet, onFocusChange,
}: {
line: StocktakeLine;
editable: boolean;
onSet: (v: number | null) => Promise<boolean>;
onFocusChange: (focused: boolean) => void;
}) {
const [draft, setDraft] = useState<string>(line.qty_counted?.toString() ?? "");
// Сервер отказал — в документе осталось прежнее, и поле обязано показывать
// его же: иначе на экране висит количество, которого в базе нет, и строка
// выглядит обойдённой.
const save = useDeferredSave<number | null>(async (v) => {
if (!(await onSet(v))) setDraft(line.qty_counted?.toString() ?? "");
});
const tone =
line.resolution === "shortage" ? "border-destructive/40 bg-destructive/5"
: line.resolution === "surplus" ? "border-border bg-accent/40"
: line.resolution === "match" ? "border-border bg-muted/30"
: "border-border bg-card";
const onType = (raw: string) => {
setDraft(raw);
const v = parseQty(raw);
// Пустое поле посреди набора — ещё не решение «не считали»: стирание
// отправляем только когда человек ушёл с поля.
if (v == null || v === line.qty_counted) save.cancel();
else save.hold(v);
};
const onLeave = () => {
onFocusChange(false);
const v = parseQty(draft);
if (v === undefined || v === line.qty_counted) save.cancel();
else save.sendNow(v);
};
const tap = (v: number) => { setDraft(String(v)); save.sendNow(v); };
return (
<li className={`rounded-lg border p-3 ${tone}`}>
<div className="flex items-start justify-between gap-2">
<div className="min-w-0">
<div className="text-sm font-medium truncate">{line.part_name}</div>
<div className="text-xs text-muted-foreground truncate">
{line.article ? `арт. ${line.article} · ` : ""}
числится {line.qty_expected}
{line.place_code ? ` · ${line.place_code}` : ""}
</div>
</div>
{line.delta !== 0 && (
<span
className={`text-sm font-semibold whitespace-nowrap tabular-nums ${
line.delta < 0 ? "text-destructive" : ""
}`}
>
{line.delta > 0 ? `+${line.delta}` : line.delta}
</span>
)}
</div>
{editable && (
<div className="mt-2 flex items-center gap-2">
<Input
type="number"
inputMode="numeric"
min={0}
placeholder="сколько нашли"
value={draft}
onChange={(e) => onType(e.target.value)}
onFocus={() => onFocusChange(true)}
onBlur={onLeave}
className="flex-1"
/>
<Button variant="outline" size="sm" onClick={() => tap(line.qty_expected)}>
Сходится
</Button>
<Button variant="outline" size="sm" onClick={() => tap(0)}>
Нет
</Button>
</div>
)}
</li>
);
}
/**
* Находка в черновике: количество правится, ошибочную строку убирают.
*
* Кнопок «Сходится»/«Нет» здесь нет намеренно. Сходиться находке не с чем — в
* учёте её не числилось, — а «Нет» раньше служил удалением и ставил ноль:
* строка навсегда оставалась в документе сошедшейся пустышкой «числилось 0 —
* столько и нашли» и завышала счётчик совпавших. Ошибочная находка теперь
* удаляется по-настоящему.
*/
function FindRow({
line, onQty, onRemove,
}: {
line: StocktakeLine;
onQty: (qty: number) => Promise<boolean>;
onRemove: () => void;
}) {
const [qty, setQty] = useState<number | "">(line.qty_counted ?? 1);
// Сервер отказал (например, находку уже провели) — поле возвращается к тому,
// что реально лежит в документе, а не остаётся с непринятым числом.
const save = useDeferredSave<number>(async (next) => {
if (!(await onQty(next))) setQty(line.qty_counted ?? 1);
});
// Курсор внутри строки: пока правят, число только удерживается. Сервер пишет
// каждую правку в аудит «было → стало», и промежуточная «1» из «12» осталась
// бы там навсегда.
const editing = useRef(false);
const onChange = (next: number | "") => {
setQty(next);
// "" — промежуточное состояние ввода (см. QtyStepper), отправлять нечего;
// QtyStepper сам вернёт минимум, когда человек уйдёт с поля.
if (next === "" || next < 1 || next === line.qty_counted) save.cancel();
else if (editing.current) save.hold(next);
// Кнопки −/+ на мобильном фокуса не берут: уходить неоткуда, шлём по паузе.
else save.schedule(next);
};
return (
<li className="rounded-lg border border-border bg-accent/40 p-3">
<div className="flex items-start justify-between gap-2">
<div className="min-w-0">
<div className="text-sm font-medium truncate">{line.part_name}</div>
<div className="text-xs text-muted-foreground truncate">
{line.article ? `арт. ${line.article} · ` : ""}
находка
{line.place_code ? ` · ${line.place_code}` : ""}
</div>
</div>
<span className="text-sm font-semibold whitespace-nowrap tabular-nums">
+{line.qty_counted ?? 0}
</span>
</div>
<div className="mt-2 flex items-center justify-between gap-2">
{/* Границы правки — сам счётчик: переход поле ↔ −/+ её не завершает,
а уход из счётчика (в том числе табом на «Убрать») отправляет. */}
<div
onFocus={() => { editing.current = true; }}
onBlur={(e) => {
if (e.relatedTarget instanceof Node && e.currentTarget.contains(e.relatedTarget)) return;
editing.current = false;
save.flush();
}}
>
<QtyStepper value={qty} onChange={onChange} />
</div>
<Button variant="ghost" size="sm" onClick={onRemove} className="text-destructive">
<Trash2 className="h-4 w-4 mr-1" />
Убрать
</Button>
</div>
</li>
);
}
@@ -0,0 +1,115 @@
/**
* Журнал выданных комплектов.
*
* Отвечает на два вопроса сезона: сколько машин уже переобуто и у кого
* комплект до сих пор на руках. Полноценный экран кампании (прогресс по парку,
* дефицит размеров) — следующим шагом в CRM, здесь нужен минимум, по которому
* кладовщик сверяется прямо у склада.
*/
import { useState } from "react";
import { useNavigate } from "react-router-dom";
import { useQuery } from "@tanstack/react-query";
import { ChevronLeft } from "lucide-react";
import { Button } from "@/components/ui/button";
import { getTyreSets, TYRE_GRADE_LABEL, type TyreSet } from "@/api/warehouse";
const STATUS_LABEL: Record<TyreSet["status"], string> = {
on_car: "На машине",
returned: "Вернули на склад",
scrapped: "Списан",
lost: "Не найден",
};
const FILTERS: { key: string | undefined; label: string }[] = [
{ key: "on_car", label: "На машинах" },
{ key: undefined, label: "Все" },
];
function fmtDate(iso: string | null): string {
if (!iso) return "—";
const d = new Date(iso);
return Number.isNaN(d.getTime())
? iso
: new Intl.DateTimeFormat("ru-RU", { day: "2-digit", month: "2-digit", year: "numeric" }).format(d);
}
export default function TyreJournalPage() {
const navigate = useNavigate();
const [status, setStatus] = useState<string | undefined>("on_car");
const q = useQuery({
queryKey: ["tyre-sets", status],
queryFn: () => getTyreSets({ status, limit: 200 }),
staleTime: 15_000,
});
const items = q.data?.items ?? [];
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center gap-2 p-3">
<Button variant="ghost" size="sm" className="-ml-2" onClick={() => navigate("/wh/tyres")}>
<ChevronLeft className="h-5 w-5" />
</Button>
<div>
<h1 className="text-base font-semibold">Выданные комплекты</h1>
<p className="text-xs text-muted-foreground">
на машинах: {q.data?.on_car ?? 0} · всего записей: {q.data?.total ?? 0}
</p>
</div>
</div>
<div className="flex gap-2 px-3 pb-3">
{FILTERS.map((f) => (
<Button
key={f.label}
size="sm"
variant={status === f.key ? "default" : "outline"}
onClick={() => setStatus(f.key)}
>
{f.label}
</Button>
))}
</div>
</header>
<main className="flex-1 divide-y">
{q.isLoading && <p className="p-4 text-sm text-muted-foreground">Загрузка…</p>}
{!q.isLoading && items.length === 0 && (
<p className="p-4 text-sm text-muted-foreground">Пока ничего не выдавали.</p>
)}
{items.map((s) => (
<div key={s.id} className="p-3">
<div className="flex items-baseline gap-2 flex-wrap">
<span className="font-mono font-semibold">{s.car_number ?? "—"}</span>
<span className="text-sm">{s.size ?? s.part_name}</span>
<span className="text-sm text-muted-foreground">{s.qty} шт</span>
<span
className={`text-xs rounded px-1.5 py-0.5 ${
s.status === "on_car"
? "bg-primary/10 text-primary"
: "bg-muted text-muted-foreground"
}`}
>
{STATUS_LABEL[s.status]}
</span>
</div>
<p className="text-xs text-muted-foreground mt-0.5">
{fmtDate(s.issued_at)}
{s.grade_out ? ` · ${TYRE_GRADE_LABEL[s.grade_out].toLowerCase()}` : ""}
{s.driver_fio ? ` · ${s.driver_fio}` : ""}
{s.issued_by ? ` · выдал ${s.issued_by}` : ""}
</p>
{s.status !== "on_car" && (
<p className="text-xs text-muted-foreground">
закрыт {fmtDate(s.closed_at)}
{s.grade_in ? ` · вернули как «${TYRE_GRADE_LABEL[s.grade_in].toLowerCase()}»` : ""}
{s.close_comment ? ` · ${s.close_comment}` : ""}
</p>
)}
</div>
))}
</main>
</div>
);
}
@@ -0,0 +1,124 @@
/**
* Штатные размеры резины по моделям парка.
*
* Заполняется один раз перед сезоном: без размера выдача не подсказывает, что
* брать, и кладовщик ищет позицию в номенклатуре руками — на четырёхстах
* машинах это заметно. Модели идут по числу машин, чтобы самые ходовые
* заполнились первыми и дальше можно было не продолжать.
*
* В поле — подсказка из тех размеров, что реально лежат на складе: набирать
* «225/65/17» с телефона долго и легко ошибиться.
*/
import { useMemo, useState } from "react";
import { useNavigate } from "react-router-dom";
import { useQuery, useQueryClient } from "@tanstack/react-query";
import { Check, ChevronLeft } from "lucide-react";
import { toast } from "sonner";
import { Button } from "@/components/ui/button";
import {
apiErrorText,
getTyreSizes,
getTyreStock,
setTyreSize,
type TyreSizeRow,
} from "@/api/warehouse";
export default function TyreSizesPage() {
const navigate = useNavigate();
const qc = useQueryClient();
const [savingKey, setSavingKey] = useState<string | null>(null);
const sizesQuery = useQuery({ queryKey: ["tyre-sizes"], queryFn: getTyreSizes, staleTime: 30_000 });
const stockQuery = useQuery({ queryKey: ["tyre-stock"], queryFn: getTyreStock, staleTime: 300_000 });
const rows = sizesQuery.data ?? [];
const filled = useMemo(() => rows.filter((r) => r.tyre_size).length, [rows]);
const known = useMemo(
() => Array.from(new Set((stockQuery.data ?? []).map((s) => s.size).filter(Boolean))) as string[],
[stockQuery.data],
);
const save = async (row: TyreSizeRow, value: string | null) => {
const key = `${row.brand}|${row.model}`;
setSavingKey(key);
try {
await setTyreSize({ brand: row.brand ?? "", model: row.model ?? "", tyre_size: value });
await qc.invalidateQueries({ queryKey: ["tyre-sizes"] });
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось сохранить размер"));
} finally {
setSavingKey(null);
}
};
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center gap-2 p-3">
<Button variant="ghost" size="sm" className="-ml-2" onClick={() => navigate("/wh/tyres")}>
<ChevronLeft className="h-5 w-5" />
</Button>
<div>
<h1 className="text-base font-semibold">Штатные размеры</h1>
<p className="text-xs text-muted-foreground">
заполнено {filled} из {rows.length}
</p>
</div>
</div>
</header>
<datalist id="tyre-sizes-known">
{known.map((s) => (
<option key={s} value={s} />
))}
</datalist>
<main className="flex-1 divide-y">
{sizesQuery.isLoading && <p className="p-4 text-sm text-muted-foreground">Загрузка…</p>}
{rows.map((r) => {
const key = `${r.brand}|${r.model}`;
return <SizeRow key={key} row={r} saving={savingKey === key} onSave={(v) => save(r, v)} />;
})}
</main>
</div>
);
}
function SizeRow({
row,
saving,
onSave,
}: {
row: TyreSizeRow;
saving: boolean;
onSave: (value: string | null) => void;
}) {
const [draft, setDraft] = useState(row.tyre_size ?? "");
const dirty = (draft.trim() || null) !== (row.tyre_size ?? null);
return (
<div className="p-3 flex items-center gap-3">
<div className="flex-1 min-w-0">
<p className="text-sm font-medium truncate">
{[row.brand, row.model].filter(Boolean).join(" ") || "—"}
</p>
<p className="text-xs text-muted-foreground">{row.cars_count} авто</p>
</div>
<input
list="tyre-sizes-known"
placeholder="225/65/17"
value={draft}
onChange={(e) => setDraft(e.target.value)}
className="w-32 rounded-md border border-input bg-background px-2 py-1.5 text-sm"
/>
<Button
size="sm"
variant={dirty ? "default" : "ghost"}
disabled={saving || !dirty}
onClick={() => onSave(draft.trim() || null)}
>
{saving ? "…" : <Check className="h-4 w-4" />}
</Button>
</div>
);
}
@@ -0,0 +1,440 @@
/**
* Выдача резины — экран кладовщика у подъёмника.
*
* Осенью через него проходит весь парк, поэтому всё построено вокруг скорости:
* выбрал машину → приложение само подсказало штатный размер и остаток → три
* кнопки состояния → выдал. Один запрос за контекстом вместо трёх — телефон у
* подъёмника работает по слабой связи.
*
* Главное правило: пока не сказано, что случилось с предыдущим комплектом,
* новый не выдаётся. Сервер это тоже проверяет (409), здесь просто не даём
* дойти до отказа.
*/
import { useEffect, useMemo, useState } from "react";
import { useNavigate, useSearchParams } from "react-router-dom";
import { useQuery } from "@tanstack/react-query";
import { ChevronLeft, Circle, History, Ruler } from "lucide-react";
import { toast } from "sonner";
import { Button } from "@/components/ui/button";
import { Input } from "@/components/ui/input";
import CarPicker from "@/components/warehouse/CarPicker";
import {
apiErrorText,
getTyreContext,
issueTyres,
TYRE_GRADE_LABEL,
type TyreClose,
type TyreContext,
type TyreGrade,
type TyreStockRow,
} from "@/api/warehouse";
const GRADES: TyreGrade[] = ["good", "season", "worn"];
const CLOSE_LABEL: Record<TyreClose["action"], string> = {
returned: "Вернули на склад",
scrapped: "Списали",
lost: "Не найден",
};
function fmtDate(iso: string | null): string {
if (!iso) return "—";
const d = new Date(iso);
return Number.isNaN(d.getTime())
? iso
: new Intl.DateTimeFormat("ru-RU", { day: "2-digit", month: "2-digit", year: "numeric" }).format(d);
}
/** Сколько дней комплект отходил — по этому видно, доездил он сезон или месяц. */
function daysOn(iso: string): number {
const d = new Date(iso).getTime();
return Number.isNaN(d) ? 0 : Math.max(0, Math.round((Date.now() - d) / 86_400_000));
}
/** Подпись кнопки выдачи. «Комплект» — только когда колёс действительно четыре:
* с тех пор как выдавать можно поштучно, на одной покрышке эта подпись врала. */
function issueLabel(qty: number, addToOpen: boolean): string {
const noun = qty === 1 ? "покрышку" : "покрышки";
if (addToOpen) return `Доложить ${qty} ${noun}`;
if (qty === 4) return "Выдать комплект";
return `Выдать ${qty} ${noun}`;
}
export default function TyresPage() {
const navigate = useNavigate();
const [sp, setSp] = useSearchParams();
const carId = sp.get("car") ? Number(sp.get("car")) : null;
return (
<div className="min-h-screen bg-background flex flex-col">
<header className="sticky top-0 z-10 bg-background/95 backdrop-blur border-b">
<div className="flex items-center justify-between p-3">
<div className="flex items-center gap-2">
<Button
variant="ghost"
size="sm"
className="-ml-2"
onClick={() => (carId ? setSp({}, { replace: true }) : navigate("/"))}
>
<ChevronLeft className="h-5 w-5" />
</Button>
<h1 className="text-base font-semibold">Выдача резины</h1>
</div>
<div className="flex gap-1">
<Button variant="ghost" size="sm" onClick={() => navigate("/wh/tyres/sizes")}>
<Ruler className="h-4 w-4 mr-1" />
Размеры
</Button>
<Button variant="ghost" size="sm" onClick={() => navigate("/wh/tyres/journal")}>
<History className="h-4 w-4" />
</Button>
</div>
</div>
</header>
{carId ? (
<IssueForm carId={carId} onDone={() => setSp({}, { replace: true })} />
) : (
<CarPicker onPick={(id) => setSp({ car: String(id) }, { replace: true })} />
)}
</div>
);
}
// ── Выдача ─────────────────────────────────────────────────────────────────
function IssueForm({ carId, onDone }: { carId: number; onDone: () => void }) {
const ctxQuery = useQuery({
queryKey: ["tyre-ctx", carId],
queryFn: () => getTyreContext(carId),
staleTime: 0,
});
const ctx: TyreContext | undefined = ctxQuery.data;
const [partId, setPartId] = useState<number | null>(null);
const [qty, setQty] = useState(4);
const [grade, setGrade] = useState<TyreGrade>("good");
const [closeAction, setCloseAction] = useState<TyreClose["action"] | null>(null);
const [closeGrade, setCloseGrade] = useState<TyreGrade>("season");
const [comment, setComment] = useState("");
const [saving, setSaving] = useState(false);
const [showAll, setShowAll] = useState(false);
const [addToOpen, setAddToOpen] = useState(false);
// Ключ идемпотентности живёт, пока форма открыта: ретрай после обрыва связи
// должен попасть в ТУ ЖЕ выдачу, а не создать вторую.
const [idemKey] = useState(() => crypto.randomUUID());
// Подставляем подсказанный размер, как только пришёл контекст.
useEffect(() => {
if (!ctx || partId !== null) return;
const best = ctx.stock.find((s) => (s.fits || s.suggested) && s.qty > 0);
if (best) setPartId(best.part_id);
}, [ctx, partId]);
// По умолчанию показываем ТОЛЬКО подходящее этой машине — иначе кладовщик
// выбирает размер из девятнадцати позиций глазами. Если применимость по
// машине не заполнена, фильтровать нечем: прятать правильную резину по
// незнанию хуже, чем показать лишнюю (то же правило, что у подбора запчастей).
const fitting = useMemo(
() => (ctx ? ctx.stock.filter((s) => s.fits || s.suggested) : []),
[ctx],
);
const visibleStock = showAll || !ctx?.fit_known ? (ctx?.stock ?? []) : fitting;
if (ctxQuery.isLoading) {
return <main className="p-4 text-sm text-muted-foreground">Загрузка…</main>;
}
if (!ctx) {
return <main className="p-4 text-sm text-destructive">Не удалось загрузить машину</main>;
}
const openSet = ctx.open_set;
// «Доложить» — когда старые колёса остаются на машине, а добавляется ещё
// одно-два. Закрывать комплект ради этого нельзя: «списали» врёт на живой
// резине, «вернули» приходует на склад то, что с машины не снимали.
const needClose = openSet !== null && !addToOpen && closeAction === null;
const chosen = ctx.stock.find((s) => s.part_id === partId) ?? null;
const submit = async () => {
if (partId === null) {
toast.error("Выберите размер");
return;
}
setSaving(true);
try {
await issueTyres(
{
car_id: carId,
part_id: partId,
qty,
grade,
comment: comment.trim() || null,
add_to_open: addToOpen,
close:
!addToOpen && closeAction
? {
action: closeAction,
grade: closeAction === "returned" ? closeGrade : undefined,
}
: null,
},
idemKey,
);
toast.success(
`${addToOpen ? "Доложено" : "Выдано"} ${qty} шт · ${ctx.car_number ?? ""}`.trim(),
);
onDone();
} catch (e) {
toast.error(await apiErrorText(e, "Не удалось выдать резину"));
setSaving(false);
}
};
return (
<main className="flex-1 pb-28">
{/* Машина и арендатор */}
<section className="p-3 border-b">
<div className="flex items-baseline gap-3">
<span className="font-mono text-lg font-semibold">{ctx.car_number ?? "—"}</span>
<span className="text-sm text-muted-foreground">
{[ctx.brand, ctx.model].filter(Boolean).join(" ")}
</span>
</div>
<p className="text-sm text-muted-foreground mt-0.5">
{ctx.driver_fio ? `Арендатор: ${ctx.driver_fio}` : "Арендатор не определён"}
</p>
{ctx.suggested_size ? (
<p className="text-sm mt-1">
Штатный размер: <span className="font-semibold">{ctx.suggested_size}</span>
</p>
) : (
<p className="text-sm text-muted-foreground mt-1">
Штатный размер модели не задан — укажите его в разделе «Размеры», и подсказка появится.
</p>
)}
</section>
{/* Предыдущий комплект — закрыть обязательно */}
{openSet && (
<section className="p-3 border-b bg-amber-50 dark:bg-amber-950/30">
<h2 className="text-sm font-semibold">На машине уже есть комплект</h2>
<p className="text-sm text-muted-foreground mt-0.5">
{openSet.size ?? openSet.part_name} · {openSet.qty} шт · выдан {fmtDate(openSet.issued_at)}
{` (${daysOn(openSet.issued_at)} дн.)`}
{openSet.grade_out ? ` · при выдаче ${TYRE_GRADE_LABEL[openSet.grade_out].toLowerCase()}` : ""}
</p>
{openSet.additions && openSet.additions.length > 0 && (
<p className="text-xs text-muted-foreground mt-0.5">
из них доложено:{" "}
{openSet.additions
.map((a) => `${a.qty} шт ${fmtDate(a.created_at)}`)
.join(", ")}
</p>
)}
{/* Развилка: доложить к тем колёсам или заменить их целиком. */}
<div className="grid grid-cols-2 gap-2 mt-2">
<Button
variant={addToOpen ? "default" : "outline"}
size="sm"
onClick={() => setAddToOpen(true)}
>
Доложить
</Button>
<Button
variant={!addToOpen ? "default" : "outline"}
size="sm"
onClick={() => setAddToOpen(false)}
>
Заменить
</Button>
</div>
{addToOpen ? (
<p className="text-xs text-muted-foreground mt-2">
Комплект остаётся тем же, колёса добавятся к нему. Размер должен совпадать.
</p>
) : (
<>
<p className="text-sm mt-3 mb-1">Что со старым?</p>
<div className="grid grid-cols-3 gap-2">
{(Object.keys(CLOSE_LABEL) as TyreClose["action"][]).map((a) => (
<Button
key={a}
variant={closeAction === a ? "default" : "outline"}
size="sm"
onClick={() => setCloseAction(a)}
>
{CLOSE_LABEL[a]}
</Button>
))}
</div>
</>
)}
{!addToOpen && closeAction === "returned" && (
<div className="mt-3">
<p className="text-sm mb-1">Состояние снятой резины</p>
<GradePicker value={closeGrade} onChange={setCloseGrade} />
<p className="text-xs text-muted-foreground mt-1">
Вернётся на склад отдельной партией с этой оценкой.
</p>
</div>
)}
</section>
)}
{/* Что выдаём */}
<section className="p-3 border-b">
<div className="flex items-baseline justify-between mb-2">
<h2 className="text-sm font-semibold">Что выдаём</h2>
{ctx.fit_known && (
<span className="text-xs text-muted-foreground">
{showAll ? `все размеры (${ctx.stock.length})` : `подходит: ${fitting.length}`}
</span>
)}
</div>
{!ctx.fit_known && (
<p className="text-xs text-muted-foreground mb-2">
Для этой модели не отмечено, какая резина подходит, — показаны все размеры.
Отметить можно в карточке позиции на складе.
</p>
)}
<div className="space-y-1">
{visibleStock.length === 0 && (
<p className="text-sm text-muted-foreground">На складе нет резины.</p>
)}
{visibleStock.map((s) => (
<StockRow
key={s.part_id}
row={s}
selected={partId === s.part_id}
onSelect={() => setPartId(s.part_id)}
/>
))}
</div>
{ctx.fit_known && (
<Button
variant="ghost"
size="sm"
className="mt-1"
onClick={() => setShowAll((v) => !v)}
>
{showAll
? `Только подходящие (${fitting.length})`
: `Показать все размеры (${ctx.stock.length})`}
</Button>
)}
{chosen && chosen.qty < qty && (
<p className="text-sm text-amber-700 dark:text-amber-500 mt-2">
На складе {chosen.qty} шт — склад уйдёт в минус на {qty - chosen.qty}. Выдать можно.
</p>
)}
</section>
{/* Количество и состояние */}
<section className="p-3 border-b">
<p className="text-sm mb-1">Сколько покрышек</p>
{/* Поштучно, а не только комплектом: в переобувку часто уходит одно-два
колеса — порезали боковину, поймали грыжу. Раньше выбор был 2/4/5 и
под такой случай не подходил (задача 4684). */}
<div className="flex gap-2">
{[1, 2, 3, 4].map((n) => (
<Button
key={n}
variant={qty === n ? "default" : "outline"}
size="sm"
className="flex-1"
onClick={() => setQty(n)}
>
{n}
</Button>
))}
</div>
<p className="text-sm mt-3 mb-1">Состояние выдаваемой резины</p>
<GradePicker value={grade} onChange={setGrade} />
<Input
className="mt-3"
placeholder="Комментарий (необязательно)"
value={comment}
onChange={(e) => setComment(e.target.value)}
/>
</section>
{/* Кнопка выдачи */}
<div className="fixed bottom-0 left-0 right-0 border-t bg-background p-3">
<Button className="w-full" disabled={saving || needClose || partId === null} onClick={submit}>
{saving
? "Выдаём…"
: needClose
? "Сначала выберите: доложить или заменить"
: issueLabel(qty, addToOpen)}
</Button>
</div>
</main>
);
}
function GradePicker({
value,
onChange,
}: {
value: TyreGrade;
onChange: (g: TyreGrade) => void;
}) {
return (
<div className="grid grid-cols-3 gap-2">
{GRADES.map((g) => (
<Button
key={g}
variant={value === g ? "default" : "outline"}
size="sm"
onClick={() => onChange(g)}
>
{TYRE_GRADE_LABEL[g]}
</Button>
))}
</div>
);
}
function StockRow({
row,
selected,
onSelect,
}: {
row: TyreStockRow;
selected: boolean;
onSelect: () => void;
}) {
const grades = (Object.keys(TYRE_GRADE_LABEL) as TyreGrade[])
.filter((g) => (row.by_grade[g] ?? 0) > 0)
.map((g) => `${TYRE_GRADE_LABEL[g].toLowerCase()}: ${row.by_grade[g]}`);
return (
<button
onClick={onSelect}
className={`w-full text-left rounded-md border p-2.5 flex items-start gap-2 ${
selected ? "border-primary bg-primary/5" : "border-border"
}`}
>
<Circle
className={`h-4 w-4 mt-0.5 shrink-0 ${selected ? "fill-primary text-primary" : "text-muted-foreground"}`}
/>
<span className="flex-1 min-w-0">
<span className="flex items-baseline gap-2 flex-wrap">
<span className="font-semibold">{row.size ?? row.name}</span>
{(row.fits || row.suggested) && (
<span className="text-xs rounded px-1.5 py-0.5 bg-primary/10 text-primary">
{row.fits ? "подходит" : "штатный"}
</span>
)}
<span className={`text-sm ${row.qty > 0 ? "text-muted-foreground" : "text-destructive"}`}>
{row.qty} шт
</span>
</span>
<span className="block text-xs text-muted-foreground truncate">
{[grades.join(" · "), row.places.join(", ")].filter(Boolean).join(" — ") || row.name}
</span>
</span>
</button>
);
}
@@ -0,0 +1,199 @@
import { describe, expect, it } from "vitest";
import type { StocktakeLine } from "@/api/warehouse";
import {
buildSummary,
countPhrase,
groupOf,
isFind,
isUnpriced,
reasonLabel,
splitByGroup,
} from "./stocktakeSummary";
function line(over: Partial<StocktakeLine>): StocktakeLine {
return {
id: 1,
batch_id: 10,
part_id: 100,
part_name: "Фильтр масляный",
article: "C-110",
place_id: null,
place_code: "А-1",
qty_expected: 5,
qty_counted: 5,
unit_price: "100.00",
condition: "new",
seasons_left: null,
resolution: "match",
delta: 0,
delta_amount: "0.00",
comment: null,
reason_code: null,
...over,
};
}
describe("группировка итогов инвентаризации", () => {
it("«дошли и не нашли ни одной» — отдельная группа от «нашли меньше»", () => {
const none = line({ qty_counted: 0, resolution: "shortage", delta: -5 });
const less = line({ qty_counted: 3, resolution: "shortage", delta: -2 });
expect(groupOf(none)).toBe("missing");
expect(groupOf(less)).toBe("shortage");
});
it("не дошли — это не «сошлось», хотя дельта тоже ноль", () => {
expect(groupOf(line({ qty_counted: null, resolution: "not_counted", delta: 0 }))).toBe("skipped");
expect(groupOf(line({ resolution: "match", delta: 0 }))).toBe("match");
});
it("находка узнаётся после проведения, когда batch_id уже подставлен", () => {
// apply прописывает находке id созданной партии — признак «batch_id === null»
// к этому моменту потерян, остаётся только qty_expected === 0.
const find = line({ batch_id: 77, qty_expected: 0, qty_counted: 3, resolution: "surplus", delta: 3 });
expect(isFind(find)).toBe(true);
expect(groupOf(find)).toBe("find");
});
it("обычный излишек находкой не считается", () => {
const surplus = line({ qty_expected: 2, qty_counted: 5, resolution: "surplus", delta: 3 });
expect(isFind(surplus)).toBe(false);
expect(groupOf(surplus)).toBe("surplus");
});
it("splitByGroup раскладывает все строки без потерь", () => {
const lines = [
line({ id: 1, qty_counted: 0, resolution: "shortage", delta: -5 }),
line({ id: 2, qty_counted: 3, resolution: "shortage", delta: -2 }),
line({ id: 3, qty_expected: 0, qty_counted: 1, resolution: "surplus", delta: 1 }),
line({ id: 4, resolution: "match" }),
line({ id: 5, qty_counted: null, resolution: "not_counted" }),
];
const g = splitByGroup(lines);
expect(g.missing.map((l) => l.id)).toEqual([1]);
expect(g.shortage.map((l) => l.id)).toEqual([2]);
expect(g.find.map((l) => l.id)).toEqual([3]);
expect(g.match.map((l) => l.id)).toEqual([4]);
expect(g.skipped.map((l) => l.id)).toEqual([5]);
expect(g.surplus).toHaveLength(0);
});
});
describe("формулировки", () => {
it("говорят числами, а не терминами", () => {
expect(countPhrase(line({ qty_counted: 3, resolution: "shortage", delta: -2 })))
.toBe("числилось 5 → нашли 3, не хватает 2");
expect(countPhrase(line({ qty_counted: 8, resolution: "surplus", delta: 3 })))
.toBe("числилось 5 → нашли 8, лишние 3");
expect(countPhrase(line({ qty_counted: 0, resolution: "shortage", delta: -5 })))
.toBe("числилось 5 → не нашли");
});
it("причина `resort` подписывается по-разному у излишка и недостачи", () => {
expect(reasonLabel("resort", true)).toBe("Лежала не там / из другой зоны");
expect(reasonLabel("resort", false)).toBe("Учтено в другой зоне / пересорт");
expect(reasonLabel(null, false)).toBeNull();
expect(reasonLabel("unknown_code", false)).toBe("unknown_code");
});
});
// Смесь, покрывающая все исходы разом: по ней удобно сверять шапку с группами.
const MIXED: StocktakeLine[] = [
// не нашли, цена есть
line({ id: 1, qty_expected: 5, qty_counted: 0, resolution: "shortage", delta: -5, delta_amount: "-500.00" }),
// не хватает
line({ id: 2, qty_expected: 5, qty_counted: 3, resolution: "shortage", delta: -2, delta_amount: "-200.00" }),
// не нашли, но у партии нет цены — расхождение есть, денег нет
line({ id: 3, qty_expected: 4, qty_counted: 0, resolution: "shortage", delta: -4, unit_price: "0.00", delta_amount: "0.00" }),
// излишек
line({ id: 4, qty_expected: 2, qty_counted: 5, resolution: "surplus", delta: 3, delta_amount: "300.00" }),
// находка
line({ id: 5, qty_expected: 0, qty_counted: 7, resolution: "surplus", delta: 7, delta_amount: "700.00" }),
line({ id: 6, resolution: "match" }),
line({ id: 7, qty_counted: null, resolution: "not_counted" }),
];
describe("шапка итогов", () => {
it("«всё сошлось» не появляется, пока обойдено не всё", () => {
const s = buildSummary([
line({ id: 1, resolution: "match" }),
line({ id: 2, qty_counted: null, resolution: "not_counted" }),
]);
expect(s.hasDiff).toBe(false);
expect(s.headline?.tone).toBe("warn");
expect(s.headline?.text).toContain("1 позиция из 2");
expect(s.headline?.text).not.toContain("Обошли все позиции");
});
it("«всё сошлось» — только когда обойдено всё и расхождений нет", () => {
const s = buildSummary([line({ id: 1, resolution: "match" }), line({ id: 2, resolution: "match" })]);
expect(s.headline).toEqual({ tone: "ok", text: "Обошли все позиции — расхождений нет." });
});
it("обошли всё, но есть расхождения — плашки нет, говорят группы", () => {
const s = buildSummary([
line({ id: 1, resolution: "match" }),
line({ id: 2, qty_counted: 3, resolution: "shortage", delta: -2, delta_amount: "-200.00" }),
]);
expect(s.headline).toBeNull();
});
it("непосчитанные при расхождениях тоже читаются предупреждением", () => {
const s = buildSummary(MIXED);
expect(s.headline?.tone).toBe("warn");
expect(s.headline?.text).toContain("не считали");
});
it("итог шапки сходится с суммой групп", () => {
const s = buildSummary(MIXED);
const sum = (parts: { totals: { qty: number; amount: number } }[]) =>
parts.reduce((a, p) => ({ qty: a.qty + p.totals.qty, amount: a.amount + p.totals.amount }), { qty: 0, amount: 0 });
expect(s.shortage.parts.map((p) => p.title)).toEqual(["Не нашли", "Не хватает"]);
expect(s.surplus.parts.map((p) => p.title)).toEqual(["Излишек", "Находки"]);
expect(sum(s.shortage.parts)).toEqual(s.shortage.total);
expect(sum(s.surplus.parts)).toEqual(s.surplus.total);
});
it("недостача и излишек считаются по группам с экрана, а не одной кучей", () => {
const s = buildSummary(MIXED);
// «не нашли» (5 + 4 шт) и «не хватает» (2 шт) разведены, как секции ниже
expect(s.shortage.parts[0].totals).toEqual({ qty: 9, amount: 500 });
expect(s.shortage.parts[1].totals).toEqual({ qty: 2, amount: 200 });
expect(s.shortage.total).toEqual({ qty: 11, amount: 700 });
// находки видны отдельным слагаемым, а не растворены в излишке
expect(s.surplus.parts[0].totals).toEqual({ qty: 3, amount: 300 });
expect(s.surplus.parts[1].totals).toEqual({ qty: 7, amount: 700 });
expect(s.surplus.total).toEqual({ qty: 10, amount: 1000 });
});
it("находки не раздувают «обошли X из Y»", () => {
const s = buildSummary(MIXED);
// 7 строк, из них одна находка: обходили 6 позиций, до одной не дошли
expect(s.finds).toBe(1);
expect(s.walked).toEqual({ done: 5, total: 6, left: 1 });
// «не дошли» из чипов и остаток обхода — одно и то же число
expect(s.groups.skipped).toHaveLength(s.walked.left);
});
it("строки без цены партии видны отдельно и не теряются", () => {
const s = buildSummary(MIXED);
expect(s.unpriced).toBe(1);
// штуки в шапку попали, деньги — нет: 9 шт «не нашли» стоят 500 ₽
expect(s.shortage.parts[0].totals).toEqual({ qty: 9, amount: 500 });
});
it("«без цены» — про расхождение, а не про сошедшуюся строку", () => {
expect(isUnpriced(line({ qty_counted: 0, resolution: "shortage", delta: -5, delta_amount: "0.00" }))).toBe(true);
expect(isUnpriced(line({ resolution: "match", delta: 0, delta_amount: "0.00" }))).toBe(false);
expect(isUnpriced(line({ qty_counted: 3, resolution: "shortage", delta: -2, delta_amount: "-200.00" }))).toBe(false);
});
it("копейки округляются один раз — слагаемые дают итог", () => {
const s = buildSummary([
line({ id: 1, qty_counted: 0, resolution: "shortage", delta: -5, delta_amount: "-100.50" }),
line({ id: 2, qty_counted: 3, resolution: "shortage", delta: -2, delta_amount: "-100.50" }),
]);
expect(s.shortage.parts[0].totals.amount + s.shortage.parts[1].totals.amount)
.toBe(s.shortage.total.amount);
});
});
@@ -0,0 +1,245 @@
/**
* Разбор проведённой инвентаризации в человеческие итоги.
*
* Вынесено из экрана отдельным модулем ради двух вещей: логику «во что попала
* строка» можно проверить тестом без рендера, а формулировки лежат в одном
* месте — их правят чаще, чем вёрстку.
*
* Бэкенд отдаёт только коды (resolution, reason_code) и голые числа; подписи
* для человека живут на клиенте. Словарь причин зеркалит backend
* stock_reasons.py — общего пакета между репозиториями нет, поэтому он
* продублирован; коды менять синхронно с бэкендом.
*/
import type { StocktakeLine } from "@/api/warehouse";
export type ResultGroup =
| "missing" // числилось, на полке пусто
| "shortage" // нашли меньше, чем числилось
| "surplus" // нашли больше, чем числилось
| "find" // нашли то, чего в учёте не было
| "match" // сошлось
| "skipped"; // до позиции не дошли
/**
* Находка на ПРОВЕДЁННОЙ сессии. Родной признак batch_id === null тут не
* работает: при проведении находке создаётся партия и её id прописывается в
* строку, после чего находка неотличима от обычного излишка. Единственное, что
* остаётся в ответе, — qty_expected: находке он ставится в 0 и больше не
* меняется.
*/
export function isFind(l: StocktakeLine): boolean {
return l.resolution === "surplus" && l.qty_expected === 0;
}
export function groupOf(l: StocktakeLine): ResultGroup {
if (l.resolution === "not_counted") return "skipped";
if (l.resolution === "match") return "match";
if (l.resolution === "surplus") return isFind(l) ? "find" : "surplus";
// shortage: «дошли и не нашли ни одной» читается иначе, чем «нашли меньше»,
// поэтому недостача разводится на две группы.
return l.qty_counted === 0 ? "missing" : "shortage";
}
export interface GroupMeta {
key: ResultGroup;
title: string;
/** Пояснение под заголовком — что вообще значит эта группа. */
note?: string;
/** Свёрнуто по умолчанию: на большом пересчёте это сотни строк. */
collapsed?: boolean;
}
/** Порядок групп на экране: сначала то, из-за чего пересчёт и затевали. */
export const GROUPS: GroupMeta[] = [
{ key: "missing", title: "Не нашли", note: "числились на складе, на полке пусто" },
{ key: "shortage", title: "Не хватает", note: "нашли меньше, чем числилось — разница списана" },
{ key: "surplus", title: "Излишек", note: "нашли больше, чем числилось" },
{ key: "find", title: "Находки", note: "лежали на полке, в учёте их не было" },
{ key: "match", title: "Сошлось", collapsed: true },
{ key: "skipped", title: "Не дошли", note: "эти позиции не считали — остались как были", collapsed: true },
];
export type Groups = Record<ResultGroup, StocktakeLine[]>;
export function splitByGroup(lines: StocktakeLine[]): Groups {
const out: Groups = { missing: [], shortage: [], surplus: [], find: [], match: [], skipped: [] };
for (const l of lines) out[groupOf(l)].push(l);
return out;
}
/** Что стало с позицией — одной строкой, без слов «дельта» и «resolution». */
export function countPhrase(l: StocktakeLine): string {
const expected = l.qty_expected;
const counted = l.qty_counted;
switch (groupOf(l)) {
case "missing":
return `числилось ${expected} → не нашли`;
case "shortage":
return `числилось ${expected} → нашли ${counted}, не хватает ${-l.delta}`;
case "surplus":
return `числилось ${expected} → нашли ${counted}, лишние ${l.delta}`;
case "find":
return `нашли ${counted} — в учёте не числилось`;
case "match":
return `числилось ${expected} — столько и нашли`;
default:
return `числилось ${expected} — до этой позиции не дошли`;
}
}
// ── Причины расхождения ────────────────────────────────────────────────────
// Один и тот же код `resort` для излишка и недостачи означает разное, поэтому
// подписи разведены по знаку расхождения — как в CRM.
const SURPLUS_REASONS: Record<string, string> = {
resort: "Лежала не там / из другой зоны",
back_from_car: "Сняли с машины / из ремонта, не оприходовали",
unrecorded_receipt: "Неучтённый приход",
count_fix: "Правка прошлого просчёта",
other: "Другое",
};
const SHORTAGE_REASONS: Record<string, string> = {
issued_unposted: "Поставили на машину, не списали",
resort: "Учтено в другой зоне / пересорт",
lost: "Утеря / не найдено",
damaged_unposted: "Выкинули по браку, не провели",
other: "Другое",
};
/** Подпись причины; незнакомый код показываем как есть, чтобы не терять данные. */
export function reasonLabel(code: string | null | undefined, positive: boolean): string | null {
if (!code) return null;
const dict = positive ? SURPLUS_REASONS : SHORTAGE_REASONS;
return dict[code] ?? SURPLUS_REASONS[code] ?? SHORTAGE_REASONS[code] ?? code;
}
/** Сколько денег стоит расхождение по строке — всегда положительное число. */
export function lineAmount(l: StocktakeLine): number {
return Math.abs(Number(l.delta_amount || 0));
}
/**
* Расхождение есть, а денег нет: у партии не проставлена цена (фантомные
* партии, прошлые находки без закупки). Такую строку нельзя молча ронять из
* сумм — иначе шапку принимают за полную картину недостачи.
*/
export function isUnpriced(l: StocktakeLine): boolean {
return l.delta !== 0 && lineAmount(l) === 0;
}
/** 1 → «позиция», 2..4 → «позиции», 5+/11..14 → «позиций». */
export function pluralPositions(n: number): string {
const mod10 = n % 10;
const mod100 = n % 100;
if (mod100 >= 11 && mod100 <= 14) return "позиций";
if (mod10 === 1) return "позиция";
if (mod10 >= 2 && mod10 <= 4) return "позиции";
return "позиций";
}
// ── Итоги для шапки документа ──────────────────────────────────────────────
//
// Всё считаем по тем же строкам, что показаны группами ниже, а НЕ берём из
// шапки ответа бэкенда: там shortage_amount = «не нашли» + «не хватает», а
// surplus_amount включает находки, вынесенные на экране в отдельную секцию.
// Сверить такую шапку с группами невозможно — цифры расходятся в разы. Считая
// по группам, получаем сходимость по определению, а не по совпадению.
/** Итог по группе: сколько штук и на сколько денег. */
export interface GroupTotals {
qty: number;
amount: number;
}
/** Блок денег в шапке: итог и его слагаемые — ровно группы с экрана. */
export interface MoneyBlock {
total: GroupTotals;
parts: { key: ResultGroup; title: string; totals: GroupTotals }[];
}
export interface Headline {
/** warn — обойдено не всё; такой документ нельзя читать как «зона чистая». */
tone: "ok" | "warn";
text: string;
}
export interface StocktakeSummary {
groups: Groups;
/**
* Обход списка. Находки не в счёт: они появились сверх списка и завышали бы
* долю обойдённого (бэкендовые lines_total/lines_counted их включают).
*/
walked: { done: number; total: number; left: number };
finds: number;
shortage: MoneyBlock;
surplus: MoneyBlock;
/** Строк с расхождением, которые не дали денег из-за отсутствия цены. */
unpriced: number;
hasDiff: boolean;
/** null — обошли всё и расхождения есть: группы ниже говорят сами за себя. */
headline: Headline | null;
}
function titleOf(key: ResultGroup): string {
return GROUPS.find((g) => g.key === key)?.title ?? key;
}
function totalsOf(lines: StocktakeLine[]): GroupTotals {
let qty = 0;
let amount = 0;
for (const l of lines) {
qty += Math.abs(l.delta);
amount += lineAmount(l);
}
// Округляем на уровне группы: иначе слагаемые в шапке округляются каждое
// само по себе и визуально не дают итог — та самая «не сходится».
return { qty, amount: Math.round(amount) };
}
function blockOf(groups: Groups, keys: ResultGroup[]): MoneyBlock {
const parts = keys.map((key) => ({ key, title: titleOf(key), totals: totalsOf(groups[key]) }));
const total = parts.reduce(
(acc, p) => ({ qty: acc.qty + p.totals.qty, amount: acc.amount + p.totals.amount }),
{ qty: 0, amount: 0 },
);
return { total, parts };
}
export function buildSummary(lines: StocktakeLine[]): StocktakeSummary {
const groups = splitByGroup(lines);
const finds = groups.find.length;
const total = lines.length - finds;
const left = groups.skipped.length;
const shortage = blockOf(groups, ["missing", "shortage"]);
const surplus = blockOf(groups, ["surplus", "find"]);
const hasDiff =
groups.missing.length + groups.shortage.length + groups.surplus.length + finds > 0;
// «Всё сошлось» имеет право появиться, только когда обойдено ВСЁ и
// расхождений нет. Непосчитанная позиция — это не «сошлось», а неизвестность,
// и на самом заметном месте документа она должна читаться предупреждением.
const headline: Headline | null =
left === 0
? hasDiff
? null
: { tone: "ok", text: "Обошли все позиции — расхождений нет." }
: {
tone: "warn",
text: hasDiff
? `Обойдено не всё: ${left} ${pluralPositions(left)} из ${total} не считали. Расхождения ниже — только по тому, что успели посчитать.`
: `Среди посчитанного расхождений нет, но обойдено не всё: ${left} ${pluralPositions(left)} из ${total} не считали — что там на полке, неизвестно.`,
};
return {
groups,
walked: { done: total - left, total, left },
finds,
shortage,
surplus,
unpriced: lines.filter(isUnpriced).length,
hasDiff,
headline,
};
}