zklib-ts 1.0.7 → 1.0.8

package/dist/ztcp.js

@@ -0,0 +1,800 @@
+import { Socket } from 'net';
+import { COMMANDS, Constants, REQUEST_DATA, DISCOVERED_CMD } from './helper/command';
+import { ZkError } from './exceptions/handler';
+import { authKey, checkNotEventTCP, decodeTCPHeader, createTCPHeader, removeTcpHeader, exportErrorMessage, decodeRTEvent, splitTcpPackets } from './helper/utils';
+import { UserService } from './services/user.service';
+import { TransactionService } from './services/transaction.service';
+import { OptionsService } from './services/options.service';
+
+class ZTCP {
+    /**
+     * @param_ip ip address of device
+     * @param_port port number of device
+     * @param_timeout connection timout
+     * @param_comm_key communication key of device (if the case)
+     * @return Zkteco TCP socket connection instance
+     */
+    ip;
+    port;
+    timeout;
+    sessionId = 0;
+    replyId = 0;
+    socket;
+    comm_key;
+    user_count = 0;
+    fp_count = 0;
+    pwd_count = 0;
+    oplog_count = 0;
+    attlog_count = 0;
+    fp_cap = 0;
+    user_cap = 0;
+    attlog_cap = 0;
+    fp_av = 0;
+    user_av = 0;
+    attlog_av = 0;
+    face_count = 0;
+    face_cap = 0;
+    userPacketSize = 72;
+    verbose = false;
+    packetNumber = 0;
+    replyData = Buffer.from([]);
+    _optionsService;
+    _transactionService;
+    _userService;
+    constructor(ip, port, timeout, comm_key, verbose) {
+        this.ip = ip;
+        this.port = port;
+        this.timeout = timeout ? timeout : 10000;
+        this.replyId = 0;
+        this.comm_key = comm_key;
+        this.verbose = verbose;
+        this._optionsService = new OptionsService(this);
+        this._userService = new UserService(this);
+        this._transactionService = new TransactionService(this);
+    }
+    createSocket(cbError, cbClose) {
+        return new Promise((resolve, reject) => {
+            this.socket = new Socket();
+            // Handle socket error
+            this.socket.once("error", (err) => {
+                this.socket = undefined; // Ensure socket reference is cleared
+                reject(err);
+                if (typeof cbError === "function")
+                    cbError(err);
+            });
+            // Handle successful connection
+            this.socket.once("connect", () => {
+                resolve(this.socket);
+            });
+            // Handle socket closure
+            this.socket.once("close", () => {
+                this.socket = undefined; // Ensure socket reference is cleared
+                if (typeof cbClose === "function")
+                    cbClose("tcp");
+            });
+            // Set socket timeout if provided
+            if (this.timeout) {
+                this.socket.setTimeout(this.timeout);
+            }
+            // Initiate connection
+            this.socket.connect(this.port, this.ip);
+        });
+    }
+    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("error de authenticacion");
+                }
+            }
+            else {
+                // No reply received; throw an error
+                throw new Error("NO_REPLY_ON_CMD_CONNECT");
+            }
+        }
+        catch (err) {
+            // Log the error for debugging, if necessary
+            console.error("Failed to connect:", err);
+            // Re-throw the error for handling by the caller
+            throw err;
+        }
+    }
+    async closeSocket() {
+        return new Promise((resolve, reject) => {
+            // If no socket is present, resolve immediately
+            if (!this.socket) {
+                return resolve(true);
+            }
+            // Clean up listeners to avoid potential memory leaks or duplicate handling
+            this.socket.removeAllListeners("data");
+            // Set a timeout to handle cases where socket.end might not resolve
+            const timer = setTimeout(() => {
+                this.socket?.destroy(); // Forcibly close the socket if not closed properly
+                resolve(true); // Resolve even if the socket was not closed properly
+            }, 2000);
+            // Close the socket and clear the timeout upon successful completion
+            this.socket.end(() => {
+                clearTimeout(timer);
+                resolve(true); // Resolve once the socket has ended
+            });
+            // Handle socket errors during closing
+            this.socket.once("error", (err) => {
+                clearTimeout(timer);
+                reject(err); // Reject the promise with the error
+            });
+        });
+    }
+    writeMessage(msg, connect, cb) {
+        return new Promise((resolve, reject) => {
+            // Check if the socket is initialized
+            if (!this.socket) {
+                return reject(new Error("Socket is not initialized"));
+            }
+            // Define a variable for the timeout reference
+            const timer = setTimeout(() => {
+                // Check if the socket is still valid before trying to remove the listener
+                cleanUp();
+                reject(new Error("TIMEOUT_ON_WRITING_MESSAGE")); // Reject the promise on timeout
+            }, connect ? 3000 : this.timeout);
+            // Handle incoming data
+            const onData = (data) => {
+                // Check if the socket is still valid before trying to remove the listener
+                cleanUp(); // Clear the timeout once data is received
+                resolve(cb(data)); // Resolve the promise with the received data
+            };
+            const cleanUp = () => {
+                if (timer)
+                    clearTimeout(timer);
+                if (this.socket) {
+                    this.socket.removeListener("data", onData); // Remove the data event listener
+                }
+            };
+            // Attach the data event listener
+            this.socket.on("data", onData);
+            // Attempt to write the message to the socket
+            this.socket.write(msg, undefined, (err) => {
+                if (err) {
+                    cleanUp();
+                    reject(err); // Reject the promise with the write error
+                }
+            });
+        });
+    }
+    async requestData(msg) {
+        try {
+            return await new Promise((resolve, reject) => {
+                let timer = null;
+                let replyBuffer = Buffer.from([]);
+                // Internal callback to handle data reception
+                const internalCallback = (data_1) => {
+                    if (this.socket) {
+                        this.socket.removeListener("data", handleOnData); // Clean up listener
+                    }
+                    if (timer)
+                        clearTimeout(timer); // Clear the timeout
+                    resolve(data_1); // Resolve the promise with the data
+                };
+                const onTimeOut = () => setTimeout(() => {
+                    if (this.socket) {
+                        this.socket.removeListener("data", handleOnData); // Clean up listener on timeout
+                    }
+                    reject(new Error("TIMEOUT_IN_RECEIVING_RESPONSE_AFTER_REQUESTING_DATA")); // Reject on timeout
+                }, this.timeout);
+                // Handle incoming data
+                const handleOnData = (data_3) => {
+                    replyBuffer = Buffer.concat([replyBuffer, data_3]); // Accumulate data
+                    // Check if the data is a valid TCP event
+                    if (checkNotEventTCP(data_3))
+                        return;
+                    // Decode the TCP header
+                    const header = decodeTCPHeader(replyBuffer.subarray(0, 16));
+                    if (this.verbose) {
+                        console.log("response command: ", header.commandId, COMMANDS[header.commandId], "replyid: ", header.replyId);
+                    }
+                    // Handle based on command ID
+                    if (header.commandId === COMMANDS.CMD_DATA) {
+                        // Set a timeout to handle delayed responses
+                        timer = setTimeout(() => {
+                            internalCallback(replyBuffer); // Resolve with accumulated buffer
+                        }, 1000);
+                    }
+                    else {
+                        // Set a timeout to handle errors
+                        timer = onTimeOut();
+                        // Extract packet length and handle accordingly
+                        const packetLength = data_3.readUIntLE(4, 2);
+                        if (packetLength > 8) {
+                            internalCallback(data_3); // Resolve immediately if sufficient data
+                        }
+                    }
+                };
+                // Ensure the socket is valid before attaching the listener
+                if (this.socket) {
+                    this.socket.on("data", handleOnData);
+                    // Write the message to the socket
+                    this.socket.write(msg, undefined, (err) => {
+                        if (err) {
+                            if (this.socket) {
+                                this.socket.removeListener("data", handleOnData); // Clean up listener on error
+                            }
+                            return reject(err); // Reject the promise with the error
+                        }
+                        // Set a timeout to handle cases where no response is received
+                        timer = onTimeOut();
+                    });
+                }
+                else {
+                    reject(new Error("SOCKET_NOT_INITIALIZED")); // Reject if socket is not initialized
+                }
+            });
+        }
+        catch (err_1) {
+            console.error("Promise Rejected:", err_1); // Log the rejection reason
+            throw err_1; // Re-throw the error to be handled by the caller
+        }
+    }
+    /**
+     *
+     * @param {*} command
+     * @param {*} data
+     *
+     *
+     * reject error when command fail and resolve data when success
+     */
+    async executeCmd(command, data) {
+        // Reset sessionId and replyId for connection commands
+        if (command === COMMANDS.CMD_CONNECT) {
+            this.sessionId = 0;
+            this.replyId = 0;
+        }
+        else {
+            this.replyId++;
+        }
+        const currentReply = this.replyId;
+        const buf = createTCPHeader(command, this.sessionId, this.replyId, data);
+        const callback = (responseData) => {
+            const packets = splitTcpPackets(responseData);
+            for (const packet of packets) {
+                const headers = decodeTCPHeader(packet);
+                if (this.verbose) {
+                    const JOIN_CMD = { ...COMMANDS, ...DISCOVERED_CMD };
+                    console.debug("request command:", COMMANDS[command], "\nresponse command: ", JOIN_CMD[headers.commandId], "replyid: ", headers.replyId);
+                }
+                if (+headers.replyId === currentReply + 1) {
+                    return packet;
+                }
+                continue;
+            }
+        };
+        return new Promise((Resolve, Reject) => {
+            // Write the message to the socket and wait for a response
+            this.writeMessage(buf, command === COMMANDS.CMD_CONNECT || command === COMMANDS.CMD_EXIT, callback)
+                .then((reply) => {
+                // Remove TCP header from the response
+                let rReply;
+                try {
+                    rReply = removeTcpHeader(reply);
+                }
+                catch (e) {
+                    console.log("reply", reply);
+                }
+                // Update sessionId for connection command responses
+                if (command === COMMANDS.CMD_CONNECT &&
+                    rReply &&
+                    rReply.length >= 6) {
+                    // Assuming sessionId is located at offset 4 and is 2 bytes long
+                    this.sessionId = rReply.readUInt16LE(4);
+                }
+                Resolve(rReply);
+            })
+                .catch((err) => {
+                // Log or handle the error if necessary
+                console.error("Error executing command:", err);
+                Reject(err); // Re-throw the error for handling by the caller
+            });
+        });
+    }
+    async sendChunkRequest(start, size) {
+        this.replyId++;
+        const reqData = Buffer.alloc(8);
+        reqData.writeUInt32LE(start, 0);
+        reqData.writeUInt32LE(size, 4);
+        const buf = createTCPHeader(COMMANDS.CMD_DATA_RDY, this.sessionId, this.replyId, reqData);
+        try {
+            const promise = new Promise((resolve, reject) => {
+                this.socket?.write(buf, undefined, (err) => {
+                    if (err) {
+                        console.error(`[TCP][SEND_CHUNK_REQUEST] Error sending chunk request: ${err.message}`);
+                        reject(err); // Reject the promise if there is an error
+                    }
+                    else {
+                        resolve(true); // Resolve the promise if the write operation succeeds
+                    }
+                });
+            });
+            await promise;
+        }
+        catch (err) {
+            // Handle or log the error as needed
+            console.error(`[TCP][SEND_CHUNK_REQUEST] Exception: ${err.message}`);
+            throw err; // Re-throw the error for handling by the caller
+        }
+    }
+    /**
+     *
+     * @param {Buffer} reqData - indicate the type of data that need to receive ( user or attLog)
+     * @param {Function} cb - callback is triggered when receiving packets
+     *
+     * readWithBuffer will reject error if it'wrong when starting request data
+     * readWithBuffer will return { data: replyData , err: Error } when receiving requested data
+     */
+    readWithBuffer(reqData, cb) {
+        return new Promise(async (resolve, reject) => {
+            this.replyId++;
+            const buf = createTCPHeader(COMMANDS.CMD_DATA_WRRQ, this.sessionId, this.replyId, reqData);
+            let reply;
+            try {
+                reply = await this.requestData(buf);
+            }
+            catch (err) {
+                reject(err);
+            }
+            const header = decodeTCPHeader(reply?.subarray(0, 16));
+            switch (header.commandId) {
+                case COMMANDS.CMD_DATA: {
+                    resolve({ data: reply.subarray(16), mode: 8 });
+                    break;
+                }
+                case COMMANDS.CMD_ACK_OK:
+                case COMMANDS.CMD_PREPARE_DATA: {
+                    // this case show that data is prepared => send command to get these data
+                    // reply variable includes information about the size of following data
+                    const recvData = reply.subarray(16);
+                    const size = recvData.readUIntLE(1, 4);
+                    // We need to split the data to many chunks to receive , because it's to large
+                    // After receiving all chunk data , we concat it to TotalBuffer variable , that 's the data we want
+                    const remain = size % Constants.MAX_CHUNK;
+                    const numberChunks = Math.round(size - remain) / Constants.MAX_CHUNK;
+                    this.packetNumber = numberChunks + (remain > 0 ? 1 : 0);
+                    //let replyData = Buffer.from([])
+                    let totalBuffer = Buffer.from([]);
+                    let realTotalBuffer = Buffer.from([]);
+                    let timer = setTimeout(() => {
+                        internalCallback(this.replyData, new Error("TIMEOUT WHEN RECEIVING PACKET"));
+                    }, this.timeout);
+                    const internalCallback = (replyData, err = null) => {
+                        this.socket && this.socket.removeAllListeners("data");
+                        timer && clearTimeout(timer);
+                        resolve({ data: replyData, err });
+                    };
+                    this.socket?.once("close", () => {
+                        internalCallback(this.replyData, new Error("Socket is disconnected unexpectedly"));
+                    });
+                    for (let i = 0; i <= numberChunks; i++) {
+                        const data = await new Promise((resolve2, reject2) => {
+                            try {
+                                this.sendChunkRequest(i * Constants.MAX_CHUNK, i === numberChunks ? remain : Constants.MAX_CHUNK);
+                                this.socket?.on("data", (reply) => {
+                                    clearTimeout(timer);
+                                    timer = setTimeout(() => {
+                                        internalCallback(this.replyData, new Error(`TIME OUT !! ${this.packetNumber} PACKETS REMAIN !`));
+                                    }, this.timeout);
+                                    if (this.verbose && reply.length >= 8) {
+                                        const headers = decodeTCPHeader(reply);
+                                        if (COMMANDS[headers.commandId]) {
+                                            switch (headers.commandId) {
+                                                case COMMANDS.CMD_ACK_OK:
+                                                case COMMANDS.CMD_DATA:
+                                                    this.verbose &&
+                                                        console.log("CMD received: ", COMMANDS[headers.commandId]);
+                                                    break;
+                                                case COMMANDS.CMD_PREPARE_DATA:
+                                                    this.verbose &&
+                                                        console.log("CMD received: ", COMMANDS[headers.commandId]);
+                                                    this.verbose &&
+                                                        console.log(`recieve chunk: prepare data size is ${headers.payloadSize}`);
+                                                    break;
+                                                default:
+                                                    break;
+                                            }
+                                        }
+                                    }
+                                    totalBuffer = Buffer.concat([totalBuffer, reply]);
+                                    const packetLength = totalBuffer.readUIntLE(4, 2);
+                                    if (totalBuffer.length >= 8 + packetLength) {
+                                        realTotalBuffer = Buffer.concat([
+                                            realTotalBuffer,
+                                            totalBuffer.subarray(16, 8 + packetLength),
+                                        ]);
+                                        totalBuffer = totalBuffer.subarray(8 + packetLength);
+                                        if ((this.packetNumber > 1 &&
+                                            realTotalBuffer.length === Constants.MAX_CHUNK + 8) ||
+                                            (this.packetNumber === 1 &&
+                                                realTotalBuffer.length === remain + 8)) {
+                                            this.packetNumber--;
+                                            cb && cb(realTotalBuffer.length, size);
+                                            resolve2(realTotalBuffer.subarray(8));
+                                            totalBuffer = Buffer.from([]);
+                                            realTotalBuffer = Buffer.from([]);
+                                        }
+                                    }
+                                });
+                            }
+                            catch (e) {
+                                reject2(e);
+                            }
+                        });
+                        this.replyData = Buffer.concat([
+                            this.replyData,
+                            data,
+                        ]);
+                        this.socket?.removeAllListeners("data");
+                        if (this.packetNumber <= 0) {
+                            resolve({ data: this.replyData });
+                        }
+                    }
+                    break;
+                }
+                default: {
+                    reject(new Error("ERROR_IN_UNHANDLE_CMD " + exportErrorMessage(header.commandId)));
+                }
+            }
+        });
+    }
+    /**
+     *
+     * @param {*} callbackInProcess
+     *  reject error when starting request data
+     *  return { data: records, err: Error } when receiving requested data
+     */
+    async freeData() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_FREE_DATA, "");
+            return !!resp;
+        }
+        catch (err) {
+            console.error("Error freeing data:", err);
+            throw err; // Optionally, re-throw the error if you need to handle it upstream
+        }
+    }
+    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; // Optionally, re-throw the error if you need to handle it upstream
+        }
+    }
+    async enableDevice() {
+        try {
+            const resp = await this.executeCmd(COMMANDS.CMD_ENABLEDEVICE, "");
+            return !!resp;
+        }
+        catch (err) {
+            console.error("Error enabling device:", err);
+            throw err; // Optionally, re-throw the error if you need to handle it upstream
+        }
+    }
+    async disconnect() {
+        try {
+            // Attempt to execute the disconnect command
+            await this.executeCmd(COMMANDS.CMD_EXIT, "");
+        }
+        catch (err) {
+            // Log any errors encountered during command execution
+            console.error("Error during disconnection:", err);
+            // Optionally, add more handling or recovery logic here
+        }
+        // Attempt to close the socket and return the result
+        try {
+            await this.closeSocket();
+        }
+        catch (err) {
+            // Log any errors encountered while closing the socket
+            console.error("Error during socket closure:", err);
+            // Optionally, rethrow or handle the error if necessary
+            throw err; // Re-throwing to propagate the error
+        }
+    }
+    async getInfo() {
+        try {
+            // Execute the command to retrieve free sizes from the device
+            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, "");
+            // Parse the response data to extract and return relevant information
+            return {
+                userCounts: data.readUIntLE(24, 4), // Number of users
+                logCounts: data.readUIntLE(40, 4), // Number of logs
+                logCapacity: data.readUIntLE(72, 4), // Capacity of logs in bytes
+            };
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error("Error getting device info:", err);
+            // Re-throw the error to allow upstream error handling
+            throw err;
+        }
+    }
+    async getSizes() {
+        try {
+            // Execute the command to retrieve free sizes from the device
+            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, "");
+            // Parse the response data to extract and return relevant information
+            const buf = data.slice(8); // remove header
+            this.user_count = buf.readUIntLE(16, 4);
+            this.fp_count = buf.readUIntLE(24, 4);
+            this.pwd_count = buf.readUIntLE(52, 4);
+            this.oplog_count = buf.readUIntLE(40, 4);
+            this.attlog_count = buf.readUIntLE(32, 4);
+            this.fp_cap = buf.readUIntLE(56, 4);
+            this.user_cap = buf.readUIntLE(60, 4);
+            this.attlog_cap = buf.readUIntLE(64, 4);
+            this.fp_av = buf.readUIntLE(68, 4);
+            this.user_av = buf.readUIntLE(72, 4);
+            this.attlog_av = buf.readUIntLE(76, 4);
+            this.face_count = buf.readUIntLE(80, 4);
+            this.face_cap = buf.readUIntLE(88, 4);
+            return {
+                userCounts: this.user_count, // Number of users
+                logCounts: this.attlog_count, // Number of logs
+                fingerCount: this.fp_count,
+                adminCount: this.pwd_count,
+                opLogCount: this.oplog_count,
+                logCapacity: this.attlog_cap, // Capacity of logs in bytes
+                fingerCapacity: this.fp_cap,
+                userCapacity: this.user_cap,
+                attLogCapacity: this.attlog_cap,
+                fingerAvailable: this.fp_av,
+                userAvailable: this.user_av,
+                attLogAvailable: this.attlog_av,
+                faceCount: this.face_count,
+                faceCapacity: this.face_cap,
+            };
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error("Error getting device info:", err);
+            // Re-throw the error to allow upstream error handling
+            throw err;
+        }
+    }
+    #listeners = new Map();
+    async getAttendanceSize() {
+        try {
+            // Execute command to get free sizes
+            const data = await this.executeCmd(COMMANDS.CMD_GET_FREE_SIZES, "");
+            // Parse and return the attendance size
+            return data.readUIntLE(40, 4); // Assuming data at offset 40 represents the attendance size
+        }
+        catch (err) {
+            // Log error details for debugging
+            console.error("Error getting attendance size:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    // Clears the attendance logs on the device
+    async clearAttendanceLog() {
+        return await this._transactionService.clearAttendanceLog();
+    }
+    /**
+     * Clears all data on the device
+     * @value 1 Attendance records
+     * @value 2 Fingerprint templates
+     * @value 3 None
+     * @value 4 Operation records
+     * @value 5 User information
+     * @default 0 Delete all
+     */
+    async clearData(value) {
+        try {
+            // Execute the command to clear all data
+            await this.disableDevice();
+            if (!value)
+                value = 3;
+            const buf = await this.executeCmd(COMMANDS.CMD_CLEAR_DATA, value.toString());
+            await this.refreshData();
+            await this.enableDevice();
+            return !!buf;
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error("Error clearing data:", err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    async getRealTimeLogs(cb = (realTimeLog) => { }) {
+        this.replyId++; // Increment the reply ID for this request
+        try {
+            // Create a buffer with the command header to request real-time logs
+            const buf = createTCPHeader(COMMANDS.CMD_REG_EVENT, this.sessionId, this.replyId, Buffer.from([0x01, 0x00, 0x00, 0x00]));
+            // Send the request to the device
+            this.socket?.write(buf, undefined, (err) => {
+                if (err) {
+                    // Log and reject the promise if there is an error writing to the socket
+                    console.error("Error sending real-time logs request:", err);
+                    throw err;
+                }
+            });
+            // Ensure data listeners are added only once
+            if (this.socket?.listenerCount("data") === 0) {
+                console.log("entraaa");
+                this.socket.on("data", (data) => {
+                    // Check if the data is an event and not just a regular response
+                    if (checkNotEventTCP(data)) {
+                        // Process the data if it is of the expected length
+                        if (data.length > 16) {
+                            // Decode and pass the log to the callback
+                            cb(decodeRTEvent(data));
+                        }
+                    }
+                });
+            }
+        }
+        catch (err) {
+            // Handle errors and reject the promise
+            console.error("Error getting real-time logs:", err);
+            throw err;
+        }
+    }
+    /**
+     * Get all Finger objects
+     * @returns {Record<string, Finger[]>}
+     */
+    async getTemplates(callbackInProcess = () => { }) {
+        return await this._userService.getTemplates(callbackInProcess);
+    }
+    /**
+     * Return size
+     * @param packet
+     */
+    testTcpTop(packet) {
+        // Check if packet is too small
+        if (packet.length <= 8)
+            return 0;
+        // Extract header values using little-endian format
+        const headerValue1 = packet.readUInt16LE(0);
+        const headerValue2 = packet.readUInt16LE(2);
+        const size = packet.readUInt32LE(4);
+        // Check if magic numbers match
+        if (headerValue1 === Constants.MACHINE_PREPARE_DATA_1 &&
+            headerValue2 === Constants.MACHINE_PREPARE_DATA_2) {
+            return size;
+        }
+        return 0;
+    }
+    async refreshData() {
+        try {
+            const reply = await this.executeCmd(COMMANDS.CMD_REFRESHDATA, "");
+            return !!reply;
+        }
+        catch (err) {
+            console.error("Error getting user templates: ", err);
+            throw err;
+        }
+    }
+    async sendWithBuffer(buffer) {
+        const MAX_CHUNK = 1024;
+        const size = buffer.length;
+        await this.freeData();
+        const commandString = Buffer.alloc(4); // 'I' is 4 bytes
+        commandString.writeUInt32LE(size, 0);
+        try {
+            const cmdResponse = await this.executeCmd(COMMANDS.CMD_PREPARE_DATA, commandString);
+            // responds with 2000 = CMD_ACK_OK
+            if (!cmdResponse) {
+                throw new Error("Can't prepare data");
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        const remain = size % MAX_CHUNK;
+        const packets = Math.floor((size - remain) / MAX_CHUNK);
+        let start = 0;
+        try {
+            for (let i = 0; i < packets; i++) {
+                const resp = await this.sendChunk(buffer.slice(start, start + MAX_CHUNK));
+                if (resp) {
+                    start += MAX_CHUNK;
+                    if (i == packets - 1 && remain) {
+                        const lastPacket = await this.sendChunk(buffer.slice(start, start + remain));
+                        return lastPacket;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    async sendChunk(commandString) {
+        try {
+            return await new Promise((resolve, reject) => {
+                resolve(this.executeCmd(COMMANDS.CMD_DATA, commandString));
+            });
+        }
+        catch (e) {
+            throw new ZkError(e, COMMANDS.CMD_DATA, this.ip);
+        }
+    }
+    async readSocket(length, cb = null) {
+        let replyBufer = Buffer.from([]);
+        const totalPackets = 0;
+        return new Promise((resolve, reject) => {
+            let timer = setTimeout(() => {
+                internalCallback(replyBufer, new Error("TIMEOUT WHEN RECEIVING PACKET"));
+            }, this.timeout);
+            const internalCallback = (replyData, err = null) => {
+                this.socket && this.socket.removeListener("data", onDataEnroll);
+                timer && clearTimeout(timer);
+                resolve({ data: replyData, err: err });
+            };
+            function onDataEnroll(data) {
+                clearTimeout(timer);
+                timer = setTimeout(() => {
+                    internalCallback(replyBufer, new Error(`TIME OUT !! ${totalPackets} PACKETS REMAIN !`));
+                }, this.timeout);
+                replyBufer = Buffer.concat([replyBufer, data], replyBufer.length + data.length);
+                if (data.length == length) {
+                    internalCallback(data);
+                }
+            }
+            this.socket.once("close", () => {
+                internalCallback(replyBufer, new Error("Socket is disconnected unexpectedly"));
+            });
+            this.socket.on("data", onDataEnroll);
+        }).catch((err) => {
+            console.error("Promise Rejected:", err); // Log the rejection reason
+            throw err; // Re-throw the error to be handled by the caller
+        });
+    }
+    /**
+     * Register events
+     * @param {number} flags - Event flags
+     * @returns {Promise<void>}
+     * @throws {ZKErrorResponse} If registration fails
+     */
+    async regEvent(flags) {
+        try {
+            const commandString = Buffer.alloc(4); // 'I' format is 4 bytes
+            commandString.writeUInt32LE(flags, 0); // Little-endian unsigned int
+            const cmdResponse = await this.executeCmd(COMMANDS.CMD_REG_EVENT, commandString);
+            if (this.verbose)
+                console.log("regEvent: ", cmdResponse.readUInt16LE(0));
+        }
+        catch (e) {
+            throw new ZkError(e, COMMANDS.CMD_REG_EVENT, this.ip);
+        }
+    }
+    async cancelCapture() {
+        try {
+            const reply = await this.executeCmd(COMMANDS.CMD_CANCELCAPTURE, "");
+            return !!reply;
+        }
+        catch (e) {
+            throw new ZkError(e, COMMANDS.CMD_CANCELCAPTURE, this.ip);
+        }
+    }
+    async restartDevice() {
+        try {
+            await this.executeCmd(COMMANDS.CMD_RESTART, "");
+        }
+        catch (e) {
+            throw new ZkError(e, COMMANDS.CMD_RESTART, this.ip);
+        }
+    }
+}
+
+export { ZTCP };