@alizadefaig/pos-server 1.2.26 → 1.2.27

package/app/core/services/ReportService.js

@@ -0,0 +1,581 @@
+const PrinterRepository = require('../repositories/PrinterRepository');
+const {round, toFloat, toBool} = require('../support/num');
+const {now, parse} = require('../support/time');
+const {translated} = require('../support/lang');
+const {DEFAULT_TIMEZONE, zonedParts, zonedTimeToUtc} = require('../support/tz');
+
+// Команда, у которой дневной отчёт идёт по закрытию чека, а не по созданию (как в Laravel).
+const CLOSED_AT_TEAMS = ['a0cc12ea-ea58-488b-9e4b-d0dc429aabed'];
+const CLOSED_STATUSES = ['closing', 'closed'];
+const TYPES = ['date', 'cash_shift'];
+
+// Order::WITHOUT_PAYMENT_REASONS. trans() их не переводит: ключей нет ни в az.json, ни в en.json.
+const WITHOUT_PAYMENT_REASONS = {
+    guest_left: 'Qonaq getdi',
+    on_the_house: 'Müəssisənin hesabına',
+    employees_wrong: 'Qarson səhvi',
+};
+const NO_REASON = 'Səbəb göstərilməyib';
+const DELETED_USER = 'Silinmiş istifadəçi';
+const DELETED_PRODUCT = 'Silinən məhsul';
+
+// Отчёт за длинный период облако считает дольше обычного запроса.
+const CLOUD_REPORT_TIMEOUT_MS = 60000;
+
+const pad = (value) => String(value).padStart(2, '0');
+
+const sqlUtc = (date) => date.toISOString().slice(0, 19).replace('T', ' ');
+
+const formatZoned = (date, timeZone) => {
+    let parts;
+    try {
+        parts = zonedParts(date, timeZone || DEFAULT_TIMEZONE);
+    } catch (e) {
+        parts = zonedParts(date, DEFAULT_TIMEZONE);
+    }
+    return `${parts.year}-${pad(parts.month)}-${pad(parts.day)} ${pad(parts.hour)}:${pad(parts.minute)}:${pad(parts.second)}`;
+};
+
+const LOCAL_DATE = /^(\d{4})-(\d{1,2})-(\d{1,2})(?:[ T](\d{1,2}):(\d{1,2})(?::(\d{1,2})(?:\.\d+)?)?)?$/;
+const ZONED_DATE = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})$/i;
+
+const daysInMonth = (year, month) => new Date(Date.UTC(year, month, 0)).getUTCDate();
+
+/**
+ * Carbon::parse($value, $tz): стенные часы без зоны — в зоне команды, строка с зоной — как есть.
+ * Фронт шлёт 'YYYY-MM-DD HH:mm:ss' и 'YYYY-MM-DD'. Непонятное — null (правило 'date' Laravel).
+ */
+const parseDate = (value, timeZone) => {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const text = value.trim();
+    const local = LOCAL_DATE.exec(text);
+    if (local) {
+        const [year, month, day, hour = 0, minute = 0, second = 0] = local.slice(1).map((part) => Number(part || 0));
+        if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)
+            || hour > 23 || minute > 59 || second > 59) {
+            return null;
+        }
+        return zonedTimeToUtc({year, month, day, hour, minute, second}, timeZone || DEFAULT_TIMEZONE);
+    }
+    if (ZONED_DATE.test(text)) {
+        const date = new Date(text.replace(' ', 'T'));
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    return null;
+};
+
+// Collection::sum по полю — float в порядке коллекции, как в PHP.
+const sumOf = (rows, key) => rows.reduce((carry, row) => carry + toFloat(row[key]), 0);
+
+/**
+ * Порт App\Http\Controllers\Api\Platform\ReportController (reports.getReport): X/Z-отчёт кассы
+ * без облака. Форма ответа совпадает с Laravel поле в поле — её печатает ReportReceipt.vue.
+ *
+ * Отличия:
+ * - by_product группирует позиции по точной цене. Laravel groupBy('price') по float обрезал
+ *   ключ до целого и сливал, например, 2.5 и 2.9 в одну строку; исправлено и там.
+ * - Касса хранит не всю историю (mirror.historyFrom + уборка закрытых чеков). Период раньше
+ *   этой границы при доступном и полном облаке считает облако, иначе отчёт считается по
+ *   локальным данным и помечается `report.partial_from` — начало полных данных в зоне команды.
+ *   Облако недоступно — `report.offline`: чеки других касс без мастера сюда не попали.
+ * - Запросы по чекам — подзапросами, а не списком id: отчёт за месяц упёрся бы в лимит
+ *   параметров SQLite.
+ */
+class ReportService {
+    /**
+     * history — () => sync.history(companyId) либо null (облачный контур ядра, синка нет).
+     */
+    constructor({db, context, history = null}) {
+        this.db = db;
+        this.context = context;
+        this.history = history;
+        this.printers = new PrinterRepository(db);
+    }
+
+    notDeleted(alias) {
+        // Эти справочники снапшот кладёт на кассу только живыми, колонки deleted_at там нет.
+        return this.db.dialect === 'pgsql' ? ` AND ${alias}.deleted_at IS NULL` : '';
+    }
+
+    locale() {
+        return this.context ? this.context.locale() : 'az';
+    }
+
+    timezone() {
+        const team = this.context.getTeam();
+        return (team && team.timezone) || DEFAULT_TIMEZONE;
+    }
+
+    // ------------------------------------------------------------ getReport
+
+    async getReport(params = {}) {
+        const timeZone = this.timezone();
+        const errors = await this.validate(params, timeZone);
+        const window = errors ? null : await this.resolveWindow(params, timeZone);
+        const history = typeof this.history === 'function' ? this.history() : null;
+
+        // Период раньше полной истории кассы (или смена, которой у кассы нет) — считает облако,
+        // если оно на связи и в нём уже всё, что есть у кассы.
+        const shiftMissing = errors && errors.shift && Object.keys(errors).length === 1;
+        const early = window && history && window.from < history.from;
+        if (history && history.cloud && (early || shiftMissing)) {
+            const response = await this.fromCloud(history.cloud, params);
+            if (response) {
+                return {...response, printer: await this.printer()};
+            }
+        }
+
+        if (errors) {
+            return {success: false, error: 'validation', errors};
+        }
+
+        const report = await this.generate(window, params, timeZone);
+        if (early) {
+            report.partial_from = formatZoned(history.from, timeZone);
+        }
+        if (history && history.mode === 'offline') {
+            report.offline = true;
+        }
+        return {success: true, report, printer: await this.printer()};
+    }
+
+    async fromCloud(cloud, params) {
+        try {
+            const response = await cloud.call('reports.getReport', params, {timeout: CLOUD_REPORT_TIMEOUT_MS});
+            return response && response.success ? response : null;
+        } catch (e) {
+            console.warn(`[report] cloud report failed, using local data: ${e.message}`);
+            return null;
+        }
+    }
+
+    /** Validator::make: 'date' => required|array, 'date.*' => required|date, type, shift exists. */
+    async validate(params, timeZone) {
+        const errors = {};
+        const date = params.date;
+        if (date === undefined || date === null || (Array.isArray(date) && date.length === 0)) {
+            errors.date = ['The date field is required.'];
+        } else if (!Array.isArray(date)) {
+            errors.date = ['The date field must be an array.'];
+        } else {
+            date.forEach((item, index) => {
+                if (item === null || item === undefined || item === '') {
+                    errors[`date.${index}`] = [`The date.${index} field is required.`];
+                } else if (!parseDate(item, timeZone)) {
+                    errors[`date.${index}`] = [`The date.${index} field must be a valid date.`];
+                }
+            });
+        }
+        if (!params.type) {
+            errors.type = ['The type field is required.'];
+        } else if (!TYPES.includes(params.type)) {
+            errors.type = ['The selected type is invalid.'];
+        }
+        if (params.shift !== undefined && params.shift !== null && params.shift !== '') {
+            // exists:shifts,id видит и удалённые смены. Не-uuid в Postgres — ошибка запроса.
+            let exists = null;
+            try {
+                exists = await this.db.value('SELECT 1 FROM shifts WHERE id = ?', [String(params.shift)]);
+            } catch (e) {
+                exists = null;
+            }
+            if (!exists) {
+                errors.shift = ['The selected shift is invalid.'];
+            }
+        }
+        return Object.keys(errors).length ? errors : null;
+    }
+
+    async resolveWindow(params, timeZone) {
+        // Shift::find не видит удалённую смену — тогда отчёт считается по датам, как в Laravel.
+        const shift = params.type === 'cash_shift' && params.shift
+            ? await this.db.get('SELECT * FROM shifts WHERE id = ? AND deleted_at IS NULL', [String(params.shift)])
+            : null;
+        if (shift) {
+            return {shift, from: parse(shift.started_at), to: shift.ended_at ? parse(shift.ended_at) : now()};
+        }
+        return {
+            shift: null,
+            from: parseDate(params.date[0], timeZone),
+            to: parseDate(params.date[1], timeZone),
+        };
+    }
+
+    async printer() {
+        const printer = await this.printers.findBillPrinter(this.context.terminalId);
+        if (!printer) {
+            return null;
+        }
+        return {
+            name: printer.name,
+            type: printer.type,
+            ip_address: printer.ip_address,
+            mac_address: printer.mac_address ?? null,
+            vendor_id: printer.vendor_id,
+            product_id: printer.product_id,
+            // Каста у модели нет: Postgres отдаёт boolean, SQLite — 0/1.
+            bell: printer.bell === null || printer.bell === undefined ? null : toBool(printer.bell),
+            cashdraw: false,
+        };
+    }
+
+    // ------------------------------------------------------------ generateReport
+
+    /** Условие выборки чеков отчёта: {sql, params} для подзапросов «чеки отчёта». */
+    ordersFilter(window) {
+        const team = this.context.getTeam();
+        const companyId = this.context.companyId;
+        const statuses = CLOSED_STATUSES.map(() => '?').join(', ');
+        if (window.shift) {
+            return {
+                sql: `o.company_id = ? AND o.deleted_at IS NULL
+                      AND (o.created_at BETWEEN ? AND ? OR o.shift_id = ?)
+                      AND o.status IN (${statuses})`,
+                params: [companyId, sqlUtc(window.from), sqlUtc(window.to), window.shift.id, ...CLOSED_STATUSES],
+            };
+        }
+        const column = team && CLOSED_AT_TEAMS.includes(team.id) ? 'closed_at' : 'created_at';
+        return {
+            sql: `o.company_id = ? AND o.deleted_at IS NULL AND o.${column} BETWEEN ? AND ?`,
+            params: [companyId, sqlUtc(window.from), sqlUtc(window.to)],
+        };
+    }
+
+    async shiftHeader(shift) {
+        const opened = shift.opened_by ? await this.userName(shift.opened_by) : null;
+        const closed = shift.closed_by ? await this.userName(shift.closed_by) : null;
+        return {opened_by: opened || DELETED_USER, closed_by: closed || null};
+    }
+
+    /** $teamUser->user?->name с withTrashed у сотрудника; удалённый пользователь — null. */
+    async userName(teamUserId) {
+        const row = await this.db.get(
+            `SELECT u.name FROM team_users tu
+             LEFT JOIN users u ON u.id = tu.user_id${this.notDeleted('u')}
+             WHERE tu.id = ?`,
+            [teamUserId]
+        );
+        return row ? row.name ?? null : null;
+    }
+
+    async generate(window, params, timeZone) {
+        const team = this.context.getTeam();
+        const companyId = this.context.companyId;
+        const locale = this.locale();
+        const formats = Array.isArray(params.formats) ? params.formats : [];
+        const has = (format) => formats.includes(format);
+
+        let report;
+        if (window.shift) {
+            const header = await this.shiftHeader(window.shift);
+            report = {
+                date: formatZoned(now(), timeZone),
+                from: formatZoned(window.from, timeZone),
+                to: formatZoned(window.to, timeZone),
+                shift: window.shift.id,
+                opened_by: header.opened_by,
+                closed_by: header.closed_by,
+                data: {},
+            };
+        } else {
+            report = {
+                date: formatZoned(now(), timeZone),
+                from: params.date[0],
+                to: params.date[1],
+                data: {},
+            };
+        }
+
+        const filter = this.ordersFilter(window);
+        const orderIds = `SELECT o.id FROM orders o WHERE ${filter.sql}`;
+
+        const orders = (await this.db.all(
+            `SELECT o.id, o.table_id, o.serving_id, o.order_source_id, o.number,
+                    o.total, o.subtotal, o.service_charge_amount, o.discount_amount, o.deposit_gap,
+                    o.is_closed_without_payment, o.without_payment_reason
+             FROM orders o WHERE ${filter.sql}`,
+            filter.params
+        )).map((order) => ({
+            ...order,
+            total: toFloat(order.total),
+            subtotal: toFloat(order.subtotal),
+            service_charge_amount: toFloat(order.service_charge_amount),
+            discount_amount: toFloat(order.discount_amount),
+            deposit_gap: toFloat(order.deposit_gap),
+        }));
+
+        // withTrashed: снятые позиции нужны для by_product и removed_products.
+        const orderProducts = (await this.db.all(
+            `SELECT op.id, op.order_id, op.product_id, op.deleted_at, op.total, op.price,
+                    op.workshop_print_quantity, op.total_workshop_print_quantity
+             FROM order_products op WHERE op.order_id IN (${orderIds})`,
+            filter.params
+        )).map((row) => ({
+            ...row,
+            total: round(row.total, 3),
+            price: round(row.price, 3),
+            workshop_print_quantity: round(row.workshop_print_quantity, 3),
+            total_workshop_print_quantity: round(row.total_workshop_print_quantity, 3),
+        }));
+        const aliveProducts = orderProducts.filter((row) => !row.deleted_at);
+
+        // Удалённые товары Laravel не читает (SoftDeletes без withTrashed). Цех категории — для
+        // мутатора Product::productWorkshopId: ignore_workshop в select Laravel нет, поэтому
+        // мутатор отдаёт колонку, а пустую — цех живой категории.
+        const productRows = await this.db.all(
+            `SELECT p.id, p.full_name, p.product_category_id, p.product_workshop_id, p.is_weight_item, p.unit_id,
+                    c.product_workshop_id AS category_workshop_id
+             FROM products p
+             LEFT JOIN product_categories c ON c.id = p.product_category_id${this.notDeleted('c')}
+             WHERE p.deleted_at IS NULL
+               AND p.id IN (SELECT op.product_id FROM order_products op WHERE op.order_id IN (${orderIds}))`,
+            filter.params
+        );
+        const products = new Map(productRows.map((product) => [product.id, {
+            ...product,
+            full_name: translated(product.full_name, locale),
+        }]));
+
+        if (has('by_table')) {
+            report.data.tables = await this.byTable(orders, companyId);
+        }
+        if (has('by_workshop')) {
+            report.data.workshops = await this.byWorkshop(aliveProducts, products, team);
+        }
+        if (has('by_employee')) {
+            report.data.employees = await this.byEmployee(orders);
+        }
+        if (has('by_category')) {
+            report.data.categories = await this.byCategory(aliveProducts, products, locale);
+        }
+        if (has('by_product')) {
+            report.data.products = this.byProduct(orderProducts, products);
+            report.data.removed_products = this.removedProducts(orderProducts, products);
+        }
+        if (has('by_payment_method')) {
+            report.data.payments = await this.byPaymentMethod(orderIds, filter.params);
+        }
+        if (has('by_order_source')) {
+            report.data.order_sources = await this.byOrderSource(orders);
+        }
+
+        // Закрытия без оплаты — всегда, не по formats (как в Laravel).
+        const withoutPayment = orders.filter((order) => toBool(order.is_closed_without_payment));
+        report.data.without_payments = this.withoutPayments(withoutPayment);
+
+        report.footer = {
+            without_payment_total: round(sumOf(withoutPayment, 'total'), 2),
+            without_payment_count: withoutPayment.length,
+            subtotal: round(sumOf(orders, 'subtotal'), 2),
+            service_charge_amount: round(sumOf(orders, 'service_charge_amount'), 2),
+            discount_amount: round(sumOf(orders, 'discount_amount'), 2),
+            deposit_gap: round(sumOf(orders, 'deposit_gap'), 2),
+            total: round(sumOf(orders, 'total'), 2),
+        };
+        return report;
+    }
+
+    async byTable(orders, companyId) {
+        const halls = await this.db.all(
+            `SELECT h.id, h.name FROM halls h WHERE h.company_id = ?${this.notDeleted('h')}`,
+            [companyId]
+        );
+        const rows = [];
+        for (const hall of halls) {
+            const tables = await this.db.all(
+                `SELECT t.id, t.label FROM tables t WHERE t.hall_id = ?${this.notDeleted('t')} ORDER BY t."order"`,
+                [hall.id]
+            );
+            for (const table of tables) {
+                rows.push({
+                    label: `${hall.name ?? ''} ${table.label ?? ''}`,
+                    value: round(sumOf(orders.filter((order) => order.table_id === table.id), 'total'), 2),
+                });
+            }
+        }
+        return rows.filter((row) => row.value > 0);
+    }
+
+    async byWorkshop(aliveProducts, products, team) {
+        const workshops = await this.db.all(
+            `SELECT w.id, w.name FROM product_workshops w WHERE w.team_id = ?${this.notDeleted('w')}`,
+            [team ? team.id : this.context.teamId]
+        );
+        return workshops.map((workshop) => {
+            let value = 0;
+            for (const orderProduct of aliveProducts) {
+                const product = products.get(orderProduct.product_id);
+                if (product && (product.product_workshop_id || product.category_workshop_id) === workshop.id) {
+                    value += orderProduct.total;
+                }
+            }
+            return {label: workshop.name, value: round(value, 2)};
+        }).filter((row) => row.value > 0);
+    }
+
+    async byEmployee(orders) {
+        const servingIds = [...new Set(orders.map((order) => order.serving_id).filter(Boolean))];
+        if (!servingIds.length) {
+            return [];
+        }
+        const staff = await this.db.all(
+            `SELECT tu.id, u.name FROM team_users tu
+             LEFT JOIN users u ON u.id = tu.user_id${this.notDeleted('u')}
+             WHERE tu.id IN (${servingIds.map(() => '?').join(', ')})`,
+            servingIds
+        );
+        return staff.map((teamUser) => {
+            const own = orders.filter((order) => order.serving_id === teamUser.id);
+            return {
+                label: teamUser.name ?? null,
+                value: round(sumOf(own, 'total'), 2),
+                service_charge_amount: round(sumOf(own, 'service_charge_amount'), 2),
+                discount_amount: round(sumOf(own, 'discount_amount'), 2),
+                subtotal: round(sumOf(own, 'subtotal'), 2),
+            };
+        });
+    }
+
+    async byCategory(aliveProducts, products, locale) {
+        const categoryIds = [...new Set([...products.values()].map((product) => product.product_category_id).filter(Boolean))];
+        if (!categoryIds.length) {
+            return [];
+        }
+        const categories = await this.db.all(
+            `SELECT c.id, c.name FROM product_categories c
+             WHERE c.deleted_at IS NULL AND c.id IN (${categoryIds.map(() => '?').join(', ')})`,
+            categoryIds
+        );
+        return categories.map((category) => {
+            const ids = new Set([...products.values()]
+                .filter((product) => product.product_category_id === category.id)
+                .map((product) => product.id));
+            return {
+                label: translated(category.name, locale),
+                value: round(sumOf(aliveProducts.filter((row) => ids.has(row.product_id)), 'total'), 2),
+            };
+        });
+    }
+
+    byProduct(orderProducts, products) {
+        const rows = [];
+        for (const product of products.values()) {
+            // Снятые позиции тоже: их workshop_print_quantity — то, что успело уйти на кухню.
+            const groups = new Map();
+            for (const row of orderProducts) {
+                if (row.product_id !== product.id) {
+                    continue;
+                }
+                const key = String(row.price);
+                if (!groups.has(key)) {
+                    groups.set(key, []);
+                }
+                groups.get(key).push(row);
+            }
+            for (const group of groups.values()) {
+                const quantity = sumOf(group, 'workshop_print_quantity');
+                rows.push({
+                    label: product.full_name,
+                    quantity,
+                    value: round(quantity * group[0].price, 2),
+                    price: group[0].price,
+                    is_weight_item: toBool(product.is_weight_item),
+                    unit_id: product.unit_id ?? null,
+                });
+            }
+        }
+        // sortByDesc устойчив (PHP 8): равные остаются в исходном порядке.
+        return rows
+            .filter((row) => row.quantity > 0)
+            .map((row, index) => ({row, index}))
+            .sort((a, b) => (b.row.value - a.row.value) || (a.index - b.index))
+            .map(({row}) => row);
+    }
+
+    removedProducts(orderProducts, products) {
+        const removed = {};
+        for (const row of orderProducts) {
+            if (!(row.total_workshop_print_quantity > row.workshop_print_quantity)) {
+                continue;
+            }
+            const key = row.product_id ?? '';
+            if (!Object.prototype.hasOwnProperty.call(removed, key)) {
+                const product = products.get(row.product_id) || null;
+                removed[key] = {
+                    label: (product && product.full_name) ?? DELETED_PRODUCT,
+                    quantity: 0,
+                    value: 0,
+                    is_weight_item: Boolean(product && toBool(product.is_weight_item)),
+                    unit_id: product ? product.unit_id ?? null : null,
+                };
+            }
+            removed[key].quantity += round(row.total_workshop_print_quantity - row.workshop_print_quantity, 3);
+            removed[key].value = round(removed[key].quantity * row.price, 2);
+        }
+        return Object.keys(removed).length ? removed : [];
+    }
+
+    async byPaymentMethod(orderIds, params) {
+        const payments = await this.db.all(
+            `SELECT p.payment_method_id, p.amount FROM order_payments p
+             WHERE p.deleted_at IS NULL AND p.order_id IN (${orderIds})`,
+            params
+        );
+        const methodIds = [...new Set(payments.map((payment) => payment.payment_method_id).filter(Boolean))];
+        if (!methodIds.length) {
+            return [];
+        }
+        const methods = await this.db.all(
+            `SELECT m.id, m.name FROM payment_methods m
+             WHERE m.id IN (${methodIds.map(() => '?').join(', ')})${this.notDeleted('m')}`,
+            methodIds
+        );
+        return methods.map((method) => ({
+            label: method.name,
+            value: round(sumOf(payments.filter((payment) => payment.payment_method_id === method.id), 'amount'), 2),
+        }));
+    }
+
+    async byOrderSource(orders) {
+        const sourceIds = [...new Set(orders.map((order) => order.order_source_id).filter(Boolean))];
+        if (!sourceIds.length) {
+            return [];
+        }
+        const sources = await this.db.all(
+            `SELECT s.id, s.name FROM order_sources s
+             WHERE s.id IN (${sourceIds.map(() => '?').join(', ')})${this.notDeleted('s')}`,
+            sourceIds
+        );
+        return sources.map((source) => ({
+            label: source.name,
+            value: round(sumOf(orders.filter((order) => order.order_source_id === source.id), 'total'), 2),
+        }));
+    }
+
+    withoutPayments(orders) {
+        const groups = new Map();
+        for (const order of orders) {
+            const reason = order.without_payment_reason ?? '';
+            if (!groups.has(reason)) {
+                groups.set(reason, []);
+            }
+            groups.get(reason).push(order);
+        }
+        const rows = [...groups.entries()].map(([reason, list]) => ({
+            label: WITHOUT_PAYMENT_REASONS[reason] ?? NO_REASON,
+            count: list.length,
+            value: round(sumOf(list, 'total'), 2),
+            numbers: list.map((order) => order.number).filter(Boolean).sort((a, b) => a - b),
+        }));
+        return rows
+            .map((row, index) => ({row, index}))
+            .sort((a, b) => (b.row.value - a.row.value) || (a.index - b.index))
+            .map(({row}) => row);
+    }
+}
+
+ReportService.parseDate = parseDate;
+
+module.exports = ReportService;