@alizadefaig/pos-server 1.2.25 → 1.2.27

package/app/core/services/OrderService.js

@@ -0,0 +1,903 @@
+const OrderRepository = require('../repositories/OrderRepository');
+const OrderProductRepository = require('../repositories/OrderProductRepository');
+const PaymentRepository = require('../repositories/PaymentRepository');
+const EventRepository = require('../repositories/EventRepository');
+const SnapshotRepository = require('../repositories/SnapshotRepository');
+const OrderResource = require('../resources/OrderResource');
+const OrderProduct = require('../models/OrderProduct');
+const StorageService = require('./StorageService');
+const KdsService = require('./KdsService');
+const TelegramService = require('./TelegramService');
+const {HttpError, notFound} = require('../errors');
+const {money, qty, toFloat, toInt, toBool} = require('../support/num');
+const {now, nowSql, fromTimestamp, toSql} = require('../support/time');
+const {businessDay} = require('../support/tz');
+const {uuid, isUuid} = require('../support/ids');
+const {htmlspecialchars, md5, phpJsonEncode} = require('../support/str');
+const {castRow} = require('../support/db');
+const {assertOrderMutable} = require('../guard');
+const {withLock} = require('../support/lock');
+
+const TYPE_TIMER = OrderProduct.TYPE_TIMER;
+const TYPE_EXTRA = OrderProduct.TYPE_EXTRA;
+
+const DINE_IN = 'dine_in';
+const DELIVERY = 'delivery';
+const PIECE_CODE = 'pcs';
+
+const numberFormat = (value, decimals = 2) => toFloat(value).toFixed(decimals);
+
+/**
+ * Порт App\Services\Platform\OrderService — жизненный цикл чека от открытия до закрытия.
+ *
+ * Печать живёт в PrintService, кухонный экран — в KdsService (тикеты гасятся здесь, на закрытии
+ * и удалении чека). Склад (StorageService) и Telegram (TelegramService) работают только в
+ * облачном контуре; на кассе их ведёт облако при приёме выгруженных чеков.
+ *
+ * Склад двигается по одному правилу — по позиции списано
+ * StorageService.held(quantity, workshop_print_quantity): каждое изменение количества или
+ * напечатанного идёт через storage.settle(было, стало). Прежние ошибки учёта (блюдо списывало
+ * одну порцию, возврат при печати считался от напечатанного) исправлены по этому правилу
+ * одновременно здесь и в PHP — событие по-прежнему можно возить через CORE_EVENTS.
+ * То же правило у orderProducts.remove, слияния строк в setGuestNumber и removeCustomer (строки
+ * гостя удаляются — held возвращается целиком); updateModifiers меняет только модификаторы на
+ * held позиции (StorageService.swapModifiers).
+ */
+class OrderService {
+    constructor({db, context, emitter = null}) {
+        this.db = db;
+        this.context = context;
+        this.emitter = emitter;
+
+        this.orders = new OrderRepository(db, context);
+        this.orderProducts = new OrderProductRepository(db);
+        this.payments = new PaymentRepository(db);
+        this.events = new EventRepository(db);
+        this.snapshot = new SnapshotRepository(db);
+        this.storage = new StorageService({db, context});
+        this.telegram = new TelegramService({db, context});
+    }
+
+    resource() {
+        // Новый экземпляр на каждый ответ: внутри связи товаров, которые не должны переживать
+        // изменение справочников между запросами.
+        return new OrderResource(this.snapshot, this.context.locale());
+    }
+
+    /** Список чеков через один ресурс: связи товаров всех чеков грузятся одним заходом. */
+    async mapResource(orders) {
+        const resource = this.resource();
+        await resource.preload(orders);
+        const result = [];
+        for (const order of orders) {
+            result.push(await resource.order(order));
+        }
+        return result;
+    }
+
+    /**
+     * Ответ мутации: бродкаст-патч уже собрал ресурс — переиспользуем его вместо
+     * повторного чтения чека. Без эмиттера (тесты, локальный старт) собираем сами.
+     */
+    async patchOrResource(orderId, options = {}) {
+        const payload = await this.emitPatch(orderId);
+        if (payload) {
+            return payload;
+        }
+        return this.resource().order(await this.findOrFail(orderId, options));
+    }
+
+    async findOrFail(orderId, options = {}) {
+        const order = await this.orders.find(orderId, options);
+        if (!order) {
+            throw notFound('Order not found');
+        }
+        return order;
+    }
+
+    async saveEvents(events) {
+        await this.events.saveEvents(events, this.context);
+        // Только облако (TelegramService.active): на кассе уведомления шлёт облако при приёме чеков.
+        await this.telegram.notifyEvents(events);
+    }
+
+    /** Guard закрытого чека с контекстом запроса для журнала. */
+    assertMutable(order, action, message = null) {
+        assertOrderMutable(order, action, message, this.context);
+    }
+
+    /**
+     * Открытая кассовая смена — порт `ShiftService::getCashShift`. Резолв смены не имеет
+     * права сорвать закрытие: деньги уже приняты, привязку досоставит syncClosedOrder.
+     */
+    async resolveCashShiftId() {
+        if (!toBool(this.context.setting('manage.use_cash_shift', false))) {
+            return null;
+        }
+        try {
+            const shift = await this.snapshot.findOpenCashShift(this.context.teamId, this.context.companyId);
+            return shift ? shift.id : null;
+        } catch (error) {
+            console.warn('[order-close] shift resolve failed', error.message);
+            return null;
+        }
+    }
+
+    /** Патч одного чека в сокет — аналог SocketService::emitOrderPatch. */
+    async emitPatch(orderId) {
+        if (!this.emitter) {
+            return null;
+        }
+        const order = await this.orders.find(orderId, {withTrashed: true});
+        if (!order) {
+            return null;
+        }
+        const payload = await this.resource().order(order);
+        this.emitter.orderPatch(order.company_id, payload);
+        return payload;
+    }
+
+    async emitUpdateOrders() {
+        if (this.emitter) {
+            // Ждём обязательно: updateOrders сам ходит в БД за списком открытых чеков, и
+            // брошенный промис = unhandled rejection (в Node 22 это падение процесса).
+            // В Laravel эмит тоже блокирующий (HTTP к Node), так что порядок тот же.
+            await this.emitter.updateOrders(this.context.companyId);
+        }
+    }
+
+    // ---------------------------------------------------------------- чек
+
+    async create({orderSourceId, tableId, guestCount = 1, hallId = null, servingId = null, id = null, slotIndex = 1}) {
+        const context = this.context;
+
+        let orderSource = await this.snapshot.findOrderSource(context.teamId, orderSourceId);
+        if (!orderSource) {
+            orderSource = await this.snapshot.findOrderSourceByType(context.teamId, DINE_IN);
+        }
+        if (!orderSource) {
+            throw notFound('Order source not found');
+        }
+
+        if (!servingId) {
+            if (orderSource.type === DINE_IN) {
+                servingId = context.employeeId;
+            }
+            if (orderSource.type === DELIVERY) {
+                const courierRole = await this.snapshot.findCourierRole(context.teamId);
+                const courier = courierRole ? await this.snapshot.findFirstTeamUserByRole(courierRole.id) : null;
+                servingId = courier ? courier.id : context.employeeId;
+            }
+        }
+
+        let serviceCharge = 0;
+        if (context.setting('terminal_settings.apply_service_charge_automatically', false)) {
+            const company = context.getCompany();
+            serviceCharge = company ? toFloat(company.service_charge) : 0;
+        }
+
+        const team = context.getTeam();
+        const resetNumber = toBool(context.setting('receipts.reset_number', false));
+        const table = tableId ? await this.snapshot.findTable(tableId) : null;
+        const orderId = id || uuid();
+
+        // Номер и вставка — под одним замком компании: иначе два одновременных create прочли бы
+        // один и тот же MAX(number).
+        await withLock(`order-number:${context.companyId}`, async () => {
+            let numbers;
+            if (resetNumber && team) {
+                const [dayFrom, dayTo] = businessDay(now(), {
+                    timezone: team.timezone,
+                    shiftEndsAt: team.shift_ends_at,
+                    now: now(),
+                });
+                numbers = await this.orders.nextNumbers(context.companyId, {
+                    resetNumber: true,
+                    dayFrom: toSql(dayFrom),
+                    dayTo: toSql(dayTo),
+                });
+            } else {
+                numbers = await this.orders.nextNumbers(context.companyId);
+            }
+
+            await this.orders.insert({
+                id: orderId,
+                team_id: context.teamId,
+                company_id: context.companyId,
+                terminal_id: context.terminalId,
+                order_source_id: orderSource.id,
+                opened_by_id: context.employeeId,
+                serving_id: servingId,
+                table_id: tableId,
+                customers: [1],
+                slot_index: toInt(slotIndex, 1),
+                service_charge: serviceCharge,
+                guest_count: Math.max(toInt(guestCount, 1), 1),
+                hall_id: hallId || (table ? table.hall_id : null),
+                opened_at: fromTimestamp(context.timestamp),
+                global_number: numbers.globalNumber,
+                number: numbers.number,
+                status: 'created',
+            });
+        });
+
+        await this.saveEvents([{
+            event: 'orders:create',
+            time: nowSql(),
+            order_id: orderId,
+        }]);
+
+        return await this.patchOrResource(orderId);
+    }
+
+    async addProduct({productId, orderId, guestNumber = 1, quantity = 1, modifierSets = []}) {
+        const context = this.context;
+        const order = await this.findOrFail(orderId);
+        this.assertMutable(order, 'orders.addProduct');
+        const product = await this.snapshot.findProduct(productId);
+        if (!product) {
+            throw notFound('Product not found');
+        }
+
+        const [sets, , hash] = await OrderService.collectModifierSets(this.snapshot, modifierSets);
+
+        // Повременная позиция уникальна по времени старта — её нельзя доливать в существующую.
+        const hasTimerModifier = await this.snapshot.hasTimerModifier(product.id);
+        const appendMode = toBool(context.setting('terminal_settings.append_order_product', false));
+
+        const existing = hasTimerModifier ? null : await this.orderProducts.findMergeCandidate({
+            orderId: order.id,
+            productId: product.id,
+            guestNumber,
+            hash,
+            appendMode,
+        });
+
+        let orderProductId;
+        if (!existing) {
+            orderProductId = await this.orderProducts.insert({
+                order_id: order.id,
+                product_id: product.id,
+                guest_number: guestNumber,
+                price: money(product.price),
+                added_at: fromTimestamp(context.timestamp),
+                team_id: context.teamId,
+                company_id: context.companyId,
+                type: product.type,
+                unit_id: product.unit_id,
+                quantity: qty(quantity),
+                cost: money(product.cost),
+                profit: 0,
+                modifications_sets_hash: hash,
+                workshop_print_quantity: product.type === TYPE_TIMER ? qty(quantity) : 0,
+            });
+
+            await this.orderProducts.insertModifierSets(orderProductId, sets);
+            await this.storage.withdraw(orderProductId, quantity);
+
+            await this.saveEvents([{
+                event: 'orders:add_product',
+                time: nowSql(),
+                order_id: order.id,
+                quantity,
+                product_id: product.id,
+            }]);
+        } else {
+            await this.saveEvents([{
+                event: 'orders:add_product',
+                time: nowSql(),
+                order_id: order.id,
+                product_id: product.id,
+                quantity,
+            }]);
+
+            orderProductId = existing.id;
+            const newQuantity = qty(existing.quantity + toFloat(quantity));
+            await this.orderProducts.update(existing.id, {
+                quantity: newQuantity,
+                modified_at: nowSql(),
+            });
+            // Довес в строку, с которой уже сняли напечатанное: held не растёт, пока новое
+            // количество не превысит напечатанное, — склад по ней уже списан.
+            await this.storage.settle(
+                existing,
+                StorageService.held(existing.quantity, existing.workshop_print_quantity),
+                StorageService.held(newQuantity, existing.workshop_print_quantity),
+                'rollback'
+            );
+        }
+
+        await this.recalculate(order.id, {full: true});
+        await this.emitPatch(order.id);
+
+        // Laravel возвращает саму модель позиции (сырые атрибуты), а не ресурс — повторяем,
+        // хотя терминал этот ответ и не использует: состояние он берёт из orders:patch.
+        return await this.orderProducts.findRow(orderProductId);
+    }
+
+    async addExtra({name, productWorkshopId, price = 1, orderId, quantity = 1, guestNumber = 1}) {
+        const context = this.context;
+        // Проверяем ДО создания товара-экстры: иначе на закрытом чеке оставался бы мусор в справочнике.
+        this.assertMutable(await this.orders.findRow(orderId), 'orders.addExtra');
+        let product = isUuid(name) ? await this.snapshot.findProduct(name) : null;
+
+        if (!product) {
+            const unit = await this.snapshot.findUnitByCode(PIECE_CODE);
+            const productId = uuid();
+            // Переводимое поле: Laravel кладёт строку под текущую локаль команды.
+            const translatable = phpJsonEncode({[context.locale()]: name});
+
+            await this.db.insert('products', castRow({
+                id: productId,
+                team_id: context.teamId,
+                name: translatable,
+                full_name: translatable,
+                product_workshop_id: productWorkshopId,
+                unit_id: unit ? unit.id : null,
+                price: money(price),
+                cost: money(price),
+                type: TYPE_EXTRA,
+                is_giftable: 1,
+                is_active: 1,
+                is_available: 1,
+                // synced_at есть только в локальном снапшоте: товар создан кассой и ещё не
+                // подтверждён облаком. В общей с Laravel базе такой колонки нет.
+                ...(this.db.dialect === 'sqlite' ? {synced_at: null} : {}),
+            }));
+            product = await this.snapshot.findProduct(productId);
+
+            await this.saveEvents([{
+                event: 'products:create_extra',
+                time: nowSql(),
+                order_id: orderId,
+                product_id: productId,
+                quantity,
+            }]);
+        }
+
+        return this.addProduct({productId: product.id, orderId, guestNumber, quantity, modifierSets: []});
+    }
+
+    /** Пересчёт и сохранение — калька на `$order->calculate(...)->save()`. */
+    async recalculate(orderId, {withProducts = true, full = false} = {}) {
+        const order = await this.findOrFail(orderId, {withTrashed: true});
+        order.calculate(withProducts, full);
+        await this.orders.save(order);
+        return order;
+    }
+
+    async closeOrder({orderId, payments = [], reason = null, fiscalId = null, rrn = null}) {
+        const context = this.context;
+        const order = await this.findOrFail(orderId, {withTrashed: true});
+        // Без guard повторное закрытие переписывало платежи «поверх» новыми суммами.
+        this.assertMutable(order, 'orders.closeOrder', 'Çek artıq bağlanıb. Dəyişiklik üçün əvvəlcə çeki geri açın.');
+        const closedAt = fromTimestamp(context.timestamp);
+
+        // Недоплата — до первой записи: проверка ниже стоит после syncWorkshopCount, и 422 оставлял
+        // чек открытым, но с проведённой печатью и складом. Та же заморозка таймеров в памяти и та
+        // же формула; total от workshop_print_quantity не зависит, поэтому совпадает с проверкой ниже.
+        if (!reason) {
+            const draft = await this.findOrFail(orderId, {withTrashed: true});
+            for (const product of draft.products) {
+                if (product.type === TYPE_TIMER && !product.is_stopped) {
+                    product.is_stopped = true;
+                    product.stopped_at = closedAt;
+                }
+            }
+            draft.calculate(true, true);
+            const paid = payments
+                .filter((payment) => toFloat(payment.value) > 0)
+                .reduce((carry, payment) => carry + toFloat(payment.value), 0);
+
+            if (paid + 0.01 < draft.total) {
+                throw new HttpError(422, {
+                    success: false,
+                    message: `Ödəniş çek məbləğindən azdır. Ödənilib: ${numberFormat(paid)} ₼, ödəniləcək: ${numberFormat(draft.total)} ₼`,
+                });
+            }
+        }
+
+        order.closed_at = closedAt;
+        order.closed_by_id = context.employeeId;
+        order.fiscal_id = fiscalId;
+        order.rrn = rrn;
+        order.status = 'closing';
+
+        const productRows = await this.db.all(
+            'SELECT id FROM order_products WHERE order_id = ? AND deleted_at IS NULL',
+            [orderId]
+        );
+        await this.syncWorkshopCount(productRows.map((row) => row.id), orderId);
+
+        // Позиции могли измениться в syncWorkshopCount — перечитываем перед заморозкой таймеров.
+        const fresh = await this.findOrFail(orderId, {withTrashed: true});
+        fresh.closed_at = closedAt;
+        fresh.closed_by_id = context.employeeId;
+        fresh.fiscal_id = fiscalId;
+        fresh.rrn = rrn;
+        fresh.status = 'closing';
+
+        // Таймеры останавливаем В ПАМЯТИ: если оплаты не хватит, ничего не сохранится
+        // и позиция не останется ошибочно остановленной.
+        for (const product of fresh.products) {
+            if (product.type === TYPE_TIMER && !product.is_stopped) {
+                product.is_stopped = true;
+                product.stopped_at = closedAt;
+                product.receipt_print_quantity = 1;
+            }
+        }
+
+        if (reason) {
+            fresh.is_closed_without_payment = true;
+            fresh.without_payment_reason = reason;
+        } else {
+            // Серверная проверка покрытия от замороженного времени: фронт мог сверять оплату
+            // со старым total (с пречека), а в БД лёг бы пересчитанный от живого таймера.
+            fresh.calculate(true, true);
+            const paid = payments
+                .filter((payment) => toFloat(payment.value) > 0)
+                .reduce((carry, payment) => carry + toFloat(payment.value), 0);
+
+            if (paid + 0.01 < fresh.total) {
+                throw new HttpError(422, {
+                    success: false,
+                    message: `Ödəniş çek məbləğindən azdır. Ödənilib: ${numberFormat(paid)} ₼, ödəniləcək: ${numberFormat(fresh.total)} ₼`,
+                });
+            }
+
+            await this.payments.deleteOfOrder(orderId);
+            for (const payment of payments) {
+                if (toFloat(payment.value) <= 0) {
+                    continue;
+                }
+                await this.payments.insert({
+                    order_id: fresh.id,
+                    payment_method_id: payment.id,
+                    amount: money(payment.value),
+                    change: money(payment.change),
+                    real_amount: money(payment.real),
+                });
+            }
+        }
+
+        await this.saveEvents([{
+            event: 'orders:close',
+            time: nowSql(),
+            order_id: fresh.id,
+        }]);
+
+        // Финальный статус и смена — ЗДЕСЬ, а не отдельным запросом клиента (finalizeClose):
+        // не доехавший syncClosedOrder оставлял чек в `closing`, вне выручки и смены.
+        fresh.status = 'closed';
+        if (!fresh.shift_id) {
+            fresh.shift_id = await this.resolveCashShiftId();
+        }
+
+        fresh.calculate(true, true);
+        await this.orders.save(fresh);
+        // KDS: чек оплачен — снять тикеты с экранов кухни и готовности.
+        await this.closeKdsTickets(fresh.id, 'close');
+
+        return await this.patchOrResource(fresh.id, {withTrashed: true});
+    }
+
+    /** Сбой KDS не должен ломать закрытие или удаление чека — как try/catch в Laravel. */
+    async closeKdsTickets(orderId, reason) {
+        try {
+            await new KdsService({db: this.db, context: this.context, emitter: this.emitter}).closeOrderTickets(orderId);
+        } catch (e) {
+            console.warn(`[core][kds] closeOrderTickets (${reason}) failed`, {order_id: orderId, error: e.message});
+        }
+    }
+
+    /**
+     * Совместимость со старым циклом закрытия — идемпотентная доводка. shift_id пишется
+     * только пустой: повторный вызов с терминала без открытой смены не должен отвязать чек.
+     * Рассылается патч одного чека, а не полный список (снимок, доехавший позже свежего
+     * create, вычищал у кассиров живые чеки).
+     */
+    async syncClosedOrder(orderId) {
+        const order = await this.orders.findRow(orderId);
+        if (!order) {
+            return true;
+        }
+
+        const attributes = {};
+        if (order.status !== 'closed') {
+            attributes.status = 'closed';
+        }
+        if (!order.shift_id) {
+            const shiftId = await this.resolveCashShiftId();
+            if (shiftId) {
+                attributes.shift_id = shiftId;
+            }
+        }
+        if (Object.keys(attributes).length) {
+            await this.orders.updateRow(orderId, attributes);
+        }
+
+        await this.emitPatch(orderId);
+        return true;
+    }
+
+    /**
+     * Порт syncWorkshopCount: печать «догоняет» количество позиций.
+     * Принимает id позиций — как и в Laravel, где джоб получает id из кэша.
+     *
+     * @param {Map<string, number>|null} printedQuantities снимок, по которому собран напечатанный
+     *        чек. Позиция ставится напечатанной ровно на это количество: добавленное после
+     *        снимка уйдёт следующей отправкой. Нет позиции в снимке — её текущее quantity.
+     */
+    async syncWorkshopCount(orderProductIds, orderId = null, printedQuantities = null) {
+        for (const id of orderProductIds) {
+            try {
+                const orderProduct = await this.orderProducts.find(id);
+                if (!orderProduct) {
+                    continue;
+                }
+
+                const quantity = printedQuantities && printedQuantities.has(id)
+                    ? printedQuantities.get(id)
+                    : orderProduct.quantity;
+                const newQuantity = Math.max(quantity - orderProduct.workshop_print_quantity, 0);
+                const previousPrintQuantity = orderProduct.workshop_print_quantity;
+                let workshopPrintQuantity = quantity;
+                let totalWorkshopPrintQuantity = orderProduct.total_workshop_print_quantity;
+                let modifiedAt = orderProduct.modified_at;
+
+                if (!orderId) {
+                    orderId = orderProduct.order_id;
+                }
+
+                // Склад — по held до и после печати: ушла отмена в цех (напечатанное опустилось
+                // к количеству в чеке) — возврат. Повторная печать без изменений склад не двигает.
+                // До softDelete: движение блюда читает живые модификаторы позиции.
+                await this.storage.settle(
+                    orderProduct,
+                    StorageService.held(orderProduct.quantity, previousPrintQuantity),
+                    StorageService.held(orderProduct.quantity, workshopPrintQuantity),
+                    'refund'
+                );
+                if (newQuantity > 0) {
+                    totalWorkshopPrintQuantity = qty(totalWorkshopPrintQuantity + newQuantity);
+                    modifiedAt = nowSql();
+                }
+
+                const removeQuantity = totalWorkshopPrintQuantity - workshopPrintQuantity;
+                if (removeQuantity > 0 && previousPrintQuantity !== quantity) {
+                    await this.saveEvents([{
+                        event: 'orders:remove_product',
+                        time: nowSql(),
+                        order_id: orderId,
+                        product_id: orderProduct.product_id,
+                        quantity: removeQuantity,
+                    }]);
+                }
+
+                await this.orderProducts.update(orderProduct.id, {
+                    workshop_print_quantity: workshopPrintQuantity,
+                    total_workshop_print_quantity: totalWorkshopPrintQuantity,
+                    modified_at: modifiedAt,
+                });
+
+                if (orderProduct.quantity == 0 && workshopPrintQuantity == 0) {
+                    await this.orderProducts.softDelete(orderProduct.id);
+                }
+            } catch (error) {
+                // Сбой по одной позиции не должен прерывать остальные.
+                console.error('[core] syncWorkshopCount: item failed, skip', id, error.message);
+            }
+        }
+
+        if (orderId) {
+            await this.orderProducts.deleteEmpty(orderId);
+        }
+        return true;
+    }
+
+    // ------------------------------------------------------- атрибуты чека
+
+    async changeTable({orderId, tableId, hallId}) {
+        this.assertMutable(await this.findOrFail(orderId), 'orders.changeTable');
+        await this.orders.updateRow(orderId, {table_id: tableId, hall_id: hallId});
+        await this.saveEvents([{event: 'orders:change_table', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    async changeWaiter({orderId, waiterId}) {
+        this.assertMutable(await this.findOrFail(orderId), 'orders.changeWaiter');
+        await this.orders.updateRow(orderId, {serving_id: waiterId});
+        await this.saveEvents([{event: 'orders:change_waiter', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    async changeGuestCount({orderId, guestCount = 1}) {
+        this.assertMutable(await this.findOrFail(orderId), 'orders.changeGuestCount');
+        await this.orders.updateRow(orderId, {guest_count: toInt(guestCount, 1)});
+        await this.saveEvents([{event: 'orders:change_guest_count', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    async setComment({orderId, comment = ''}) {
+        const order = await this.findOrFail(orderId);
+        this.assertMutable(order, 'orders.setComment');
+        const escaped = htmlspecialchars(comment);
+        if (escaped !== order.comment) {
+            await this.orders.updateRow(orderId, {comment: escaped});
+        }
+        await this.saveEvents([{event: 'orders:comment', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    async applyServiceCharge({orderId, serviceCharge}) {
+        const order = await this.findOrFail(orderId);
+        this.assertMutable(order, 'orders.applyServiceCharge');
+        const value = toFloat(serviceCharge);
+        if (!Number.isFinite(value)) {
+            return false;
+        }
+        order.applyServiceCharge(value).calculate();
+        await this.orders.save(order);
+        await this.saveEvents([{event: 'orders:service_charge', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    async applyDiscount({orderId, discount, type}) {
+        return type === 'percent'
+            ? this.applyDiscountByPercent(orderId, discount)
+            : this.applyDiscountByAmount(orderId, discount);
+    }
+
+    async applyDiscountByAmount(orderId, amount) {
+        const order = await this.findOrFail(orderId);
+        this.assertMutable(order, 'orders.applyDiscount:amount');
+        const value = toFloat(amount);
+        if (!Number.isFinite(value)) {
+            return false;
+        }
+        if (order.max_discount_amount < value) {
+            throw new HttpError(403, {success: false, error: 'max_discount_amount'});
+        }
+        order.applyAmountDiscount(value).calculate();
+        await this.orders.save(order);
+        await this.saveEvents([{event: 'orders:discount:amount', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    async applyDiscountByPercent(orderId, percent) {
+        const order = await this.findOrFail(orderId);
+        this.assertMutable(order, 'orders.applyDiscount:percent');
+        const value = toFloat(percent);
+        if (!Number.isFinite(value) || value > 100) {
+            return false;
+        }
+        order.applyPercentDiscount(value).calculate();
+        await this.orders.save(order);
+        await this.saveEvents([{event: 'orders:discount:percent', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    async applyDeposit({orderId, deposit}) {
+        const order = await this.findOrFail(orderId);
+        this.assertMutable(order, 'orders.applyDeposit');
+        order.deposit_amount = money(Math.max(0, toFloat(deposit)));
+        order.calculate();
+        await this.orders.save(order);
+        await this.saveEvents([{event: 'orders:deposit', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    // ------------------------------------------------------------- гости
+
+    async addCustomer(orderId) {
+        const order = await this.findOrFail(orderId);
+        this.assertMutable(order, 'orders.addCustomer');
+        const customers = order.customers.slice();
+        customers.push(Math.max(...customers) + 1);
+        await this.orders.updateRow(orderId, {customers});
+        await this.saveEvents([{event: 'orders:add_guest', time: nowSql(), order_id: orderId}]);
+        return await this.patchOrResource(orderId);
+    }
+
+    async removeCustomer({orderId, guestNumber}) {
+        const order = await this.findOrFail(orderId);
+        this.assertMutable(order, 'orders.removeCustomer');
+        const customers = order.customers.filter((customer) => customer !== guestNumber);
+        await this.orders.updateRow(orderId, {customers});
+        // Склад: всё списанное по строкам гостя возвращается сразу — строки удаляются, отмену
+        // в цех по ним уже не отправить. До softDelete: движение блюда читает живые модификаторы.
+        const guestRows = await this.db.all(
+            `SELECT id, quantity, workshop_print_quantity FROM order_products
+             WHERE order_id = ? AND guest_number = ? AND deleted_at IS NULL`,
+            [orderId, guestNumber]
+        );
+        for (const row of guestRows) {
+            await this.storage.settle(row, StorageService.held(row.quantity, row.workshop_print_quantity), 0, 'rollback');
+        }
+        await this.orderProducts.removeGuestProducts(orderId, guestNumber);
+        await this.saveEvents([{event: 'orders:remove_guest', time: nowSql(), order_id: orderId}]);
+        await this.recalculate(orderId);
+        return await this.patchOrResource(orderId);
+    }
+
+    // ------------------------------------------------------ чек целиком
+
+    async removeOrder(orderId) {
+        const order = await this.orders.findRow(orderId);
+        // Закрытый чек без позиций (закрыт без оплаты) удалять нельзя — пропал бы из отчёта и смены.
+        this.assertMutable(order, 'orders.removeOrder');
+        if (order && (await this.orders.countProducts(orderId)) === 0) {
+            await this.saveEvents([{event: 'orders:removed', time: nowSql(), order_id: orderId}]);
+            await this.closeKdsTickets(orderId, 'remove');
+            await this.orders.softDelete(orderId);
+            await this.emitUpdateOrders();
+            return true;
+        }
+        await this.emitUpdateOrders();
+        return false;
+    }
+
+    async rollback(orderId) {
+        const order = await this.findOrFail(orderId, {withTrashed: true});
+        await this.payments.deleteOfOrder(orderId);
+        // closed_at отменённого закрытия — свидетельство для облака (SyncService::reopenAccepted):
+        // чек, закрытый ещё онлайн и переоткрытый на кассе без связи, облако примет открытым,
+        // только если касса отменила именно то закрытие, что лежит в облаке.
+        await this.saveEvents([{
+            event: 'orders:rollback',
+            time: nowSql(),
+            order_id: orderId,
+            data: {closed_at: toSql(order.closed_at)},
+        }]);
+        await this.orders.updateRow(orderId, {
+            status: 'opened',
+            closed_at: null,
+            closed_by_id: null,
+            is_closed_without_payment: 0,
+            fiscal_id: null,
+            rrn: null,
+            without_payment_reason: null,
+            // Открытый чек ни к какой смене не относится: иначе повторное закрытие осталось
+            // бы в СТАРОЙ (возможно уже закрытой) смене — closeOrder резолвит только пустой.
+            shift_id: null,
+        });
+        return await this.patchOrResource(orderId, {withTrashed: true});
+    }
+
+    async merge({sourceId, targetId}) {
+        if (!sourceId || !targetId || sourceId === targetId) {
+            return null;
+        }
+
+        // Оба чека должны существовать: повторное слияние (дубль socket+HTTP) не должно
+        // ничего делать, иначе пересчитывался бы уже удалённый чек.
+        const sourceRow = await this.orders.findRow(sourceId);
+        const targetRow = await this.orders.findRow(targetId);
+        if (!sourceRow || !targetRow) {
+            return null;
+        }
+
+        // Слияние двигает позиции и удаляет source — на закрытом это тот же перенос денег.
+        this.assertMutable(sourceRow, 'orders.merge:source');
+        this.assertMutable(targetRow, 'orders.merge:target');
+
+        await this.orderProducts.moveToOrder(sourceId, targetId);
+
+        await this.recalculate(sourceId);
+        await this.saveEvents([{
+            event: 'orders:merged',
+            time: nowSql(),
+            order_id: sourceId,
+            data: {target_id: targetId},
+        }]);
+        await this.orders.softDelete(sourceId);
+
+        await this.recalculate(targetId);
+        await this.emitUpdateOrders();
+        return true;
+    }
+
+    // ------------------------------------------------------------ чтение
+
+    async getOpenOrders(companyId = null) {
+        const orders = await this.orders.openOrders(companyId || this.context.companyId);
+        return this.mapResource(orders);
+    }
+
+    async getById(orderId) {
+        return await this.resource().order(await this.findOrFail(orderId, {withTrashed: true}));
+    }
+
+    async archive({companyId = null, date = null} = {}) {
+        const team = this.context.getTeam();
+        const target = date ? new Date(date) : now();
+        // Архив показывает календарные сутки заведения, без сдвига на бизнес-день.
+        const [from, to] = businessDay(target, {
+            timezone: team ? team.timezone : undefined,
+            shiftEndsAt: 0,
+            now: now(),
+        });
+        const orders = await this.orders.archivedOrders(companyId || this.context.companyId, toSql(from), toSql(to));
+        return this.mapResource(orders);
+    }
+
+    async isFiscalExists(fiscalId) {
+        const row = await this.db.get(
+            'SELECT 1 AS found FROM orders WHERE team_id = ? AND fiscal_id = ? LIMIT 1',
+            [this.context.teamId, fiscalId]
+        );
+        return {success: true, exists: Boolean(row)};
+    }
+
+    /**
+     * Тик повременных позиций: пересчёт в памяти + батч-патч по компаниям.
+     * Ничего не пишет в БД — цена таймера всегда выводится из времени.
+     */
+    async tickTimers(filter = {}) {
+        const orders = await this.orders.ordersWithRunningTimers(filter);
+        const resource = this.resource();
+        await resource.preload(orders);
+        const byCompany = new Map();
+
+        for (const order of orders) {
+            order.calculate(true, true);
+            if (!byCompany.has(order.company_id)) {
+                byCompany.set(order.company_id, []);
+            }
+            byCompany.get(order.company_id).push(await resource.order(order));
+        }
+
+        if (this.emitter && this.emitter.orderPatchBatch) {
+            for (const [companyId, patches] of byCompany) {
+                this.emitter.orderPatchBatch(companyId, patches);
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Порт OrderProductService::collectModifierSets.
+     *
+     * Порядок ключей в элементе важен: хэш считается от json_encode этого массива и служит
+     * ключом склейки строк чека — переставь поля, и одинаковые позиции перестанут склеиваться.
+     */
+    static async collectModifierSets(snapshot, modifierSets) {
+        let totalPrice = 0;
+        const data = [];
+
+        for (const modifier of modifierSets || []) {
+            const modifierSet = await snapshot.findModifierSet(modifier.modifier_set_id);
+            if (!modifierSet) {
+                throw notFound('Modifier set not found');
+            }
+            const productModifierSet = await snapshot.findProductModifierSetBySet(modifierSet.id);
+            if (!productModifierSet) {
+                throw notFound('Product modifier set not found');
+            }
+
+            const price = toFloat(modifier.price);
+            const quantity = modifier.quantity;
+            if (quantity === 0) {
+                continue;
+            }
+            const total = price * quantity;
+
+            data.push({
+                modifier_set_type: modifierSet.type,
+                modifier_set_title: productModifierSet.title,
+                name: modifier.name,
+                total,
+                price,
+                quantity,
+                modifier_set_modifier_id: modifier.modifier_set_modifier_id,
+                modifier_set_id: modifierSet.id,
+            });
+            totalPrice += total;
+        }
+
+        const hash = data.length ? md5(phpJsonEncode(data)) : null;
+        return [data, totalPrice, hash];
+    }
+}
+
+module.exports = OrderService;