@alizadefaig/pos-server 1.0.0

package/app/db/Database.js

@@ -0,0 +1,6 @@
+class Database {
+    constructor() {
+    }
+}
+
+module.exports = Database;

package/app/socket/client.js

@@ -0,0 +1,21 @@
+const {io} = require("socket.io-client");
+const serverSocket = require('../socket/server')();
+let clientSocket = null;
+module.exports = (target, companyId) => {
+    if (!clientSocket && companyId) {
+        clientSocket = io(target, {
+            query: {
+                company_id: companyId
+            }
+        });
+    }
+
+    if (clientSocket) {
+        clientSocket.onAny((companyId, eventName, ...args) => {
+            serverSocket.to(companyId).emit(eventName, ...args);
+        })
+    }
+
+
+    return clientSocket;
+}

package/app/socket/server.js

@@ -0,0 +1,17 @@
+const {Server} = require("socket.io");
+let serverSocket = null;
+module.exports = (server = null) => {
+    if (server && !serverSocket) {
+        serverSocket = new Server(server, {
+            cors: {
+                origin: '*'
+            }
+        })
+
+        serverSocket.on('connection', (socket) => {
+            socket.join(socket.handshake.query.company_id);
+        });
+    }
+
+    return serverSocket;
+}

package/config.json

@@ -0,0 +1,6 @@
+{
+    "isServer": true,
+    "apiUrl": "https://admin.cafepos.az",
+    "debug": false,
+    "port": 3005
+}

package/lib/axios.js

@@ -0,0 +1,8 @@
+const axios = require("axios");
+const {appConfig} = require("../server");
+const instance = axios.create({
+    baseURL: appConfig.apiUrl
+})
+
+
+module.exports = instance

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "@alizadefaig/pos-server",
+    "version": "1.0.0",
+    "description": "Server in express js with Proxy to Main server if need and will work with Electron JS",
+    "homepage": "https://gitlab.com/faigalizade/pos-server#readme",
+    "bugs": {
+        "url": "https://gitlab.com/faigalizade/pos-server/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@gitlab.com/faigalizade/pos-server.git"
+    },
+    "license": "ISC",
+    "author": "faigalizade@newave.az",
+    "type": "commonjs",
+    "main": "server.js",
+    "directories": {
+        "lib": "lib"
+    },
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1",
+        "start": "node server.js"
+    },
+    "dependencies": {
+        "axios": "^1.8.4",
+        "cors": "^2.8.5",
+        "express": "^5.1.0",
+        "form-data": "^4.0.2",
+        "multer": "^1.4.5-lts.2",
+        "sequelize": "^6.37.7",
+        "socket.io": "^4.8.1",
+        "socket.io-client": "^4.8.1",
+        "cafetap-escpos-usb": "gitlab:faigalizade/escpos-usb",
+        "escpos": "^3.0.0-alpha.6",
+        "escpos-network": "^3.0.0-alpha.5"
+    }
+}

package/routes/desktop/api/printers.js

@@ -0,0 +1,143 @@
+const express = require('express');
+const router = express.Router();
+const escpos = require('escpos');
+const {getIpAddress, ipRange, getPrinterDevice} = require("../../../utils");
+const net = require('net');
+escpos.USB = require('cafetap-escpos-usb');
+escpos.Network = require('escpos-network');
+const axios = require('axios');
+const appConfig = require("../../../config.json");
+
+let PROXY_TARGET = appConfig.apiUrl || 'http://localhost:8000';
+const getUsbPrinters = async () => {
+    let result = [];
+    const usbDevices = escpos.USB.findPrinter();
+    for (const usbDevice of usbDevices) {
+        usbDevice.open((error) => {
+            console.log(error)
+        });
+        result.push({
+            type: 'USB',
+            name: await getStringDescriptor(usbDevice, usbDevice.deviceDescriptor.iProduct),
+            vendor_id: usbDevice.deviceDescriptor.idVendor,
+            product_id: usbDevice.deviceDescriptor.idProduct
+        });
+        usbDevice.close();
+    }
+    result.push({
+        type: 'USB',
+        name: 'Text',
+        vendor_id: 123,
+        product_id: 345
+    });
+
+    return result;
+}
+
+const getStringDescriptor = async (device, index) => {
+    return new Promise((resolve, reject) => {
+        device.getStringDescriptor(index, (err, data) => {
+            if (err) {
+                reject(err);
+            } else {
+                resolve(data);
+            }
+        });
+    });
+}
+
+const getNetworkDevices = async () => {
+    let networkDevices = [];
+    const connectionTimeout = 1000;
+    const ip = await getIpAddress();
+    if (!ip) {
+        return [];
+    }
+    const ips = await ipRange(ip);
+    if (ips.length) {
+        await Promise.all(
+            ips.map(async (ip) => {
+                const socket = new net.Socket();
+                let connected = false;
+
+                try {
+                    await new Promise((resolve) => {
+                        socket.on('connect', async () => {
+                            connected = true;
+                            networkDevices.push({
+                                type: 'LAN',
+                                name: 'ESC/POS',
+                                ip_address: ip
+                            });
+                            socket.destroy();
+                            resolve();
+                        });
+
+                        socket.on('error', (e) => {
+                            socket.destroy();
+                            resolve();
+                        });
+
+                        socket.connect(9100, ip);
+
+                        setTimeout(() => {
+                            if (!connected) {
+                                socket.destroy();
+                                resolve();
+                            }
+                        }, connectionTimeout);
+                    });
+                } catch (error) {
+                    console.error('Socket connection error:', error);
+                }
+            })
+        );
+    }
+    return networkDevices;
+}
+
+router.get('/printers.get', async (req, res) => {
+    let usbPrinters = await getUsbPrinters();
+    let networkPrinters = await getNetworkDevices();
+    axios.get(PROXY_TARGET + '/api/printers.get', {
+        headers: {...req.headers, host: new URL(PROXY_TARGET).host},
+    }).then(data => {
+        console.log(data.data);
+    })
+
+
+    res.json([...usbPrinters, ...networkPrinters]);
+});
+
+router.post('/printers.print', (req, res) => {
+    const device = getPrinterDevice(req.body.printer)
+    if (!device) {
+        res.send('bad').status(404);
+    }
+    const image = req.body.content;
+    const printer = new escpos.Printer(device, {});
+    const imageBuffer = Buffer.from(image, 'base64');
+
+    device.open((err) => {
+        if (err) {
+            console.error('Ошибка подключения к принтеру:', err);
+            res.send(err).status(404);
+            return;
+        }
+
+        printer.image(imageBuffer, 's8');
+        if (req.body.bell) {
+            printer.beep(2, 3);
+        }
+        if (req.body.bell) {
+            printer.cashdraw(2);
+        }
+
+        printer.cut()
+            .close();
+
+        res.send('ok');
+    });
+})
+
+module.exports = router;

package/routes/server/socket.js

@@ -0,0 +1,19 @@
+const express = require('express');
+const serverSocket = require("../../app/socket/server")();
+const router = express.Router();
+
+
+router.all('/socket', (req, res) => {
+    const companyId = req.body?.company_id || req.query?.company_id;
+    const eventName = req.body?.event || req.query?.event;
+    const data = req.body?.data || req.query?.data;
+    if (companyId || eventName || data) {
+        return res.send('ok');
+    }
+    serverSocket
+        .to(companyId)
+        .emit(eventName, data);
+    res.send('ok');
+});
+
+module.exports = router;

package/server.js

@@ -0,0 +1,111 @@
+const express = require('express')
+const app = express();
+const http = require('http');
+const cors = require('cors')
+const server = http.createServer(app);
+const multer = require('multer');
+const {join} = require("node:path");
+const upload = multer();
+const axios = require("axios");
+const {loadRoutes, streamToString} = require("./utils");
+const appConfig = require("./config.json");
+const FormData = require("form-data");
+app.use(express.json());
+app.use(express.urlencoded({extended: true})); // Для обработки form-urlencoded
+app.use(upload.any()); // Позволяет обрабатывать файлы
+app.use(cors());
+const runExpress = (conf = null) => {
+    const appConfig = conf || require('./config.json');
+    let PROXY_TARGET = appConfig.apiUrl;
+    const port = appConfig.port;
+    const isServer = appConfig.isServer;
+    const serverSocket = require('./app/socket/server')(server);
+    let clientSocket = null;
+    app.get('/up', (req, res) => {
+        res.send('ok');
+    });
+
+
+    app.get('/init', (req, res) => {
+        if (!appConfig.isServer && clientSocket && req.header('company-id')) {
+            clientSocket = require('./app/socket/client')(PROXY_TARGET, req.header('company-id'));
+        }
+        res.send('ok');
+    });
+
+
+    loadRoutes(app, join(__dirname, ('routes/' + (appConfig.isServer ? 'server' : 'desktop'))));
+    loadRoutes(app, join(__dirname, ('routes/common')));
+    app.use(async (req, res, next) => {
+        try {
+            const targetUrl = PROXY_TARGET + req.originalUrl;
+            const config = {
+                method: req.method,
+                url: targetUrl,
+                headers: {...req.headers, host: new URL(PROXY_TARGET).host},
+                responseType: 'stream'
+            };
+
+            if (req.body && Object.keys(req.body).length > 0) {
+                config.data = req.body;
+            }
+
+            if (req.files && req.files.length > 0) {
+                const FormData = require('form-data');
+                const form = new FormData();
+                req.files.forEach(file => {
+                    form.append(file.fieldname, file.buffer, file.originalname);
+                });
+
+                Object.entries(req.body).forEach(([key, value]) => {
+                    form.append(key, value);
+                });
+
+                config.data = form;
+                config.headers = {...config.headers, ...form.getHeaders(), 'Accept': 'application/json'};
+            }
+
+            const response = await axios(config);
+
+
+            res.status(response.status);
+            // Object.entries(response.headers).forEach(([key, value]) => {
+            //     res.setHeader(key, value);
+            // });
+
+            const responseData = await streamToString(response.data);
+
+
+            if (typeof responseData === 'string' || Buffer.isBuffer(responseData)) {
+                res.send(responseData);
+            } else {
+                res.json(responseData);
+            }
+
+        } catch (error) {
+            if (error.response) {
+                // Если сервер вернул ответ с ошибкой
+                res.status(error.response.status);
+
+
+                if (error.response.data && typeof error.response.data === 'object') {
+                    const details = await streamToString(error.response.data)
+                    res.json({error: 'Ошибка от проксируемого сервера', details});
+                } else {
+                    res.send(error.response.data);
+                }
+            } else {
+                // Внутренняя ошибка сервера (например, таймаут или потеря связи)
+                res.status(500).json({error: 'Внутренняя ошибка прокси', details: error.message});
+            }
+
+
+            console.error('Ошибка при проксировании запроса:', error.message);
+        }
+    });
+    server.listen(port, () => {
+        console.log('Server started on: ' + port);
+    })
+}
+
+module.exports = runExpress

package/utils.js

@@ -0,0 +1,100 @@
+const {readdirSync, existsSync} = require("node:fs");
+const {extname, join} = require("node:path");
+const {networkInterfaces} = require("os");
+
+function loadRoutes(app, routesDir, prefix = '') {
+    if (!existsSync(routesDir)) {
+        return;
+    }
+    // Читаем содержимое директории
+    const items = readdirSync(routesDir, {withFileTypes: true});
+
+    for (const item of items) {
+        const fullPath = join(routesDir, item.name);
+
+        if (item.isDirectory()) {
+            // Для папок - рекурсивно загружаем содержимое с новым префиксом
+            const newPrefix = join(prefix, item.name);
+            loadRoutes(app, fullPath, newPrefix);
+        } else if (item.isFile() && extname(item.name) === '.js') {
+            // Для JS файлов - загружаем роутер
+            const routePrefix = prefix;
+            const router = require(fullPath);
+
+            // Регистрируем роутер с префиксом
+            app.use(`/${routePrefix}/`, router);
+
+            console.log(`Route loaded ${prefix}: ${routePrefix} -> ${fullPath}`);
+        }
+    }
+}
+
+async function getIpAddress() {
+    const interfaces = networkInterfaces();
+    for (const interfaceName in interfaces) {
+        const addresses = interfaces[interfaceName];
+        for (const addressInfo of addresses) {
+            if (addressInfo.family === 'IPv4' && !addressInfo.internal) {
+                return addressInfo.address;
+            }
+        }
+    }
+    return null;
+}
+
+async function ipRange(ip) {
+    if (!ip) {
+        return [];
+    }
+    const parts = ip.split('.');
+    const networkAddress = parts.slice(0, 3).join('.') + '.';
+    const start = 0;
+    const end = 256;
+    const ips = [];
+
+    for (let i = start; i < end; i++) {
+        ips.push(networkAddress + i);
+    }
+
+    return ips;
+}
+
+function getPrinterDevice(printer) {
+    const escpos = require('escpos');
+    escpos.USB = require('cafetap-escpos-usb');
+    escpos.Network = require('escpos-network');
+    let device = null;
+    try {
+        if (printer.type === 'USB') {
+            device = new escpos.USB(printer.vendor_id, printer.product_id);
+        } else {
+            device = new escpos.Network(printer.ip_address);
+        }
+    } catch (e) {
+        console.log(e);
+    }
+
+    return device;
+}
+
+const streamToString = async (stream) => {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+    }
+    const buffer = Buffer.concat(chunks);
+
+    try {
+        return JSON.parse(buffer.toString()); // Если это JSON
+    } catch (e) {
+        return buffer.toString(); // Обычный текст или бинарные данные
+    }
+};
+
+module.exports = {
+    loadRoutes,
+    getIpAddress,
+    ipRange,
+    getPrinterDevice,
+    streamToString
+}