@alizadefaig/pos-server 1.2.25 → 1.2.27

package/app/core/services/KdsService.js

@@ -0,0 +1,639 @@
+const moment = require('moment');
+const SnapshotRepository = require('../repositories/SnapshotRepository');
+const {qty, toFloat, toBool} = require('../support/num');
+const {nowSql, parse} = require('../support/time');
+const {translated} = require('../support/lang');
+const {uuid} = require('../support/ids');
+const {castRow} = require('../support/db');
+const {phpTruthy} = require('../support/receipts');
+const {notFound} = require('../errors');
+
+const STATUS_WAITING = 'waiting';
+const STATUS_COOKING = 'cooking';
+const STATUS_READY = 'ready';
+const STATUSES = [STATUS_WAITING, STATUS_COOKING, STATUS_READY];
+
+// Позиции этих типов в цех не уходят — как в Laravel (и как у печати).
+const SKIP_TYPES = ['standalone', 'modifier'];
+const TERMINAL_TYPE_KDS = 'kds';
+const SENT_COLUMN = 'workshop_print_quantity';
+
+const alive = (row) => (row && !row.deleted_at ? row : null);
+
+// Carbon::toIso8601String() для UTC-времени из БД: '2026-09-26T10:00:00+00:00'.
+const iso = (value) => {
+    const date = parse(value);
+    return date ? moment.utc(date).format('YYYY-MM-DDTHH:mm:ss+00:00') : null;
+};
+
+const normalizeStatus = (status) => (STATUSES.includes(status) ? status : STATUS_WAITING);
+
+const isCancelled = (item) => {
+    const cancelled = toFloat(item.cancelled_quantity);
+    return cancelled > 0 && qty(toFloat(item.quantity) - cancelled) <= 0;
+};
+
+/**
+ * Порт App\Services\Platform\KdsService: кухонный экран и экран готовности без облака.
+ *
+ * Тикеты создаются при отправке в цех (PrintService.sendToWorkshops, до печати и независимо
+ * от её успеха), статусы ведёт KDS-терминал, закрытие/удаление чека гасит тикеты. Бродкасты
+ * (`kds:ticket`, `kds:ticketRemoved`, `readiness:update|remove`) идут через тот же эмиттер, что
+ * и заказы: у мастера модели M они сами уходят облачным клиентам и ведомым кассам.
+ *
+ * Отличия от Laravel:
+ * - без транзакции: SQLite ядра работает на одном соединении, а номер тикета защищён локом
+ *   отправки `print:order:<id>`, внутри которого и зовётся createTicketsForSend;
+ * - `kds_print_quantity` пишется точечным UPDATE (в OrderRepository этой колонки нет намеренно).
+ */
+class KdsService {
+    constructor({db, context, emitter = null}) {
+        this.db = db;
+        this.context = context;
+        this.emitter = emitter;
+        this.snapshot = new SnapshotRepository(db);
+    }
+
+    notDeleted(alias = null) {
+        // В локальном снапшоте удалённые справочники не лежат вовсе, и колонки deleted_at там нет.
+        if (this.db.dialect !== 'pgsql') {
+            return '';
+        }
+        return ` AND ${alias ? `${alias}.` : ''}deleted_at IS NULL`;
+    }
+
+    locale() {
+        return this.context ? this.context.locale() : 'az';
+    }
+
+    emit(eventName, companyId, data) {
+        if (this.emitter) {
+            this.emitter.emit(eventName, companyId, data);
+        }
+    }
+
+    // ————— создание тикетов —————
+
+    async isEnabled(order) {
+        const team = order.team_id ? await this.db.get('SELECT settings FROM teams WHERE id = ?', [order.team_id]) : null;
+        let settings = team ? team.settings : null;
+        if (typeof settings === 'string') {
+            try {
+                settings = JSON.parse(settings);
+            } catch (e) {
+                settings = null;
+            }
+        }
+        const kds = settings && typeof settings === 'object' ? settings.kds : null;
+        // (bool) data_get($settings, 'kds.enabled', false)
+        return phpTruthy(kds && typeof kds === 'object' ? kds.enabled : false);
+    }
+
+    /**
+     * Создать тикеты для новой отправки в цех(а).
+     *
+     * @param {object} order строка/модель заказа (нужны id, team_id, company_id, number)
+     * @param {string|null} sentColumn 'workshop_print_quantity' — отправку сделала другая сторона,
+     *        и видно её только по счётчику печати (так Laravel разбирает выгрузку кассы)
+     */
+    async createTicketsForSend(order, sentColumn = null) {
+        const column = sentColumn === SENT_COLUMN ? SENT_COLUMN : null;
+
+        // Мастер-выключатель: выключен (по умолчанию) → KDS не делает ничего.
+        if (!(await this.isEnabled(order))) {
+            return;
+        }
+
+        // Все цеха команды без фильтра print_ticket — KDS работает и без бумажных чеков.
+        const workshops = await this.db.all(
+            `SELECT id FROM product_workshops WHERE team_id = ?${this.notDeleted()}`,
+            [order.team_id]
+        );
+        if (!workshops.length) {
+            return;
+        }
+        const allWorkshops = new Set(workshops.map((row) => row.id));
+
+        const orderProducts = column
+            ? await this.db.all(
+                `SELECT * FROM order_products
+                 WHERE order_id = ?
+                   AND ((deleted_at IS NULL AND workshop_print_quantity != kds_print_quantity)
+                        OR (deleted_at IS NOT NULL AND kds_print_quantity != 0))
+                 ORDER BY created_at, id`,
+                [order.id]
+            )
+            : await this.db.all(
+                `SELECT * FROM order_products
+                 WHERE order_id = ? AND deleted_at IS NULL AND quantity != kds_print_quantity
+                 ORDER BY created_at, id`,
+                [order.id]
+            );
+        if (!orderProducts.length) {
+            return;
+        }
+
+        // Группировка по цеху — та же, что у печати в sendToWorkshops.
+        const groups = new Map();
+        const cancellations = [];
+        for (const op of orderProducts) {
+            const sent = column ? (op.deleted_at ? 0 : toFloat(op[column])) : toFloat(op.quantity);
+            const delta = sent - toFloat(op.kds_print_quantity);
+
+            // Уменьшение уже уехавшего: бумага печатает «минус»-строку, KDS зачёркивает.
+            if (delta < 0) {
+                cancellations.push({op, quantity: -delta, sent});
+                continue;
+            }
+
+            const product = await this.snapshot.findProduct(op.product_id);
+            const skip = SKIP_TYPES.includes(op.type) || !product || toBool(product.ignore_workshop);
+
+            // Цех — через мутатор, как в Laravel: пустой берётся у категории.
+            let workshopId = null;
+            if (!skip) {
+                workshopId = await this.snapshot.productWorkshopId(product);
+                if (!workshopId && product.parent_id) {
+                    workshopId = await this.snapshot.productWorkshopId(await this.snapshot.findProduct(product.parent_id));
+                }
+            }
+
+            // Нет цеха / не наш цех / нечего слать → только выровнять счётчик.
+            if (skip || !workshopId || !allWorkshops.has(workshopId) || delta <= 0) {
+                await this.bump(op, sent);
+                continue;
+            }
+
+            if (!groups.has(workshopId)) {
+                groups.set(workshopId, []);
+            }
+            groups.get(workshopId).push({op, product, delta, sent});
+        }
+
+        // Отмены — в уже существующих тикетах, до создания новых.
+        const cancelledIds = await this.applyCancellations(cancellations);
+
+        if (!groups.size) {
+            await this.emitTickets(order, cancelledIds);
+            return;
+        }
+
+        // Цех без KDS-терминала → тикет сразу «готов» (tracked=false): готовность чека он не держит.
+        const kdsWorkshops = await this.kdsWorkshopIds(order.company_id);
+
+        // Номера не переиспользуются: удалённые тикеты тоже в счёт.
+        let number = Number(await this.db.value(
+            'SELECT MAX(number) AS n FROM kds_tickets WHERE order_id = ?',
+            [order.id]
+        )) || 0;
+
+        const createdIds = [];
+        const timestamp = nowSql();
+        for (const [workshopId, rows] of groups) {
+            number += 1;
+            const tracked = kdsWorkshops.has(workshopId);
+            const status = tracked ? STATUS_WAITING : STATUS_READY;
+            const readyAt = tracked ? null : timestamp;
+
+            const ticketId = uuid();
+            await this.db.insert('kds_tickets', castRow({
+                id: ticketId,
+                company_id: order.company_id,
+                team_id: order.team_id,
+                order_id: order.id,
+                product_workshop_id: workshopId,
+                number,
+                status,
+                tracked,
+                fired_at: timestamp,
+                ready_at: readyAt,
+                created_at: timestamp,
+                updated_at: timestamp,
+            }));
+
+            for (const {op, product, delta, sent} of rows) {
+                await this.db.insert('kds_ticket_items', {
+                    id: uuid(),
+                    kds_ticket_id: ticketId,
+                    order_product_id: op.id,
+                    product_id: op.product_id,
+                    name: (product ? translated(product.full_name, this.locale()) : null) ?? '',
+                    quantity: qty(delta),
+                    cancelled_quantity: 0,
+                    comment: op.comment ?? null,
+                    status,
+                    ready_at: readyAt,
+                    created_at: timestamp,
+                    updated_at: timestamp,
+                });
+                await this.bump(op, sent);
+            }
+            createdIds.push(ticketId);
+        }
+
+        await this.emitTickets(order, [...cancelledIds, ...createdIds]);
+    }
+
+    /**
+     * Уменьшение уже отправленного: зачёркиваем в тикетах, начиная с самого нового.
+     * @returns {Promise<string[]>} id затронутых тикетов
+     */
+    async applyCancellations(cancellations) {
+        const touched = new Set();
+        const timestamp = nowSql();
+
+        for (const {op, quantity, sent} of cancellations) {
+            const items = await this.db.all(
+                `SELECT i.* FROM kds_ticket_items i
+                 JOIN kds_tickets t ON t.id = i.kds_ticket_id
+                 WHERE i.order_product_id = ? AND t.deleted_at IS NULL
+                 ORDER BY t.number DESC, i.created_at DESC, i.id DESC`,
+                [op.id]
+            );
+
+            let left = qty(quantity);
+            for (const item of items) {
+                const available = qty(toFloat(item.quantity) - toFloat(item.cancelled_quantity));
+                if (available <= 0) {
+                    continue;
+                }
+                const take = Math.min(available, left);
+                await this.db.update('kds_ticket_items', item.id, {
+                    cancelled_quantity: qty(toFloat(item.cancelled_quantity) + take),
+                    cancelled_at: timestamp,
+                    updated_at: timestamp,
+                });
+                touched.add(item.kds_ticket_id);
+                left = qty(left - take);
+                if (left <= 0) {
+                    break;
+                }
+            }
+
+            await this.bump(op, sent);
+        }
+
+        // Статус тикета пересчитывается по живым блюдам. Полностью отменённый тикет не трогаем:
+        // countedTickets выбросит его сам.
+        for (const ticketId of touched) {
+            const ticket = await this.db.get('SELECT * FROM kds_tickets WHERE id = ?', [ticketId]);
+            if (!ticket) {
+                continue;
+            }
+            const items = await this.itemsOf(ticketId);
+            if (items.length && items.every(isCancelled)) {
+                continue;
+            }
+            const status = KdsService.rollupStatus(items);
+            await this.db.update('kds_tickets', ticketId, {
+                status,
+                ready_at: status === STATUS_READY ? (ticket.ready_at ?? timestamp) : null,
+                updated_at: timestamp,
+            });
+        }
+
+        return [...touched];
+    }
+
+    async kdsWorkshopIds(companyId) {
+        const rows = await this.db.all(
+            `SELECT tw.product_workshop_id
+             FROM terminal_workshop tw
+             JOIN terminals t ON t.id = tw.terminal_id
+             WHERE t.type = ? AND t.company_id = ?${this.notDeleted('t')}`,
+            [TERMINAL_TYPE_KDS, companyId]
+        );
+        return new Set(rows.map((row) => row.product_workshop_id));
+    }
+
+    /** Точечный UPDATE: saveProduct эту колонку не пишет, и устаревшая модель её не откатит. */
+    async bump(op, sent) {
+        await this.db.run(
+            'UPDATE order_products SET kds_print_quantity = ?, updated_at = ? WHERE id = ?',
+            [qty(sent), nowSql(), op.id]
+        );
+    }
+
+    // ————— статусы с KDS —————
+
+    async setTicketStatus(ticketId, status) {
+        const value = normalizeStatus(status);
+        const ticket = ticketId
+            ? await this.db.get('SELECT * FROM kds_tickets WHERE id = ? AND deleted_at IS NULL', [ticketId])
+            : null;
+        if (!ticket) {
+            throw notFound('Ticket not found');
+        }
+
+        const timestamp = nowSql();
+        const ready = value === STATUS_READY;
+        for (const item of await this.itemsOf(ticket.id)) {
+            await this.db.update('kds_ticket_items', item.id, {
+                status: value,
+                ready_at: ready ? (item.ready_at ?? timestamp) : null,
+                updated_at: timestamp,
+            });
+        }
+        await this.db.update('kds_tickets', ticket.id, {
+            status: value,
+            ready_at: ready ? (ticket.ready_at ?? timestamp) : null,
+            updated_at: timestamp,
+        });
+
+        return this.afterStatusChange(ticket.id);
+    }
+
+    async setItemStatus(itemId, status) {
+        const value = normalizeStatus(status);
+        const item = itemId ? await this.db.get('SELECT * FROM kds_ticket_items WHERE id = ?', [itemId]) : null;
+        if (!item) {
+            throw notFound('Ticket item not found');
+        }
+        // В Laravel тикет удалённого (закрытого) чека тоже не находится — findOrFail по SoftDeletes.
+        const ticket = await this.db.get(
+            'SELECT * FROM kds_tickets WHERE id = ? AND deleted_at IS NULL',
+            [item.kds_ticket_id]
+        );
+        if (!ticket) {
+            throw notFound('Ticket not found');
+        }
+
+        const timestamp = nowSql();
+        await this.db.update('kds_ticket_items', item.id, {
+            status: value,
+            ready_at: value === STATUS_READY ? timestamp : null,
+            updated_at: timestamp,
+        });
+
+        const rolled = KdsService.rollupStatus(await this.itemsOf(ticket.id));
+        await this.db.update('kds_tickets', ticket.id, {
+            status: rolled,
+            ready_at: rolled === STATUS_READY ? (ticket.ready_at ?? timestamp) : null,
+            updated_at: timestamp,
+        });
+
+        return this.afterStatusChange(ticket.id);
+    }
+
+    async afterStatusChange(ticketId) {
+        const ticket = await this.db.get('SELECT * FROM kds_tickets WHERE id = ?', [ticketId]);
+        const resource = await this.ticketResource(ticket);
+        this.emit('kds:ticket', ticket.company_id, resource);
+
+        const order = await this.findOrder(ticket.order_id);
+        if (order) {
+            await this.emitReadiness(order);
+        }
+        return resource;
+    }
+
+    // ————— чтения —————
+
+    /** Активные тикеты по цехам терминала (KDS-экран). */
+    async getTicketsForTerminal(terminal) {
+        if (!terminal) {
+            return [];
+        }
+        const workshops = await this.db.all(
+            `SELECT pw.id
+             FROM terminal_workshop tw
+             JOIN product_workshops pw ON pw.id = tw.product_workshop_id
+             WHERE tw.terminal_id = ?${this.notDeleted('pw')}`,
+            [terminal.id]
+        );
+        if (!workshops.length) {
+            return [];
+        }
+        const ids = workshops.map((row) => row.id);
+        const tickets = await this.db.all(
+            `SELECT * FROM kds_tickets
+             WHERE company_id = ? AND deleted_at IS NULL
+               AND product_workshop_id IN (${ids.map(() => '?').join(', ')})
+             ORDER BY fired_at, number`,
+            [terminal.company_id, ...ids]
+        );
+        return this.ticketResources(tickets);
+    }
+
+    /** Тикеты одного чека — касса рисует KDS-статусы в списке позиций. */
+    async getOrderTickets(companyId, orderId) {
+        if (!orderId) {
+            return [];
+        }
+        const tickets = await this.db.all(
+            `SELECT * FROM kds_tickets
+             WHERE company_id = ? AND order_id = ? AND deleted_at IS NULL
+             ORDER BY fired_at, number`,
+            [companyId, orderId]
+        );
+        return this.ticketResources(tickets);
+    }
+
+    /** Экран готовности: агрегат по открытым чекам компании. */
+    async getReadinessOrders(companyId) {
+        const tickets = await this.db.all(
+            `SELECT * FROM kds_tickets
+             WHERE company_id = ? AND deleted_at IS NULL
+             ORDER BY fired_at, number`,
+            [companyId]
+        );
+        const grouped = new Map();
+        for (const ticket of tickets) {
+            if (!grouped.has(ticket.order_id)) {
+                grouped.set(ticket.order_id, []);
+            }
+            grouped.get(ticket.order_id).push(ticket);
+        }
+
+        const result = [];
+        for (const [orderId, group] of grouped) {
+            const counted = await this.countedTickets(group);
+            if (!counted.length) {
+                continue;
+            }
+            const order = await this.findOrder(orderId);
+            const number = order ? order.number ?? null : null;
+            if (number === null) {
+                continue;
+            }
+            result.push({order_id: orderId, number, status: KdsService.aggregateStatus(counted)});
+        }
+        return result;
+    }
+
+    /** ready — все тикеты готовы, cooking — иначе, null — тикетов нет (убрать с экрана). */
+    async computeOrderReadiness(order) {
+        const tickets = await this.db.all(
+            'SELECT * FROM kds_tickets WHERE order_id = ? AND deleted_at IS NULL',
+            [order.id]
+        );
+        const counted = await this.countedTickets(tickets);
+        if (!counted.length) {
+            return null;
+        }
+        return KdsService.aggregateStatus(counted);
+    }
+
+    // ————— закрытие чека —————
+
+    /** Закрытие/удаление чека: тикеты в soft delete, убрать с KDS и экрана готовности. */
+    async closeOrderTickets(orderId) {
+        const tickets = await this.db.all(
+            'SELECT id, company_id FROM kds_tickets WHERE order_id = ? AND deleted_at IS NULL',
+            [orderId]
+        );
+        if (!tickets.length) {
+            return;
+        }
+        const companyId = tickets[0].company_id;
+        const ticketIds = tickets.map((ticket) => ticket.id);
+        const timestamp = nowSql();
+        for (const id of ticketIds) {
+            await this.db.update('kds_tickets', id, {deleted_at: timestamp, updated_at: timestamp});
+        }
+
+        this.emit('kds:ticketRemoved', companyId, {order_id: orderId, ticket_ids: ticketIds});
+        this.emit('readiness:remove', companyId, {order_id: orderId});
+    }
+
+    // ————— бродкасты и ресурсы —————
+
+    async emitTickets(order, ticketIds) {
+        const unique = [...new Set(ticketIds)];
+        if (!unique.length) {
+            return;
+        }
+        for (const id of unique) {
+            const ticket = await this.db.get('SELECT * FROM kds_tickets WHERE id = ?', [id]);
+            if (ticket) {
+                this.emit('kds:ticket', ticket.company_id, await this.ticketResource(ticket));
+            }
+        }
+        await this.emitReadiness(order);
+    }
+
+    async emitReadiness(order) {
+        const status = await this.computeOrderReadiness(order);
+        if (status === null) {
+            this.emit('readiness:remove', order.company_id, {order_id: order.id});
+            return;
+        }
+        this.emit('readiness:update', order.company_id, {order_id: order.id, number: order.number, status});
+    }
+
+    async findOrder(id) {
+        if (!id) {
+            return null;
+        }
+        return this.db.get(
+            'SELECT id, number, team_id, company_id, hall_id, table_id, serving_id FROM orders WHERE id = ? AND deleted_at IS NULL',
+            [id]
+        );
+    }
+
+    async itemsOf(ticketId) {
+        return this.db.all(
+            'SELECT * FROM kds_ticket_items WHERE kds_ticket_id = ? ORDER BY created_at, id',
+            [ticketId]
+        );
+    }
+
+    /** Тикеты без полностью отменённых (их блюда все зачёркнуты — готовность они не держат). */
+    async countedTickets(tickets) {
+        const result = [];
+        for (const ticket of tickets) {
+            const items = await this.itemsOf(ticket.id);
+            if (items.length && items.every(isCancelled)) {
+                continue;
+            }
+            result.push(ticket);
+        }
+        return result;
+    }
+
+    async ticketResources(tickets) {
+        const result = [];
+        for (const ticket of tickets) {
+            result.push(await this.ticketResource(ticket));
+        }
+        return result;
+    }
+
+    /** KdsTicketResource + KdsTicketItemResource. */
+    async ticketResource(ticket) {
+        const order = await this.findOrder(ticket.order_id);
+        let hall = null;
+        let table = null;
+        let waiter = null;
+        if (order) {
+            // Связи заказа в Laravel — withTrashed: удалённый зал/стол всё равно подписывает карточку.
+            const hallRow = await this.snapshot.findHall(order.hall_id);
+            const tableRow = await this.snapshot.findTable(order.table_id);
+            const waiterRow = await this.snapshot.findTeamUserWithUser(order.serving_id);
+            hall = hallRow ? hallRow.name ?? null : null;
+            table = tableRow ? tableRow.label ?? null : null;
+            waiter = waiterRow ? waiterRow.user_name ?? null : null;
+        }
+
+        const items = [];
+        for (const item of await this.itemsOf(ticket.id)) {
+            // items.product — без withTrashed: удалённый товар даёт null.
+            const product = alive(await this.snapshot.findProduct(item.product_id));
+            items.push({
+                id: item.id,
+                order_product_id: item.order_product_id,
+                product_id: item.product_id,
+                name: item.name,
+                quantity: toFloat(item.quantity),
+                cancelled_quantity: toFloat(item.cancelled_quantity),
+                is_weight_item: product ? toBool(product.is_weight_item) : false,
+                unit_id: product ? product.unit_id ?? null : null,
+                comment: item.comment ?? null,
+                status: item.status,
+            });
+        }
+
+        return {
+            id: ticket.id,
+            number: ticket.number === null || ticket.number === undefined ? null : Number(ticket.number),
+            status: ticket.status,
+            tracked: toBool(ticket.tracked),
+            order_id: ticket.order_id,
+            order_number: order ? order.number ?? null : null,
+            product_workshop_id: ticket.product_workshop_id,
+            hall,
+            table,
+            waiter,
+            fired_at: iso(ticket.fired_at),
+            ready_at: iso(ticket.ready_at),
+            items,
+        };
+    }
+
+    // ————— чистые функции статусов —————
+
+    /** Статус тикета по его блюдам (отменённые не считаются). */
+    static rollupStatus(items) {
+        const statuses = items.filter((item) => !isCancelled(item)).map((item) => item.status);
+        if (!statuses.length) {
+            return STATUS_WAITING;
+        }
+        if (statuses.every((status) => status === STATUS_READY)) {
+            return STATUS_READY;
+        }
+        if (statuses.some((status) => status === STATUS_COOKING || status === STATUS_READY)) {
+            return STATUS_COOKING;
+        }
+        return STATUS_WAITING;
+    }
+
+    /** Экран клиента: ready, если готовы все тикеты, иначе cooking. */
+    static aggregateStatus(tickets) {
+        return tickets.every((ticket) => ticket.status === STATUS_READY) ? STATUS_READY : STATUS_COOKING;
+    }
+}
+
+KdsService.STATUSES = STATUSES;
+KdsService.isCancelled = isCancelled;
+
+module.exports = KdsService;