diff --git a/mechanic-pwa/frontend/src/App.tsx b/mechanic-pwa/frontend/src/App.tsx index a9d72e7..2584b87 100644 --- a/mechanic-pwa/frontend/src/App.tsx +++ b/mechanic-pwa/frontend/src/App.tsx @@ -1,5 +1,7 @@ import { Routes, Route, Navigate } from "react-router-dom"; +import { useQuery } from "@tanstack/react-query"; import { useAuth } from "@/store/auth"; +import { getMe } from "@/api/me"; import { useMeSync } from "@/hooks/useMeSync"; import Login from "@/pages/Login"; import ActionMenu from "@/pages/ActionMenu"; @@ -14,6 +16,16 @@ import EditRepairPage from "@/pages/repairs/EditRepairPage"; import CarSelectPage from "@/pages/repairs/CarSelectPage"; import CreateRepairPage from "@/pages/repairs/CreateRepairPage"; 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 }) { const token = useAuth((s) => s.token); @@ -21,6 +33,36 @@ function RequireAuth({ children }: { children: React.ReactNode }) { 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 ; + if (meQuery.isLoading) return null; + if (!meQuery.data?.is_admin) return ; + 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 ; + if (meQuery.isLoading) return null; + const me = meQuery.data; + if (!me?.is_admin && !me?.permissions?.includes("warehouse:tyres")) { + return ; + } + return <>{children}; +} + export default function App() { // У35: фоновая сверка прав механика раз в 5 минут — выкидывает на /login // с сообщением «Доступ отозван», если админ снял can_login_pwa или вывел @@ -49,6 +91,19 @@ export default function App() { } /> } /> } /> + {/* Склад — приёмка и инвентаризация с телефона (пока только админы). */} + } /> + } /> + } /> + } /> + } /> + {/* Сезонная выдача резины — по складскому праву (не только админам). */} + } /> + } /> + } /> + {/* Выдача запчастей (5763) — всем, кто вошёл в PWA: гейт на сервере require_mechanic. */} + } /> + } /> } /> ); diff --git a/mechanic-pwa/frontend/src/api/warehouse.ts b/mechanic-pwa/frontend/src/api/warehouse.ts new file mode 100644 index 0000000..d1cdb5f --- /dev/null +++ b/mechanic-pwa/frontend/src/api/warehouse.ts @@ -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 { + 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 { + return api.get("wh/places").json(); +} + +export async function getSuppliers(): Promise { + return api.get("wh/suppliers").json(); +} + +// ── Приёмка ──────────────────────────────────────────────────────────────── + +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 { + 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(); +} + +export async function getDrafts(status = "pending"): Promise { + return api.get(`wh/receiving/drafts?status=${status}`).json(); +} + +export async function getDraft(id: number): Promise { + return api.get(`wh/receiving/drafts/${id}`).json(); +} + +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 { + return api.patch(`wh/receiving/drafts/${id}`, { json: body }).json(); +} + +export async function createDraftSupplier( + id: number, + body: { name: string; legal_entity?: string | null }, +): Promise { + return api.post(`wh/receiving/drafts/${id}/supplier`, { json: body }).json(); +} + +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 { + return api.post(`wh/receiving/drafts/${id}/lines`, { json: body }).json(); +} + +export async function patchDraftLine( + id: number, + lineId: number, + body: DraftLinePatch, +): Promise { + return api.patch(`wh/receiving/drafts/${id}/lines/${lineId}`, { json: body }).json(); +} + +export async function deleteDraftLine(id: number, lineId: number): Promise { + return api.delete(`wh/receiving/drafts/${id}/lines/${lineId}`).json(); +} + +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 { + return api.post(`wh/receiving/drafts/${id}/post`, { json: body }).json(); +} + +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 { + return api.get(`wh/receipts?limit=${limit}`).json(); +} + +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 { + return api.get(`wh/receipts/${id}`).json(); +} + +// ── Инвентаризация ───────────────────────────────────────────────────────── + +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 { + return api.get("wh/stocktakes").json(); +} + +export async function getStocktake(id: number): Promise { + return api.get(`wh/stocktakes/${id}`).json(); +} + +export async function createStocktake(body: { + place_id: number | null; + comment?: string | null; +}): Promise { + return api.post("wh/stocktakes", { json: body }).json(); +} + +export async function countLine( + stocktakeId: number, + lineId: number, + body: { qty_counted: number | null; comment?: string | null }, +): Promise { + return api + .patch(`wh/stocktakes/${stocktakeId}/lines/${lineId}`, { json: body }) + .json(); +} + +export async function addFind( + stocktakeId: number, + body: { part_id: number; qty: number; place_id?: number | null; comment?: string | null }, +): Promise { + return api.post(`wh/stocktakes/${stocktakeId}/finds`, { json: body }).json(); +} + +/** + * Поправить находку в черновике. + * + * Отдельная ручка, а не 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 { + return api + .patch(`wh/stocktakes/${stocktakeId}/finds/${lineId}`, { json: body }) + .json(); +} + +/** + * Убрать строку из черновика. Сервер разрешает только находку: обычную строку + * не заводил человек — она означает «эту позицию надо обойти», и её удаление + * молча вычеркнуло бы позицию из пересчёта. + */ +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 { + return api.post(`wh/stocktakes/${id}/apply`).json(); +} + +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 = { + good: "Хорошая", + season: "На сезон", + worn: "Под списание", +}; + +export interface TyreStockRow { + part_id: number; + name: string; + size: string | null; + condition: string; + qty: number; + by_grade: Partial>; + 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 { + return api.get(`wh/tyres/context?car_id=${carId}`).json(); +} + +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 { + // Ключ идемпотентности обязателен: телефон у подъёмника теряет связь и + // ретраит, а повтор — это ещё четыре покрышки со склада. + return api + .post("wh/tyres/issue", { json: body, headers: { "Idempotency-Key": idempotencyKey } }) + .json(); +} + +export interface TyreSetsResponse { + items: TyreSet[]; + total: number; + on_car: number; +} + +export async function getTyreSets(params?: { status?: string; limit?: number }): Promise { + 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(); +} + +export interface TyreSizeRow { + brand: string | null; + model: string | null; + tyre_size: string | null; + cars_count: number; +} + +export async function getTyreSizes(): Promise { + return api.get("wh/tyres/sizes").json(); +} + +export async function setTyreSize(body: { + brand: string; + model: string; + tyre_size: string | null; +}): Promise { + return api.put("wh/tyres/sizes", { json: body }).json(); +} + +/** Вся резина в наличии — подсказка размеров в справочнике. */ +export async function getTyreStock(): Promise { + return api.get("wh/tyres/stock").json(); +} + +// ── Выдача запчастей на машину (задача 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 { + return api + .post("wh/issues", { json: body, headers: { "Idempotency-Key": idempotencyKey } }) + .json(); +} + +export async function getPartsIssues(params?: { + car_id?: number; + without_repair?: boolean; + limit?: number; +}): Promise { + 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(); +} diff --git a/mechanic-pwa/frontend/src/components/repairs/PartsPickerModal.tsx b/mechanic-pwa/frontend/src/components/repairs/PartsPickerModal.tsx new file mode 100644 index 0000000..61821a4 --- /dev/null +++ b/mechanic-pwa/frontend/src/components/repairs/PartsPickerModal.tsx @@ -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([]); + 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 ( +
+
+ + { + setQ(e.target.value); + void load(e.target.value, showAll); + }} + /> +
+ {carId != null && ( +
+ + {showAll ? "Все детали каталога" : "Подходящие этой машине"} + + +
+ )} +
+
    + {results.map((p) => ( +
  • + +
  • + ))} + {!loading && results.length === 0 && ( +
  • + {q + ? "Ничего не найдено. Если детали нет в каталоге — заведите карточку на складе." + : "Нет подходящих деталей. Нажмите «Показать все» или заведите карточку на складе."} +
  • + )} + {loading &&
  • Загрузка…
  • } +
+
+
+ ); +} diff --git a/mechanic-pwa/frontend/src/components/repairs/QtyStepper.test.tsx b/mechanic-pwa/frontend/src/components/repairs/QtyStepper.test.tsx new file mode 100644 index 0000000..4f737fd --- /dev/null +++ b/mechanic-pwa/frontend/src/components/repairs/QtyStepper.test.tsx @@ -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(start); + return ( + <> + + {qty === "" ? "empty" : qty} + + ); +} + +test("количество можно стереть и набрать заново (жалоба «4 свечи»)", async () => { + const user = userEvent.setup(); + render(); + 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(); + 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(); + 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(); + 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"); +}); diff --git a/mechanic-pwa/frontend/src/components/repairs/QtyStepper.tsx b/mechanic-pwa/frontend/src/components/repairs/QtyStepper.tsx new file mode 100644 index 0000000..3410170 --- /dev/null +++ b/mechanic-pwa/frontend/src/components/repairs/QtyStepper.tsx @@ -0,0 +1,66 @@ +/** + * Количество детали в ремонте: −/+ и поле ввода. + * + * Почему не просто . Пустое поле обязано ОСТАВАТЬСЯ + * пустым, пока человек печатает. Если на каждый 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 ( +
+ + 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" + /> + +
+ ); +} diff --git a/mechanic-pwa/frontend/src/components/warehouse/CarPicker.tsx b/mechanic-pwa/frontend/src/components/warehouse/CarPicker.tsx new file mode 100644 index 0000000..7e9cb3f --- /dev/null +++ b/mechanic-pwa/frontend/src/components/warehouse/CarPicker.tsx @@ -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(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 ( + <> +
+
+ + setQ(e.target.value)} + className="pl-8" + /> +
+
+
+ {loading &&

Загрузка…

} + {!loading && cars.length === 0 && ( +

+ {carsQuery.isError ? "Не удалось загрузить список машин" : "Ничего не нашлось"} +

+ )} + {cars.map((c) => ( + + ))} +
+ + ); +} diff --git a/mechanic-pwa/frontend/src/hooks/useRepairsFeed.ts b/mechanic-pwa/frontend/src/hooks/useRepairsFeed.ts index 04716ae..4e8d6cf 100644 --- a/mechanic-pwa/frontend/src/hooks/useRepairsFeed.ts +++ b/mechanic-pwa/frontend/src/hooks/useRepairsFeed.ts @@ -3,42 +3,122 @@ * * Использует `useInfiniteQuery` для бесконечной пагинации по 20 (У38). * На `visibilitychange` (когда вкладка/приложение получают фокус) — - * автоматический рефреш первой страницы. Pull-to-refresh вызывается - * напрямую из компонента через `refetch()`. + * автоматическое обновление через `refresh()`. Кнопка «Обновить» в шапке + * вызывает тот же `refresh()`. + * + * Поддерживает поиск по подстроке (госномер/марка/модель): `q` уходит + * в каждый запрос страницы и входит в ключ кэша. При смене запроса на + * экране остаётся прошлая выдача (`keepPreviousData`), а не скелетоны. * * SWR-кэш живёт в react-query (память + localStorage persist уже * сконфигурирован в QueryClient на уровне приложения, если такого нет — * первая отрисовка идёт без кэша, но дальше работает). */ -import { useEffect } from "react"; -import { useInfiniteQuery, type QueryKey } from "@tanstack/react-query"; +import { useCallback, useEffect, useRef, useState } from "react"; +import { + keepPreviousData, + useInfiniteQuery, + useQueryClient, + type InfiniteData, + type QueryKey, +} from "@tanstack/react-query"; import { getRepairsFeed, type FeedItem, type FeedResponse } from "@/api/repairsFeed"; export const FEED_QUERY_KEY: QueryKey = ["repairs-feed"]; export const FEED_PAGE_SIZE = 20; -export function useRepairsFeed() { - const query = useInfiniteQuery({ - queryKey: FEED_QUERY_KEY, +/** + * Ключ кэша ленты. Поисковый запрос обязан входить в ключ: иначе страницы + * разных запросов лягут в один кэш и в списке перемешаются чужие ремонты. + */ +export function feedQueryKey(q?: string | null): QueryKey { + return [...FEED_QUERY_KEY, q?.trim() || null]; +} + +/** Что лежит в кэше ленты: загруженные страницы и курсоры, по которым их брали. */ +type FeedPages = InfiniteData; + +export function useRepairsFeed(q?: string | null) { + // Нормализуем один раз: и ключ, и запрос должны видеть одно и то же + // значение, иначе кэш и фильтр разъедутся на пробелах. + const search = q?.trim() || null; + const queryClient = useQueryClient(); + + const query = useInfiniteQuery({ + queryKey: feedQueryKey(search), queryFn: ({ pageParam }) => - getRepairsFeed({ limit: FEED_PAGE_SIZE, cursor: (pageParam as string | null) ?? null }), - initialPageParam: null as string | null, + // q передаём на КАЖДОЙ странице — иначе догрузка вернёт нефильтрованный + // хвост и подмешает в результаты поиска чужие ремонты. + getRepairsFeed({ + limit: FEED_PAGE_SIZE, + cursor: pageParam, + q: search, + }), + initialPageParam: null, getNextPageParam: (last) => last.next_cursor ?? undefined, staleTime: 30_000, // 30 секунд считаем «свежим» — потом фон обновляет refetchOnWindowFocus: false, // делаем свой visibilitychange-листенер ниже + // Каждая буква в поиске — новый ключ, а у нового ключа данных ещё нет. + // Без этого список на каждое нажатие подменялся бы скелетонами и мигал. + // Держим прошлую выдачу до прихода актуальной; что она устарела — + // показываем через isPreviousResults. + placeholderData: keepPreviousData, }); + // Листенер вешаем один раз, а refetch держим в ref — после смены поискового + // запроса обновлять надо актуальную выдачу, а не ту, что была на монтировании. + const refetchRef = useRef(query.refetch); + useEffect(() => { + refetchRef.current = query.refetch; + }, [query.refetch]); + + /** + * Обновление ленты. `refetch()` у бесконечного запроса перезапрашивает ВСЕ + * загруженные страницы, причём последовательно (курсор следующей приходит + * из предыдущей). У механика, пролиставшего ленту вглубь, это десяток + * запросов на слабой сети и десять шансов словить ошибку вместо одного. + * Поэтому сначала схлопываем ленту до первой страницы, а потом обновляем — + * ровно один запрос. Плата: догруженный хвост сбрасывается, лента + * возвращается к началу (как у обычного pull-to-refresh). + */ + // Пока обновление летит, догрузка следующей страницы обязана молчать. + // Схлопывание укорачивает список, браузер прижимает скролл к новому низу, и + // маркер бесконечной прокрутки попадает в зону видимости. Его fetchNextPage + // по умолчанию ОТМЕНЯЕТ запрос в полёте — обновление не доезжает вовсе, а + // вместо него подтягивается вторая страница по старому курсору. Новых + // ремонтов сверху человек так и не увидит, сколько ни жми. + const [isRefreshing, setIsRefreshing] = useState(false); + + const refresh = useCallback(async () => { + setIsRefreshing(true); + try { + queryClient.setQueryData(feedQueryKey(search), (old) => + old && old.pages.length > 1 + ? { pages: old.pages.slice(0, 1), pageParams: old.pageParams.slice(0, 1) } + : old, + ); + await refetchRef.current(); + } finally { + setIsRefreshing(false); + } + }, [queryClient, search]); + + // Тот же приём с ref: refresh меняется вместе с поисковым запросом, + // а листенер ниже вешается один раз. + const refreshRef = useRef(refresh); + useEffect(() => { + refreshRef.current = refresh; + }, [refresh]); + // У38: обновление при возврате в приложение/вкладку. useEffect(() => { const onVisible = () => { if (document.visibilityState === "visible") { - // Рефрешим только первую страницу, бесконечный скролл сбрасывается. - void query.refetch(); + void refreshRef.current(); } }; document.addEventListener("visibilitychange", onVisible); return () => document.removeEventListener("visibilitychange", onVisible); - // eslint-disable-next-line react-hooks/exhaustive-deps }, []); // Удобный flatten для рендера в одну ленту. @@ -48,11 +128,15 @@ export function useRepairsFeed() { items, isLoading: query.isLoading, isFetching: query.isFetching, + // На экране выдача предыдущего запроса, актуальная ещё летит — + // повод приглушить список, но не повод его прятать. + isPreviousResults: query.isPlaceholderData, isError: query.isError, error: query.error, fetchNextPage: query.fetchNextPage, hasNextPage: !!query.hasNextPage, isFetchingNextPage: query.isFetchingNextPage, - refetch: query.refetch, + refresh, + isRefreshing, }; } diff --git a/mechanic-pwa/frontend/src/lib/imageDownscale.ts b/mechanic-pwa/frontend/src/lib/imageDownscale.ts new file mode 100644 index 0000000..92afcb2 --- /dev/null +++ b/mechanic-pwa/frontend/src/lib/imageDownscale.ts @@ -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 { + // Если что-то в цепочке не поддержано (старый 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((resolve) => + canvas.toBlob(resolve, "image/jpeg", QUALITY), + ); + return blob ?? file; + } catch { + return file; + } +} diff --git a/mechanic-pwa/frontend/src/pages/ActionMenu.tsx b/mechanic-pwa/frontend/src/pages/ActionMenu.tsx index 7cfc0eb..f9dbec7 100644 --- a/mechanic-pwa/frontend/src/pages/ActionMenu.tsx +++ b/mechanic-pwa/frontend/src/pages/ActionMenu.tsx @@ -1,7 +1,5 @@ -import type { ComponentType } from "react"; import { useNavigate } from "react-router-dom"; import { useQuery } from "@tanstack/react-query"; -import { ClipboardCheck, History, Wrench } from "lucide-react"; import { getMe } from "@/api/me"; import { logout } from "@/api/auth"; import { Card } from "@/components/ui/card"; @@ -11,8 +9,10 @@ interface ActionTile { key: string; title: string; description: string; - // Иконка из lucide-react (пак всего PWA); эмодзи в интерфейсе не используем. - icon: ComponentType<{ className?: string }>; + // Эмодзи, а не иконка из пака — осознанное исключение из правила проекта: + // владелец хочет цветные плитки в меню (24.09.2026), монохромные lucide + // откатили по его просьбе. + emoji: string; onClick: () => void; disabled?: boolean; comingSoon?: boolean; @@ -27,23 +27,65 @@ export default function ActionMenu() { key: "inspect", title: "Осмотр", description: "Создать или продолжить осмотр машины", - icon: ClipboardCheck, + emoji: "🔍", onClick: () => navigate("/vehicles?action=inspect"), }, { key: "repair", title: "Ремонт", description: "Лента ремонтов парка + создать новый", - icon: Wrench, + emoji: "🔧", onClick: () => navigate("/repairs"), }, { key: "repair-history", title: "История ремонта", description: "Что чинили на машине — поиск по госномеру", - icon: History, + emoji: "📜", 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 ( @@ -72,38 +114,35 @@ export default function ActionMenu() { Что делаем?
- {tiles.map((t) => { - const Icon = t.icon; - return ( - -
- -
-
-

{t.title}

- {t.comingSoon && ( - - скоро - - )} -
-

- {t.description} -

+ {tiles.map((t) => ( + +
+
{t.emoji}
+
+
+

{t.title}

+ {t.comingSoon && ( + + скоро + + )}
+

+ {t.description} +

- - ); - })} +
+
+ ))}
diff --git a/mechanic-pwa/frontend/src/pages/InspectionReview.tsx b/mechanic-pwa/frontend/src/pages/InspectionReview.tsx index 2619365..5905a24 100644 --- a/mechanic-pwa/frontend/src/pages/InspectionReview.tsx +++ b/mechanic-pwa/frontend/src/pages/InspectionReview.tsx @@ -14,6 +14,7 @@ import { AuthImg } from "@/components/AuthImg"; import { ttImageUrl } from "@/api/vehicles"; import { VendorVehicleScheme } from "@/components/vehicle-scheme/VendorVehicleScheme"; import { Card } from "@/components/ui/card"; +import { Button } from "@/components/ui/button"; import { loadZoneLabels } from "@/data/zoneLabels"; const STATUS_LABELS: Record = { @@ -138,6 +139,19 @@ export default function InspectionReview() { 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
Загружаю…
; if (isError || !ins) return
Осмотр не найден.
; @@ -243,6 +257,27 @@ export default function InspectionReview() { )}
+ {ins.meta?.auto_completed === true && ( + +
+
Закрыт автоматически
+

+ Осмотр несколько часов никто не открывал, поэтому система завершила + его сама — чтобы фотографии не пропали из отчётов. Если работа не + доделана, верните осмотр в работу и продолжите. +

+
+ +
+ )} +

Заметки механика diff --git a/mechanic-pwa/frontend/src/pages/warehouse/PartsIssueJournalPage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/PartsIssueJournalPage.tsx new file mode 100644 index 0000000..1817d1b --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/PartsIssueJournalPage.tsx @@ -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 ( +
+
+
+ +
+

Журнал выдач

+

всего записей: {q.data?.total ?? 0}

+
+
+
+ {FILTERS.map((f) => ( + + ))} +
+
+ +
+ {q.isLoading &&

Загрузка…

} + {!q.isLoading && items.length === 0 && ( +

Выдач пока не было.

+ )} + {items.map((it) => ( + + ))} +
+
+ ); +} + +function IssueRow({ issue }: { issue: PartsIssue }) { + return ( +
+
+ + {issue.car_number ?? "—"} + + {[issue.car_brand, issue.car_model].filter(Boolean).join(" ")} + + + + {fmtDateTime(issue.created_at)} + +
+
    + {issue.lines.map((ln, i) => ( +
  • + {ln.part_name} + {ln.qty} шт +
  • + ))} +
+

+ {[ + issue.repair_id ? `ремонт #${issue.repair_id}` : "без ремонта", + issue.user_name, + issue.comment, + ] + .filter(Boolean) + .join(" · ")} +

+
+ ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/PartsIssuePage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/PartsIssuePage.tsx new file mode 100644 index 0000000..7584ef5 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/PartsIssuePage.tsx @@ -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 ( +
+
+
+
+ +

Выдача запчастей

+
+ +
+
+ + {carId ? ( + // key — чтобы смена машины давала чистую форму и новый ключ идемпотентности. + setSp({}, { replace: true })} /> + ) : ( + setSp({ car: String(id) }, { replace: true })} /> + )} +
+ ); +} + +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([]); + 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
Загрузка…
; + } + if (!ctx) { + return
Не удалось загрузить машину
; + } + + return ( +
+ {/* Машина и арендатор */} +
+
+ {ctx.plate ?? "—"} + + {[ctx.brand, ctx.model].filter(Boolean).join(" ")} + +
+

+ {ctx.driver_name ? `Водитель: ${ctx.driver_name}` : "Водитель не определён"} +

+
+ + {/* Что выдаём */} +
+
+

Что выдаём

+ +
+ {lines.length === 0 ? ( +

+ Детали выбираются со склада и списываются сразу при выдаче. +

+ ) : ( +
    + {lines.map((l) => ( +
  • +
    +
    {l.name}
    +
    + {l.article ? `арт. ${l.article} · ` : ""} + {l.in_stock > 0 + ? `на складе: ${l.in_stock}` + : l.in_stock < 0 + ? `на складе: ${l.in_stock}` + : "нет в наличии"} +
    +
    + setQty(l.part_id, next)} /> + +
  • + ))} +
+ )} + {shortages.length > 0 && ( +

+ {shortages.length === 1 + ? `«${shortages[0].name}» — на складе меньше, чем выдаём. Склад уйдёт в минус, выдать можно.` + : `По ${shortages.length} позициям на складе меньше, чем выдаём. Склад уйдёт в минус, выдать можно.`} +

+ )} +
+ + {/* Комментарий */} +
+ setComment(e.target.value)} + /> +
+ + {/* Кнопка выдачи */} +
+ +
+ + setPickerOpen(false)} + /> +
+ ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/ReceiptDetailPage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/ReceiptDetailPage.tsx new file mode 100644 index 0000000..70f0d71 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/ReceiptDetailPage.tsx @@ -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 ( +
+
+
+ +

Приход

+ +
+
+ +
+ {query.isLoading &&
} + + {query.isError && ( +
+ Не удалось загрузить приход. +
+ )} + + {r && ( + <> +
+
{r.supplier_name || "Поставщик не указан"}
+
+ {r.doc_number ? `Накладная ${r.doc_number} · ` : ""} + {fmtDate(r.doc_date)} +
+ {r.posted_by_name && ( +
Провёл: {r.posted_by_name}
+ )} + {r.comment &&
{r.comment}
} +
+ + Позиций: {r.lines.length} + + + {fmtMoney(Number(r.total_amount))} ₽ + +
+
+ +
+
Состав
+
    + {r.lines.map((ln) => ( +
  • + {ln.thumb_url ? ( + + ) : ( +
    + )} +
    +
    {ln.part_name}
    +
    + {ln.article ? `арт. ${ln.article}` : "без артикула"} + {ln.place_code ? ` · ${ln.place_code}` : ""} +
    +
    + {ln.qty} × {fmtMoney(Number(ln.unit_price))} ₽ + {" · "} + +
    +
    +
    + {fmtMoney(Number(ln.amount))} ₽ +
    +
  • + ))} +
+
+ +

+ Приход уже проведён — правка и удаление только в CRM, чтобы не + разошлись остатки и журнал. +

+ + )} +
+
+ ); +} + +function RemainHint({ qty, remaining }: { qty: number; remaining: number }) { + if (remaining === qty) return лежит целиком; + if (remaining <= 0) return разошлось полностью; + return осталось {remaining}; +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/ReceivingDraftPage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/ReceivingDraftPage.tsx new file mode 100644 index 0000000..281ad06 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/ReceivingDraftPage.tsx @@ -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(null); + const [loading, setLoading] = useState(true); + const [busy, setBusy] = useState(false); + const [placeId, setPlaceId] = useState(null); + const [lightbox, setLightbox] = useState(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) => { + 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 ( +
+
+
+ +

Проверка накладной

+ +
+
+ +
+ {loading &&
} + + {draft && ( + <> + {/* Фото документа — сверять глазами по ходу правки */} + {draft.photo_urls.length > 0 && ( +
+ {draft.photo_urls.map((u) => ( + + ))} +
+ )} + + {/* Шапка документа */} +
+
+ + {draft.supplier_id ? ( + + ) : ( +
+
+ Не определён{draft.legal_entity ? ` — в документе «${draft.legal_entity}»` : ""} +
+
+ + {draft.legal_entity && ( + + )} +
+
+ )} +
+ +
+
+ + e.target.value !== draft.ext_order_id && + void mutate(() => patchDraft(draft.id, { doc_number: e.target.value }))} + /> +
+
+ + void mutate(() => + patchDraft(draft.id, { order_date: e.target.value || null }))} + /> +
+
+ +
+ + +
+
+ + {/* Позиции */} +
+
+

Позиции · {draft.lines.length}

+ {unmatched > 0 && ( + + новых карточек: {unmatched} + + )} +
+ + {draft.lines.map((ln) => ( +
+
+ {ln.thumb_url && ( + + )} + e.target.value !== ln.name && + void mutate(() => patchDraftLine(draft.id, ln.id, { name: e.target.value }))} + /> + +
+
+
+ + (e.target.value || null) !== ln.article && + void mutate(() => patchDraftLine(draft.id, ln.id, { article: e.target.value || null }))} + /> +
+
+ + Number(e.target.value) !== ln.qty && + void mutate(() => patchDraftLine(draft.id, ln.id, { + qty: Math.max(1, Number(e.target.value) || 1), + }))} + /> +
+
+ + Number(e.target.value) !== Number(ln.unit_price) && + void mutate(() => patchDraftLine(draft.id, ln.id, { + unit_price: Number(e.target.value) || 0, + }))} + /> +
+
+
+ + {ln.matched_part_id + ? `на складе: ${ln.matched_part_name ?? "карточка найдена"}` + : "новая карточка — заведётся при проведении"} + + + {fmtMoney(lineSum(ln.qty, ln.unit_price))} ₽ + +
+
+ ))} + + +
+ + + + )} +
+ + {/* Итого + проведение */} + {draft && ( +
+
+
+
Итого по накладной
+
{fmtMoney(total)} ₽
+
+ +
+
+ )} + + {lightbox && ( +
setLightbox(null)}> +
+ +
+
+ Накладная +
+
+ )} +
+ ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/ReceivingPage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/ReceivingPage.tsx new file mode 100644 index 0000000..f4b7f94 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/ReceivingPage.tsx @@ -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(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 ( +
+
+
+ +

Приёмка

+ +
+
+ +
+ {/* Главное действие */} + + + {/* Черновики на проверке */} +
+

+ На проверке{drafts.length > 0 ? ` · ${drafts.length}` : ""} +

+ {draftsQuery.isLoading ? ( +
+ ) : drafts.length === 0 ? ( +
+ Нечего проверять — все накладные проведены. +
+ ) : ( +
    + {drafts.map((d) => ( +
  • + +
  • + ))} +
+ )} +
+ + {/* Последние приходы */} +
+

Последние приходы

+ {receiptsQuery.isLoading ? ( +
+ ) : receipts.length === 0 ? ( +
Приходов пока нет.
+ ) : ( +
    + {receipts.map((r) => ( +
  • + +
  • + ))} +
+ )} +
+
+
+ ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/StocktakePage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/StocktakePage.tsx new file mode 100644 index 0000000..5189d02 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/StocktakePage.tsx @@ -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(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 ( +
+
+
+ +

Инвентаризация

+ +
+
+ +
+ {listQuery.isLoading &&
} + + {!listQuery.isLoading && items.length === 0 && ( +
+
+ +
+

Пересчётов ещё не было

+

+ Начните с одной зоны — приложение соберёт список того, что там числится. +

+ +
+ )} + +
    + {items.map((st) => ( +
  • + +
  • + ))} +
+
+ + {/* Лист выбора зоны */} + {newOpen && ( +
setNewOpen(false)}> +
e.stopPropagation()} + > +

Что пересчитываем

+
+ + +

+ Список соберётся из того, что числится в зоне. Найденное сверх списка + добавляется прямо во время обхода. +

+
+
+ + +
+
+
+ )} +
+ ); +} + +function StatusChip({ status }: { status: string }) { + const done = status !== "draft"; + return ( + + {done ? "проведена" : "идёт"} + + ); +} + +function Progress({ st }: { st: Stocktake }) { + const pct = st.lines_total > 0 ? Math.round((st.lines_counted / st.lines_total) * 100) : 0; + return ( +
+
+
+
+
+ + посчитано {st.lines_counted} из {st.lines_total} + + + {st.shortage_qty > 0 && ( + + −{st.shortage_qty} ({fmtMoney(Number(st.shortage_amount))} ₽) + + )} + {st.surplus_qty > 0 && ( + + +{st.surplus_qty} ({fmtMoney(Number(st.surplus_amount))} ₽) + + )} + +
+
+ ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/StocktakeResult.tsx b/mechanic-pwa/frontend/src/pages/warehouse/StocktakeResult.tsx new file mode 100644 index 0000000..2dcc33b --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/StocktakeResult.tsx @@ -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 ( +
+
+
+ +

Итоги пересчёта

+ +
+
+ +
+
+
+ {st.place_code ? `Зона ${st.place_code}` : "Весь склад"} +
+
+ Завершён {fmtDateTime(st.finished_at ?? st.started_at)} +
+ {/* author_name — кто ОТКРЫЛ сессию; отдельного «кто провёл» бэкенд не + отдаёт, поэтому и подписываем честно. */} + {st.author_name && ( +
Пересчёт вёл: {st.author_name}
+ )} + {st.comment &&
{st.comment}
} + +
+ {/* Считаем по строкам, а не по lines_counted/lines_total: те включают + находки и завышают долю обойдённого, противореча чипу «не дошли». */} +
+ Обошли {s.walked.done} из{" "} + {s.walked.total} {pluralPositions(s.walked.total)} + {s.finds > 0 && ( + + {" "}· сверх списка нашли {s.finds} + + )} +
+ {chips.length > 0 && ( +
+ {chips.map((c) => ( + + {c.label} {c.count} + + ))} +
+ )} + + + {/* Не просто «Излишек»: ниже есть секция с таким названием, а сюда + входят ещё и находки. Одноимённость заставляет сверять шапку + с секцией и не сходиться — ровно то, что уже лечили слева. */} + + +

+ Суммы — по закупочной цене партии. +

+ {s.unpriced > 0 && ( +

+ У {s.unpriced} {pluralPositions(s.unpriced)} с расхождением нет цены партии — + в суммы они не вошли, реальные деньги больше. +

+ )} +
+
+ + {st.lines.length === 0 ? ( +
+ В этой сессии не было ни одной позиции — считать было нечего. +
+ ) : ( + <> + {s.headline && ( +
+ {s.headline.tone === "warn" ? ( + + ) : ( + + )} + {s.headline.text} +
+ )} + + {GROUPS.map((meta) => + groups[meta.key].length > 0 ? ( + + ) : null, + )} + + {notCounted > 0 && ( +

+ Непосчитанные позиции при проведении пропущены: остатки по ним + остались прежними, ничего не списывалось. +

+ )} + + )} + +

+ Инвентаризация проведена — расхождения уже стали движениями склада. + Правка только в CRM, чтобы не разошлись остатки и журнал. +

+
+
+ ); +} + +/** + * Строка денег в шапке. Слагаемые подписаны названиями групп с этого же экрана + * — человек должен уметь сверить шапку с секциями ниже и сойтись. + */ +function MoneyRow({ label, block, bad }: { label: string; block: MoneyBlock; bad?: boolean }) { + const parts = block.parts.filter((p) => p.totals.qty > 0); + + return ( +
+
+ {label} + + {block.total.qty} шт · {fmtMoney(block.total.amount)} ₽ + +
+ {/* Расшифровку показываем не только когда слагаемых несколько, но и когда + единственное называется иначе, чем строка шапки. Иначе самый частый + случай — только находки, без обычного излишка — оставался без + объяснения: в шапке сумма есть, а секции с таким названием ниже нет. */} + {(parts.length > 1 || + (parts.length === 1 && parts[0].title.toLowerCase() !== label.toLowerCase())) && ( +
+ {parts + .map((p) => `${p.title.toLowerCase()} ${fmtMoney(p.totals.amount)} ₽`) + .join(" + ")} +
+ )} +
+ ); +} + +/** Сколько строк рисуем за раз — пересчёт всего склада это сотни позиций. */ +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 ( +
+ + + {open && ( + <> +
    + {shown.map((l) => )} +
+ {rest > 0 && ( + + )} + + )} +
+ ); +} + +function LineItem({ line }: { line: StocktakeLine }) { + const reason = reasonLabel(line.reason_code, line.delta > 0); + const amount = lineAmount(line); + + return ( +
  • +
    +
    {line.part_name}
    +
    + {line.article ? `арт. ${line.article}` : "без артикула"} + {line.place_code ? ` · ${line.place_code}` : ""} + {line.condition === "used" + ? ` · Б/У${line.seasons_left ? `, ${line.seasons_left} сез.` : ""}` + : ""} +
    +
    {countPhrase(line)}
    + {reason && ( +
    Причина: {reason}
    + )} + {line.comment && ( +
    {line.comment}
    + )} +
    + + {line.delta !== 0 && ( +
    +
    + {line.delta > 0 ? `+${line.delta}` : line.delta} +
    + {/* Цена партии не проставлена — расхождение настоящее, а денег ноль. + Молча пропустить нельзя: шапку примут за полную картину. */} + {amount > 0 ? ( +
    {fmtMoney(amount)} ₽
    + ) : ( +
    без цены
    + )} +
    + )} +
  • + ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/StocktakeSessionPage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/StocktakeSessionPage.tsx new file mode 100644 index 0000000..294c7cc --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/StocktakeSessionPage.tsx @@ -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(null); + const [onlyPending, setOnlyPending] = useState(true); + const [busy, setBusy] = useState(false); + const [pickerOpen, setPickerOpen] = useState(false); + // Выбранная в пикере деталь ждёт количество: сколько нашли, спрашиваем ДО + // отправки — иначе коробка из восьми уходит в учёт одной штукой. + const [findDraft, setFindDraft] = useState(null); + // Строка, в поле которой сейчас курсор: её фильтр не трогает (см. шапку). + const [focusedId, setFocusedId] = useState(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 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 => { + 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 => { + 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 ( +
    +
    +
    + +

    + {st?.place_code ? `Зона ${st.place_code}` : "Весь склад"} +

    + +
    + {st && ( +
    +
    +
    +
    +
    + + посчитано {counted} из {totalLines} + {finds.length > 0 && ` · находок ${finds.length}`} + + {isDraft && ( + + )} +
    +
    + )} +
    + +
    + {query.isLoading &&
    } + + {/* Обрыв связи — это не «пустая инвентаризация»: показываем отдельно, + иначе человек решит, что данные пропали. Повтор кнопкой: жеста + «потянуть экран» в приложении нет, без неё в дальнем углу склада + остаётся только перезапускать PWA. */} + {query.isError && !st && ( +
    +
    Не удалось загрузить инвентаризацию — проверьте связь.
    + +
    + )} + + {st && isDraft && ( + + )} + + {/* Находки — сразу под кнопкой, которой их добавляют, и вне фильтра + обхода (см. шапку файла). */} + {st && isDraft && finds.length > 0 && ( +
    +
    +

    Находки · {finds.length}

    + в учёте их не числилось +
    +
      + {finds.map((l) => ( + setFindQty(l, qty)} + onRemove={() => void removeFind(l)} + /> + ))} +
    +
    + )} + + {st && visible.length === 0 && ( +
    + {onlyPending && totalLines > 0 + ? "Всё обошли. Проверьте итог внизу и проводите." + : "В этой зоне ничего не числится — добавьте находки, если что-то лежит."} +
    + )} + +
      + {visible.map((l) => ( + setCount(l, v)} + onFocusChange={(f) => setFocusedId((cur) => (f ? l.id : cur === l.id ? null : cur))} + /> + ))} +
    + + {st && isDraft && ( + + )} +
    + + {st && ( +
    +
    +
    +
    Расхождения
    +
    + + недостача {totals.shortQty} · {fmtMoney(totals.shortAmt)} ₽ + + + излишек {totals.surQty} · {fmtMoney(totals.surAmt)} ₽ + +
    +
    + {isDraft && ( + // Одни находки — тоже повод провести: обход мог не дать ни одной + // посчитанной строки, а найденное уже надо оприходовать. + + )} +
    +
    + )} + + {/* Находка выбирается из общего каталога — машины тут нет, фильтр + применимости не при чём. */} + { setPickerOpen(false); setFindDraft(item); }} + onClose={() => setPickerOpen(false)} + /> + + {findDraft && ( + setFindDraft(null)} + onConfirm={(qty) => void onFind(findDraft, qty)} + /> + )} +
    + ); +} + +/** + * Сколько нашли — спрашиваем до отправки, отдельным шагом после выбора детали. + * + * Раньше находка уходила жёсткой единицей: механик нашёл коробку из восьми, в + * учёт попадала одна, и поправить было нечем. Ввод берём тот же, что у деталей + * в ремонте (QtyStepper): −/+ нажимаются в перчатках, а пустое поле остаётся + * пустым, пока набирают, — иначе «8» не набрать поверх единицы. + */ +function FindQtyDialog({ + item, onCancel, onConfirm, +}: { + item: PartCatalogItem; + onCancel: () => void; + onConfirm: (qty: number) => void; +}) { + const [qty, setQty] = useState(1); + const value = qty === "" ? 1 : qty; + + return ( +
    +
    +
    +
    Нашли на полке
    +
    {item.name}
    +
    + {item.article ? `арт. ${item.article}` : "без артикула"} + {item.brand ? ` · ${item.brand}` : ""} +
    +
    +
    + Сколько штук + +
    +
    + + +
    +
    +
    + ); +} + +/** + * Отправка набранного количества: один запрос на весь ввод, и ни одного — + * пока в поле стоит курсор. + * + * Здесь была пауза в 700 мс, и она портила склад. Промежуточное значение + * уходило на сервер, строка переставала быть непосчитанной, фильтр «только + * непосчитанные» убирал её из списка прямо посреди набора: механик вводил + * «12», в документе оставалась «1» — и это уходило в списание недостачи. + * + * Поэтому hold: пока с полем работают, набранное только удерживается, а на + * сервер уходит по завершению ввода (sendNow/flush на уходе с поля). Терять + * удержанное нельзя — ровно от этого автосохранение и делалось, — поэтому на + * время удержания висят слушатели «страницу прячут»: гашение экрана и + * сворачивание приложения дают ровно эти события. Размонтирование строки + * (ушли с экрана) отправляет удержанное тем же flush. + * + * schedule (пауза) остался для правок, у которых нет момента «ушёл с поля», — + * это кнопки −/+ у находки на мобильном: они фокус не берут, ждать нечего. + * + * Слушатели вешаем только пока есть несохранённое значение: на пересчёте всего + * склада строк сотни, и постоянный слушатель у каждой — лишний хвост на каждом + * сворачивании. + */ +function useDeferredSave(commit: (value: T) => void | Promise, delayMs = 700) { + const commitRef = useRef(commit); + const pending = useRef<{ value: T } | null>(null); + const timer = useRef | 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; + onFocusChange: (focused: boolean) => void; +}) { + const [draft, setDraft] = useState(line.qty_counted?.toString() ?? ""); + // Сервер отказал — в документе осталось прежнее, и поле обязано показывать + // его же: иначе на экране висит количество, которого в базе нет, и строка + // выглядит обойдённой. + const save = useDeferredSave(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 ( +
  • +
    +
    +
    {line.part_name}
    +
    + {line.article ? `арт. ${line.article} · ` : ""} + числится {line.qty_expected} + {line.place_code ? ` · ${line.place_code}` : ""} +
    +
    + {line.delta !== 0 && ( + + {line.delta > 0 ? `+${line.delta}` : line.delta} + + )} +
    + + {editable && ( +
    + onType(e.target.value)} + onFocus={() => onFocusChange(true)} + onBlur={onLeave} + className="flex-1" + /> + + +
    + )} +
  • + ); +} + +/** + * Находка в черновике: количество правится, ошибочную строку убирают. + * + * Кнопок «Сходится»/«Нет» здесь нет намеренно. Сходиться находке не с чем — в + * учёте её не числилось, — а «Нет» раньше служил удалением и ставил ноль: + * строка навсегда оставалась в документе сошедшейся пустышкой «числилось 0 — + * столько и нашли» и завышала счётчик совпавших. Ошибочная находка теперь + * удаляется по-настоящему. + */ +function FindRow({ + line, onQty, onRemove, +}: { + line: StocktakeLine; + onQty: (qty: number) => Promise; + onRemove: () => void; +}) { + const [qty, setQty] = useState(line.qty_counted ?? 1); + // Сервер отказал (например, находку уже провели) — поле возвращается к тому, + // что реально лежит в документе, а не остаётся с непринятым числом. + const save = useDeferredSave(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 ( +
  • +
    +
    +
    {line.part_name}
    +
    + {line.article ? `арт. ${line.article} · ` : ""} + находка + {line.place_code ? ` · ${line.place_code}` : ""} +
    +
    + + +{line.qty_counted ?? 0} + +
    + +
    + {/* Границы правки — сам счётчик: переход поле ↔ −/+ её не завершает, + а уход из счётчика (в том числе табом на «Убрать») отправляет. */} +
    { editing.current = true; }} + onBlur={(e) => { + if (e.relatedTarget instanceof Node && e.currentTarget.contains(e.relatedTarget)) return; + editing.current = false; + save.flush(); + }} + > + +
    + +
    +
  • + ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/TyreJournalPage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/TyreJournalPage.tsx new file mode 100644 index 0000000..b074881 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/TyreJournalPage.tsx @@ -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 = { + 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("on_car"); + + const q = useQuery({ + queryKey: ["tyre-sets", status], + queryFn: () => getTyreSets({ status, limit: 200 }), + staleTime: 15_000, + }); + + const items = q.data?.items ?? []; + + return ( +
    +
    +
    + +
    +

    Выданные комплекты

    +

    + на машинах: {q.data?.on_car ?? 0} · всего записей: {q.data?.total ?? 0} +

    +
    +
    +
    + {FILTERS.map((f) => ( + + ))} +
    +
    + +
    + {q.isLoading &&

    Загрузка…

    } + {!q.isLoading && items.length === 0 && ( +

    Пока ничего не выдавали.

    + )} + {items.map((s) => ( +
    +
    + {s.car_number ?? "—"} + {s.size ?? s.part_name} + {s.qty} шт + + {STATUS_LABEL[s.status]} + +
    +

    + {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}` : ""} +

    + {s.status !== "on_car" && ( +

    + закрыт {fmtDate(s.closed_at)} + {s.grade_in ? ` · вернули как «${TYRE_GRADE_LABEL[s.grade_in].toLowerCase()}»` : ""} + {s.close_comment ? ` · ${s.close_comment}` : ""} +

    + )} +
    + ))} +
    +
    + ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/TyreSizesPage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/TyreSizesPage.tsx new file mode 100644 index 0000000..6cbd2a2 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/TyreSizesPage.tsx @@ -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(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 ( +
    +
    +
    + +
    +

    Штатные размеры

    +

    + заполнено {filled} из {rows.length} +

    +
    +
    +
    + + + {known.map((s) => ( + + +
    + {sizesQuery.isLoading &&

    Загрузка…

    } + {rows.map((r) => { + const key = `${r.brand}|${r.model}`; + return save(r, v)} />; + })} +
    +
    + ); +} + +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 ( +
    +
    +

    + {[row.brand, row.model].filter(Boolean).join(" ") || "—"} +

    +

    {row.cars_count} авто

    +
    + setDraft(e.target.value)} + className="w-32 rounded-md border border-input bg-background px-2 py-1.5 text-sm" + /> + +
    + ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/TyresPage.tsx b/mechanic-pwa/frontend/src/pages/warehouse/TyresPage.tsx new file mode 100644 index 0000000..65a7651 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/TyresPage.tsx @@ -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 = { + 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 ( +
    +
    +
    +
    + +

    Выдача резины

    +
    +
    + + +
    +
    +
    + + {carId ? ( + setSp({}, { replace: true })} /> + ) : ( + setSp({ car: String(id) }, { replace: true })} /> + )} +
    + ); +} + +// ── Выдача ───────────────────────────────────────────────────────────────── + +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(null); + const [qty, setQty] = useState(4); + const [grade, setGrade] = useState("good"); + const [closeAction, setCloseAction] = useState(null); + const [closeGrade, setCloseGrade] = useState("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
    Загрузка…
    ; + } + if (!ctx) { + return
    Не удалось загрузить машину
    ; + } + + 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 ( +
    + {/* Машина и арендатор */} +
    +
    + {ctx.car_number ?? "—"} + + {[ctx.brand, ctx.model].filter(Boolean).join(" ")} + +
    +

    + {ctx.driver_fio ? `Арендатор: ${ctx.driver_fio}` : "Арендатор не определён"} +

    + {ctx.suggested_size ? ( +

    + Штатный размер: {ctx.suggested_size} +

    + ) : ( +

    + Штатный размер модели не задан — укажите его в разделе «Размеры», и подсказка появится. +

    + )} +
    + + {/* Предыдущий комплект — закрыть обязательно */} + {openSet && ( +
    +

    На машине уже есть комплект

    +

    + {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()}` : ""} +

    + {openSet.additions && openSet.additions.length > 0 && ( +

    + из них доложено:{" "} + {openSet.additions + .map((a) => `${a.qty} шт ${fmtDate(a.created_at)}`) + .join(", ")} +

    + )} + + {/* Развилка: доложить к тем колёсам или заменить их целиком. */} +
    + + +
    + + {addToOpen ? ( +

    + Комплект остаётся тем же, колёса добавятся к нему. Размер должен совпадать. +

    + ) : ( + <> +

    Что со старым?

    +
    + {(Object.keys(CLOSE_LABEL) as TyreClose["action"][]).map((a) => ( + + ))} +
    + + )} + {!addToOpen && closeAction === "returned" && ( +
    +

    Состояние снятой резины

    + +

    + Вернётся на склад отдельной партией с этой оценкой. +

    +
    + )} +
    + )} + + {/* Что выдаём */} +
    +
    +

    Что выдаём

    + {ctx.fit_known && ( + + {showAll ? `все размеры (${ctx.stock.length})` : `подходит: ${fitting.length}`} + + )} +
    + {!ctx.fit_known && ( +

    + Для этой модели не отмечено, какая резина подходит, — показаны все размеры. + Отметить можно в карточке позиции на складе. +

    + )} +
    + {visibleStock.length === 0 && ( +

    На складе нет резины.

    + )} + {visibleStock.map((s) => ( + setPartId(s.part_id)} + /> + ))} +
    + {ctx.fit_known && ( + + )} + {chosen && chosen.qty < qty && ( +

    + На складе {chosen.qty} шт — склад уйдёт в минус на {qty - chosen.qty}. Выдать можно. +

    + )} +
    + + {/* Количество и состояние */} +
    +

    Сколько покрышек

    + {/* Поштучно, а не только комплектом: в переобувку часто уходит одно-два + колеса — порезали боковину, поймали грыжу. Раньше выбор был 2/4/5 и + под такой случай не подходил (задача 4684). */} +
    + {[1, 2, 3, 4].map((n) => ( + + ))} +
    +

    Состояние выдаваемой резины

    + + setComment(e.target.value)} + /> +
    + + {/* Кнопка выдачи */} +
    + +
    +
    + ); +} + +function GradePicker({ + value, + onChange, +}: { + value: TyreGrade; + onChange: (g: TyreGrade) => void; +}) { + return ( +
    + {GRADES.map((g) => ( + + ))} +
    + ); +} + +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 ( + + ); +} diff --git a/mechanic-pwa/frontend/src/pages/warehouse/stocktakeSummary.test.ts b/mechanic-pwa/frontend/src/pages/warehouse/stocktakeSummary.test.ts new file mode 100644 index 0000000..34f1936 --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/stocktakeSummary.test.ts @@ -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 { + 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); + }); +}); diff --git a/mechanic-pwa/frontend/src/pages/warehouse/stocktakeSummary.ts b/mechanic-pwa/frontend/src/pages/warehouse/stocktakeSummary.ts new file mode 100644 index 0000000..edb52fc --- /dev/null +++ b/mechanic-pwa/frontend/src/pages/warehouse/stocktakeSummary.ts @@ -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; + +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 = { + resort: "Лежала не там / из другой зоны", + back_from_car: "Сняли с машины / из ремонта, не оприходовали", + unrecorded_receipt: "Неучтённый приход", + count_fix: "Правка прошлого просчёта", + other: "Другое", +}; + +const SHORTAGE_REASONS: Record = { + 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, + }; +}