zklib-ts 1.0.6 → 1.0.8

package/dist/zudp.js

@@ -0,0 +1,510 @@
+import { authKey, createUDPHeader, decodeUDPHeader, exportErrorMessage, checkNotEventUDP, decodeUserData28, decodeRecordData16, decodeRecordRealTimeLog18 } from './helper/utils';
+import { COMMANDS, Constants, REQUEST_DATA } from './helper/command';
+import { appendFile } from 'fs';
+import * as dgram from 'node:dgram';
+
+const parseCurrentTime = () => {
+    const currentTime = new Date();
+    return {
+        year: currentTime.getFullYear(),
+        month: currentTime.getMonth() + 1,
+        day: currentTime.getDate(),
+        hour: currentTime.getHours(),
+        second: currentTime.getSeconds()
+    };
+};
+const log = (text) => {
+    const currentTime = parseCurrentTime();
+    const fileName = `${currentTime.day}`.padStart(2, '0') +
+        `${currentTime.month}`.padStart(2, '0') +
+        `${currentTime.year}.err.log`;
+    const logMessage = `\n [${currentTime.hour}:${currentTime.second}] ${text}`;
+    appendFile(fileName, logMessage, () => { });
+};
+
+/**
+ *
+ * @param {number} time
+ */
+const decode = time => {
+    const second = time % 60;
+    time = (time - second) / 60;
+    const minute = time % 60;
+    time = (time - minute) / 60;
+    const hour = time % 24;
+    time = (time - hour) / 24;
+    const day = time % 31 + 1;
+    time = (time - (day - 1)) / 31;
+    const month = time % 12;
+    time = (time - month) / 12;
+    const year = time + 2000;
+    return new Date(year, month, day, hour, minute, second);
+};
+/**
+ *
+ * @param {Date} date
+ */
+const encode = date => {
+    return (((date.getFullYear() % 100) * 12 * 31 + date.getMonth() * 31 + date.getDate() - 1) * (24 * 60 * 60) +
+        (date.getHours() * 60 + date.getMinutes()) * 60 +
+        date.getSeconds());
+};
+var timeParser = { encode, decode };
+
+class ZUDP {
+    ip;
+    port;
+    timeout;
+    socket;
+    sessionId;
+    replyId;
+    inport;
+    comm_key;
+    constructor(ip, port, timeout, inport, comm_key = 0) {
+        this.ip = ip;
+        this.port = port;
+        this.timeout = timeout;
+        this.socket = null;
+        this.sessionId = null;
+        this.replyId = 0;
+        this.inport = inport;
+        this.comm_key = comm_key;
+    }
+    createSocket(cbError, cbClose) {
+        return new Promise((resolve, reject) => {
+            this.socket = dgram.createSocket('udp4');
+            this.socket.setMaxListeners(Infinity);
+            this.socket.once('error', (err) => {
+                this.socket = null;
+                reject(err);
+                if (cbError)
+                    cbError(err);
+            });
+            this.socket.once('close', () => {
+                this.socket = null;
+                if (cbClose)
+                    cbClose('udp');
+            });
+            this.socket.once('listening', () => {
+                resolve(this.socket);
+            });
+            try {
+                this.socket.bind(this.inport);
+            }
+            catch (err) {
+                this.socket = null;
+                reject(err);
+                if (cbError)
+                    cbError(err);
+            }
+        });
+    }
+    async connect() {
+        try {
+            let reply = await this.executeCmd(COMMANDS.CMD_CONNECT, '');
+            if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_OK) {
+                return true;
+            }
+            if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_UNAUTH) {
+                const hashedCommkey = authKey(this.comm_key, this.sessionId);
+                reply = await this.executeCmd(COMMANDS.CMD_AUTH, hashedCommkey);
+                if (reply.readUInt16LE(0) === COMMANDS.CMD_ACK_OK) {
+                    return true;
+                }
+                else {
+                    throw new Error('Authentication error');
+                }
+            }
+            else {
+                throw new Error('NO_REPLY_ON_CMD_CONNECT');
+            }
+        }
+        catch (err) {
+            console.error('Error in connect method:', err);
+            throw err;
+        }
+    }
+    async closeSocket() {
+        return new Promise((resolve, reject) => {
+            if (!this.socket) {
+                resolve(true);
+                return;
+            }
+            const timeout = 2000;
+            const timer = setTimeout(() => {
+                console.warn('Socket close timeout');
+                resolve(true);
+            }, timeout);
+            this.socket.removeAllListeners('message');
+            // @ts-ignore
+            this.socket.close((err) => {
+                clearTimeout(timer);
+                if (err) {
+                    console.error('Error closing socket:', err);
+                    reject(err);
+                }
+                else {
+                    resolve(true);
+                }
+                this.socket = null;
+            });
+        });
+    }
+    writeMessage(msg, connect) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket) {
+                reject(new Error('Socket not initialized'));
+                return;
+            }
+            let sendTimeoutId;
+            const onMessage = (data) => {
+                clearTimeout(sendTimeoutId);
+                this.socket.removeListener('message', onMessage);
+                resolve(data);
+            };
+            this.socket.once('message', onMessage);
+            this.socket.send(msg, 0, msg.length, this.port, this.ip, (err) => {
+                if (err) {
+                    this.socket.removeListener('message', onMessage);
+                    reject(err);
+                    return;
+                }
+                if (this.timeout) {
+                    sendTimeoutId = setTimeout(() => {
+                        this.socket.removeListener('message', onMessage);
+                        reject(new Error('TIMEOUT_ON_WRITING_MESSAGE'));
+                    }, connect ? 2000 : this.timeout);
+                }
+            });
+        });
+    }
+    requestData(msg) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket) {
+                reject(new Error('Socket not initialized'));
+                return;
+            }
+            let sendTimeoutId;
+            let responseTimeoutId;
+            const handleOnData = (data) => {
+                if (checkNotEventUDP(data))
+                    return;
+                clearTimeout(sendTimeoutId);
+                clearTimeout(responseTimeoutId);
+                this.socket.removeListener('message', handleOnData);
+                resolve(data);
+            };
+            const onReceiveTimeout = () => {
+                this.socket.removeListener('message', handleOnData);
+                reject(new Error('TIMEOUT_ON_RECEIVING_REQUEST_DATA'));
+            };
+            this.socket.on('message', handleOnData);
+            this.socket.send(msg, 0, msg.length, this.port, this.ip, (err) => {
+                if (err) {
+                    this.socket.removeListener('message', handleOnData);
+                    reject(err);
+                    return;
+                }
+                responseTimeoutId = setTimeout(onReceiveTimeout, this.timeout);
+            });
+            sendTimeoutId = setTimeout(() => {
+                this.socket.removeListener('message', handleOnData);
+                reject(new Error('TIMEOUT_IN_RECEIVING_RESPONSE_AFTER_REQUESTING_DATA'));
+            }, this.timeout);
+        });
+    }
+    async executeCmd(command, data) {
+        try {
+            if (command === COMMANDS.CMD_CONNECT) {
+                this.sessionId = 0;
+                this.replyId = 0;
+            }
+            else {
+                this.replyId++;
+            }
+            const buf = createUDPHeader(command, this.sessionId, this.replyId, data);
+            const reply = await this.writeMessage(buf, command === COMMANDS.CMD_CONNECT || command === COMMANDS.CMD_EXIT);
+            if (reply && reply.length > 0) {
+                if (command === COMMANDS.CMD_CONNECT) {
+                    this.sessionId = reply.readUInt16LE(4);
+                }
+            }
+            return reply;
+        }
+        catch (err) {
+            console.error(`Error executing command ${command}:`, err);
+            throw err;
+        }
+    }
+    async sendChunkRequest(start, size) {
+        this.replyId++;
+        const reqData = Buffer.alloc(8);
+        reqData.writeUInt32LE(start, 0);
+        reqData.writeUInt32LE(size, 4);
+        const buf = createUDPHeader(COMMANDS.CMD_DATA_RDY, this.sessionId, this.replyId, reqData);
+        try {
+            await new Promise((resolve, reject) => {
+                this.socket.send(buf, 0, buf.length, this.port, this.ip, (err) => {
+                    if (err) {
+                        log(`[UDP][SEND_CHUNK_REQUEST] Error sending chunk request: ${err.message}`);
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (error) {
+            log(`[UDP][SEND_CHUNK_REQUEST] Exception: ${error.message}`);
+            throw error;
+        }
+    }
+    async readWithBuffer(reqData, cb = null) {
+        this.replyId++;
+        const buf = createUDPHeader(COMMANDS.CMD_DATA_WRRQ, this.sessionId, this.replyId, reqData);
+        try {
+            const reply = await this.requestData(buf);
+            const header = decodeUDPHeader(reply.subarray(0, 8));
+            switch (header.commandId) {
+                case COMMANDS.CMD_DATA:
+                    return { data: reply.subarray(8), err: null };
+                case COMMANDS.CMD_ACK_OK:
+                case COMMANDS.CMD_PREPARE_DATA:
+                    return await this.handleChunkedData(reply, header.commandId, cb);
+                default:
+                    throw new Error('ERROR_IN_UNHANDLE_CMD ' + exportErrorMessage(header.commandId));
+            }
+        }
+        catch (err) {
+            return { data: null, err: err };
+        }
+    }
+    async handleChunkedData(reply, commandId, cb) {
+        return new Promise((resolve) => {
+            const recvData = reply.subarray(8);
+            const size = recvData.readUIntLE(1, 4);
+            let totalBuffer = Buffer.from([]);
+            const timeout = 3000;
+            let timer = setTimeout(() => {
+                this.socket.removeListener('message', handleOnData);
+                resolve({ data: null, err: new Error('TIMEOUT WHEN RECEIVING PACKET') });
+            }, timeout);
+            const internalCallback = (replyData, err = null) => {
+                this.socket.removeListener('message', handleOnData);
+                clearTimeout(timer);
+                resolve({ data: err ? null : replyData, err });
+            };
+            const handleOnData = (reply) => {
+                if (checkNotEventUDP(reply))
+                    return;
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    internalCallback(totalBuffer, new Error(`TIMEOUT !! ${(size - totalBuffer.length) / size} % REMAIN !`));
+                }, timeout);
+                const header = decodeUDPHeader(reply);
+                switch (header.commandId) {
+                    case COMMANDS.CMD_PREPARE_DATA:
+                        break;
+                    case COMMANDS.CMD_DATA:
+                        totalBuffer = Buffer.concat([totalBuffer, reply.subarray(8)]);
+                        cb && cb(totalBuffer.length, size);
+                        break;
+                    case COMMANDS.CMD_ACK_OK:
+                        if (totalBuffer.length === size) {
+                            internalCallback(totalBuffer);
+                        }
+                        break;
+                    default:
+                        internalCallback(Buffer.from([]), new Error('ERROR_IN_UNHANDLE_CMD ' + exportErrorMessage(header.commandId)));
+                }
+            };
+            this.socket.on('message', handleOnData);
+            const chunkCount = Math.ceil(size / Constants.MAX_CHUNK);
+            for (let i = 0; i < chunkCount; i++) {
+                const start = i * Constants.MAX_CHUNK;
+                const chunkSize = (i === chunkCount - 1) ? size % Constants.MAX_CHUNK : Constants.MAX_CHUNK;
+                this.sendChunkRequest(start, chunkSize).catch(err => {
+                    internalCallback(Buffer.from([]), err);
+                });
+            }
+        });
+    }
+    async getUsers() {
+        try {
+            if (this.socket) {
+                await this.freeData();
+            }
+            const data = await this.readWithBuffer(REQUEST_DATA.GET_USERS);
+            if (this.socket) {
+                await this.freeData();
+            }
+            const USER_PACKET_SIZE = 28;
+            let userData = data.data?.subarray(4) || Buffer.from([]);
+            const users = [];
+            while (userData.length >= USER_PACKET_SIZE) {
+                const user = decodeUserData28(userData.subarray(0, USER_PACKET_SIZE));
+                users.push(user);
+                userData = userData.subarray(USER_PACKET_SIZE);
+            }
+            return { data: users };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    async getAttendances(callbackInProcess) {
+        try {
+            if (this.socket) {
+                await this.freeData();
+            }
+            const data = await this.readWithBuffer(REQUEST_DATA.GET_ATTENDANCE_LOGS);
+            if (this.socket) {
+                await this.freeData();
+            }
+            const RECORD_PACKET_SIZE = 16;
+            let recordData = data.data?.subarray(4) || Buffer.from([]);
+            const records = [];
+            while (recordData.length >= RECORD_PACKET_SIZE) {
+                const record = decodeRecordData16(recordData.subarray(0, RECORD_PACKET_SIZE));
+                records.push({ ...record, ip: this.ip });
+                recordData = recordData.subarray(RECORD_PACKET_SIZE);
+            }
+            return { data: records, err: data.err };
+        }
+        catch (err) {
+            return { data: [], err: err };
+        }
+    }
+    async freeData() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_FREE_DATA, Buffer.alloc(0));
+            return !!resp;
+        }
+        catch (err) {
+            console.error('Error freeing data:', err);
+            throw err;
+        }
+    }
+    async getInfo() {
+        try {
+            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, Buffer.alloc(0));
+            return {
+                userCounts: data.readUIntLE(24, 4),
+                logCounts: data.readUIntLE(40, 4),
+                logCapacity: data.readUIntLE(72, 4)
+            };
+        }
+        catch (err) {
+            console.error('Error retrieving info:', err);
+            throw err;
+        }
+    }
+    async getTime() {
+        try {
+            const response = await this.executeCmd(COMMANDS.CMD_GET_TIME, Buffer.alloc(0));
+            const timeValue = response.readUInt32LE(8);
+            return timeParser.decode(timeValue);
+        }
+        catch (err) {
+            console.error('Error retrieving time:', err);
+            throw err;
+        }
+    }
+    async setTime(tm) {
+        try {
+            const commandBuffer = Buffer.alloc(32);
+            commandBuffer.writeUInt32LE(timeParser.encode(new Date(tm)), 0);
+            await this.executeCmd(COMMANDS.CMD_SET_TIME, commandBuffer);
+            return true;
+        }
+        catch (err) {
+            console.error('Error setting time:', err);
+            throw err;
+        }
+    }
+    async clearAttendanceLog() {
+        try {
+            return !!await this.executeCmd(COMMANDS.CMD_CLEAR_ATTLOG, Buffer.alloc(0));
+        }
+        catch (err) {
+            console.error('Error clearing attendance log:', err);
+            throw err;
+        }
+    }
+    async clearData() {
+        try {
+            return !!await this.executeCmd(COMMANDS.CMD_CLEAR_DATA, Buffer.alloc(0));
+        }
+        catch (err) {
+            console.error('Error clearing data:', err);
+            throw err;
+        }
+    }
+    async disableDevice() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_DISABLEDEVICE, REQUEST_DATA.DISABLE_DEVICE);
+            return !!resp;
+        }
+        catch (err) {
+            console.error('Error disabling device:', err);
+            throw err;
+        }
+    }
+    async enableDevice() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_ENABLEDEVICE, Buffer.alloc(0));
+            return !!resp;
+        }
+        catch (err) {
+            console.error('Error enabling device:', err);
+            throw err;
+        }
+    }
+    async disconnect() {
+        try {
+            await this.executeCmd(COMMANDS.CMD_EXIT, Buffer.alloc(0));
+        }
+        catch (err) {
+            console.error('Error executing disconnect command:', err);
+        }
+        try {
+            await this.closeSocket();
+        }
+        catch (err) {
+            console.error('Error closing the socket:', err);
+        }
+    }
+    async getRealTimeLogs(cb = () => { }) {
+        this.replyId++;
+        const buf = createUDPHeader(COMMANDS.CMD_REG_EVENT, this.sessionId, this.replyId, REQUEST_DATA.GET_REAL_TIME_EVENT);
+        try {
+            this.socket.send(buf, 0, buf.length, this.port, this.ip, (err) => {
+                if (err) {
+                    console.error('Error sending UDP message:', err);
+                    return;
+                }
+                console.log('UDP message sent successfully');
+            });
+        }
+        catch (err) {
+            console.error('Error during send operation:', err);
+            return;
+        }
+        const handleMessage = (data) => {
+            if (!checkNotEventUDP(data))
+                return;
+            if (data.length === 18) {
+                cb(decodeRecordRealTimeLog18(data));
+            }
+        };
+        if (this.socket.listenerCount('message') === 0) {
+            this.socket.on('message', handleMessage);
+        }
+        else {
+            console.warn('Multiple message listeners detected. Ensure only one listener is attached.');
+        }
+    }
+}
+
+export { ZUDP };

package/package.json

@@ -1,69 +1,87 @@
-{
-  "name": "zklib-ts",
-  "version": "1.0.6",
-  "description": "Unofficial zkteco library allows Node.js developers to easily interface with ZK BioMetric Fingerprint Attendance Devices",
-  "main": "dist/index.cjs.js",
-  "module": "dist/index.es.js",
-  "typings": "dist/index",
-  "types": "dist/index.d.ts",
-  "type": "commonjs",
-  "files": [
-    "dist/",
-    "README.md"
-  ],
-  "scripts": {
-    "test": "jest",
-    "build": "rollup -c",
-    "watch": "rollup -c --watch",
-    "prepare": "npm run build"
-  },
-  "repositoryUrl": "https://github.com/guspaz0/zklib-ts.git",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/guspaz0/zklib-ts.git"
-  },
-  "keywords": [
-    "typescript",
-    "javascript",
-    "jest",
-    "ip",
-    "libs",
-    "device",
-    "zkteco",
-    "address",
-    "realtime",
-    "real-time",
-    "biometric",
-    "attendance",
-    "biometric attendance",
-    "biometric attendance device"
-  ],
-  "author": "Gustavo Paz",
-  "license": "MIT",
-  "directories": {
-    "test": "tests"
-  },
-  "devDependencies": {
-    "@rollup/plugin-commonjs": "^28.0.3",
-    "@rollup/plugin-node-resolve": "^16.0.1",
-    "@rollup/plugin-typescript": "^12.1.2",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.14",
-    "dotenv": "^16.4.7",
-    "jest": "30.2.0",
-    "rollup": "^4.37.0",
-    "rollup-plugin-peer-deps-external": "^2.2.4",
-    "ts-jest": "29.4.6",
-    "ts-node": "^10.9.2",
-    "tslib": "^2.8.1",
-    "typescript": "^5.8.2"
-  },
-  "config": {
-    "commitizen": {
-      "path": "./node_modules/cz-conventional-changelog"
-    }
-  },
-  "precommit": [
-    "build"
-  ]
-}
+{
+  "name": "zklib-ts",
+  "version": "1.0.8",
+  "description": "Unofficial zkteco library allows Node.js developers to easily interface with ZK BioMetric Fingerprint Attendance Devices",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.es.js",
+  "typings": "dist/index",
+  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./ztcp": {
+      "import": "./dist/ztcp.js",
+      "require": "./dist/ztcp.cjs.js",
+      "types": "./dist/ztcp.d.ts"
+    },
+    "./zudp": {
+      "import": "./dist/zudp.js",
+      "require": "./dist/zudp.cjs.js",
+      "types": "./dist/zudp.d.ts"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "repositoryUrl": "https://github.com/guspaz0/zklib-ts.git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/guspaz0/zklib-ts.git"
+  },
+  "keywords": [
+    "typescript",
+    "javascript",
+    "jest",
+    "ip",
+    "libs",
+    "device",
+    "zkteco",
+    "address",
+    "realtime",
+    "real-time",
+    "biometric",
+    "attendance",
+    "biometric attendance",
+    "biometric attendance device"
+  ],
+  "author": "Gustavo Paz",
+  "license": "MIT",
+  "directories": {
+    "test": "tests"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/jest": "^29.5.14",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.19.17",
+    "dotenv": "^16.4.7",
+    "jest": "30.2.0",
+    "rollup": "^4.37.0",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "ts-jest": "29.4.6",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "typescript": "^5.8.2"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "precommit": [
+    "build"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "rollup -c",
+    "watch": "rollup -c --watch",
+    "lint": "eslint ."
+  }
+}