@alizadefaig/pos-server 1.2.26 → 1.2.27

package/app/core/models/Order.js

@@ -0,0 +1,176 @@
+const {money, toFloat, toInt, toBool, sum} = require('../support/num');
+
+const STATUS_CLOSED = 'closed';
+
+/**
+ * Чек. Порт App\Models\Order — расчётная часть один в один.
+ * Персистентность и связи наполняет OrderRepository.
+ */
+class Order {
+    constructor(row = {}, {products = [], payments = [], source = null, table = null, hall = null, waiter = null} = {}) {
+        Object.assign(this, row);
+
+        this.products = products;
+        this.payments = payments;
+        this.source = source;
+        this.table = table;
+        this.hall = hall;
+        this.waiter = waiter;
+
+        this.customers = Order.parseCustomers(row.customers);
+        this.guest_count = toInt(row.guest_count, 0);
+        this.slot_index = toInt(row.slot_index, 1);
+        this.number = toInt(row.number, 1);
+        this.global_number = toInt(row.global_number, 1);
+        this.discount_type = row.discount_type || 'amount';
+        this.status = row.status || 'created';
+        this.is_closed_without_payment = toBool(row.is_closed_without_payment);
+        this.should_send_to_kitchen = toBool(row.should_send_to_kitchen);
+        this.service_charge = toFloat(row.service_charge, 0);
+
+        for (const field of [
+            'subtotal', 'total', 'profit', 'cost', 'discount', 'discount_amount',
+            'service_charge_amount', 'max_discount_amount', 'deposit_amount', 'deposit_gap',
+            'tax', 'tip',
+        ]) {
+            this[field] = money(row[field] ?? 0);
+        }
+
+        // Флаг из Laravel: apply*-методы уже пересчитали позиции, повторный проход в calculate()
+        // только удвоил бы сервисный сбор.
+        this.calculateWithProducts = true;
+        // service_charge_calculate_mode команды — проставляет сервис при загрузке чека.
+        this.serviceChargeMode = 'after_discount';
+    }
+
+    static parseCustomers(value) {
+        if (Array.isArray(value)) {
+            return value;
+        }
+        if (typeof value === 'string' && value.length) {
+            try {
+                const parsed = JSON.parse(value);
+                return Array.isArray(parsed) ? parsed : [1];
+            } catch (e) {
+                return [1];
+            }
+        }
+        return [1];
+    }
+
+    isClosed() {
+        return this.status === STATUS_CLOSED;
+    }
+
+    applyServiceCharge(serviceCharge) {
+        this.service_charge = toFloat(serviceCharge);
+        for (const product of this.products) {
+            product.applyServiceCharge(serviceCharge).calculate(this.serviceChargeMode);
+        }
+        this.calculateWithProducts = false;
+        return this;
+    }
+
+    applyPercentDiscount(percent) {
+        this.discount = money(percent);
+        this.discount_type = 'percent';
+        for (const product of this.products) {
+            product.applyPercentDiscount(percent).calculate(this.serviceChargeMode);
+        }
+        this.calculateWithProducts = false;
+        return this;
+    }
+
+    applyAmountDiscount(amount) {
+        amount = toFloat(amount);
+        const maxDiscountAmount = Math.max(this.max_discount_amount, sum(this.products, 'max_discount_amount'));
+        if (maxDiscountAmount < amount) {
+            return this;
+        }
+        this.discount = money(Math.max(0, Math.min(amount, maxDiscountAmount)));
+        this.discount_type = 'amount';
+
+        // Сумма скидки размазывается по позициям в порядке чека, пока не кончится.
+        let left = amount;
+        for (const product of this.products) {
+            if (left <= 0) {
+                product.applyAmountDiscount(0);
+                continue;
+            }
+            const productDiscountAmount = Math.min(product.max_discount_amount, left);
+            left -= productDiscountAmount;
+            product.applyAmountDiscount(productDiscountAmount).calculate(this.serviceChargeMode);
+        }
+        this.calculateWithProducts = false;
+        return this;
+    }
+
+    /**
+     * Депозит стола: если сумма подходящих позиций меньше депозита, разницу добираем
+     * отдельной строкой и облагаем тем же сервисным сбором.
+     */
+    applyDepositGap() {
+        this.deposit_gap = 0;
+
+        const depositAmount = toFloat(this.deposit_amount);
+        if (depositAmount <= 0) {
+            return;
+        }
+
+        const eligibleSubtotal = this.products
+            .filter((product) => !product.productFlag('ignore_deposit'))
+            .reduce((carry, product) => carry + toFloat(product.subtotal), 0);
+
+        const gap = Math.max(0, depositAmount - eligibleSubtotal);
+        if (gap <= 0) {
+            return;
+        }
+
+        this.deposit_gap = money(gap);
+        this.total = money(this.total + gap);
+
+        if (this.service_charge > 0) {
+            const gapServiceCharge = money(gap * this.service_charge / 100);
+            this.service_charge_amount = money(this.service_charge_amount + gapServiceCharge);
+            this.total = money(this.total + gapServiceCharge);
+        }
+    }
+
+    calculate(withProducts = true, full = false) {
+        if ((withProducts && this.calculateWithProducts) || full) {
+            for (const product of this.products) {
+                if (!full || (this.service_charge == 0 && this.discount == 0)) {
+                    product.calculate(this.serviceChargeMode);
+                }
+            }
+            if (full) {
+                if (this.service_charge > 0) {
+                    this.applyServiceCharge(this.service_charge);
+                }
+                if (this.discount > 0) {
+                    if (this.discount_type === 'percent') {
+                        this.applyPercentDiscount(this.discount);
+                    } else {
+                        this.applyAmountDiscount(this.discount);
+                    }
+                }
+            }
+        }
+
+        this.subtotal = money(sum(this.products, 'subtotal'));
+        this.profit = money(sum(this.products, 'profit'));
+        this.cost = money(sum(this.products, 'cost_total'));
+        this.service_charge_amount = money(sum(this.products, 'service_charge_amount'));
+        this.discount_amount = money(sum(this.products, 'discount_amount'));
+        this.max_discount_amount = money(sum(this.products, 'max_discount_amount'));
+        this.total = money(sum(this.products, 'total'));
+
+        this.applyDepositGap();
+
+        return this;
+    }
+}
+
+Order.STATUS_CLOSED = STATUS_CLOSED;
+
+module.exports = Order;

package/app/core/models/OrderProduct.js

@@ -0,0 +1,249 @@
+const {money, qty, toFloat, toInt, toBool} = require('../support/num');
+const {now, parse, diffInSeconds} = require('../support/time');
+
+const TYPE_PRODUCT = 'product';
+const TYPE_TIMER = 'timer';
+const TYPE_EXTRA = 'extra';
+
+/**
+ * Позиция чека. Порт App\Models\OrderProduct — расчётная часть один в один,
+ * персистентность вынесена в OrderProductRepository (модель ничего не знает о БД).
+ */
+class OrderProduct {
+    constructor(row = {}, {product = null, modifiers = []} = {}) {
+        Object.assign(this, row);
+
+        this.product = product;
+        this.modifiers = modifiers;
+
+        // Не колонка БД: сколько минут «накрутил» таймер к моменту расчёта. Уезжает в ресурс
+        // и в чек, поэтому пересчитывается при каждом calculate().
+        this.elapsed_total_minutes = toInt(row.elapsed_total_minutes, 0);
+
+        this.quantity = qty(row.quantity ?? 1);
+        this.price = money(row.price ?? 0);
+        this.guest_number = toInt(row.guest_number, 1);
+        this.type = row.type || TYPE_PRODUCT;
+        this.discount_type = row.discount_type || 'percent';
+        this.is_stopped = toBool(row.is_stopped);
+        this.is_fixed = toBool(row.is_fixed);
+        this.is_gift = toBool(row.is_gift);
+        this.paused_seconds = toInt(row.paused_seconds, 0);
+        this.timer_limit_minutes = row.timer_limit_minutes ? toInt(row.timer_limit_minutes) : null;
+
+        for (const field of [
+            'cost', 'profit', 'cost_total', 'price_total', 'subtotal', 'total',
+            'price_after_service_charge', 'price_after_discount',
+            'discount', 'discount_amount', 'service_charge', 'service_charge_amount',
+            'max_discount_amount',
+        ]) {
+            this[field] = money(row[field] ?? 0);
+        }
+
+        for (const field of [
+            'print_quantity', 'receipt_print_quantity', 'workshop_print_quantity',
+            'kds_print_quantity', 'total_workshop_print_quantity',
+        ]) {
+            this[field] = qty(row[field] ?? 0);
+        }
+    }
+
+    productFlag(name, fallback = false) {
+        if (!this.product) {
+            return fallback;
+        }
+        return toBool(this.product[name]);
+    }
+
+    applyServiceCharge(serviceCharge) {
+        if (this.productFlag('ignore_service_charge')) {
+            this.service_charge = 0;
+            return this;
+        }
+        this.service_charge = Math.min(Math.max(0, toFloat(serviceCharge)), 100);
+        return this;
+    }
+
+    applyAmountDiscount(discount) {
+        this.discount_type = 'amount';
+        this.discount = 0;
+
+        if (toFloat(discount) > this.max_discount_amount) {
+            return this;
+        }
+
+        this.discount = money(discount);
+        this.discount_amount = this.discount;
+        return this;
+    }
+
+    applyPercentDiscount(discount) {
+        if (this.productFlag('is_not_discount')) {
+            this.discount = 0;
+            return this;
+        }
+        if (toFloat(discount) > 90 && !this.productFlag('is_giftable')) {
+            this.discount = 0;
+            return this;
+        }
+
+        this.discount_type = 'percent';
+        this.discount = money(discount);
+        return this;
+    }
+
+    /**
+     * @param {string} mode service_charge_calculate_mode команды: before_discount | after_discount
+     */
+    calculate(mode = 'after_discount') {
+        mode = mode || 'after_discount';
+
+        if (!this.cost) {
+            this.cost = money(this.product ? this.product.cost : 0);
+        }
+
+        // Цена, от которой пляшут сбор и скидка. У обычной позиции в неё входят модификаторы,
+        // у повременной — нет (там цена целиком выводится из минут).
+        let price = this.price;
+        let cost = this.cost;
+
+        if (this.type === TYPE_TIMER) {
+            cost = this.calculateTimer(price);
+        } else {
+            const modifiersTotal = this.modifiers.reduce((carry, modifier) => carry + toFloat(modifier.total), 0);
+            if (modifiersTotal > 0) {
+                price += modifiersTotal;
+            }
+            this.price_total = money(price * this.quantity);
+            this.subtotal = money(price * this.quantity);
+            this.total = money(price * this.quantity);
+        }
+
+        this.calculateBase(price, mode);
+
+        this.cost_total = money(cost * this.quantity);
+        this.profit = money(this.total - this.cost_total);
+        return this;
+    }
+
+    /** Общая для обеих веток часть: максимум скидки, сервисный сбор и скидка в нужном порядке. */
+    calculateBase(price, mode) {
+        this.max_discount_amount = money(this.subtotal * 90 / 100);
+        if (this.productFlag('is_not_discount')) {
+            this.max_discount_amount = 0;
+        } else if (this.productFlag('is_giftable')) {
+            this.max_discount_amount = this.subtotal;
+        }
+
+        const isTimer = this.type === TYPE_TIMER;
+        if (mode === 'before_discount') {
+            if (!isTimer) {
+                this.calculateServiceCharge(price);
+            } else {
+                this.price_after_service_charge = money(price);
+            }
+            this.calculateDiscount(this.price_after_service_charge);
+        } else {
+            this.calculateDiscount(price);
+            if (!isTimer) {
+                this.calculateServiceCharge(this.price_after_discount);
+            }
+        }
+    }
+
+    /**
+     * Повременная позиция: цена считается от прошедших минут, а не от количества.
+     * grace (after_how_many_apply) действует только в почасовом режиме — как в Laravel.
+     */
+    calculateTimer(price) {
+        const data = this.productData();
+        const timerData = (data && data.timer) || {};
+
+        let reference = now();
+        if (this.is_stopped && this.stopped_at) {
+            reference = parse(this.stopped_at);
+        }
+
+        const pausedSeconds = this.paused_seconds || 0;
+        const diffSeconds = Math.max(0, diffInSeconds(this.added_at, reference) - pausedSeconds);
+        let diffMinutes = Math.ceil(diffSeconds / 60);
+        if (this.timer_limit_minutes && diffMinutes > this.timer_limit_minutes) {
+            diffMinutes = this.timer_limit_minutes;
+        }
+
+        const grace = toFloat(timerData.after_how_many_apply);
+        const interval = 60;
+        const isPerMinute = toBool(timerData.is_per_minute);
+        const firstPrice = price;
+        const secondPrice = toFloat(timerData.after_price);
+        const thresholdMinutes = toBool(timerData.is_adjustable) ? toInt(timerData.after_minutes) : null;
+
+        const calcCost = (minutes, rate) => {
+            if (isPerMinute) {
+                return minutes * (rate / interval);
+            }
+            // Почасовой блок: первые 60 минут — целый час, дальше поминутно.
+            if (minutes <= interval) {
+                return rate;
+            }
+            return rate + ((minutes - interval) * (rate / interval));
+        };
+
+        let cost;
+        if (!isPerMinute && diffMinutes <= grace) {
+            cost = 0;
+        } else if (thresholdMinutes === null || diffMinutes <= thresholdMinutes) {
+            cost = calcCost(diffMinutes, firstPrice);
+        } else {
+            cost = calcCost(thresholdMinutes, firstPrice) + calcCost(diffMinutes - thresholdMinutes, secondPrice);
+        }
+
+        this.elapsed_total_minutes = toInt(diffMinutes);
+        this.price_total = money(cost);
+        this.subtotal = money(cost);
+        this.total = money(cost);
+
+        return cost;
+    }
+
+    productData() {
+        if (!this.product) {
+            return {};
+        }
+        if (typeof this.product.data === 'string') {
+            try {
+                return JSON.parse(this.product.data) || {};
+            } catch (e) {
+                return {};
+            }
+        }
+        return this.product.data || {};
+    }
+
+    calculateDiscount(price) {
+        if (this.discount_type === 'percent') {
+            const discountPerItem = Math.max(price * (this.discount / 100), 0);
+            this.price_after_discount = money(Math.max(price - discountPerItem, 0));
+            this.discount_amount = money(Math.max(discountPerItem * this.quantity, 0));
+            this.total = money(Math.max(this.total - this.discount_amount, 0));
+        } else {
+            const discountPerItem = this.quantity === 0 ? 0 : this.discount / this.quantity;
+            this.price_after_discount = money(price - discountPerItem);
+            this.discount_amount = this.discount;
+            this.total = money(this.total - this.discount_amount);
+        }
+    }
+
+    calculateServiceCharge(price) {
+        const serviceChargePerItem = Math.max(price * (this.service_charge / 100), 0);
+        this.price_after_service_charge = money(price + serviceChargePerItem);
+        this.service_charge_amount = money(this.quantity * serviceChargePerItem);
+        this.total = money(this.total + this.service_charge_amount);
+    }
+}
+
+OrderProduct.TYPE_PRODUCT = TYPE_PRODUCT;
+OrderProduct.TYPE_TIMER = TYPE_TIMER;
+OrderProduct.TYPE_EXTRA = TYPE_EXTRA;
+
+module.exports = OrderProduct;

package/app/core/repositories/EventRepository.js

@@ -0,0 +1,51 @@
+const {nowSql, toSql} = require('../support/time');
+const {phpJsonEncode} = require('../support/str');
+const {uuid} = require('../support/ids');
+
+// Ровно $fillable модели OrderEvent. В Laravel лишние ключи события (price, user_id)
+// молча отбрасываются массовым заполнением — здесь их отбрасывает этот же список.
+const COLUMNS = [
+    'platform_event_id', 'event', 'team_user_id', 'team_id', 'order_id', 'terminal_id',
+    'accepted_by', 'product_id', 'quantity', 'data', 'time_at', 'ip_address',
+];
+
+class EventRepository {
+    constructor(db) {
+        this.db = db;
+    }
+
+    /**
+     * Порт OrderService::saveEvents (запись). Уведомления в Telegram шлёт OrderService.saveEvents
+     * через TelegramService — только в облаке; с кассы событие уедет наверх push'ем.
+     */
+    async saveEvents(events, context) {
+        const timestamp = nowSql();
+        for (const event of events) {
+            const payload = {
+                id: uuid(),
+                team_id: context.teamId,
+                team_user_id: context.employeeId,
+                terminal_id: context.terminalId,
+                ip_address: context.ipAddress,
+                time_at: toSql(event.time) || timestamp,
+                created_at: timestamp,
+                updated_at: timestamp,
+            };
+            for (const column of COLUMNS) {
+                if (event[column] === undefined) {
+                    continue;
+                }
+                if (column === 'data') {
+                    payload.data = event.data === null ? null : phpJsonEncode(event.data);
+                } else if (column === 'time_at') {
+                    payload.time_at = toSql(event.time_at) || payload.time_at;
+                } else {
+                    payload[column] = event[column];
+                }
+            }
+            await this.db.insert('order_events', payload);
+        }
+    }
+}
+
+module.exports = EventRepository;