fix: oprava spojení při použítí tlačítka "Zpět"

client/src/App.tsx

@@ -63,13 +63,15 @@ function App() {
   const settings = useSettings();
   const navigate = useNavigate();
   const [easterEgg, _] = useEasterEgg(auth);
-  const [isConnected, setIsConnected] = useState<boolean>(false);
+  const socket = useContext(SocketContext);
+  // Socket je singleton mimo React, takže při návratu v historii prohlížeče (remount
+  // komponenty) už žádný "connect" event nepřijde - stav proto inicializujeme z něj
+  const [isConnected, setIsConnected] = useState<boolean>(() => socket.connected);
   const [data, setData] = useState<ClientData>();
   const [food, setFood] = useState<RestaurantDayMenuMap>();
   const [myOrder, setMyOrder] = useState<PizzaOrder>();
   const [foodChoiceList, setFoodChoiceList] = useState<Food[]>();
   const [closed, setClosed] = useState<boolean>(false);
-  const socket = useContext(SocketContext);
   const choiceRef = useRef<HTMLSelectElement>(null);
   const foodChoiceRef = useRef<HTMLSelectElement>(null);
   const departureChoiceRef = useRef<HTMLSelectElement>(null);
@@ -121,6 +123,8 @@ function App() {
 
   // Registrace socket eventů
   useEffect(() => {
+    // Srovnání se skutečným stavem socketu (mohl se změnit mezi renderem a efektem)
+    setIsConnected(socket.connected);
     socket.on(EVENT_CONNECT, () => {
       setIsConnected(true);
     });

client/src/components/modals/GenerateMockOrdersModal.tsx

@@ -0,0 +1,175 @@
+import { useState } from "react";
+import { Modal, Button, Form, Alert } from "react-bootstrap";
+import { generateMockOrders } from "../../../../types";
+
+type Props = {
+    isOpen: boolean;
+    onClose: () => void;
+    /** Příznak, zda je pro dnešní den založena alespoň jedna skupina objednávky. */
+    hasGroups: boolean;
+    /** Příznak, zda je nadefinován alespoň jeden obchod (bez něj nelze generovat). */
+    hasStores: boolean;
+};
+
+const DEFAULT_COUNT = '3';
+const DEFAULT_MIN_AMOUNT = '100';
+const DEFAULT_MAX_AMOUNT = '1000';
+
+/** Vybere český tvar slova podle počtu (1 osoba / 2 osoby / 5 osob). */
+function plural(count: number, one: string, few: string, many: string): string {
+    if (count === 1) return one;
+    if (count >= 2 && count <= 4) return few;
+    return many;
+}
+
+/** Modální dialog pro generování mock dat sekce Objednání (pouze DEV). */
+export default function GenerateMockOrdersModal({ isOpen, onClose, hasGroups, hasStores }: Readonly<Props>) {
+    const [count, setCount] = useState<string>(DEFAULT_COUNT);
+    const [minAmount, setMinAmount] = useState<string>(DEFAULT_MIN_AMOUNT);
+    const [maxAmount, setMaxAmount] = useState<string>(DEFAULT_MAX_AMOUNT);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+    const [success, setSuccess] = useState<string | null>(null);
+
+    const handleGenerate = async () => {
+        setError(null);
+
+        const countNum = parseInt(count, 10);
+        if (isNaN(countNum) || countNum < 1 || countNum > 50) {
+            setError('Počet osob musí být číslo mezi 1 a 50');
+            return;
+        }
+        const minNum = parseInt(minAmount, 10);
+        const maxNum = parseInt(maxAmount, 10);
+        if (isNaN(minNum) || isNaN(maxNum) || minNum < 0 || maxNum < minNum) {
+            setError('Zadejte platný rozsah částek (od ≤ do)');
+            return;
+        }
+
+        setLoading(true);
+        try {
+            const response = await generateMockOrders({
+                body: { count: countNum, minAmount: minNum, maxAmount: maxNum },
+            });
+            if (response.error) {
+                setError((response.error as any).error || 'Nastala chyba při generování dat');
+            } else {
+                const groups = response.data?.groups ?? [];
+                const total = response.data?.count ?? 0;
+                const created = groups.find(g => g.created);
+                setSuccess(
+                    `Doplněno: ${total} ${plural(total, 'osoba', 'osoby', 'osob')}`
+                    + ` / ${groups.length} ${plural(groups.length, 'skupina', 'skupiny', 'skupin')}`
+                    + (created ? ` (skupina „${created.name}“ byla nově založena).` : '.')
+                );
+                setTimeout(() => {
+                    onClose();
+                    setSuccess(null);
+                }, 2000);
+            }
+        } catch (e: any) {
+            setError(e.message || 'Nastala chyba při generování dat');
+        } finally {
+            setLoading(false);
+        }
+    };
+
+    const handleClose = () => {
+        setError(null);
+        setSuccess(null);
+        onClose();
+    };
+
+    return (
+        <Modal show={isOpen} onHide={handleClose}>
+            <Modal.Header closeButton>
+                <Modal.Title><h2>Generovat mock objednávky</h2></Modal.Title>
+            </Modal.Header>
+            <Modal.Body>
+                {success ? (
+                    <Alert variant="success">{success}</Alert>
+                ) : (
+                    <>
+                        <Alert variant="warning">
+                            <strong>DEV režim</strong> - Tato funkce je dostupná pouze ve vývojovém prostředí.
+                            Data se generují vždy jen pro aktuální den.
+                        </Alert>
+
+                        {error && (
+                            <Alert variant="danger" onClose={() => setError(null)} dismissible>
+                                {error}
+                            </Alert>
+                        )}
+
+                        {hasStores ? (
+                            <>
+                                <Form.Group className="mb-3">
+                                    <Form.Label>Počet osob</Form.Label>
+                                    <Form.Control
+                                        type="number"
+                                        value={count}
+                                        onChange={e => setCount(e.target.value)}
+                                        min={1}
+                                        max={50}
+                                        onKeyDown={e => e.stopPropagation()}
+                                    />
+                                    <Form.Text className="text-muted">
+                                        {hasGroups
+                                            ? 'Zadaný počet osob se doplní do každé existující skupiny.'
+                                            : 'Není založena žádná skupina — jedna se založí z náhodně vybraného obchodu a doplní se do ní zadaný počet osob.'}
+                                    </Form.Text>
+                                </Form.Group>
+
+                                <Form.Group className="mb-3">
+                                    <Form.Label>Rozsah částek (Kč)</Form.Label>
+                                    <div className="d-flex gap-2 align-items-center">
+                                        <Form.Control
+                                            type="number"
+                                            value={minAmount}
+                                            onChange={e => setMinAmount(e.target.value)}
+                                            min={0}
+                                            onKeyDown={e => e.stopPropagation()}
+                                        />
+                                        <span>—</span>
+                                        <Form.Control
+                                            type="number"
+                                            value={maxAmount}
+                                            onChange={e => setMaxAmount(e.target.value)}
+                                            min={0}
+                                            onKeyDown={e => e.stopPropagation()}
+                                        />
+                                    </div>
+                                    <Form.Text className="text-muted">
+                                        Každé osobě se nastaví náhodná částka z tohoto rozmezí a do poznámky náhodné jídlo.
+                                    </Form.Text>
+                                </Form.Group>
+                            </>
+                        ) : (
+                            <p className="text-muted mb-0">
+                                Není nadefinován žádný obchod — mock objednávky nelze vygenerovat.
+                                Nejprve přidejte obchod ve správě obchodů.
+                            </p>
+                        )}
+                    </>
+                )}
+            </Modal.Body>
+            <Modal.Footer>
+                {!success && (
+                    <>
+                        <Button variant="secondary" onClick={handleClose} disabled={loading}>
+                            Storno
+                        </Button>
+                        <Button variant="primary" onClick={handleGenerate} disabled={loading || !hasStores}>
+                            {loading ? 'Generuji...' : 'Generovat'}
+                        </Button>
+                    </>
+                )}
+                {success && (
+                    <Button variant="secondary" onClick={handleClose}>
+                        Zavřít
+                    </Button>
+                )}
+            </Modal.Footer>
+        </Modal>
+    );
+}

client/src/components/modals/PayForGroupModal.tsx

@@ -1,6 +1,6 @@
 import { useState, useEffect } from "react";
 import { Modal, Button, Form, Table, Alert } from "react-bootstrap";
-import { generateQr, OrderGroup, OrderGroupMember, QrRecipient } from "../../../../types";
+import { generateQr, GroupState, OrderGroup, OrderGroupMember, QrRecipient } from "../../../../types";
 import { sanitizeQrMessage } from "../../Utils";
 import { computeFeeShare, computeMemberTotal, countActiveMembers, isActiveMember } from "../../utils/groupFees";
 
@@ -102,6 +102,8 @@ export default function PayForGroupModal({ isOpen, onClose, onSuccess, group, pa
     };
 
     const hasFees = totalFees > 0;
+    // Generování QR je poslední krok objednávky — server skupinu zároveň překlopí do stavu Doručeno
+    const willBeMarkedDelivered = group.state !== GroupState.DELIVERED;
 
     return (
         <Modal show={isOpen} onHide={onClose} size="lg">
@@ -115,6 +117,12 @@ export default function PayForGroupModal({ isOpen, onClose, onSuccess, group, pa
                     </Alert>
                 ) : (
                     <>
+                        {willBeMarkedDelivered && (
+                            <Alert variant="info">
+                                Objednávka není ve stavu <strong>Doručeno</strong> — vygenerováním QR kódů se do tohoto stavu automaticky přepne.
+                            </Alert>
+                        )}
+
                         <p>Zaplatili jste za skupinu. Vyberte, komu vygenerovat QR kód k úhradě.</p>
 
                         {error && (

client/src/pages/OrderGroupsPage.tsx

@@ -2,7 +2,7 @@ import { useCallback, useContext, useEffect, useRef, useState } from 'react';
 import { Alert, Badge, Button, Card, Form, Modal, OverlayTrigger, Table, Tooltip } from 'react-bootstrap';
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
 import { faTrashCan } from '@fortawesome/free-regular-svg-icons';
-import { faBasketShopping, faChevronLeft, faChevronRight, faCircleCheck, faClockRotateLeft, faGear, faLock, faLockOpen, faPen, faSearch, faUserPlus } from '@fortawesome/free-solid-svg-icons';
+import { faBasketShopping, faChevronLeft, faChevronRight, faCircleCheck, faClockRotateLeft, faGear, faLock, faLockOpen, faPen, faSearch, faTruck, faUserPlus } from '@fortawesome/free-solid-svg-icons';
 import DatePicker, { registerLocale } from 'react-datepicker';
 import { cs } from 'date-fns/locale';
 import 'react-datepicker/dist/react-datepicker.css';
@@ -24,6 +24,7 @@ import StoreAdminModal from '../components/modals/StoreAdminModal';
 import PayForGroupModal from '../components/modals/PayForGroupModal';
 import EditGroupFeesModal from '../components/modals/EditGroupFeesModal';
 import BoltSimulationModal from '../components/modals/BoltSimulationModal';
+import GenerateMockOrdersModal from '../components/modals/GenerateMockOrdersModal';
 import PendingPayments from '../components/PendingPayments';
 import OrderProgress, { PROVIDER_LABEL } from '../components/OrderProgress';
 
@@ -101,11 +102,17 @@ function isoToDate(iso?: string): Date | null {
     return iso ? new Date(`${iso}T00:00:00`) : null;
 }
 
+/** Stavy, ve kterých je objednávka již odeslána do podniku (objednáno/doručeno) — skupina se nesmí upravovat. */
+function isSubmittedState(state: GroupState): boolean {
+    return state === GroupState.ORDERED || state === GroupState.DELIVERED;
+}
+
 function stateBadge(state: GroupState) {
     const map: Record<GroupState, { bg: string; label: string }> = {
         [GroupState.OPEN]: { bg: 'success', label: 'Otevřeno' },
         [GroupState.LOCKED]: { bg: 'warning', label: 'Uzamčeno' },
         [GroupState.ORDERED]: { bg: 'secondary', label: 'Objednáno' },
+        [GroupState.DELIVERED]: { bg: 'info', label: 'Doručeno' },
     };
     const { bg, label } = map[state] ?? { bg: 'light', label: state };
     return <Badge bg={bg}>{label}</Badge>;
@@ -137,6 +144,7 @@ export default function OrderGroupsPage() {
     const [payModal, setPayModal] = useState<OrderGroup | null>(null);
     const [feesModal, setFeesModal] = useState<OrderGroup | null>(null);
     const [boltSimModal, setBoltSimModal] = useState<OrderGroup | null>(null);
+    const [mockOrdersModalOpen, setMockOrdersModalOpen] = useState(false);
     const [confirmOrderGroup, setConfirmOrderGroup] = useState<OrderGroup | null>(null);
     const [pageError, setPageError] = useState<string | null>(null);
 
@@ -279,6 +287,12 @@ export default function OrderGroupsPage() {
     const handleRevertOrdered = (group: OrderGroup) =>
         refresh(() => setGroupState({ body: { id: group.id, state: GroupState.LOCKED } }));
 
+    const handleSetDelivered = (group: OrderGroup) =>
+        refresh(() => setGroupState({ body: { id: group.id, state: GroupState.DELIVERED } }));
+
+    const handleRevertDelivered = (group: OrderGroup) =>
+        refresh(() => setGroupState({ body: { id: group.id, state: GroupState.ORDERED } }));
+
     const handleDelete = (groupId: string) =>
         refresh(() => deleteGroup({ body: { id: groupId } }));
 
@@ -344,7 +358,7 @@ export default function OrderGroupsPage() {
     // Historie (jiný než aktuální den) je vždy read-only.
     const canEditMember = (group: OrderGroup, targetLogin: string) => {
         if (selectedDate) return false;
-        if (group.state === GroupState.ORDERED) return false;
+        if (isSubmittedState(group.state)) return false;
         if (auth?.login === group.creatorLogin) return true;
         if (auth?.login === targetLogin && group.state === GroupState.OPEN) return true;
         return false;
@@ -352,7 +366,7 @@ export default function OrderGroupsPage() {
 
     const canManageMembers = (group: OrderGroup) => {
         if (selectedDate) return false;
-        if (group.state === GroupState.ORDERED) return false;
+        if (isSubmittedState(group.state)) return false;
         if (auth?.login === group.creatorLogin) return true;
         return group.state === GroupState.OPEN;
     };
@@ -401,11 +415,18 @@ export default function OrderGroupsPage() {
             <div className="wrapper">
                 <div className="d-flex align-items-center justify-content-between mb-1">
                     <h1 className="title mb-0">Objednání</h1>
+                    <div className="d-flex gap-2">
+                        {IS_DEV && !isReadOnly && (
+                            <Button variant="outline-warning" size="sm" onClick={() => setMockOrdersModalOpen(true)} title="Generovat mock objednávky (DEV)">
+                                🔧 Mock objednávky
+                            </Button>
+                        )}
                         <Button variant="outline-primary" size="sm" onClick={() => setAdminModalOpen(true)} title="Správa obchodů">
                             <FontAwesomeIcon icon={faGear} className="me-1" />
                             Obchody
                         </Button>
                     </div>
+                </div>
                 <p style={{ color: 'var(--luncher-text-muted)' }}>Skupinové objednávky z obchodů a restaurací</p>
 
                 {/* Navigace mezi dny – šipky kolem výběru data (i klávesami ←/→) */}
@@ -511,6 +532,9 @@ export default function OrderGroupsPage() {
                             const isCreator = login === group.creatorLogin;
                             const isMember = login in group.members;
                             const isOrdered = group.state === GroupState.ORDERED;
+                            const isDelivered = group.state === GroupState.DELIVERED;
+                            // Objednáno i Doručeno = objednávka je odeslána do podniku, skupina se už needituje
+                            const isSubmitted = isOrdered || isDelivered;
                             const isLocked = group.state === GroupState.LOCKED;
                             const memberEntries = Object.entries(group.members) as [string, OrderGroupMember][];
                             const editingTimes = group.id in editTimes;
@@ -547,7 +571,7 @@ export default function OrderGroupsPage() {
                                             <small className="text-muted">zakladatel: {group.creatorLogin}</small>
                                         </div>
                                         <div className="d-flex gap-2">
-                                            {!isReadOnly && isCreator && !isOrdered && (
+                                            {!isReadOnly && isCreator && !isSubmitted && (
                                                 <>
                                                     <Button variant="outline-info" size="sm" onClick={() => setFeesModal(group)} title="Upravit poplatky a slevu">
                                                         Poplatky
@@ -565,20 +589,32 @@ export default function OrderGroupsPage() {
                                                     </Button>
                                                 </>
                                             )}
-                                            {!isReadOnly && isCreator && isOrdered && (
+                                            {!isReadOnly && isCreator && isSubmitted && (
                                                 <>
+                                                    {isOrdered && (
+                                                        <Button variant="outline-success" size="sm" onClick={() => handleSetDelivered(group)} title="Označit objednávku jako doručenou">
+                                                            <FontAwesomeIcon icon={faTruck} className="me-1" />
+                                                            Doručeno
+                                                        </Button>
+                                                    )}
                                                     {settings?.bankAccount && settings?.holderName && !group.qrGenerated && (
                                                         <Button variant="primary" size="sm" onClick={() => setPayModal(group)}>
                                                             <FontAwesomeIcon icon={faBasketShopping} className="me-1" />
                                                             Generovat QR
                                                         </Button>
                                                     )}
+                                                    {isDelivered ? (
+                                                        <Button variant="outline-warning" size="sm" onClick={() => handleRevertDelivered(group)} title="Vrátit na Objednáno">
+                                                            <FontAwesomeIcon icon={faClockRotateLeft} />
+                                                        </Button>
+                                                    ) : (
                                                         <Button variant="outline-warning" size="sm" onClick={() => handleRevertOrdered(group)} title="Vrátit na Uzamčeno (smaže QR kódy)">
                                                             <FontAwesomeIcon icon={faLockOpen} />
                                                         </Button>
+                                                    )}
                                                 </>
                                             )}
-                                            {!isReadOnly && !isMember && !isOrdered && !isLocked && (
+                                            {!isReadOnly && !isMember && !isSubmitted && !isLocked && (
                                                 <Button variant="outline-success" size="sm" onClick={() => handleJoin(group.id)}>
                                                     <FontAwesomeIcon icon={faUserPlus} className="me-1" />
                                                     Přidat se
@@ -764,7 +800,7 @@ export default function OrderGroupsPage() {
                                         )}
 
                                         {/* Časy objednání a doručení */}
-                                        {isOrdered && (
+                                        {isSubmitted && (
                                             <div className="px-3 py-2 border-top">
                                                 {!isReadOnly && isCreator && editingTimes ? (
                                                     <div className="d-flex align-items-center gap-3 flex-wrap">
@@ -955,6 +991,19 @@ export default function OrderGroupsPage() {
                     }}
                 />
             )}
+            {IS_DEV && (
+                <GenerateMockOrdersModal
+                    isOpen={mockOrdersModalOpen}
+                    onClose={() => {
+                        setMockOrdersModalOpen(false);
+                        // Data přijdou i websocketem, po založení skupiny se ale mění i dny s objednávkou
+                        fetchData();
+                        fetchOrderDates();
+                    }}
+                    hasGroups={groups.length > 0}
+                    hasStores={stores.length > 0}
+                />
+            )}
             {IS_DEV && boltSimModal && (
                 <BoltSimulationModal
                     isOpen={!!boltSimModal}

server/src/groups.ts

@@ -29,6 +29,26 @@ function findGroup(data: ClientData, id: string): OrderGroup | undefined {
     return data.groups?.find(g => g.id === id);
 }
 
+/** České názvy stavů pro chybová hlášení. */
+const STATE_LABEL: Record<GroupState, string> = {
+    [GroupState.OPEN]: 'otevřeno',
+    [GroupState.LOCKED]: 'uzamčeno',
+    [GroupState.ORDERED]: 'objednáno',
+    [GroupState.DELIVERED]: 'doručeno',
+};
+
+/** Stavy, ve kterých je objednávka již odeslána do podniku a nelze ji tedy upravovat. */
+function isSubmitted(state: GroupState): boolean {
+    return state === GroupState.ORDERED || state === GroupState.DELIVERED;
+}
+
+/** Ověří, že skupina není v odeslaném stavu (objednáno/doručeno), jinak vyhodí chybu. */
+function assertNotSubmitted(group: OrderGroup): void {
+    if (isSubmitted(group.state)) {
+        throw new Error(`Skupinu ve stavu "${STATE_LABEL[group.state]}" nelze upravovat`);
+    }
+}
+
 /**
  * Vrátí seznam ISO dat (YYYY-MM-DD), pro která existuje alespoň jedna objednávková skupina.
  * Slouží ke zvýraznění dnů v date pickeru na stránce objednávání.
@@ -100,7 +120,7 @@ export async function addGroupMember(login: string, groupId: string, targetLogin
     const data = await getExtraData(date);
     const group = findGroup(data, groupId);
     if (!group) throw new Error('Skupina nebyla nalezena');
-    if (group.state === GroupState.ORDERED) throw new Error('Skupinu ve stavu "objednáno" nelze upravovat');
+    assertNotSubmitted(group);
     if (login !== group.creatorLogin && login !== targetLogin) {
         throw new Error('Přidat jiného uživatele může pouze zakladatel');
     }
@@ -116,7 +136,7 @@ export async function removeGroupMember(login: string, groupId: string, targetLo
     const data = await getExtraData(date);
     const group = findGroup(data, groupId);
     if (!group) throw new Error('Skupina nebyla nalezena');
-    if (group.state === GroupState.ORDERED) throw new Error('Skupinu ve stavu "objednáno" nelze upravovat');
+    assertNotSubmitted(group);
     if (login !== group.creatorLogin && login !== targetLogin) {
         throw new Error('Odebrat jiného uživatele může pouze zakladatel');
     }
@@ -133,7 +153,7 @@ export async function updateGroupMember(login: string, groupId: string, targetLo
     const data = await getExtraData(date);
     const group = findGroup(data, groupId);
     if (!group) throw new Error('Skupina nebyla nalezena');
-    if (group.state === GroupState.ORDERED) throw new Error('Skupinu ve stavu "objednáno" nelze upravovat');
+    assertNotSubmitted(group);
     const isSelf = login === targetLogin;
     const isCreator = login === group.creatorLogin;
     if (!isSelf && !isCreator) throw new Error('Upravit jiného uživatele může pouze zakladatel');
@@ -148,7 +168,8 @@ export async function updateGroupMember(login: string, groupId: string, targetLo
 const VALID_TRANSITIONS: Record<GroupState, GroupState[]> = {
     [GroupState.OPEN]: [GroupState.LOCKED],
     [GroupState.LOCKED]: [GroupState.OPEN, GroupState.ORDERED],
-    [GroupState.ORDERED]: [GroupState.LOCKED],
+    [GroupState.ORDERED]: [GroupState.LOCKED, GroupState.DELIVERED],
+    [GroupState.DELIVERED]: [GroupState.ORDERED],
 };
 
 function getCurrentHHMM(): string {
@@ -162,7 +183,7 @@ export async function setGroupState(login: string, groupId: string, newState: Gr
     if (!group) throw new Error('Skupina nebyla nalezena');
     if (group.creatorLogin !== login) throw new Error('Stav může měnit pouze zakladatel');
     if (!VALID_TRANSITIONS[group.state].includes(newState)) {
-        throw new Error(`Nelze přejít ze stavu "${group.state}" do stavu "${newState}"`);
+        throw new Error(`Nelze přejít ze stavu "${STATE_LABEL[group.state]}" do stavu "${STATE_LABEL[newState]}"`);
     }
     if (newState === GroupState.ORDERED) {
         group.orderedAt = getCurrentHHMM();
@@ -185,14 +206,19 @@ export async function setGroupState(login: string, groupId: string, newState: Gr
     return saveExtraData(data, date);
 }
 
-export async function markGroupQrGenerated(login: string, groupId: string, date?: Date): Promise<void> {
+/**
+ * Označí skupinu za vygenerovanou (blokuje opakované generování QR) a zároveň ji
+ * překlopí do stavu "doručeno" — generování QR je poslední krok objednávky.
+ */
+export async function markGroupQrGenerated(login: string, groupId: string, date?: Date): Promise<ClientData> {
     const data = await getExtraData(date);
     const group = findGroup(data, groupId);
     if (!group) throw new Error('Skupina nebyla nalezena');
     if (group.creatorLogin !== login) throw new Error('QR kódy může generovat pouze zakladatel');
-    if (group.state !== GroupState.ORDERED) throw new Error('QR kódy lze generovat pouze ve stavu "objednáno"');
+    if (!isSubmitted(group.state)) throw new Error('QR kódy lze generovat pouze ve stavu "objednáno" nebo "doručeno"');
     group.qrGenerated = true;
-    await saveExtraData(data, date);
+    group.state = GroupState.DELIVERED;
+    return saveExtraData(data, date);
 }
 
 export async function markGroupMemberPaid(login: string, groupId: string, date?: Date): Promise<ClientData | null> {
@@ -208,7 +234,7 @@ export async function updateGroupFees(login: string, groupId: string, fees?: num
     const group = findGroup(data, groupId);
     if (!group) throw new Error('Skupina nebyla nalezena');
     if (group.creatorLogin !== login) throw new Error('Poplatky může měnit pouze zakladatel');
-    if (group.state === GroupState.ORDERED) throw new Error('Skupinu ve stavu "objednáno" nelze upravovat');
+    assertNotSubmitted(group);
     if (fees !== undefined) group.fees = fees > 0 ? fees : undefined;
     if (shipping !== undefined) group.shipping = shipping > 0 ? shipping : undefined;
     if (tip !== undefined) group.tip = tip > 0 ? tip : undefined;
@@ -238,7 +264,7 @@ export async function setGroupTracking(login: string, groupId: string, shareUrl?
         group.trackingOrderState = undefined;
         group.trackingCourierState = undefined;
     } else {
-        if (group.state !== GroupState.ORDERED) throw new Error('Sledování objednávky lze nastavit pouze ve stavu "objednáno"');
+        if (!isSubmitted(group.state)) throw new Error('Sledování objednávky lze nastavit pouze ve stavu "objednáno" nebo "doručeno"');
         const tracking = extractTracking(shareUrl);
         if (!tracking) throw new Error('Neplatný odkaz na sledování objednávky');
         if (tracking.code !== group.trackingCode || tracking.provider !== group.trackingProvider) {

server/src/restaurants.ts

@@ -22,7 +22,9 @@ const SOUP_NAMES = [
     'zeleninová s ',
     'hovězí s ',
     'kachní kaldoun',
-    'dršťková'
+    'dršťková',
+    'žampionový krém',
+    'zelná',
 ];
 const DAYS_IN_WEEK = ['pondělí', 'úterý', 'středa', 'čtvrtek', 'pátek', 'sobota', 'neděle'];
 

server/src/routes/devRoutes.ts

@@ -6,7 +6,9 @@ import { getWebsocket } from "../websocket";
 import { getLogin } from "../auth";
 import { parseToken } from "../utils";
 import webpush from 'web-push';
-import { ClientData, GroupState, TrackingProvider } from "../../../types/gen/types.gen";
+import { ClientData, GroupState, MealSlot, OrderGroupMember, TrackingProvider } from "../../../types/gen/types.gen";
+import { getStores } from "../stores";
+import { createGroup } from "../groups";
 import {
     startBoltSimulation, advanceBoltSimulation, setBoltSimulationStep,
     stopBoltSimulationByGroup, getBoltSimulation,
@@ -36,6 +38,39 @@ const LUNCH_CHOICES = [
     'ROZHODUJI',
 ];
 
+// Náhodné názvy jídel do poznámek mock objednávek
+const MOCK_ORDER_FOODS = [
+    'Malá kuřecí tortilla',
+    'Jalapenos burger',
+    'Chicken Palak',
+    'Pad Thai s kuřecím',
+    'Bún bò nam bo',
+    'Trhané hovězí v bulce',
+    'Caesar salát s kuřetem',
+    'Kuřecí vindaloo',
+    'Smažený sýr s hranolkami',
+    'Pizza Diavola',
+    'Burrito s trhaným masem',
+    'Ramen s vepřovým bůčkem',
+    'Falafel wrap v pitě',
+    'Krůtí steak s bramborovou kaší',
+    'Gyros se zeleninou',
+    'Losos s grilovanou zeleninou',
+    'Svíčková na smetaně s knedlíkem',
+    'Kuřecí kung pao',
+    'Poke bowl s tuňákem',
+    'Vepřový řízek s bramborovým salátem',
+];
+
+/** Výchozí hodnoty dialogu pro generování mock objednávek. */
+const DEFAULT_ORDER_MEMBER_COUNT = 3;
+const DEFAULT_MIN_AMOUNT = 100;
+const DEFAULT_MAX_AMOUNT = 1000;
+/** Nejvyšší povolený počet osob doplněných do jedné skupiny. */
+const MAX_ORDER_MEMBER_COUNT = 50;
+/** Nejvyšší povolená částka (v Kč) — musí odpovídat OpenAPI definici. */
+const MAX_ORDER_AMOUNT = 100000;
+
 // Restaurace s menu
 const RESTAURANTS_WITH_MENU = [
     'SLADOVNICKA',
@@ -249,6 +284,112 @@ router.post("/testPush", async (req, res, next) => {
     } catch (e: any) { next(e) }
 });
 
+// --- DEV mock data pro sekci Objednání ---
+
+/** Vrátí náhodné celé číslo z intervalu <min, max>. */
+function randomInt(min: number, max: number): number {
+    return min + Math.floor(Math.random() * (max - min + 1));
+}
+
+/** Vrátí náhodný prvek neprázdného pole. */
+function randomItem<Type>(items: Type[]): Type {
+    return items[randomInt(0, items.length - 1)];
+}
+
+/**
+ * Vybere jméno, které ve skupině ještě není použité.
+ * Po vyčerpání seznamu jmen přidává číselný sufix (Alice2, Alice3, …).
+ */
+function pickMemberName(members: Record<string, OrderGroupMember>): string {
+    const free = MOCK_NAMES.filter(name => !members[name]);
+    if (free.length > 0) {
+        return randomItem(free);
+    }
+    const base = randomItem(MOCK_NAMES);
+    let suffix = 2;
+    while (members[`${base}${suffix}`]) {
+        suffix++;
+    }
+    return `${base}${suffix}`;
+}
+
+/** Rozešle klientům aktuální data sekce Objednání (dnešní den). */
+async function broadcastExtra() {
+    getWebsocket().emit("message", await getData(getToday(), MealSlot.EXTRA));
+}
+
+/**
+ * Vygeneruje mock data pro sekci Objednání — vždy jen pro aktuální den.
+ * Do každé existující skupiny doplní zadaný počet osob s náhodnou částkou
+ * a názvem náhodného jídla v poznámce. Pokud žádná skupina neexistuje,
+ * založí jednu z náhodně vybraného obchodu.
+ */
+router.post("/generateOrders", async (req: Request<{}, any, any>, res, next) => {
+    try {
+        const login = getLogin(parseToken(req));
+        const count: number = req.body?.count ?? DEFAULT_ORDER_MEMBER_COUNT;
+        const minAmount: number = req.body?.minAmount ?? DEFAULT_MIN_AMOUNT;
+        const maxAmount: number = req.body?.maxAmount ?? DEFAULT_MAX_AMOUNT;
+
+        if (!Number.isInteger(count) || count < 1 || count > MAX_ORDER_MEMBER_COUNT) {
+            return res.status(400).json({ error: `Počet osob musí být celé číslo mezi 1 a ${MAX_ORDER_MEMBER_COUNT}` });
+        }
+        if (!Number.isInteger(minAmount) || !Number.isInteger(maxAmount)
+            || minAmount < 0 || maxAmount > MAX_ORDER_AMOUNT || minAmount > maxAmount) {
+            return res.status(400).json({ error: 'Neplatný rozsah částek' });
+        }
+
+        const stores = await getStores();
+        if (stores.length === 0) {
+            return res.status(400).json({ error: 'Není nadefinován žádný obchod — mock data pro objednávání nelze vygenerovat' });
+        }
+
+        const key = `${formatDate(getToday())}_extra`;
+        const existing = await storage.getData<ClientData>(key);
+        let createdGroupId: string | undefined;
+
+        // Bez skupiny není kam objednávky doplnit — jednu založíme z náhodně vybraného obchodu
+        if (!existing?.groups?.length) {
+            const store = randomItem(stores);
+            const urls = store.urls ?? [];
+            const created = await createGroup(login, store.name, undefined, urls.length > 0 ? randomItem(urls) : undefined);
+            createdGroupId = created.groups?.[created.groups.length - 1]?.id;
+        }
+
+        const results: { id: string, name: string, added: number, created?: boolean }[] = [];
+        await storage.updateData<ClientData>(key, current => {
+            const data = current!;
+            // Mutátor může být (u Redis) zavolán opakovaně — výsledky proto vždy sestavíme znovu
+            results.length = 0;
+            for (const group of data.groups ?? []) {
+                for (let i = 0; i < count; i++) {
+                    group.members[pickMemberName(group.members)] = {
+                        amount: randomInt(minAmount, maxAmount) * 100,
+                        note: randomItem(MOCK_ORDER_FOODS),
+                    };
+                }
+                results.push({
+                    id: group.id,
+                    name: group.name,
+                    added: count,
+                    ...(group.id === createdGroupId ? { created: true } : {}),
+                });
+            }
+            return data;
+        });
+
+        await broadcastExtra();
+
+        res.status(200).json({
+            success: true,
+            count: results.reduce((sum, group) => sum + group.added, 0),
+            groups: results,
+        });
+    } catch (e: any) {
+        next(e);
+    }
+});
+
 // --- DEV simulace sledování Bolt Food (Wolt simulaci zatím nemá) ---
 
 /** Nastaví/zruší sledovací token skupiny a zajistí stav ORDERED. Vrátí aktualizovaná data. */

server/src/routes/qrRoutes.ts

@@ -4,7 +4,7 @@ import { parseToken, formatDate } from "../utils";
 import { generateQr } from "../qr";
 import { addPendingQr } from "../pizza";
 import { markGroupQrGenerated } from "../groups";
-import { emitToUser } from "../websocket";
+import { emitToUser, getWebsocket } from "../websocket";
 import { GenerateQrData } from "../../../types";
 import crypto from "crypto";
 
@@ -59,7 +59,9 @@ router.post("/generate", async (req: Request<{}, any, GenerateQrData["body"]>, r
         }
 
         if (groupId) {
-            await markGroupQrGenerated(login, groupId);
+            // Skupina se zároveň překlopí do stavu "doručeno" — rozešleme nová data všem
+            const data = await markGroupQrGenerated(login, groupId);
+            getWebsocket().emit("message", data);
         }
 
         res.status(200).json({ success: true, count: recipients.length });

server/src/service.ts

@@ -259,8 +259,10 @@ export async function getRestaurantMenu(restaurant: Restaurant, date?: Date, for
     const lastFetchExpired = !existingMenu?.lastUpdate ||
         existingMenu.lastUpdate === now || // freshly initialized, never fetched
         (now - existingMenu.lastUpdate) > MENU_REFETCH_TTL_MS;
-    const shouldFetch = forceRefresh ||
+    // Data označená jako "z minulého týdne" se musí zkoušet načíst znovu, jinak by u nich
-        (!existingMenu?.food?.length && !existingMenu?.closed && lastFetchExpired);
+    // varování zůstalo viset celý týden i poté, co podnik nabídku na svém webu aktualizuje.
+    const needsData = existingMenu?.isStale || (!existingMenu?.food?.length && !existingMenu?.closed);
+    const shouldFetch = forceRefresh || (needsData && lastFetchExpired);
     if (shouldFetch) {
         const firstDay = getFirstWorkDayOfWeek(usedDate);
 

server/src/tests/devRoutes.test.ts

@@ -0,0 +1,157 @@
+import express from 'express';
+import request from 'supertest';
+import bodyParser from 'body-parser';
+import { generateToken } from '../auth';
+import { resetMemoryStorage } from '../storage/memory';
+import getStorage from '../storage';
+import devRouter from '../routes/devRoutes';
+import { createGroup } from '../groups';
+import { ClientData, Store } from '../../../types/gen/types.gen';
+import { formatDate } from '../utils';
+import { getToday } from '../service';
+
+// Websocket v testech neexistuje – broadcast jen odchytíme
+jest.mock('../websocket', () => ({
+    getWebsocket: () => ({ emit: jest.fn() }),
+    emitToUser: jest.fn(),
+}));
+
+const storage = getStorage();
+const TOKEN = `Bearer ${generateToken('testuser')}`;
+
+function buildApp() {
+    const app = express();
+    app.use(bodyParser.json());
+    app.use('/api/dev', devRouter);
+    app.use((err: any, _req: any, res: any, _next: any) => {
+        res.status(400).json({ error: err.message });
+    });
+    return app;
+}
+
+/** Vrátí uložená data sekce Objednání pro dnešní den. */
+async function getExtra(): Promise<ClientData | undefined> {
+    return storage.getData<ClientData>(`${formatDate(getToday())}_extra`);
+}
+
+async function setStores(stores: Store[]) {
+    await storage.setData('stores', stores);
+}
+
+beforeEach(() => {
+    resetMemoryStorage();
+});
+
+test('POST /dev/generateOrders bez nadefinovaného obchodu vrátí 400', async () => {
+    const res = await request(buildApp())
+        .post('/api/dev/generateOrders')
+        .set('Authorization', TOKEN)
+        .send({});
+    expect(res.status).toBe(400);
+});
+
+test('POST /dev/generateOrders bez existující skupiny založí jednu a doplní do ní osoby', async () => {
+    await setStores([{ name: 'Bistro', urls: ['https://example.com/bistro'] }]);
+
+    const res = await request(buildApp())
+        .post('/api/dev/generateOrders')
+        .set('Authorization', TOKEN)
+        .send({ count: 4, minAmount: 100, maxAmount: 1000 });
+
+    expect(res.status).toBe(200);
+    expect(res.body.count).toBe(4);
+    expect(res.body.groups).toHaveLength(1);
+    expect(res.body.groups[0].created).toBe(true);
+
+    const data = await getExtra();
+    const group = data?.groups?.[0];
+    expect(group?.name).toBe('Bistro');
+    expect(group?.url).toBe('https://example.com/bistro');
+    // Zakladatel (přihlášený uživatel) + 4 doplněné osoby
+    const members = Object.entries(group!.members);
+    expect(members).toHaveLength(5);
+    const mockMembers = members.filter(([login]) => login !== 'testuser');
+    expect(mockMembers).toHaveLength(4);
+    for (const [, member] of mockMembers) {
+        expect(member.amount).toBeGreaterThanOrEqual(100 * 100);
+        expect(member.amount).toBeLessThanOrEqual(1000 * 100);
+        expect(member.note).toBeTruthy();
+    }
+});
+
+test('POST /dev/generateOrders doplní osoby do všech existujících skupin', async () => {
+    await setStores([{ name: 'Bistro' }, { name: 'Pizzerie' }]);
+    await createGroup('testuser', 'Bistro');
+    await createGroup('kolega', 'Pizzerie');
+
+    const res = await request(buildApp())
+        .post('/api/dev/generateOrders')
+        .set('Authorization', TOKEN)
+        .send({ count: 2 });
+
+    expect(res.status).toBe(200);
+    expect(res.body.count).toBe(4);
+    expect(res.body.groups).toHaveLength(2);
+    expect(res.body.groups.every((g: any) => g.created === undefined)).toBe(true);
+
+    const data = await getExtra();
+    expect(data?.groups).toHaveLength(2);
+    for (const group of data!.groups!) {
+        // Zakladatel + 2 doplněné osoby
+        expect(Object.keys(group.members)).toHaveLength(3);
+    }
+});
+
+test('POST /dev/generateOrders použije výchozí hodnoty, když nejsou zadány', async () => {
+    await setStores([{ name: 'Bistro' }]);
+
+    const res = await request(buildApp())
+        .post('/api/dev/generateOrders')
+        .set('Authorization', TOKEN)
+        .send({});
+
+    expect(res.status).toBe(200);
+    // Výchozí počet osob je 3
+    expect(res.body.count).toBe(3);
+
+    const data = await getExtra();
+    for (const [login, member] of Object.entries(data!.groups![0].members)) {
+        if (login === 'testuser') continue;
+        // Výchozí rozsah částek je 100–1000 Kč
+        expect(member.amount).toBeGreaterThanOrEqual(100 * 100);
+        expect(member.amount).toBeLessThanOrEqual(1000 * 100);
+    }
+});
+
+test('POST /dev/generateOrders zvládne počet osob přesahující seznam jmen', async () => {
+    await setStores([{ name: 'Bistro' }]);
+
+    const res = await request(buildApp())
+        .post('/api/dev/generateOrders')
+        .set('Authorization', TOKEN)
+        .send({ count: 50 });
+
+    expect(res.status).toBe(200);
+    expect(res.body.count).toBe(50);
+
+    const data = await getExtra();
+    // Všechna jména musí být unikátní (zakladatel + 50 doplněných osob)
+    expect(Object.keys(data!.groups![0].members)).toHaveLength(51);
+});
+
+test('POST /dev/generateOrders odmítne neplatný počet osob a rozsah částek', async () => {
+    await setStores([{ name: 'Bistro' }]);
+    const app = buildApp();
+
+    const badCount = await request(app)
+        .post('/api/dev/generateOrders')
+        .set('Authorization', TOKEN)
+        .send({ count: 0 });
+    expect(badCount.status).toBe(400);
+
+    const badRange = await request(app)
+        .post('/api/dev/generateOrders')
+        .set('Authorization', TOKEN)
+        .send({ minAmount: 500, maxAmount: 100 });
+    expect(badRange.status).toBe(400);
+});

server/src/tests/groups.test.ts

@@ -1,6 +1,6 @@
 import { resetMemoryStorage } from '../storage/memory';
 import { getStores, addStore } from '../stores';
-import { createGroup, deleteGroup, addGroupMember, removeGroupMember, updateGroupMember, setGroupState, setGroupTracking, markGroupMemberPaid } from '../groups';
+import { createGroup, deleteGroup, addGroupMember, removeGroupMember, updateGroupMember, setGroupState, setGroupTracking, markGroupMemberPaid, markGroupQrGenerated } from '../groups';
 import { GroupState } from '../../../types/gen/types.gen';
 
 const CREATOR = 'tomas';
@@ -219,12 +219,48 @@ describe('setGroupState', () => {
         await expect(setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY)).rejects.toThrow('Nelze přejít');
     });
 
-    test('ordered je terminální stav', async () => {
+    test('ordered → open není povoleno', async () => {
         await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
         await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
         await expect(setGroupState(CREATOR, groupId, GroupState.OPEN, TODAY)).rejects.toThrow('Nelze přejít');
     });
 
+    test('ordered → delivered', async () => {
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
+        const d = await setGroupState(CREATOR, groupId, GroupState.DELIVERED, TODAY);
+        expect(d.groups![0].state).toBe(GroupState.DELIVERED);
+    });
+
+    test('delivered → ordered (vrácení)', async () => {
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.DELIVERED, TODAY);
+        const d = await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
+        expect(d.groups![0].state).toBe(GroupState.ORDERED);
+    });
+
+    test('locked → delivered není povoleno', async () => {
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await expect(setGroupState(CREATOR, groupId, GroupState.DELIVERED, TODAY)).rejects.toThrow('Nelze přejít');
+    });
+
+    test('delivered → locked není povoleno', async () => {
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.DELIVERED, TODAY);
+        await expect(setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY)).rejects.toThrow('Nelze přejít');
+    });
+
+    test('skupinu ve stavu delivered nelze upravovat', async () => {
+        await addGroupMember(CREATOR, groupId, USER, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.DELIVERED, TODAY);
+        await expect(updateGroupMember(CREATOR, groupId, USER, { amount: 100 }, TODAY)).rejects.toThrow('doručeno');
+        await expect(addGroupMember(CREATOR, groupId, 'dalsi', TODAY)).rejects.toThrow('doručeno');
+    });
+
     test('nečlen nemůže měnit stav', async () => {
         await expect(setGroupState(USER, groupId, GroupState.LOCKED, TODAY)).rejects.toThrow('zakladatel');
     });
@@ -240,6 +276,42 @@ describe('setGroupState', () => {
     });
 });
 
+describe('markGroupQrGenerated', () => {
+    let groupId: string;
+
+    beforeEach(async () => {
+        const d = await createGroup(CREATOR, STORE, TODAY);
+        groupId = d.groups![0].id;
+    });
+
+    test('ze stavu ordered přepne skupinu na delivered', async () => {
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
+        const d = await markGroupQrGenerated(CREATOR, groupId, TODAY);
+        expect(d.groups![0].state).toBe(GroupState.DELIVERED);
+        expect(d.groups![0].qrGenerated).toBe(true);
+    });
+
+    test('funguje i ve stavu delivered', async () => {
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.DELIVERED, TODAY);
+        const d = await markGroupQrGenerated(CREATOR, groupId, TODAY);
+        expect(d.groups![0].state).toBe(GroupState.DELIVERED);
+    });
+
+    test('ve stavu locked selže', async () => {
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await expect(markGroupQrGenerated(CREATOR, groupId, TODAY)).rejects.toThrow('objednáno');
+    });
+
+    test('QR může generovat pouze zakladatel', async () => {
+        await setGroupState(CREATOR, groupId, GroupState.LOCKED, TODAY);
+        await setGroupState(CREATOR, groupId, GroupState.ORDERED, TODAY);
+        await expect(markGroupQrGenerated(USER, groupId, TODAY)).rejects.toThrow('zakladatel');
+    });
+});
+
 describe('markGroupMemberPaid', () => {
     test('označí člena jako zaplaceného pro daný den', async () => {
         const d = await createGroup(CREATOR, STORE, TODAY);

server/src/tests/service.staleMenu.test.ts

@@ -0,0 +1,87 @@
+const mockStorageData = new Map<string, any>();
+jest.mock('../storage', () => ({
+    __esModule: true,
+    default: () => ({
+        hasData: async (key: string) => mockStorageData.has(key),
+        getData: async <T>(key: string) => mockStorageData.get(key) as T,
+        setData: async <T>(key: string, val: T) => void mockStorageData.set(key, val),
+    }),
+    storageReady: Promise.resolve(),
+}));
+
+const mockGetMenuTechTower = jest.fn();
+jest.mock('../restaurants', () => ({
+    ...jest.requireActual('../restaurants'),
+    getMenuTechTower: (...args: any[]) => mockGetMenuTechTower(...args),
+}));
+
+import { getMenuKey, getRestaurantMenu } from '../service';
+
+// Středa 2025-01-08 (týden 2025-02)
+const STREDA = new Date('2025-01-08T10:00:00');
+const HODINA = 60 * 60 * 1000;
+
+/** Menu jednoho dne se všemi náležitostmi, aby nevznikala jiná varování. */
+const denniMenu = (nazev: string) => [
+    { amount: '-', name: `Polévka ${nazev}`, price: '30 Kč', isSoup: true },
+    { amount: '-', name: nazev, price: '150 Kč', isSoup: false },
+];
+
+/** Naplní storage týdenním menu TechTower s předaným příznakem zastaralosti. */
+const seedWeekMenu = (isStale: boolean, lastUpdate: number) => {
+    const week = [0, 1, 2, 3, 4].map(i => ({
+        TECHTOWER: {
+            lastUpdate,
+            closed: false,
+            isStale,
+            food: denniMenu(`Jídlo z minulého týdne ${i}`),
+        },
+    }));
+    mockStorageData.set(getMenuKey(STREDA), week);
+};
+
+describe('getRestaurantMenu – obnovení dat z minulého týdne', () => {
+    beforeAll(() => {
+        jest.useFakeTimers();
+        jest.setSystemTime(STREDA);
+    });
+
+    afterAll(() => {
+        jest.useRealTimers();
+    });
+
+    beforeEach(() => {
+        mockStorageData.clear();
+        mockGetMenuTechTower.mockReset();
+    });
+
+    test('zastaralá data se znovu načtou a varování zmizí', async () => {
+        seedWeekMenu(true, Date.now() - 2 * HODINA);
+        mockGetMenuTechTower.mockResolvedValue([0, 1, 2, 3, 4].map(i => denniMenu(`Aktuální jídlo ${i}`)));
+
+        const menu = await getRestaurantMenu('TECHTOWER', STREDA);
+
+        expect(mockGetMenuTechTower).toHaveBeenCalledTimes(1);
+        expect(menu.isStale).toBe(false);
+        expect(menu.food?.[1].name).toBe('Aktuální jídlo 2');
+        expect(menu.warnings).not.toContain('Data jsou z minulého týdne');
+    });
+
+    test('aktuální data se znovu nenačítají', async () => {
+        seedWeekMenu(false, Date.now() - 2 * HODINA);
+
+        const menu = await getRestaurantMenu('TECHTOWER', STREDA);
+
+        expect(mockGetMenuTechTower).not.toHaveBeenCalled();
+        expect(menu.warnings).toEqual([]);
+    });
+
+    test('zastaralá data se neobnovují častěji než jednou za hodinu', async () => {
+        seedWeekMenu(true, Date.now() - 5 * 60 * 1000);
+
+        const menu = await getRestaurantMenu('TECHTOWER', STREDA);
+
+        expect(mockGetMenuTechTower).not.toHaveBeenCalled();
+        expect(menu.warnings).toContain('Data jsou z minulého týdne');
+    });
+});

types/api.yml

@@ -162,6 +162,8 @@ paths:
     $ref: "./paths/dev/generate.yml"
   /dev/clear:
     $ref: "./paths/dev/clear.yml"
+  /dev/generateOrders:
+    $ref: "./paths/dev/generateOrders.yml"
   /dev/bolt/simulate:
     $ref: "./paths/dev/boltSimulate.yml"
   /dev/bolt/advance:

types/paths/dev/generateOrders.yml

@@ -0,0 +1,31 @@
+post:
+  operationId: generateMockOrders
+  summary: Vygenerování mock dat pro sekci Objednání – vždy jen pro aktuální den (pouze DEV režim)
+  requestBody:
+    required: false
+    content:
+      application/json:
+        schema:
+          $ref: "../../schemas/_index.yml#/GenerateMockOrdersRequest"
+  responses:
+    "200":
+      description: Mock data pro objednávání byla úspěšně vygenerována
+      content:
+        application/json:
+          schema:
+            type: object
+            properties:
+              success:
+                type: boolean
+              count:
+                description: Celkový počet doplněných osob
+                type: integer
+              groups:
+                description: Rozpis doplněných osob po skupinách
+                type: array
+                items:
+                  $ref: "../../schemas/_index.yml#/MockOrdersGroupResult"
+    "400":
+      description: Chybný požadavek (např. není nadefinován žádný obchod)
+    "403":
+      description: Endpoint není dostupný v tomto režimu

types/schemas/_index.yml

@@ -783,6 +783,47 @@ MockDataDayResult:
     count:
       description: Počet vygenerovaných záznamů pro daný den
       type: integer
+GenerateMockOrdersRequest:
+  description: Request pro generování mock dat sekce Objednání (pouze DEV režim)
+  type: object
+  additionalProperties: false
+  properties:
+    count:
+      description: Počet osob, které se doplní do každé existující skupiny objednávky
+      type: integer
+      minimum: 1
+      maximum: 50
+    minAmount:
+      description: Dolní hranice náhodně generované částky v Kč
+      type: integer
+      minimum: 0
+      maximum: 100000
+    maxAmount:
+      description: Horní hranice náhodně generované částky v Kč
+      type: integer
+      minimum: 0
+      maximum: 100000
+MockOrdersGroupResult:
+  description: Výsledek doplnění mock osob do jedné skupiny objednávky
+  type: object
+  additionalProperties: false
+  required:
+    - id
+    - name
+    - added
+  properties:
+    id:
+      description: ID skupiny objednávky
+      type: string
+    name:
+      description: Název obchodu skupiny
+      type: string
+    added:
+      description: Počet osob doplněných do skupiny
+      type: integer
+    created:
+      description: Příznak, zda byla skupina právě založena (neexistovala žádná)
+      type: boolean
 ClearMockDataRequest:
   description: Request pro smazání mock dat (pouze DEV režim)
   type: object
@@ -909,10 +950,12 @@ GroupState:
     - open
     - locked
     - ordered
+    - delivered
   x-enum-varnames:
     - OPEN
     - LOCKED
     - ORDERED
+    - DELIVERED
 
 OrderGroupMember:
   description: Data člena skupiny objednávky