@alizadefaig/pos-server 1.2.26 → 1.2.27

package/app/printers/address.js

@@ -0,0 +1,348 @@
+'use strict';
+
+/**
+ * Где сейчас стоит сетевой принтер — привязка по MAC (фронт с VITE_PRINTER_MAC шлёт
+ * `mac_binding: true`, выключить на кассе — PRINTER_MAC_BINDING=false).
+ *
+ * У LAN-принтера в базе записан IP, а роутер заведения раздаёт адреса по DHCP: после
+ * перезагрузки принтер встаёт на другой адрес, и чеки цеха уходят в пустоту (или на чужое
+ * устройство, которое заняло старый адрес). MAC у принтера постоянный.
+ *
+ * Порядок проверки (как у evopos):
+ *   1. адрес из кэша или из задания: порт 9100 открыт и ARP показывает на нём наш MAC — печатаем;
+ *   2. ARP-таблица ОС: наш MAC уже виден на другом адресе — проверяем порт и берём его;
+ *   3. скан своей подсети (не шире /24) пачками по BATCH с коротким таймаутом, после каждой
+ *      пачки — ARP: соединение наполняет таблицу ОС и для закрытых портов.
+ *
+ * ARP не знает адрес (принтер за маршрутизатором, в другой подсети) — сверять не с чем, IP из
+ * задания считается верным: так работала печать до привязки. На адресе ДРУГОЙ MAC — туда не
+ * печатаем: ответ `printer_not_found` честнее, чем чек на чужом принтере.
+ *
+ * Проверенный адрес живёт VERIFY_EVERY_MS: поток цеховых чеков не сканирует сеть. Неудачная
+ * печать сбрасывает проверку — следующее задание проверит адрес заново.
+ */
+const {execFile} = require('node:child_process');
+const fs = require('node:fs');
+const net = require('node:net');
+const os = require('node:os');
+const path = require('node:path');
+
+const PRINTER_PORT = 9100;
+const BATCH = 48;
+const SCAN_TIMEOUT_MS = 400;
+const VERIFY_TIMEOUT_MS = 1000;
+const VERIFY_EVERY_MS = 60000;
+const LEARN_TTL_MS = 10 * 60 * 1000;
+const CACHE_FILE = 'printer-addresses.json';
+
+const enabled = (body) => Boolean(body)
+    && body.mac_binding === true
+    && process.env.PRINTER_MAC_BINDING !== 'false'
+    && Boolean(body.printer)
+    && body.printer.type === 'LAN';
+
+/** aa:bb:cc:dd:ee:ff — нижний регистр, два знака на октет. Пустой, нулевой и broadcast → null. */
+const normalizeMac = (value) => {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const parts = value.trim().toLowerCase().split(/[:-]/);
+    if (parts.length !== 6 || !parts.every((part) => /^[0-9a-f]{1,2}$/.test(part))) {
+        return null;
+    }
+    const mac = parts.map((part) => part.padStart(2, '0')).join(':');
+    if (mac === '00:00:00:00:00:00' || mac === 'ff:ff:ff:ff:ff:ff') {
+        return null;
+    }
+    return mac;
+};
+
+const IPV4 = /\b(\d{1,3}(?:\.\d{1,3}){3})\b/;
+const MAC = /\b([0-9a-f]{1,2}(?:[:-][0-9a-f]{1,2}){5})\b/i;
+
+/**
+ * Разбор вывода arp / /proc/net/arp → Map(ip → mac). В строке ищутся IPv4 и MAC, поэтому один
+ * разбор понимает все форматы:
+ *   Windows `arp -a`:     `  192.168.1.40      aa-bb-cc-dd-ee-04     dynamic`
+ *   macOS `arp -an`:      `? (192.168.1.40) at aa:bb:cc:dd:ee:4 on en0 ifscope [ethernet]`
+ *   Linux `arp -an`:      `? (192.168.1.40) at aa:bb:cc:dd:ee:04 [ether] on eth0`
+ *   /proc/net/arp:        `192.168.1.40  0x1  0x2  aa:bb:cc:dd:ee:04  *  eth0`
+ * Строки `(incomplete)` и нулевые MAC (/proc, flags 0x0) отбрасываются нормализацией.
+ */
+const parseArp = (text) => {
+    const table = new Map();
+    for (const line of String(text || '').split(/\r?\n/)) {
+        const ip = line.match(IPV4);
+        const mac = line.match(MAC);
+        if (!ip || !mac) {
+            continue;
+        }
+        const normalized = normalizeMac(mac[1]);
+        if (normalized) {
+            table.set(ip[1], normalized);
+        }
+    }
+    return table;
+};
+
+const systemArp = () => new Promise((resolve) => {
+    const windows = process.platform === 'win32';
+    execFile('arp', windows ? ['-a'] : ['-an'], {timeout: 2000, windowsHide: true}, (error, stdout) => {
+        if (!error && stdout) {
+            resolve(String(stdout));
+            return;
+        }
+        // Linux без net-tools: та же таблица в /proc.
+        fs.readFile('/proc/net/arp', 'utf8', (readError, text) => resolve(readError ? '' : text));
+    });
+});
+
+const probe = (ip, timeout, port = PRINTER_PORT) => new Promise((resolve) => {
+    const socket = new net.Socket();
+    let done = false;
+    const finish = (open) => {
+        if (done) {
+            return;
+        }
+        done = true;
+        clearTimeout(timer);
+        socket.destroy();
+        resolve(open);
+    };
+    const timer = setTimeout(() => finish(false), timeout);
+    socket.once('connect', () => finish(true));
+    socket.once('error', () => finish(false));
+    socket.connect(port, ip);
+});
+
+const ipToInt = (ip) => ip.split('.').reduce((sum, part) => (sum * 256) + Number(part), 0);
+const intToIp = (value) => [24, 16, 8, 0].map((shift) => Math.floor(value / (2 ** shift)) % 256).join('.');
+
+/** Адреса своих подсетей (IPv4, не loopback), каждая не шире /24, без своего адреса. */
+const subnetHosts = () => {
+    const hosts = new Set();
+    const own = new Set();
+    for (const list of Object.values(os.networkInterfaces())) {
+        for (const item of list || []) {
+            if (item.family !== 'IPv4' && item.family !== 4) {
+                continue;
+            }
+            if (item.internal || item.address.startsWith('169.254.')) {
+                continue;
+            }
+            own.add(item.address);
+            const address = ipToInt(item.address);
+            // Сеть шире /24 (например, /16) целиком не сканируем: берём /24 вокруг своего адреса.
+            const mask = Math.max(ipToInt(item.netmask || '255.255.255.0'), ipToInt('255.255.255.0'));
+            const network = Math.floor(address / (2 ** 32 - mask)) * (2 ** 32 - mask);
+            const size = 2 ** 32 - mask;
+            for (let offset = 1; offset < size - 1; offset += 1) {
+                hosts.add(intToIp(network + offset));
+            }
+        }
+    }
+    own.forEach((address) => hosts.delete(address));
+    return [...hosts];
+};
+
+// ------------------------------------------------------------------ состояние
+
+const hooks = {arp: systemArp, probe, hosts: subnetHosts};
+const verified = new Map(); // mac → {ip, at}
+const learned = new Map(); // ip → {mac, at}
+const searches = new Map(); // mac → Promise<ip|null>
+let loaded = false;
+
+const cacheFile = () => (process.env.CAFEPOS_DATA_DIR ? path.join(process.env.CAFEPOS_DATA_DIR, CACHE_FILE) : null);
+
+// Кэш mac → ip на диске: после перезапуска кассы без интернета снапшот отдаёт старый IP, а
+// облака, которое записало бы новый, нет — без файла каждый старт начинался бы со скана.
+const load = () => {
+    if (loaded) {
+        return;
+    }
+    loaded = true;
+    const file = cacheFile();
+    if (!file) {
+        return;
+    }
+    try {
+        const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+        for (const [mac, ip] of Object.entries(data || {})) {
+            if (normalizeMac(mac) && typeof ip === 'string' && IPV4.test(ip)) {
+                verified.set(normalizeMac(mac), {ip, at: 0});
+            }
+        }
+    } catch (e) {
+        // нет файла или битый — начинаем с пустого
+    }
+};
+
+const save = () => {
+    const file = cacheFile();
+    if (!file) {
+        return;
+    }
+    const data = Object.fromEntries([...verified.entries()].map(([mac, entry]) => [mac, entry.ip]));
+    const tmp = `${file}.tmp`;
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(data), {mode: 0o600});
+        fs.renameSync(tmp, file);
+    } catch (e) {
+        console.warn('[printer-mac] cache not saved:', e.message);
+    }
+};
+
+const remember = (mac, ip) => {
+    const previous = verified.get(mac);
+    verified.set(mac, {ip, at: Date.now()});
+    if (!previous || previous.ip !== ip) {
+        save();
+    }
+};
+
+// ------------------------------------------------------------------ проверка и поиск
+
+const readArp = async () => parseArp(await hooks.arp());
+
+/** 'ok' — на адресе наш принтер (или сверить нечем), 'closed' — порт не отвечает, 'mismatch' — чужой MAC. */
+const check = async (ip, mac, timeout = VERIFY_TIMEOUT_MS) => {
+    if (!ip || !(await hooks.probe(ip, timeout))) {
+        return 'closed';
+    }
+    const seen = (await readArp()).get(ip);
+    if (!seen) {
+        return 'ok';
+    }
+    return seen === mac ? 'ok' : 'mismatch';
+};
+
+const scan = async (mac) => {
+    // Ступень 2: ОС уже знает, где этот MAC.
+    for (const [ip, seen] of await readArp()) {
+        if (seen === mac && await check(ip, mac) === 'ok') {
+            return ip;
+        }
+    }
+    // Ступень 3: скан подсети. Пачкой, а не всей подсетью разом: слабая касса и дешёвый роутер
+    // плохо переносят сотни одновременных соединений.
+    const hosts = hooks.hosts();
+    for (let start = 0; start < hosts.length; start += BATCH) {
+        const batch = hosts.slice(start, start + BATCH);
+        const open = (await Promise.all(batch.map(async (ip) => ((await hooks.probe(ip, SCAN_TIMEOUT_MS)) ? ip : null))))
+            .filter(Boolean);
+        if (!open.length) {
+            continue;
+        }
+        const table = await readArp();
+        const found = open.find((ip) => table.get(ip) === mac);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+};
+
+/** Поиск по MAC; одновременные задания на один принтер ждут один скан. */
+const findByMac = (mac) => {
+    if (!searches.has(mac)) {
+        const search = scan(mac).finally(() => searches.delete(mac));
+        searches.set(mac, search);
+    }
+    return searches.get(mac);
+};
+
+/**
+ * Адрес для печати.
+ * @returns {Promise<{ip: string|null, mac: string|null, moved: boolean, learnedMac: string|null,
+ *                    error?: string}>}
+ *   moved — принтер найден не там, где записан (ответ фронту: resolved_ip → printers.syncAddress);
+ *   learnedMac — MAC принтера, у которого его ещё нет в базе (из ARP после прошлых печатей).
+ */
+const resolve = async (printer) => {
+    load();
+    const recorded = printer.ip_address || null;
+    const mac = normalizeMac(printer.mac_address);
+    if (!mac) {
+        return {ip: recorded, mac: null, moved: false, learnedMac: recorded ? await learn(recorded) : null};
+    }
+
+    const cached = verified.get(mac);
+    if (cached && Date.now() - cached.at < VERIFY_EVERY_MS) {
+        return {ip: cached.ip, mac, moved: cached.ip !== recorded, learnedMac: null};
+    }
+
+    let mismatch = false;
+    for (const ip of [...new Set([cached && cached.ip, recorded].filter(Boolean))]) {
+        const state = await check(ip, mac);
+        if (state === 'ok') {
+            remember(mac, ip);
+            return {ip, mac, moved: ip !== recorded, learnedMac: null};
+        }
+        mismatch = mismatch || state === 'mismatch';
+    }
+
+    const found = await findByMac(mac);
+    if (found) {
+        console.log(`[printer-mac] ${mac}: ${recorded} → ${found}`);
+        remember(mac, found);
+        return {ip: found, mac, moved: found !== recorded, learnedMac: null};
+    }
+    if (mismatch) {
+        return {ip: null, mac, moved: false, learnedMac: null, error: 'printer_not_found'};
+    }
+    // Принтер выключен или сеть недоступна: печать по записанному адресу упадёт так же, как до привязки.
+    return {ip: recorded, mac, moved: false, learnedMac: null};
+};
+
+/** MAC принтера без привязки: читаем ARP не чаще раза в LEARN_TTL_MS на адрес. */
+const learn = async (ip) => {
+    const known = learned.get(ip);
+    if (known && Date.now() - known.at < LEARN_TTL_MS) {
+        return known.mac;
+    }
+    const mac = (await readArp()).get(ip) || null;
+    learned.set(ip, {mac, at: Date.now()});
+    return mac;
+};
+
+/** Печать не удалась — следующее задание проверит адрес заново, а не поверит кэшу. */
+const invalidate = (mac, ip = null) => {
+    const entry = verified.get(mac);
+    if (entry) {
+        entry.at = 0;
+    }
+    if (ip) {
+        learned.delete(ip);
+    }
+};
+
+/** Скан принтеров (/printers.get): добавить MAC из одной ARP-таблицы. */
+const withMacs = async (devices) => {
+    const table = await readArp();
+    return devices.map((device) => (device.type === 'LAN' && table.get(device.ip_address)
+        ? {...device, mac_address: table.get(device.ip_address)}
+        : device));
+};
+
+/** Только для тестов: подмена ARP, пробы порта и списка хостов; сброс состояния. */
+const setHooks = (overrides = {}) => {
+    Object.assign(hooks, {arp: systemArp, probe, hosts: subnetHosts}, overrides);
+    verified.clear();
+    learned.clear();
+    searches.clear();
+    loaded = false;
+};
+
+module.exports = {
+    enabled,
+    normalizeMac,
+    parseArp,
+    subnetHosts,
+    resolve,
+    findByMac,
+    invalidate,
+    withMacs,
+    setHooks,
+    VERIFY_EVERY_MS,
+};

package/app/proxy.js

@@ -3,12 +3,13 @@ const {getLogger} = require("./logger/Log");
 const {createProxyMiddleware, fixRequestBody} = require("http-proxy-middleware");
 const moment = require("moment");
 const {v4: uuidv4} = require('uuid');
+const {isSyncEnabled} = require('./sync/config');
+const {redactHeaders, redactBody} = require('./security');
 
 
 function isLocalRoute(req, app) {
     const path = req.path;
     const method = req.method.toLowerCase();
-    console.log(app._router);
     // Проверяем стек роутов Express
     return app._router.stack.some((layer) => {
         if (!layer.route) return false; // Это не роут
@@ -38,10 +39,11 @@ const loadProxy = (app) => {
                     traceId,
                     timeStamp,
                     request: {
-                        headers: req.headers,
+                        // Токены, ключи и пароли в лог не пишем.
+                        headers: redactHeaders(req.headers),
                         method: req.method,
                         url: req.url,
-                        body: req.body,
+                        body: redactBody(req.body),
                         params: req.params,
                     }
                 })
@@ -94,6 +96,12 @@ const loadProxy = (app) => {
                     error: err
                 })
 
+                // С синком (модель F) фронт в офлайне ходит сюда за событиями, которых нет в
+                // ядре, — ему нужен честный 502, а не 200 с ошибкой в теле. Без синка ответ
+                // прежний: на 200 рассчитывают старые клиенты.
+                if (isSyncEnabled() && typeof res.writeHead === 'function' && !res.headersSent) {
+                    res.writeHead(502, {'Content-Type': 'application/json'});
+                }
                 res.end(JSON.stringify({
                     error: 'Bad Gateway',
                     message: err.message,

package/app/relay/masters.js

@@ -0,0 +1,173 @@
+const axios = require('axios');
+const {getConfig} = require('../config');
+const syncConfig = require('../sync/config');
+const {socketRequest} = require('../socket/request');
+
+/**
+ * Облачный Node, модель M (OFFLINE-FIRST-PLAN §12): реестр сигнальных сокетов мастер-касс.
+ *
+ * Заведение в режиме local: истина — SQLite мастер-кассы. Терминалы, которые работают через
+ * облако (PWA, телефоны официантов, кассы без офлайна), шлют события как раньше; Laravel
+ * (LocalModeMiddleware) не исполняет их сам, а отправляет сюда — POST /master/request, — и мы
+ * передаём событие мастеру по его сигнальному сокету (master:request, ответ ack).
+ *
+ * Обратно по тому же сокету мастер шлёт:
+ *   master:broadcast       — бродкаст ядра кассы → клиентам заведения, подключённым к облаку;
+ *   master:terminalRequest — запрос к терминалу, который есть только в облаке (печать).
+ *
+ * Личность проверяется один раз на подключение: sync.mode в Laravel с токеном кассы
+ * (token_matches — токен выдан ЭТОМУ терминалу). До проверки сокет в реестре не виден.
+ * Реестр живёт в памяти процесса: при нескольких репликах Node нужны sticky-сессии.
+ */
+const masters = new Map();
+
+const PRINT_EVENTS = new Set(['orders.sendToWorkshops', 'orders.printBillReceipt']);
+
+const bucket = (companyId) => {
+    if (!masters.has(companyId)) {
+        masters.set(companyId, new Map());
+    }
+    return masters.get(companyId);
+};
+
+const unregister = (socket) => {
+    const companyMasters = masters.get(socket.masterCompanyId);
+    if (companyMasters && companyMasters.get(socket.masterTerminalId) === socket) {
+        companyMasters.delete(socket.masterTerminalId);
+        if (!companyMasters.size) {
+            masters.delete(socket.masterCompanyId);
+        }
+    }
+};
+
+/** Проверка через Laravel: токен выдан этому терминалу этой компании. */
+const verify = async (auth) => {
+    if (!auth.token || !auth.company_id || !auth.team_id || !auth.terminal_id) {
+        return {ok: false, reason: 'missing_credentials'};
+    }
+    let response;
+    try {
+        response = await axios.post(`${getConfig().apiUrl}/api/sync.mode`, {}, {
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${auth.token}`,
+                'team-id': String(auth.team_id),
+                'company-id': String(auth.company_id),
+                'terminal-id': String(auth.terminal_id),
+            },
+            timeout: syncConfig.relayTimeouts().verify,
+            validateStatus: () => true,
+        });
+    } catch (e) {
+        return {ok: false, reason: 'verify_unavailable'};
+    }
+    if (response.status !== 200 || !response.data || response.data.token_matches !== true) {
+        return {ok: false, reason: `verify_failed_${response.status}`};
+    }
+    return {ok: true};
+};
+
+/**
+ * Сигнальный сокет с handshake.auth.master. company_id в query сокета обязан совпасть с
+ * тем, что проверено токеном, иначе касса слушала бы комнату чужой компании.
+ */
+const register = (socket) => {
+    const auth = socket.handshake.auth || {};
+    const queryCompanyId = String(socket.handshake.query.company_id || '');
+
+    socket.on('disconnect', () => unregister(socket));
+
+    (async () => {
+        const result = String(auth.company_id || '') === queryCompanyId
+            ? await verify(auth)
+            : {ok: false, reason: 'company_mismatch'};
+        if (!socket.connected) {
+            return;
+        }
+        if (!result.ok) {
+            console.warn(`[relay] master socket refused (${result.reason}) terminal=${auth.terminal_id}`);
+            socket.emit('master:ready', {ok: false, reason: result.reason});
+            return;
+        }
+
+        socket.masterCompanyId = queryCompanyId;
+        socket.masterTerminalId = String(auth.terminal_id);
+        bucket(socket.masterCompanyId).set(socket.masterTerminalId, socket);
+        attachHandlers(socket);
+        socket.emit('master:ready', {ok: true});
+        console.log(`[relay] master connected company=${socket.masterCompanyId} terminal=${socket.masterTerminalId}`);
+    })().catch((e) => console.error('[relay] master register failed:', e.message));
+};
+
+const attachHandlers = (socket) => {
+    const companyId = socket.masterCompanyId;
+
+    // Бродкаст ядра мастера → остальные сокеты заведения в облаке (не обратно мастеру).
+    socket.on('master:broadcast', (payload) => {
+        if (!payload || typeof payload.event !== 'string' || !payload.event) {
+            return;
+        }
+        // Служебные каналы адресные: мастер не может через бродкаст отвечать за других.
+        if (/^(api|request|response|master):/.test(payload.event)) {
+            return;
+        }
+        const args = Array.isArray(payload.args) ? payload.args : [];
+        socket.to(companyId).emit(payload.event, ...args);
+    });
+
+    // Печать/запрос на терминал, подключённый только к облаку. Только терминалы своей компании.
+    socket.on('master:terminalRequest', async (payload, ack) => {
+        if (typeof ack !== 'function') {
+            return;
+        }
+        if (!payload || !payload.terminal_id || !payload.event) {
+            ack({success: false, message: 'Invalid request'});
+            return;
+        }
+        const response = await socketRequest({
+            terminalId: String(payload.terminal_id),
+            companyId,
+            eventName: String(payload.event),
+            data: payload.data ?? null,
+            requestId: payload.request_id ?? null,
+            timeout: Number(payload.timeout) > 0 ? Number(payload.timeout) : undefined,
+        });
+        ack(response);
+    });
+};
+
+/**
+ * POST /master/request от Laravel → мастер-касса. Возвращает {status, body} для ответа Laravel:
+ * {relayed:true, status, body} — ответ мастера; relayed:false — мастера нет/не успел.
+ */
+const relayRequest = async (payload) => {
+    const companyId = String(payload.company_id || '');
+    const terminalId = String(payload.master_terminal_id || '');
+    const socket = masters.get(companyId)?.get(terminalId);
+    if (!socket || !socket.connected) {
+        return {status: 503, body: {relayed: false, error_code: 'master_offline'}};
+    }
+
+    const timeouts = syncConfig.relayTimeouts();
+    const waitMs = PRINT_EVENTS.has(payload.event) ? timeouts.print : timeouts.api;
+    try {
+        const ack = await socket.timeout(waitMs).emitWithAck('master:request', {
+            company_id: companyId,
+            master_terminal_id: terminalId,
+            epoch: payload.epoch,
+            event: payload.event,
+            headers: payload.headers || {},
+            params: payload.params || {},
+        });
+        return {status: 200, body: ack || {relayed: false, error_code: 'master_error'}};
+    } catch (e) {
+        return {status: 504, body: {relayed: false, error_code: 'master_timeout'}};
+    }
+};
+
+const status = () => [...masters.entries()].map(([companyId, companyMasters]) => ({
+    company_id: companyId,
+    terminals: [...companyMasters.keys()],
+}));
+
+module.exports = {register, relayRequest, status, _masters: masters};