@alizadefaig/pos-server 1.2.26 → 1.2.28

package/app/core/services/OrderProductService.js

@@ -0,0 +1,309 @@
+const OrderService = require('./OrderService');
+const StorageService = require('./StorageService');
+const OrderProduct = require('../models/OrderProduct');
+const {notFound} = require('../errors');
+const {money, qty, toFloat, toInt, toBool} = require('../support/num');
+const {nowSql, diffInSeconds, now} = require('../support/time');
+const {htmlspecialchars} = require('../support/str');
+
+const TYPE_TIMER = OrderProduct.TYPE_TIMER;
+
+/**
+ * Порт App\Services\Platform\OrderProductService — операции над позицией чека.
+ * Разделяет репозитории и контекст с OrderService: часть операций (append) уходит туда.
+ */
+class OrderProductService {
+    constructor({db, context, emitter = null}) {
+        this.db = db;
+        this.context = context;
+        this.orderService = new OrderService({db, context, emitter});
+
+        this.orders = this.orderService.orders;
+        this.orderProducts = this.orderService.orderProducts;
+        this.snapshot = this.orderService.snapshot;
+    }
+
+    async findOrFail(orderProductId) {
+        const orderProduct = await this.orderProducts.find(orderProductId);
+        if (!orderProduct) {
+            throw notFound('Order product not found');
+        }
+        return orderProduct;
+    }
+
+    /** Позиция + guard её чека (`$orderProduct->order` в Laravel — без удалённых). */
+    async findMutable(orderProductId, action) {
+        const orderProduct = await this.findOrFail(orderProductId);
+        this.orderService.assertMutable(await this.orders.findRow(orderProduct.order_id), action);
+        return orderProduct;
+    }
+
+    // ------------------------------------------------------------ таймеры
+
+    async stopTimer({orderProductId, orderId}) {
+        await this.findMutable(orderProductId, 'orderProducts.stopTimer');
+        await this.orderProducts.update(orderProductId, {is_stopped: 1, stopped_at: nowSql()});
+        await this.orderService.emitPatch(orderId);
+        return true;
+    }
+
+    async fixTimer({orderProductId, orderId}) {
+        await this.findMutable(orderProductId, 'orderProducts.fixTimer');
+        await this.orderProducts.update(orderProductId, {is_stopped: 1, stopped_at: nowSql(), is_fixed: 1});
+        await this.orderService.emitPatch(orderId);
+        return true;
+    }
+
+    /** Пауза не должна оплачиваться: время простоя копится в paused_seconds. */
+    async resumeTimer({orderProductId, orderId}) {
+        const orderProduct = await this.findMutable(orderProductId, 'orderProducts.resumeTimer');
+        const additionalPaused = orderProduct.stopped_at
+            ? Math.max(0, diffInSeconds(orderProduct.stopped_at, now()))
+            : 0;
+        await this.orderProducts.update(orderProductId, {
+            is_stopped: 0,
+            stopped_at: null,
+            paused_seconds: toInt(orderProduct.paused_seconds, 0) + additionalPaused,
+        });
+        await this.orderService.emitPatch(orderId);
+        return true;
+    }
+
+    async setTimerLimit({orderProductId, orderId, timerLimitMinutes}) {
+        await this.findMutable(orderProductId, 'orderProducts.setTimerLimit');
+        await this.orderProducts.update(orderProductId, {
+            timer_limit_minutes: toFloat(timerLimitMinutes) > 0 ? toInt(timerLimitMinutes) : null,
+        });
+        await this.orderService.emitPatch(orderId);
+        return true;
+    }
+
+    // ---------------------------------------------------------- позиции
+
+    async transfer({orderProductId, orderId}) {
+        const orderProduct = await this.findOrFail(orderProductId);
+        const sourceOrderId = orderProduct.order_id;
+        // Перенос с/на закрытый чек — тот же перенос денег: проверяем оба.
+        this.orderService.assertMutable(await this.orders.findRow(sourceOrderId), 'orderProducts.transfer:source');
+        this.orderService.assertMutable(await this.orders.findRow(orderId), 'orderProducts.transfer:target');
+
+        await this.orderProducts.update(orderProductId, {order_id: orderId});
+
+        await this.orderService.saveEvents([{
+            event: 'products:transfer',
+            time: nowSql(),
+            order_id: orderId,
+            product_id: orderProductId,
+        }]);
+
+        await this.orderService.recalculate(sourceOrderId);
+        await this.orderService.recalculate(orderId);
+        await this.orderService.emitPatch(sourceOrderId);
+        await this.orderService.emitPatch(orderId);
+        return true;
+    }
+
+    async setQuantity({orderProductId, quantity}) {
+        const orderProduct = await this.findMutable(orderProductId, 'orderProducts.setQuantity');
+        quantity = qty(quantity);
+
+        if (quantity === orderProduct.quantity) {
+            return await this.orderProducts.findRow(orderProductId);
+        }
+
+        // Склад — по held(quantity, workshop_print_quantity) до и после правки. Снятое до печати
+        // возвращается сразу (rollback), снятое после печати держится списанным, пока отмена не
+        // уйдёт в цех (refund в OrderService.syncWorkshopCount).
+        const heldBefore = StorageService.held(orderProduct.quantity, orderProduct.workshop_print_quantity);
+
+        // Позиция, которую ещё не отправляли в цех, удаляется физически (мягко) —
+        // печатать по ней уже нечего.
+        if (quantity == 0 && orderProduct.workshop_print_quantity == 0) {
+            // До softDelete: движение блюда читает живые модификаторы позиции.
+            await this.orderService.storage.settle(orderProduct, heldBefore, StorageService.held(0, 0), 'rollback');
+            await this.orderProducts.softDelete(orderProductId);
+            await this.orderService.recalculate(orderProduct.order_id);
+            await this.orderService.emitPatch(orderProduct.order_id);
+            return true;
+        }
+
+        quantity = Math.max(quantity, 0);
+        await this.orderService.saveEvents([{
+            event: quantity > orderProduct.quantity ? 'orders:add_product' : 'orders:trash_product',
+            time: nowSql(),
+            order_id: orderProduct.order_id,
+            product_id: orderProduct.product_id,
+            quantity: qty(quantity - orderProduct.quantity),
+        }]);
+
+        const appendMode = toBool(this.context.setting('terminal_settings.append_order_product', false));
+        const hasTimerModifier = await this.snapshot.hasTimerModifier(orderProduct.product_id);
+
+        // Возврат ранее удалённой, но уже напечатанной позиции — просто правим количество,
+        // отдельной строкой такое добавлять нельзя (цех получил бы дубль).
+        const isRestoring = orderProduct.workshop_print_quantity > 0
+            && quantity > orderProduct.quantity
+            && quantity <= orderProduct.workshop_print_quantity;
+
+        const shouldAppend = !isRestoring
+            && quantity > orderProduct.quantity
+            && (appendMode || hasTimerModifier);
+
+        let isAppend = false;
+        let newProductId = null;
+
+        if (shouldAppend) {
+            // Прибавка уходит новой строкой (или доливается addProduct'ом в подходящую) — склад
+            // двигает addProduct. У этой строки количество не меняется, её held тоже.
+            const created = await this.orderService.addProduct({
+                productId: orderProduct.product_id,
+                orderId: orderProduct.order_id,
+                guestNumber: orderProduct.guest_number,
+                quantity: qty(quantity - orderProduct.quantity),
+                modifierSets: orderProduct.modifiers,
+            });
+            newProductId = created ? created.id : null;
+            isAppend = true;
+        } else {
+            const data = {quantity};
+            if (!isRestoring) {
+                data.modified_at = nowSql();
+            }
+            if (orderProduct.type === TYPE_TIMER) {
+                data.workshop_print_quantity = 0;
+            }
+            // Напечатанное — как до правки, как в PHP. Обнуление у повременной позиции ничего не
+            // меняет: склад она не двигает (тип товара не product и не dish).
+            await this.orderService.storage.settle(
+                orderProduct,
+                heldBefore,
+                StorageService.held(quantity, orderProduct.workshop_print_quantity),
+                'rollback'
+            );
+            await this.orderProducts.update(orderProductId, data);
+
+            if (orderProduct.type === TYPE_TIMER && quantity == 0) {
+                await this.orderProducts.softDelete(orderProductId);
+            }
+        }
+
+        await this.orderService.recalculate(orderProduct.order_id);
+        await this.orderService.emitPatch(orderProduct.order_id);
+
+        return {
+            ...((await this.orderProducts.findRow(orderProductId)) || {}),
+            is_append: isAppend,
+            new_product_id: newProductId,
+        };
+    }
+
+    async setPrice({orderProductId, price}) {
+        const orderProduct = await this.findMutable(orderProductId, 'orderProducts.setPrice');
+        await this.orderProducts.update(orderProductId, {price: money(price)});
+        await this.orderService.recalculate(orderProduct.order_id);
+        await this.orderService.emitPatch(orderProduct.order_id);
+        return await this.orderProducts.findRow(orderProductId);
+    }
+
+    /** «Удаление» позиции — это количество 0: строка нужна печати, чтобы отбить сторно. */
+    async remove(orderProductId) {
+        const orderProduct = await this.findMutable(orderProductId, 'orderProducts.remove');
+        // Склад — как в setQuantity до 0: не напечатанное возвращается сразу, напечатанное
+        // держится списанным, пока отмена не уйдёт в цех.
+        await this.orderService.storage.settle(
+            orderProduct,
+            StorageService.held(orderProduct.quantity, orderProduct.workshop_print_quantity),
+            StorageService.held(0, orderProduct.workshop_print_quantity),
+            'rollback'
+        );
+        await this.orderProducts.update(orderProductId, {quantity: 0});
+        await this.orderService.recalculate(orderProduct.order_id);
+        await this.orderService.emitPatch(orderProduct.order_id);
+        return true;
+    }
+
+    async setComment({orderProductId, comment}) {
+        const orderProduct = await this.findMutable(orderProductId, 'orderProducts.setComment');
+        const escaped = htmlspecialchars(comment);
+        if (orderProduct.comment === escaped) {
+            return await this.orderProducts.findRow(orderProductId);
+        }
+        await this.orderProducts.update(orderProductId, {comment: escaped});
+        await this.orderService.emitPatch(orderProduct.order_id);
+        return await this.orderProducts.findRow(orderProductId);
+    }
+
+    async updateModifiers({orderProductId, modifiers}) {
+        const orderProduct = await this.findMutable(orderProductId, 'orderProducts.updateModifiers');
+        const [sets, , hash] = await OrderService.collectModifierSets(this.snapshot, modifiers, this.context.locale());
+
+        await this.orderProducts.update(orderProductId, {modifications_sets_hash: hash});
+        await this.orderProducts.deleteModifierSets(orderProductId);
+        await this.orderProducts.insertModifierSets(orderProductId, sets);
+
+        // Склад: старые модификаторы возвращаются, новые списываются — на held позиции.
+        // orderProduct.modifiers прочитаны findMutable до удаления. Тот же набор — движений нет.
+        if ((hash || null) !== (orderProduct.modifications_sets_hash || null)) {
+            await this.orderService.storage.swapModifiers(
+                orderProduct,
+                orderProduct.modifiers,
+                StorageService.held(orderProduct.quantity, orderProduct.workshop_print_quantity)
+            );
+        }
+
+        await this.orderService.recalculate(orderProduct.order_id);
+        await this.orderService.emitPatch(orderProduct.order_id);
+        return true;
+    }
+
+    /**
+     * Перенос позиции другому гостю. Если у него уже есть такая же строка — сливаем,
+     * иначе в чеке появятся две одинаковые позиции у одного гостя.
+     */
+    async setGuestNumber({orderProductId, guestNumber}) {
+        const orderProduct = await this.findMutable(orderProductId, 'orderProducts.setGuestNumber');
+        const other = await this.orderProducts.findSameProductForGuest({
+            orderId: orderProduct.order_id,
+            productId: orderProduct.product_id,
+            guestNumber,
+            price: orderProduct.price,
+            hash: orderProduct.modifications_sets_hash,
+            excludeId: orderProduct.id,
+        });
+
+        if (!other) {
+            await this.orderProducts.update(orderProductId, {guest_number: toInt(guestNumber, 1)});
+            await this.orderService.emitPatch(orderProduct.order_id);
+            return await this.orderProducts.findRow(orderProductId);
+        }
+
+        const quantity = qty(other.quantity + orderProduct.quantity);
+        const printed = qty(other.workshop_print_quantity + orderProduct.workshop_print_quantity);
+        // Склад: held слитой строки не больше суммы held двух (снятое после печати у одной
+        // перекрывается количеством другой) — разница возвращается сразу.
+        const heldBefore = StorageService.held(other.quantity, other.workshop_print_quantity)
+            + StorageService.held(orderProduct.quantity, orderProduct.workshop_print_quantity);
+        const heldAfter = StorageService.held(quantity, printed);
+
+        await this.orderProducts.update(other.id, {
+            quantity,
+            total: money(other.total + orderProduct.total),
+            comment: other.comment || orderProduct.comment,
+            print_quantity: qty(other.print_quantity + orderProduct.print_quantity),
+            receipt_print_quantity: qty(other.receipt_print_quantity + orderProduct.receipt_print_quantity),
+            total_workshop_print_quantity: qty(other.total_workshop_print_quantity + orderProduct.total_workshop_print_quantity),
+            workshop_print_quantity: printed,
+        });
+        // Модификаторы у строк одинаковые (слияние только по тому же хэшу) — двигаем по B.
+        await this.orderService.storage.settle(other, heldBefore, heldAfter, 'rollback');
+        await this.orderProducts.softDelete(orderProductId);
+        await this.orderService.emitPatch(orderProduct.order_id);
+        return await this.orderProducts.findRow(other.id);
+    }
+
+    async getById(orderId) {
+        return await this.orderService.getById(orderId);
+    }
+}
+
+module.exports = OrderProductService;