zklib-ts 1.0.5 → 1.0.6

package/dist/index.es.js

@@ -5,99 +5,190 @@ import * as dgram from 'node:dgram';
 var COMMANDS;
 (function (COMMANDS) {
     COMMANDS[COMMANDS["CMD_ACK_DATA"] = 2002] = "CMD_ACK_DATA";
+    /** There was an error when processing the request.*/
     COMMANDS[COMMANDS["CMD_ACK_ERROR"] = 2001] = "CMD_ACK_ERROR";
     COMMANDS[COMMANDS["CMD_ACK_ERROR_CMD"] = 65533] = "CMD_ACK_ERROR_CMD";
     COMMANDS[COMMANDS["CMD_ACK_ERROR_DATA"] = 65531] = "CMD_ACK_ERROR_DATA";
     COMMANDS[COMMANDS["CMD_ACK_ERROR_INIT"] = 65532] = "CMD_ACK_ERROR_INIT";
+    /** [0xD0, 0x07] The request was processed sucessfully. */
     COMMANDS[COMMANDS["CMD_ACK_OK"] = 2000] = "CMD_ACK_OK";
     COMMANDS[COMMANDS["CMD_ACK_REPEAT"] = 2004] = "CMD_ACK_REPEAT";
     COMMANDS[COMMANDS["CMD_ACK_RETRY"] = 2003] = "CMD_ACK_RETRY";
+    /** [0xD5, 0x07] Connection not authorized. */
     COMMANDS[COMMANDS["CMD_ACK_UNAUTH"] = 2005] = "CMD_ACK_UNAUTH";
+    /** Received unknown command. */
     COMMANDS[COMMANDS["CMD_ACK_UNKNOWN"] = 65535] = "CMD_ACK_UNKNOWN";
+    /** Request attendance log. */
     COMMANDS[COMMANDS["CMD_ATTLOG_RRQ"] = 13] = "CMD_ATTLOG_RRQ";
+    /** [0x4E, 0x04] Request to begin session using commkey. */
     COMMANDS[COMMANDS["CMD_AUTH"] = 1102] = "CMD_AUTH";
+    /** Disable normal authentication of users. */
     COMMANDS[COMMANDS["CMD_CANCELCAPTURE"] = 62] = "CMD_CANCELCAPTURE";
+    /** Capture fingerprint picture. */
     COMMANDS[COMMANDS["CMD_CAPTUREFINGER"] = 1009] = "CMD_CAPTUREFINGER";
+    /** Capture the entire image. */
     COMMANDS[COMMANDS["CMD_CAPTUREIMAGE"] = 1012] = "CMD_CAPTUREIMAGE";
+    /** Change transmission speed. */
     COMMANDS[COMMANDS["CMD_CHANGE_SPEED"] = 1101] = "CMD_CHANGE_SPEED";
+    /** [0x77, 0x00] Get checksum of machine's buffer. */
     COMMANDS[COMMANDS["CMD_CHECKSUM_BUFFER"] = 119] = "CMD_CHECKSUM_BUFFER";
+    /** Restore access control to default. */
     COMMANDS[COMMANDS["CMD_CLEAR_ACC"] = 32] = "CMD_CLEAR_ACC";
+    /** Clears admins privileges. */
     COMMANDS[COMMANDS["CMD_CLEAR_ADMIN"] = 20] = "CMD_CLEAR_ADMIN";
+    /** Delete attendance record. */
     COMMANDS[COMMANDS["CMD_CLEAR_ATTLOG"] = 15] = "CMD_CLEAR_ATTLOG";
+    /** Delete data. */
     COMMANDS[COMMANDS["CMD_CLEAR_DATA"] = 14] = "CMD_CLEAR_DATA";
+    /** Clear screen captions. */
     COMMANDS[COMMANDS["CMD_CLEAR_LCD"] = 67] = "CMD_CLEAR_LCD";
+    /** Delete operations log. */
     COMMANDS[COMMANDS["CMD_CLEAR_OPLOG"] = 33] = "CMD_CLEAR_OPLOG";
+    /** [0xE8, 0x03] Begin connection. */
     COMMANDS[COMMANDS["CMD_CONNECT"] = 1000] = "CMD_CONNECT";
+    /** [0xDD, 0x05] Data packet. */
     COMMANDS[COMMANDS["CMD_DATA"] = 1501] = "CMD_DATA";
+    /** Indicates that it is ready to receive data. */
     COMMANDS[COMMANDS["CMD_DATA_RDY"] = 1504] = "CMD_DATA_RDY";
+    /** Read/Write a large data set. */
     COMMANDS[COMMANDS["CMD_DATA_WRRQ"] = 1503] = "CMD_DATA_WRRQ";
+    /** Read saved data. */
     COMMANDS[COMMANDS["CMD_DB_RRQ"] = 7] = "CMD_DB_RRQ";
+    /** Deletes fingerprint template. */
     COMMANDS[COMMANDS["CMD_DEL_FPTMP"] = 134] = "CMD_DEL_FPTMP";
+    /** Delete short message. */
     COMMANDS[COMMANDS["CMD_DELETE_SMS"] = 72] = "CMD_DELETE_SMS";
+    /** Delete user short message. */
     COMMANDS[COMMANDS["CMD_DELETE_UDATA"] = 74] = "CMD_DELETE_UDATA";
+    /** Delete user. */
     COMMANDS[COMMANDS["CMD_DELETE_USER"] = 18] = "CMD_DELETE_USER";
+    /** Delete user fingerprint template. */
     COMMANDS[COMMANDS["CMD_DELETE_USERTEMP"] = 19] = "CMD_DELETE_USERTEMP";
+    /** Disables fingerprint, rfid reader and keyboard. */
     COMMANDS[COMMANDS["CMD_DISABLEDEVICE"] = 1003] = "CMD_DISABLEDEVICE";
+    /** Get door state. */
     COMMANDS[COMMANDS["CMD_DOORSTATE_RRQ"] = 75] = "CMD_DOORSTATE_RRQ";
+    /** Clear Mifare card. */
     COMMANDS[COMMANDS["CMD_EMPTY_MIFARE"] = 78] = "CMD_EMPTY_MIFARE";
+    /** Enables the ":" in screen clock. */
     COMMANDS[COMMANDS["CMD_ENABLE_CLOCK"] = 57] = "CMD_ENABLE_CLOCK";
+    /** Change machine state to "normal work". */
     COMMANDS[COMMANDS["CMD_ENABLEDEVICE"] = 1002] = "CMD_ENABLEDEVICE";
+    /** [0xE9, 0x03] Disconnect. */
     COMMANDS[COMMANDS["CMD_EXIT"] = 1001] = "CMD_EXIT";
+    /** [0xDE, 0x05] Release buffer used for data transmission. */
     COMMANDS[COMMANDS["CMD_FREE_DATA"] = 1502] = "CMD_FREE_DATA";
+    /** Request machine status (remaining space). */
     COMMANDS[COMMANDS["CMD_GET_FREE_SIZES"] = 50] = "CMD_GET_FREE_SIZES";
+    /** Request max size for users id. */
     COMMANDS[COMMANDS["CMD_GET_PINWIDTH"] = 69] = "CMD_GET_PINWIDTH";
+    /** Request machine time. */
     COMMANDS[COMMANDS["CMD_GET_TIME"] = 201] = "CMD_GET_TIME";
     COMMANDS[COMMANDS["CMD_GET_USERTEMP"] = 88] = "CMD_GET_USERTEMP";
+    /** Request the firmware edition. */
     COMMANDS[COMMANDS["CMD_GET_VERSION"] = 1100] = "CMD_GET_VERSION";
+    /** Get group timezone. */
     COMMANDS[COMMANDS["CMD_GRPTZ_RRQ"] = 25] = "CMD_GRPTZ_RRQ";
+    /** Set group timezone. */
     COMMANDS[COMMANDS["CMD_GRPTZ_WRQ"] = 26] = "CMD_GRPTZ_WRQ";
+    /** Read operations log. */
     COMMANDS[COMMANDS["CMD_OPLOG_RRQ"] = 34] = "CMD_OPLOG_RRQ";
+    /** Read configuration value of the machine. */
     COMMANDS[COMMANDS["CMD_OPTIONS_RRQ"] = 11] = "CMD_OPTIONS_RRQ";
+    /** Change configuration value of the machine. */
     COMMANDS[COMMANDS["CMD_OPTIONS_WRQ"] = 12] = "CMD_OPTIONS_WRQ";
+    /** Shut-down machine. */
     COMMANDS[COMMANDS["CMD_POWEROFF"] = 1005] = "CMD_POWEROFF";
+    /** [0xDC, 0x05] Prepare for data transmission. */
     COMMANDS[COMMANDS["CMD_PREPARE_DATA"] = 1500] = "CMD_PREPARE_DATA";
+    /** [0xF5, 0x03] Refresh the machine stored data. */
     COMMANDS[COMMANDS["CMD_REFRESHDATA"] = 1013] = "CMD_REFRESHDATA";
+    /** Refresh the configuration parameters. */
     COMMANDS[COMMANDS["CMD_REFRESHOPTION"] = 1014] = "CMD_REFRESHOPTION";
+    /** Realtime events. */
     COMMANDS[COMMANDS["CMD_REG_EVENT"] = 500] = "CMD_REG_EVENT";
+    /** Restart machine. */
     COMMANDS[COMMANDS["CMD_RESTART"] = 1004] = "CMD_RESTART";
+    /** Change machine state to "awaken". */
     COMMANDS[COMMANDS["CMD_RESUME"] = 1007] = "CMD_RESUME";
+    /** Set machine time. */
     COMMANDS[COMMANDS["CMD_SET_TIME"] = 202] = "CMD_SET_TIME";
+    /** Change machine state to "idle". */
     COMMANDS[COMMANDS["CMD_SLEEP"] = 1006] = "CMD_SLEEP";
+    /** Download short message. */
     COMMANDS[COMMANDS["CMD_SMS_RRQ"] = 71] = "CMD_SMS_RRQ";
+    /** Upload short message. */
     COMMANDS[COMMANDS["CMD_SMS_WRQ"] = 70] = "CMD_SMS_WRQ";
+    /** Start enroll procedure. */
     COMMANDS[COMMANDS["CMD_STARTENROLL"] = 61] = "CMD_STARTENROLL";
+    /** Set the machine to authentication state. */
     COMMANDS[COMMANDS["CMD_STARTVERIFY"] = 60] = "CMD_STARTVERIFY";
+    /** Query state. */
     COMMANDS[COMMANDS["CMD_STATE_RRQ"] = 64] = "CMD_STATE_RRQ";
+    /** Test if fingerprint exists. */
     COMMANDS[COMMANDS["CMD_TEST_TEMP"] = 1011] = "CMD_TEST_TEMP";
+    /** Test voice. */
     COMMANDS[COMMANDS["CMD_TESTVOICE"] = 1017] = "CMD_TESTVOICE";
+    /** [0x77, 0x00] Transfer fp template from buffer. */
     COMMANDS[COMMANDS["CMD_TMP_WRITE"] = 87] = "CMD_TMP_WRITE";
+    /** Get device timezones. */
     COMMANDS[COMMANDS["CMD_TZ_RRQ"] = 27] = "CMD_TZ_RRQ";
+    /** Set device timezones. */
     COMMANDS[COMMANDS["CMD_TZ_WRQ"] = 28] = "CMD_TZ_WRQ";
+    /** Set user short message. */
     COMMANDS[COMMANDS["CMD_UDATA_WRQ"] = 73] = "CMD_UDATA_WRQ";
+    /** Get group combination to unlock. */
     COMMANDS[COMMANDS["CMD_ULG_RRQ"] = 29] = "CMD_ULG_RRQ";
+    /** Set group combination to unlock. */
     COMMANDS[COMMANDS["CMD_ULG_WRQ"] = 30] = "CMD_ULG_WRQ";
+    /** Unlock door for a specified amount of time. */
     COMMANDS[COMMANDS["CMD_UNLOCK"] = 31] = "CMD_UNLOCK";
+    /** Upload user data. */
     COMMANDS[COMMANDS["CMD_USER_WRQ"] = 8] = "CMD_USER_WRQ";
+    /** Read user group. */
     COMMANDS[COMMANDS["CMD_USERGRP_RRQ"] = 21] = "CMD_USERGRP_RRQ";
+    /** Set user group. */
     COMMANDS[COMMANDS["CMD_USERGRP_WRQ"] = 22] = "CMD_USERGRP_WRQ";
+    /** [0x09, 0x00] Read user fingerprint template. */
     COMMANDS[COMMANDS["CMD_USERTEMP_RRQ"] = 9] = "CMD_USERTEMP_RRQ";
+    /** Upload user fingerprint template. */
     COMMANDS[COMMANDS["CMD_USERTEMP_WRQ"] = 10] = "CMD_USERTEMP_WRQ";
+    /** Get user timezones. */
     COMMANDS[COMMANDS["CMD_USERTZ_RRQ"] = 23] = "CMD_USERTZ_RRQ";
+    /** Set the user timezones. */
     COMMANDS[COMMANDS["CMD_USERTZ_WRQ"] = 24] = "CMD_USERTZ_WRQ";
+    /** Read verification style of a given user. */
     COMMANDS[COMMANDS["CMD_VERIFY_RRQ"] = 80] = "CMD_VERIFY_RRQ";
+    /** Change verification style of a given user. */
     COMMANDS[COMMANDS["CMD_VERIFY_WRQ"] = 79] = "CMD_VERIFY_WRQ";
+    /** Prints chars to the device screen. */
     COMMANDS[COMMANDS["CMD_WRITE_LCD"] = 66] = "CMD_WRITE_LCD";
+    /** Write data to Mifare card. */
     COMMANDS[COMMANDS["CMD_WRITE_MIFARE"] = 76] = "CMD_WRITE_MIFARE";
+    /** Triggered alarm. */
     COMMANDS[COMMANDS["EF_ALARM"] = 512] = "EF_ALARM";
+    /** Attendance entry. */
     COMMANDS[COMMANDS["EF_ATTLOG"] = 1] = "EF_ATTLOG";
+    /** Pressed keyboard key. */
     COMMANDS[COMMANDS["EF_BUTTON"] = 16] = "EF_BUTTON";
+    /** Upload user data. */
     COMMANDS[COMMANDS["EF_ENROLLFINGER"] = 8] = "EF_ENROLLFINGER";
+    /** Enrolled user. */
     COMMANDS[COMMANDS["EF_ENROLLUSER"] = 4] = "EF_ENROLLUSER";
+    /** Pressed finger. */
     COMMANDS[COMMANDS["EF_FINGER"] = 2] = "EF_FINGER";
+    /** Fingerprint score in enroll procedure. */
     COMMANDS[COMMANDS["EF_FPFTR"] = 256] = "EF_FPFTR";
+    /** Restore access control to default. */
     COMMANDS[COMMANDS["EF_UNLOCK"] = 32] = "EF_UNLOCK";
+    /** Registered user placed finger. */
     COMMANDS[COMMANDS["EF_VERIFY"] = 128] = "EF_VERIFY";
 })(COMMANDS || (COMMANDS = {}));
+var DISCOVERED_CMD;
+(function (DISCOVERED_CMD) {
+    /** Returned when the Finger id not exists in the user uid, when attempting to download single finger template */
+    DISCOVERED_CMD[DISCOVERED_CMD["FID_NOT_FOUND"] = 4993] = "FID_NOT_FOUND";
+})(DISCOVERED_CMD || (DISCOVERED_CMD = {}));
 var Constants;
 (function (Constants) {
     Constants[Constants["USHRT_MAX"] = 65535] = "USHRT_MAX";
@@ -106,6 +197,7 @@ var Constants;
     Constants[Constants["MACHINE_PREPARE_DATA_2"] = 32130] = "MACHINE_PREPARE_DATA_2";
 })(Constants || (Constants = {}));
 const REQUEST_DATA = {
+    START_TAG: Buffer.from([0x50, 0x50, 0x82, 0x7d]),
     DISABLE_DEVICE: Buffer.from([0, 0, 0, 0]),
     GET_REAL_TIME_EVENT: Buffer.from([0x01, 0x00, 0x00, 0x00]),
     GET_ATTENDANCE_LOGS: Buffer.from([0x01, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
@@ -253,18 +345,23 @@ class User {
 }
 
 class Attendance {
+    /** Internal serial number for the user */
     sn;
+    /** User ID/Pin stored as a string */
     user_id;
-    record_time;
+    /** Verification type */
     type;
+    /** Time of the attendance event */
+    record_time;
+    /** Verify state */
     state;
     ip;
-    constructor(sn, user_id, record_time, type, state) {
+    constructor(sn, user_id, type, record_time, state) {
         this.sn = sn;
         this.user_id = user_id;
+        this.type = type || undefined;
         this.record_time = record_time;
-        this.type = type;
-        this.state = state;
+        this.state = state || undefined;
     }
 }
 
@@ -308,17 +405,7 @@ const createUDPHeader = (command, sessionId, replyId, data) => {
     return buf;
 };
 const createTCPHeader = (command, sessionId, replyId, data) => {
-    const dataBuffer = Buffer.from(data);
-    const buf = Buffer.alloc(8 + dataBuffer.length);
-    buf.writeUInt16LE(command, 0);
-    buf.writeUInt16LE(0, 2);
-    buf.writeUInt16LE(sessionId, 4);
-    buf.writeUInt16LE(replyId, 6);
-    dataBuffer.copy(buf, 8);
-    const chksum2 = createChkSum(buf);
-    buf.writeUInt16LE(chksum2, 2);
-    replyId = (replyId + 1) % Constants.USHRT_MAX;
-    buf.writeUInt16LE(replyId, 6);
+    const buf = createUDPHeader(command, sessionId, replyId, data);
     const prefixBuf = Buffer.from([0x50, 0x50, 0x82, 0x7d, 0x13, 0x00, 0x00, 0x00]);
     prefixBuf.writeUInt16LE(buf.length, 4);
     return Buffer.concat([prefixBuf, buf]);
@@ -378,7 +465,7 @@ const decodeRecordData40 = (recordData) => {
         .slice(2, 2 + 9)
         .toString('ascii')
         .split('\0')
-        .shift() || '', parseTimeToDate(recordData.readUInt32LE(27)), recordData.readUIntLE(26, 1), recordData.readUIntLE(31, 1));
+        .shift() || '', recordData.readUIntLE(26, 1), parseTimeToDate(recordData.readUInt32LE(27)), recordData.readUIntLE(31, 1));
 };
 const decodeRecordData16 = (recordData) => {
     return {
@@ -494,6 +581,59 @@ const authKey = (comKey, sessionId) => {
     return Array.from(response);
 };
 
+/**
+ * Error types for device communication
+ */
+const ERROR_TYPES = {
+    ECONNRESET: 'ECONNRESET',
+    ECONNREFUSED: 'ECONNREFUSED'};
+/**
+ * Custom error class for device communication errors
+ */
+class ZkError {
+    err;
+    ip;
+    command;
+    /**
+     * Creates a new ZkError instance
+     * @param err The error object
+     * @param command The command that caused the error
+     * @param ip The IP address of the device
+     */
+    constructor(err, command, ip) {
+        this.err = err;
+        this.ip = ip;
+        this.command = command;
+    }
+    /**
+     * Gets a user-friendly error message
+     * @returns A formatted error message
+     */
+    toast() {
+        if (this.err.code === ERROR_TYPES.ECONNRESET) {
+            return 'Another device is connecting to the device so the connection is interrupted';
+        }
+        else if (this.err.code === ERROR_TYPES.ECONNREFUSED) {
+            return 'IP of the device is refused';
+        }
+        return this.err.message;
+    }
+    /**
+     * Gets detailed error information
+     * @returns An object containing error details
+     */
+    getError() {
+        return {
+            err: {
+                message: this.err.message,
+                code: this.err.code
+            },
+            ip: this.ip,
+            command: this.command
+        };
+    }
+}
+
 /**
  * Represents a fingerprint template with associated metadata
  */
@@ -567,56 +707,547 @@ class Finger {
     }
 }
 
-/**
- * Error types for device communication
- */
-const ERROR_TYPES = {
-    ECONNRESET: 'ECONNRESET',
-    ECONNREFUSED: 'ECONNREFUSED'};
-/**
- * Custom error class for device communication errors
- */
-class ZkError {
-    err;
-    ip;
-    command;
-    /**
-     * Creates a new ZkError instance
-     * @param err The error object
-     * @param command The command that caused the error
-     * @param ip The IP address of the device
-     */
-    constructor(err, command, ip) {
-        this.err = err;
-        this.ip = ip;
-        this.command = command;
+class UserService {
+    _zkTcp;
+    _users;
+    constructor(zkTcp) {
+        this._zkTcp = zkTcp;
+    }
+    async getUserByUserId(user_id) {
+        if (!this._users) {
+            await this.getUsers();
+        }
+        if (this._users.has(String(user_id))) {
+            return this._users.get(String(user_id));
+        }
+        else
+            throw new Error("user_id not exists");
+    }
+    async getUsers() {
+        try {
+            // Free any existing buffer data to prepare for a new request
+            if (this._users) {
+                return { data: Array.from(this._users.values()) };
+            }
+            else {
+                this._users = new Map([]);
+            }
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            // Request user data
+            const data = await this._zkTcp.readWithBuffer(REQUEST_DATA.GET_USERS);
+            // Free buffer data after receiving the data
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            // Constants for user data processing
+            const USER_PACKET_SIZE = 72;
+            // Ensure data.data is a valid buffer
+            if (!data.data || !(data.data instanceof Buffer)) {
+                throw new Error('Invalid data received');
+            }
+            let userData = data.data.subarray(4); // Skip the first 4 bytes (headers)
+            const users = [];
+            // Process each user packet
+            while (userData.length >= USER_PACKET_SIZE) {
+                // Decode user data and add to the users array
+                const user = decodeUserData72(userData.subarray(0, USER_PACKET_SIZE));
+                users.push(user);
+                this._users.set(user.user_id, user);
+                userData = userData.subarray(USER_PACKET_SIZE); // Move to the next packet
+            }
+            // Return the list of users
+            return { data: users };
+        }
+        catch (err) {
+            // Log the error for debugging
+            console.error('Error getting users:', err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
+    }
+    async setUser(user_id, name, password, role = 0, cardno = 0) {
+        let user;
+        try {
+            user = await this.getUserByUserId(user_id);
+        }
+        catch (err) {
+            if (err.message.includes("user_id not exists")) {
+                user.uid = Math.max(...Array.from(this._users.values()).map(usr => usr.uid)) + 1;
+                this._users.set(user_id, user);
+            }
+        }
+        try {
+            // Validate input parameters
+            if (user_id.length > 9 ||
+                name.length > 24 ||
+                password.length > 8 ||
+                typeof role !== 'number' ||
+                cardno.toString().length > 10) {
+                throw new Error('Invalid input parameters');
+            }
+            // Allocate and initialize the buffer
+            const commandBuffer = Buffer.alloc(72);
+            // Fill the buffer with user data
+            commandBuffer.writeUInt16LE(user.uid, 0);
+            commandBuffer.writeUInt16LE(role, 2);
+            commandBuffer.write(password.padEnd(8, '\0'), 3, 8); // Ensure password is 8 bytes
+            commandBuffer.write(name.padEnd(24, '\0'), 11, 24); // Ensure name is 24 bytes
+            commandBuffer.writeUInt16LE(cardno, 35);
+            commandBuffer.writeUInt32LE(0, 40); // Placeholder or reserved field
+            commandBuffer.write(user_id.padEnd(9, '\0'), 48, 9); // Ensure userid is 9 bytes
+            // Send the command and return the result
+            const created = await this._zkTcp.executeCmd(COMMANDS.CMD_USER_WRQ, commandBuffer);
+            return !!created;
+        }
+        catch (err) {
+            // Log error details for debugging
+            console.error('Error setting user:', err);
+            // Re-throw error for upstream handling
+            throw err;
+        }
+    }
+    async DeleteUser(user_id) {
+        try {
+            const user = await this.getUserByUserId(user_id);
+            // Allocate and initialize the buffer
+            const commandBuffer = Buffer.alloc(72);
+            // Write UID to the buffer
+            commandBuffer.writeUInt16LE(user.uid, 0);
+            // Send the delete command and return the result
+            const deleted = await this._zkTcp.executeCmd(COMMANDS.CMD_DELETE_USER, commandBuffer);
+            return !!deleted;
+        }
+        catch (err) {
+            // Log error details for debugging
+            console.error('Error deleting user:', err);
+            // Re-throw error for upstream handling
+            throw err;
+        }
+    }
+    async getTemplates(callbackInProcess = () => { }) {
+        let templates = [];
+        try {
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            await this._zkTcp.getSizes();
+            if (this._zkTcp.fp_count == 0)
+                return { data: [] };
+            await this._zkTcp.disableDevice();
+            const resp = await this._zkTcp.readWithBuffer(REQUEST_DATA.GET_TEMPLATES);
+            let templateData = resp.data.subarray(4);
+            let totalSize = resp.data.readUIntLE(0, 4);
+            while (totalSize) {
+                const buf = templateData.subarray(0, 6);
+                const size = buf.readUIntLE(0, 2);
+                const uid = buf.readUIntLE(2, 2);
+                const fid = buf.readUIntLE(4, 1);
+                const valid = buf.readUIntLE(5, 1);
+                // Force-copy bytes so we don't retain the entire big backing buffer
+                const tplBytes = Buffer.from(templateData.subarray(6, size));
+                templates.push(new Finger(uid, fid, valid, tplBytes));
+                templateData = templateData.subarray(size);
+                totalSize -= size;
+            }
+            return { data: templates };
+        }
+        catch (err) {
+            this._zkTcp.verbose && console.log("Error getting templates", err);
+            return { data: templates };
+        }
+        finally {
+            await this._zkTcp.freeData();
+            await this._zkTcp.enableDevice();
+        }
+    }
+    async DownloadFp(user_id, fid) {
+        try {
+            const user = await this.getUserByUserId(user_id);
+            if (0 > fid || fid > 9)
+                throw new Error('fid must be between 0 and 9');
+            // Allocate and initialize the buffer
+            const data = Buffer.alloc(3);
+            // Fill the buffer with user data
+            data.writeUInt16LE(user.uid, 0);
+            data.writeUIntLE(fid, 2, 1);
+            this._zkTcp.replyId++;
+            const packet = createTCPHeader(COMMANDS.CMD_USERTEMP_RRQ, this._zkTcp.sessionId, this._zkTcp.replyId, data);
+            let fingerSize = 0;
+            let fingerTemplate = Buffer.from([]);
+            return await new Promise((resolve, reject) => {
+                let timeout;
+                const cleanup = () => {
+                    if (this._zkTcp.socket) {
+                        this._zkTcp.socket.removeListener('data', receiveData);
+                    }
+                    if (timeout)
+                        clearTimeout(timeout);
+                };
+                let timer = () => setTimeout(() => {
+                    cleanup();
+                    reject(new Error('Time Out, Could not retrieve data'));
+                }, this._zkTcp.timeout);
+                const receiveData = (data) => {
+                    timeout = timer();
+                    if (data.length === 0)
+                        return;
+                    try {
+                        if (data.length == 0)
+                            return;
+                        const headers = decodeTCPHeader(data);
+                        switch (headers.commandId) {
+                            case DISCOVERED_CMD.FID_NOT_FOUND:
+                                throw new Error('Could not retrieve data. maybe finger id not exists?');
+                            case COMMANDS.CMD_PREPARE_DATA:
+                                fingerSize = data.readUIntLE(16, 2);
+                                break;
+                            case COMMANDS.CMD_DATA:
+                                // A single 'data' event might contain multiple TCP packets combined by the OS
+                                // in this method, is possible to get CMD_DATA and CMD_ACK_OK in the same event,
+                                // so It's important to split data received for remove CMD_ACK_OK headers
+                                fingerTemplate = Buffer.concat([fingerTemplate, data.subarray(16, fingerSize + 10)]);
+                                // @ts-ignore
+                                resolve(fingerTemplate);
+                                break;
+                            case COMMANDS.CMD_ACK_OK:
+                                cleanup();
+                                // @ts-ignore
+                                resolve(fingerTemplate);
+                                return;
+                            default:
+                                // If it's not a recognized command but has data, it might be raw template data
+                                if (headers.commandId > 2000 && headers.commandId < 3000) {
+                                    // Likely another ACK or system msg
+                                }
+                                else {
+                                    fingerTemplate = Buffer.concat([fingerTemplate, data]);
+                                }
+                                break;
+                        }
+                        clearTimeout(timeout);
+                    }
+                    catch (e) {
+                        cleanup();
+                        reject(e);
+                    }
+                };
+                if (this._zkTcp.socket) {
+                    this._zkTcp.socket.on('data', receiveData);
+                    this._zkTcp.socket.write(packet, (err) => {
+                        if (err) {
+                            cleanup();
+                            reject(err);
+                        }
+                    });
+                }
+                else {
+                    reject(new Error('Socket not initialized'));
+                }
+            });
+        }
+        catch (err) {
+            throw err;
+        }
+        finally {
+            await this._zkTcp.refreshData();
+        }
     }
     /**
-     * Gets a user-friendly error message
-     * @returns A formatted error message
-     */
-    toast() {
-        if (this.err.code === ERROR_TYPES.ECONNRESET) {
-            return 'Another device is connecting to the device so the connection is interrupted';
+     *
+     * @param user_id {string} user
+     * @param fingers {Finger[]} array of finger templates instances
+     * */
+    async saveTemplates(user_id, fingers = []) {
+        if (fingers.length > 9 || fingers.length == 0)
+            throw new Error("maximum finger length is 10 and can't be empty");
+        try {
+            await this._zkTcp.disableDevice();
+            // check users exists
+            const user = await this.getUserByUserId(user_id);
+            let fpack = Buffer.alloc(0);
+            let table = Buffer.alloc(0);
+            const fnum = 0x10;
+            let tstart = 0;
+            for (const finger of fingers) {
+                const tfp = finger.repackOnly();
+                const tableEntry = Buffer.alloc(11); // b=1, H=2, b=1, I=4 => 1+2+1+4=8? Wait, bHbI is 1+2+1+4=8 bytes
+                tableEntry.writeInt8(2, 0);
+                tableEntry.writeUInt16LE(user.uid, 1);
+                tableEntry.writeInt8(fnum + finger.fid, 3);
+                tableEntry.writeUInt32LE(tstart, 4);
+                table = Buffer.concat([table, tableEntry]);
+                tstart += tfp.length;
+                fpack = Buffer.concat([fpack, tfp]);
+            }
+            let upack;
+            if (this._zkTcp.userPacketSize === 28) {
+                upack = user.repack29();
+            }
+            else {
+                upack = user.repack73();
+            }
+            const head = Buffer.alloc(12); // III = 3*4 bytes
+            head.writeUInt32LE(upack.length, 0);
+            head.writeUInt32LE(table.length, 4);
+            head.writeUInt32LE(fpack.length, 8);
+            const packet = Buffer.concat([head, upack, table, fpack]);
+            const bufferResponse = await this._zkTcp.sendWithBuffer(packet);
+            const command = 110;
+            const commandString = Buffer.alloc(8); // <IHH = I(4) + H(2) + H(2) = 8 bytes
+            commandString.writeUInt32LE(12, 0);
+            commandString.writeUInt16LE(0, 4);
+            commandString.writeUInt16LE(8, 6);
+            const cmdResponse = await this._zkTcp.executeCmd(command, commandString);
+            if (this._zkTcp.verbose)
+                console.log("finally bulk save user templates: \n", cmdResponse.readUInt16LE(0));
         }
-        else if (this.err.code === ERROR_TYPES.ECONNREFUSED) {
-            return 'IP of the device is refused';
+        catch (error) {
+            throw error;
+        }
+        finally {
+            await this._zkTcp.refreshData();
+            await this._zkTcp.enableDevice();
+        }
+    }
+    async deleteFinger(user_id, fid) {
+        try {
+            if (!this._users.has(user_id))
+                throw new Error("user_id not exists");
+            const user = await this.getUserByUserId(user_id);
+            const buf = Buffer.alloc(4);
+            buf.writeUInt16LE(user_id ? user.uid : 0, 0);
+            buf.writeUint16LE(fid ? fid : 0, 2);
+            const reply = await this._zkTcp.executeCmd(COMMANDS.CMD_DELETE_USERTEMP, buf);
+            return !!reply;
+        }
+        catch (error) {
+            throw new Error("Can't save utemp");
+        }
+        finally {
+            await this._zkTcp.refreshData();
+        }
+    }
+    async enrollInfo(user_id, tempId) {
+        let done = false;
+        try {
+            const userBuf = Buffer.alloc(24);
+            userBuf.write(user_id, 0, 24, 'ascii');
+            let commandString = Buffer.concat([
+                userBuf,
+                Buffer.from([tempId, 1])
+            ]);
+            const sendAckOk = async () => {
+                try {
+                    const buf = createTCPHeader(COMMANDS.CMD_ACK_OK, this._zkTcp.sessionId, Constants.USHRT_MAX - 1, Buffer.from([]));
+                    this._zkTcp.socket.write(buf);
+                }
+                catch (e) {
+                    throw new ZkError(e, COMMANDS.CMD_ACK_OK, this._zkTcp.ip);
+                }
+            };
+            const cancel = await this._zkTcp.cancelCapture();
+            const cmdResponse = await this._zkTcp.executeCmd(COMMANDS.CMD_STARTENROLL, commandString);
+            this._zkTcp.timeout = 60000; // 60 seconds timeout
+            let attempts = 3;
+            while (attempts > 0) {
+                if (this._zkTcp.verbose)
+                    console.log(`A:${attempts} esperando primer regevent`);
+                let dataRecv = await this._zkTcp.readSocket(17);
+                await sendAckOk();
+                if (dataRecv.length > 16) {
+                    const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
+                    const res = padded.readUInt16LE(16);
+                    if (this._zkTcp.verbose)
+                        console.log(`res ${res}`);
+                    if (res === 0 || res === 6 || res === 4) {
+                        if (this._zkTcp.verbose)
+                            console.log("posible timeout o reg Fallido");
+                        break;
+                    }
+                }
+                if (this._zkTcp.verbose)
+                    console.log(`A:${attempts} esperando 2do regevent`);
+                dataRecv = await this._zkTcp.readSocket(17);
+                await sendAckOk();
+                if (this._zkTcp.verbose)
+                    console.log(dataRecv);
+                if (dataRecv.length > 8) {
+                    const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
+                    const res = padded.readUInt16LE(16);
+                    if (this._zkTcp.verbose)
+                        console.log(`res ${res}`);
+                    if (res === 6 || res === 4) {
+                        if (this._zkTcp.verbose)
+                            console.log("posible timeout o reg Fallido");
+                        break;
+                    }
+                    else if (res === 0x64) {
+                        if (this._zkTcp.verbose)
+                            console.log("ok, continue?");
+                        attempts--;
+                    }
+                }
+            }
+            if (attempts === 0) {
+                const dataRecv = await this._zkTcp.readSocket(17);
+                await sendAckOk();
+                if (this._zkTcp.verbose)
+                    console.log(dataRecv.toString('hex'));
+                const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
+                let res = padded.readUInt16LE(16);
+                if (this._zkTcp.verbose)
+                    console.log(`res ${res}`);
+                if (res === 5) {
+                    if (this._zkTcp.verbose)
+                        console.log("finger duplicate");
+                }
+                if (res === 6 || res === 4) {
+                    if (this._zkTcp.verbose)
+                        console.log("posible timeout");
+                }
+                if (res === 0) {
+                    const size = padded.readUInt16LE(10);
+                    const pos = padded.readUInt16LE(12);
+                    if (this._zkTcp.verbose)
+                        console.log(`enroll ok ${size} ${pos}`);
+                    done = true;
+                }
+            }
+            //this.__sock.setTimeout(this.__timeout);
+            await this._zkTcp.regEvent(0); // TODO: test
+            return done;
+        }
+        catch (error) {
+            throw error;
+        }
+        finally {
+            await this._zkTcp.cancelCapture();
+            await this.verify(user_id);
+        }
+    }
+    async verify(user_id) {
+        try {
+            const user = await this.getUserByUserId(user_id);
+            const command_string = Buffer.alloc(4);
+            command_string.writeUInt32LE(user.uid, 0);
+            const reply = await this._zkTcp.executeCmd(COMMANDS.CMD_STARTVERIFY, command_string);
+            if (this._zkTcp.verbose)
+                console.log(reply.readUInt16LE(0));
+            return !!reply;
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
         }
-        return this.err.message;
     }
     /**
-     * Gets detailed error information
-     * @returns An object containing error details
+     * Upload a single fingerprint for a given user id
+     * @param user_id {string} user id for customer
+     * @param fingerTemplate {string} finger template in base64 string
+     * @param fid {number} finger id is a number between 0 and 9
+     * @param fp_valid {number} finger flag. e.g., valid=1, duress=3
      */
-    getError() {
-        return {
-            err: {
-                message: this.err.message,
-                code: this.err.code
-            },
-            ip: this.ip,
-            command: this.command
-        };
+    async uploadFingerTemplate(user_id, fingerTemplate, fid, fp_valid) {
+        try {
+            const check_ACK_OK = (buf) => {
+                let resp_cmd = initPacket.readUInt16LE(0);
+                if (resp_cmd === COMMANDS.CMD_ACK_OK)
+                    return true;
+                else
+                    throw new Error(`received unexpected command: ${resp_cmd}`);
+            };
+            const user = this._users.get(user_id);
+            await this._zkTcp.disableDevice();
+            const prep_struct = Buffer.alloc(4);
+            const fingerBuffer = Buffer.from(fingerTemplate, 'base64');
+            const fp_size = fingerBuffer.length;
+            prep_struct.writeUInt16LE(fp_size, 0);
+            const initPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_PREPARE_DATA, prep_struct);
+            check_ACK_OK(initPacket);
+            const fpPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_DATA, fingerBuffer);
+            check_ACK_OK(fpPacket);
+            const cheksumPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_CHECKSUM_BUFFER, '');
+            check_ACK_OK(cheksumPacket);
+            const checksum = cheksumPacket.readUInt32LE(8);
+            const tmp_wreq = Buffer.alloc(6);
+            tmp_wreq.writeUInt16LE(user.uid, 0);
+            tmp_wreq.writeUIntLE(fid, 2, 1);
+            tmp_wreq.writeUIntLE(fp_valid, 3, 1);
+            tmp_wreq.writeUInt16LE(fp_size, 4);
+            const tmp_wreqPacket = await this._zkTcp.executeCmd(COMMANDS.CMD_TMP_WRITE, tmp_wreq);
+            check_ACK_OK(tmp_wreqPacket);
+            const freeData = await this._zkTcp.executeCmd(COMMANDS.CMD_FREE_DATA, '');
+            return check_ACK_OK(freeData);
+        }
+        catch (err) {
+            throw err;
+        }
+        finally {
+            await this._zkTcp.refreshData();
+            await this._zkTcp.enableDevice();
+        }
+    }
+}
+
+class TransactionService {
+    _zkTcp;
+    constructor(zkTcp) {
+        this._zkTcp = zkTcp;
+    }
+    async getAttendances(callbackInProcess = () => { }) {
+        try {
+            // Free any existing buffer data to prepare for a new request
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            // Request attendance logs and handle chunked data
+            const data = await this._zkTcp.readWithBuffer(REQUEST_DATA.GET_ATTENDANCE_LOGS, callbackInProcess);
+            // Free buffer data after receiving the attendance logs
+            if (this._zkTcp.socket) {
+                await this._zkTcp.freeData();
+            }
+            // Constants for record processing
+            const RECORD_PACKET_SIZE = 40;
+            // Ensure data.data is a valid buffer
+            if (!data.data || !(data.data instanceof Buffer)) {
+                throw new Error('Invalid data received');
+            }
+            // Process the record data
+            let recordData = data.data.subarray(4); // Skip header
+            const records = [];
+            // Process each attendance record
+            while (recordData.length >= RECORD_PACKET_SIZE) {
+                const record = decodeRecordData40(recordData.subarray(0, RECORD_PACKET_SIZE));
+                records.push({ ...record, ip: this._zkTcp.ip }); // Add IP address to each record
+                recordData = recordData.subarray(RECORD_PACKET_SIZE); // Move to the next packet
+            }
+            // Return the list of attendance records
+            return { data: records };
+        }
+        catch (err) {
+            // Log and re-throw the error
+            console.error('Error getting attendance records:', err);
+            throw err; // Re-throw the error for handling by the caller
+        }
+    }
+    // Clears the attendance logs on the device
+    async clearAttendanceLog() {
+        try {
+            // Execute the command to clear attendance logs
+            await this._zkTcp.disableDevice();
+            const buf = await this._zkTcp.executeCmd(COMMANDS.CMD_CLEAR_ATTLOG, '');
+            await this._zkTcp.refreshData();
+            await this._zkTcp.enableDevice();
+            return !!buf;
+        }
+        catch (err) {
+            // Log the error for debugging purposes
+            console.error('Error clearing attendance log:', err);
+            // Re-throw the error to be handled by the caller
+            throw err;
+        }
     }
 }
 
@@ -652,6 +1283,8 @@ class ZTCP {
     verbose = false;
     packetNumber = 0;
     replyData = Buffer.from([]);
+    _userService;
+    _transactionService;
     constructor(ip, port, timeout, comm_key, verbose) {
         this.ip = ip;
         this.port = port;
@@ -659,6 +1292,8 @@ class ZTCP {
         this.replyId = 0;
         this.comm_key = comm_key;
         this.verbose = verbose;
+        this._userService = new UserService(this);
+        this._transactionService = new TransactionService(this);
     }
     createSocket(cbError, cbClose) {
         return new Promise((resolve, reject) => {
@@ -880,6 +1515,10 @@ class ZTCP {
         try {
             // Write the message to the socket and wait for a response
             const reply = await this.writeMessage(buf, command === COMMANDS.CMD_CONNECT || command === COMMANDS.CMD_EXIT);
+            if (this.verbose) {
+                let headers = decodeTCPHeader(reply);
+                console.log('command: ', COMMANDS[headers.commandId], 'replyid: ', headers.replyId);
+            }
             // Remove TCP header from the response
             const rReply = removeTcpHeader(reply);
             // Update sessionId for connection command responses
@@ -1024,94 +1663,19 @@ class ZTCP {
                     break;
                 }
                 default: {
-                    reject(new Error('ERROR_IN_UNHANDLE_CMD ' + exportErrorMessage(header.commandId)));
-                }
-            }
-        });
-    }
-    /**
-     *  reject error when starting request data
-     *  @return {Record<string, User[] | Error>} when receiving requested data
-     */
-    async getUsers() {
-        try {
-            // Free any existing buffer data to prepare for a new request
-            if (this.socket) {
-                await this.freeData();
-            }
-            // Request user data
-            const data = await this.readWithBuffer(REQUEST_DATA.GET_USERS);
-            // Free buffer data after receiving the data
-            if (this.socket) {
-                await this.freeData();
-            }
-            // Constants for user data processing
-            const USER_PACKET_SIZE = 72;
-            // Ensure data.data is a valid buffer
-            if (!data.data || !(data.data instanceof Buffer)) {
-                throw new Error('Invalid data received');
-            }
-            let userData = data.data.subarray(4); // Skip the first 4 bytes (headers)
-            const users = [];
-            // Process each user packet
-            while (userData.length >= USER_PACKET_SIZE) {
-                // Decode user data and add to the users array
-                const user = decodeUserData72(userData.subarray(0, USER_PACKET_SIZE));
-                users.push(user);
-                userData = userData.subarray(USER_PACKET_SIZE); // Move to the next packet
-            }
-            // Return the list of users
-            return { data: users };
-        }
-        catch (err) {
-            // Log the error for debugging
-            console.error('Error getting users:', err);
-            // Re-throw the error to be handled by the caller
-            throw err;
-        }
-    }
-    /**
-     *
-     * @param {*} ip
-     * @param {*} callbackInProcess
-     *  reject error when starting request data
-     *  return { data: records, err: Error } when receiving requested data
-     */
-    async getAttendances(callbackInProcess = () => { }) {
-        try {
-            // Free any existing buffer data to prepare for a new request
-            if (this.socket) {
-                await this.freeData();
-            }
-            // Request attendance logs and handle chunked data
-            const data = await this.readWithBuffer(REQUEST_DATA.GET_ATTENDANCE_LOGS, callbackInProcess);
-            // Free buffer data after receiving the attendance logs
-            if (this.socket) {
-                await this.freeData();
-            }
-            // Constants for record processing
-            const RECORD_PACKET_SIZE = 40;
-            // Ensure data.data is a valid buffer
-            if (!data.data || !(data.data instanceof Buffer)) {
-                throw new Error('Invalid data received');
-            }
-            // Process the record data
-            let recordData = data.data.subarray(4); // Skip header
-            const records = [];
-            // Process each attendance record
-            while (recordData.length >= RECORD_PACKET_SIZE) {
-                const record = decodeRecordData40(recordData.subarray(0, RECORD_PACKET_SIZE));
-                records.push({ ...record, ip: this.ip }); // Add IP address to each record
-                recordData = recordData.subarray(RECORD_PACKET_SIZE); // Move to the next packet
-            }
-            // Return the list of attendance records
-            return { data: records };
-        }
-        catch (err) {
-            // Log and re-throw the error
-            console.error('Error getting attendance records:', err);
-            throw err; // Re-throw the error for handling by the caller
-        }
+                    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 getAttendances(callbackInProcess = () => { }) {
+        return await this._transactionService.getAttendances(callbackInProcess);
     }
     async freeData() {
         try {
@@ -1438,11 +2002,10 @@ class ZTCP {
             // Execute the command to get the PIN information
             const data = await this.executeCmd(COMMANDS.CMD_OPTIONS_RRQ, keyword);
             // Extract and format the PIN information from the response data
-            // Remove null characters
             return data.slice(8) // Skip the first 8 bytes (header)
                 .toString('ascii') // Convert buffer to ASCII string
                 .replace(`${keyword}=`, '') // Remove the keyword prefix
-                .replace(/\u0000/g, '');
+                .replace(/\u0000/g, ''); // Remove null characters 0x00
         }
         catch (err) {
             // Log the error for debugging
@@ -1494,7 +2057,9 @@ class ZTCP {
             // Execute the command to get firmware information
             const data = await this.executeCmd(1100, '');
             // Extract and return the firmware version from the response data
-            return data.slice(8).toString('ascii'); // Skip the first 8 bytes (header) and convert to ASCII string
+            return data.slice(8) // Skip the first 8 bytes (header)
+                .toString('ascii') // convert to ASCII string
+                .replace(/\u0000/g, ''); // remove x00
         }
         catch (err) {
             // Log the error for debugging
@@ -1560,59 +2125,6 @@ class ZTCP {
             throw err;
         }
     }
-    async setUser(uid, userid, name, password, role = 0, cardno = 0) {
-        try {
-            // Validate input parameters
-            if (uid <= 0 || uid > 3000 ||
-                userid.length > 9 ||
-                name.length > 24 ||
-                password.length > 8 ||
-                typeof role !== 'number' ||
-                cardno.toString().length > 10) {
-                throw new Error('Invalid input parameters');
-            }
-            // Allocate and initialize the buffer
-            const commandBuffer = Buffer.alloc(72);
-            // Fill the buffer with user data
-            commandBuffer.writeUInt16LE(uid, 0);
-            commandBuffer.writeUInt16LE(role, 2);
-            commandBuffer.write(password.padEnd(8, '\0'), 3, 8); // Ensure password is 8 bytes
-            commandBuffer.write(name.padEnd(24, '\0'), 11, 24); // Ensure name is 24 bytes
-            commandBuffer.writeUInt16LE(cardno, 35);
-            commandBuffer.writeUInt32LE(0, 40); // Placeholder or reserved field
-            commandBuffer.write(userid.padEnd(9, '\0'), 48, 9); // Ensure userid is 9 bytes
-            // Send the command and return the result
-            const created = await this.executeCmd(COMMANDS.CMD_USER_WRQ, commandBuffer);
-            return !!created;
-        }
-        catch (err) {
-            // Log error details for debugging
-            console.error('Error setting user:', err);
-            // Re-throw error for upstream handling
-            throw err;
-        }
-    }
-    async deleteUser(uid) {
-        try {
-            // Validate input parameter
-            if (uid <= 0 || uid > 3000) {
-                throw new Error('Invalid UID: must be between 1 and 3000');
-            }
-            // Allocate and initialize the buffer
-            const commandBuffer = Buffer.alloc(72);
-            // Write UID to the buffer
-            commandBuffer.writeUInt16LE(uid, 0);
-            // Send the delete command and return the result
-            const deleted = await this.executeCmd(COMMANDS.CMD_DELETE_USER, commandBuffer);
-            return !!deleted;
-        }
-        catch (err) {
-            // Log error details for debugging
-            console.error('Error deleting user:', err);
-            // Re-throw error for upstream handling
-            throw err;
-        }
-    }
     async getAttendanceSize() {
         try {
             // Execute command to get free sizes
@@ -1629,22 +2141,27 @@ class ZTCP {
     }
     // Clears the attendance logs on the device
     async clearAttendanceLog() {
-        try {
-            // Execute the command to clear attendance logs
-            return await this.executeCmd(COMMANDS.CMD_CLEAR_ATTLOG, '');
-        }
-        catch (err) {
-            // Log the error for debugging purposes
-            console.error('Error clearing attendance log:', err);
-            // Re-throw the error to be handled by the caller
-            throw err;
-        }
+        return await this._transactionService.clearAttendanceLog();
     }
-    // Clears all data on the device
-    async clearData() {
+    /**
+     * 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
-            return await this.executeCmd(COMMANDS.CMD_CLEAR_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
@@ -1691,33 +2208,7 @@ class ZTCP {
      * @returns {Record<string, Finger[]>}
      */
     async getTemplates(callbackInProcess = () => { }) {
-        let templates = [];
-        try {
-            await this.getSizes();
-            if (this.fp_count == 0)
-                return { data: [] };
-            await this.freeData();
-            await this.disableDevice();
-            const Buffer = await this.readWithBuffer(REQUEST_DATA.GET_TEMPLATES);
-            let templateData = Buffer.data.subarray(4);
-            let totalSize = Buffer.data.readUIntLE(0, 4);
-            while (totalSize) {
-                const buf = templateData.subarray(0, 6);
-                const size = buf.readUIntLE(0, 2);
-                templates.push(new Finger(buf.readUIntLE(2, 2), buf.readUIntLE(4, 1), buf.readUIntLE(5, 1), templateData.subarray(6, size)));
-                templateData = templateData.subarray(size);
-                totalSize -= size;
-            }
-            return { data: templates };
-        }
-        catch (err) {
-            this.verbose && console.log("Error getting templates", err);
-            return { data: templates };
-        }
-        finally {
-            await this.enableDevice();
-            await this.freeData();
-        }
+        return await this._userService.getTemplates(callbackInProcess);
     }
     /**
      * Return size
@@ -1793,197 +2284,6 @@ class ZTCP {
             throw new ZkError(e, COMMANDS.CMD_DATA, this.ip);
         }
     }
-    /**
-     * save user and template
-     *
-     * @param {User | number | string} user - User class object | uid | user_id
-     * @param {Finger[]} fingers - Array of finger class. `0 <= index <= 9`
-     */
-    async saveUserTemplate(user, fingers = []) {
-        if (fingers.length > 9 || fingers.length == 0)
-            throw new Error("maximum finger length is 10 and can't be empty");
-        try {
-            await this.disableDevice();
-            const users = await this.getUsers();
-            //check users exists
-            if (!users.data.some(u => u.uid == user.uid || +u.user_id == +user.user_id))
-                throw new Error("error validating user input");
-            if (!(user instanceof User)) {
-                let tusers = users.data.filter(x => x.uid === +user.uid);
-                if (tusers.length === 1) {
-                    user = tusers[0];
-                }
-                else {
-                    tusers = users.data.filter(x => x.user_id === String(user));
-                    if (tusers.length === 1) {
-                        user = tusers[0];
-                    }
-                    else {
-                        throw new Error("Can't find user");
-                    }
-                }
-            }
-            if (fingers instanceof Finger) {
-                fingers = [fingers];
-            }
-            let fpack = Buffer.alloc(0);
-            let table = Buffer.alloc(0);
-            const fnum = 0x10;
-            let tstart = 0;
-            for (const finger of fingers) {
-                const tfp = finger.repackOnly();
-                const tableEntry = Buffer.alloc(11); // b=1, H=2, b=1, I=4 => 1+2+1+4=8? Wait, bHbI is 1+2+1+4=8 bytes
-                tableEntry.writeInt8(2, 0);
-                tableEntry.writeUInt16LE(user.uid, 1);
-                tableEntry.writeInt8(fnum + finger.fid, 3);
-                tableEntry.writeUInt32LE(tstart, 4);
-                table = Buffer.concat([table, tableEntry]);
-                tstart += tfp.length;
-                fpack = Buffer.concat([fpack, tfp]);
-            }
-            let upack;
-            if (this.userPacketSize === 28) {
-                upack = user.repack29();
-            }
-            else {
-                upack = user.repack73();
-            }
-            const head = Buffer.alloc(12); // III = 3*4 bytes
-            head.writeUInt32LE(upack.length, 0);
-            head.writeUInt32LE(table.length, 4);
-            head.writeUInt32LE(fpack.length, 8);
-            const packet = Buffer.concat([head, upack, table, fpack]);
-            const bufferResponse = await this.sendWithBuffer(packet);
-            const command = 110;
-            const commandString = Buffer.alloc(8); // <IHH = I(4) + H(2) + H(2) = 8 bytes
-            commandString.writeUInt32LE(12, 0);
-            commandString.writeUInt16LE(0, 4);
-            commandString.writeUInt16LE(8, 6);
-            const cmdResponse = await this.executeCmd(command, commandString);
-            if (this.verbose)
-                console.log("finally bulk save user templates: \n", cmdResponse.readUInt16LE(0));
-        }
-        catch (error) {
-            throw error;
-        }
-        finally {
-            await this.refreshData();
-            await this.enableDevice();
-        }
-    }
-    async deleteFinger(uid, fid) {
-        try {
-            const buf = Buffer.alloc(4);
-            buf.writeUInt16LE(uid, 0);
-            buf.writeUint16LE(fid, 2);
-            const reply = await this.executeCmd(COMMANDS.CMD_DELETE_USERTEMP, buf);
-            return !!reply;
-        }
-        catch (error) {
-            throw new Error("Can't save utemp");
-        }
-        finally {
-            await this.refreshData();
-        }
-    }
-    async enrollUser(uid, tempId, userId = '') {
-        let done = false;
-        try {
-            //validate user exists
-            const users = await this.getUsers();
-            const filteredUsers = users.data.filter(x => x.uid === uid);
-            if (filteredUsers.length >= 1) {
-                userId = filteredUsers[0].user_id;
-            }
-            else {
-                throw new Error("user not found");
-            }
-            const userBuf = Buffer.alloc(24);
-            userBuf.write(userId.toString(), 0, 24, 'ascii');
-            let commandString = Buffer.concat([
-                userBuf,
-                Buffer.from([tempId, 1])
-            ]);
-            const cancel = await this.cancelCapture();
-            const cmdResponse = await this.executeCmd(COMMANDS.CMD_STARTENROLL, commandString);
-            this.timeout = 60000; // 60 seconds timeout
-            let attempts = 3;
-            while (attempts > 0) {
-                if (this.verbose)
-                    console.log(`A:${attempts} esperando primer regevent`);
-                let dataRecv = await this.readSocket(17);
-                await this.ackOk();
-                if (dataRecv.length > 16) {
-                    const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
-                    const res = padded.readUInt16LE(16);
-                    if (this.verbose)
-                        console.log(`res ${res}`);
-                    if (res === 0 || res === 6 || res === 4) {
-                        if (this.verbose)
-                            console.log("posible timeout o reg Fallido");
-                        break;
-                    }
-                }
-                if (this.verbose)
-                    console.log(`A:${attempts} esperando 2do regevent`);
-                dataRecv = await this.readSocket(17);
-                await this.ackOk();
-                if (this.verbose)
-                    console.log(dataRecv);
-                if (dataRecv.length > 8) {
-                    const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
-                    const res = padded.readUInt16LE(16);
-                    if (this.verbose)
-                        console.log(`res ${res}`);
-                    if (res === 6 || res === 4) {
-                        if (this.verbose)
-                            console.log("posible timeout o reg Fallido");
-                        break;
-                    }
-                    else if (res === 0x64) {
-                        if (this.verbose)
-                            console.log("ok, continue?");
-                        attempts--;
-                    }
-                }
-            }
-            if (attempts === 0) {
-                const dataRecv = await this.readSocket(17);
-                await this.ackOk();
-                if (this.verbose)
-                    console.log(dataRecv.toString('hex'));
-                const padded = Buffer.concat([dataRecv, Buffer.alloc(24 - dataRecv.length)]);
-                let res = padded.readUInt16LE(16);
-                if (this.verbose)
-                    console.log(`res ${res}`);
-                if (res === 5) {
-                    if (this.verbose)
-                        console.log("finger duplicate");
-                }
-                if (res === 6 || res === 4) {
-                    if (this.verbose)
-                        console.log("posible timeout");
-                }
-                if (res === 0) {
-                    const size = padded.readUInt16LE(10);
-                    const pos = padded.readUInt16LE(12);
-                    if (this.verbose)
-                        console.log(`enroll ok ${size} ${pos}`);
-                    done = true;
-                }
-            }
-            //this.__sock.setTimeout(this.__timeout);
-            await this.regEvent(0); // TODO: test
-            return done;
-        }
-        catch (error) {
-            throw error;
-        }
-        finally {
-            await this.cancelCapture();
-            await this.verifyUser(undefined);
-        }
-    }
     async readSocket(length, cb = null) {
         let replyBufer = Buffer.from([]);
         let totalPackets = 0;
@@ -2033,15 +2333,6 @@ class ZTCP {
             throw new ZkError(e, COMMANDS.CMD_REG_EVENT, this.ip);
         }
     }
-    async ackOk() {
-        try {
-            const buf = createTCPHeader(COMMANDS.CMD_ACK_OK, this.sessionId, Constants.USHRT_MAX - 1, Buffer.from([]));
-            this.socket.write(buf);
-        }
-        catch (e) {
-            throw new ZkError(e, COMMANDS.CMD_ACK_OK, this.ip);
-        }
-    }
     async cancelCapture() {
         try {
             const reply = await this.executeCmd(COMMANDS.CMD_CANCELCAPTURE, '');
@@ -2051,22 +2342,6 @@ class ZTCP {
             throw new ZkError(e, COMMANDS.CMD_CANCELCAPTURE, this.ip);
         }
     }
-    async verifyUser(uid) {
-        try {
-            let command_string = '';
-            if (uid) {
-                command_string = Buffer.alloc(4);
-                command_string.writeUInt32LE(uid, 0);
-            }
-            const reply = await this.executeCmd(COMMANDS.CMD_STARTVERIFY, command_string);
-            if (this.verbose)
-                console.log(reply.readUInt16LE(0));
-            return !!reply;
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }
     async restartDevice() {
         try {
             await this.executeCmd(COMMANDS.CMD_RESTART, '');
@@ -2451,7 +2726,7 @@ class ZUDP {
     }
     async clearAttendanceLog() {
         try {
-            return await this.executeCmd(COMMANDS.CMD_CLEAR_ATTLOG, Buffer.alloc(0));
+            return !!await this.executeCmd(COMMANDS.CMD_CLEAR_ATTLOG, Buffer.alloc(0));
         }
         catch (err) {
             console.error('Error clearing attendance log:', err);
@@ -2460,7 +2735,7 @@ class ZUDP {
     }
     async clearData() {
         try {
-            return await this.executeCmd(COMMANDS.CMD_CLEAR_DATA, Buffer.alloc(0));
+            return !!await this.executeCmd(COMMANDS.CMD_CLEAR_DATA, Buffer.alloc(0));
         }
         catch (err) {
             console.error('Error clearing data:', err);
@@ -2651,7 +2926,7 @@ class Zklib {
         }
     }
     async getUsers() {
-        return this.functionWrapper(() => this.ztcp.getUsers(), () => this.zudp.getUsers(), 'GET_USERS');
+        return this.functionWrapper(() => this.ztcp._userService.getUsers(), () => this.zudp.getUsers(), 'GET_USERS');
     }
     async getTime() {
         return this.functionWrapper(() => this.ztcp.getTime(), () => this.zudp.getTime(), 'GET_TIME');
@@ -2701,11 +2976,22 @@ class Zklib {
     async getFirmware() {
         return this.functionWrapper(() => this.ztcp.getFirmware(), async () => { throw new Error('UDP get firmware not supported'); }, 'GET_FIRMWARE');
     }
-    async setUser(uid, userid, name, password, role = 0, cardno = 0) {
-        return this.functionWrapper(() => this.ztcp.setUser(uid, userid, name, password, role, cardno), async () => { throw new Error('UDP set user not supported'); }, 'SET_USER');
+    /** Update or create a user if user id/pin not exists
+     * @param user_id {string} user id/pin for customer
+     * @param name {string} user name
+     * @param password {string} user password
+     * @param role {number} role/privilege id number
+     * @param cardno {number} card number/id
+     */
+    async setUser(user_id, name, password, role = 0, cardno = 0) {
+        return this.functionWrapper(() => this.ztcp._userService.setUser(user_id, name, password, role, cardno), async () => { throw new Error('UDP set user not supported'); }, 'SET_USER');
     }
-    async deleteUser(uid) {
-        return this.functionWrapper(() => this.ztcp.deleteUser(uid), async () => { throw new Error('UDP delete user not supported'); }, 'DELETE_USER');
+    /**
+     * Delete user by a given user id/pin
+     * @param user_id {string}
+     */
+    async deleteUser(user_id) {
+        return this.functionWrapper(() => this.ztcp._userService.DeleteUser(user_id), async () => { throw new Error('UDP delete user not supported'); }, 'DELETE_USER');
     }
     async getAttendanceSize() {
         return this.functionWrapper(() => this.ztcp.getAttendanceSize(), async () => { throw new Error('UDP get attendance size not supported'); }, 'GET_ATTENDANCE_SIZE');
@@ -2719,25 +3005,55 @@ class Zklib {
     async getTemplates() {
         return this.functionWrapper(() => this.ztcp.getTemplates(), async () => { throw new Error('UDP get templates not supported'); }, 'GET_TEMPLATES');
     }
-    async saveUserTemplate(user, fingers = []) {
-        return await this.functionWrapper(async () => await this.ztcp.saveUserTemplate(user, fingers), async () => { throw new Error('UDP save user template not supported'); }, 'SAVE_USER_TEMPLATE');
+    /**
+     * Get a user template for a given user id/pin and finger id
+     * @param user_id {string} user id/pin
+     * @param fid {number} finger index
+     */
+    async getUserTemplate(user_id, fid) {
+        return await this.functionWrapper(async () => await this.ztcp._userService.DownloadFp(user_id, fid), async () => { throw new Error('UDP get user template not implemented'); }, 'GET_USER_TEMPLATE');
+    }
+    /**
+     * Upload a single fingerprint for a given user id
+     * @param user_id {string} user id/pin for customer
+     * @param fingerTemplate {string} finger template in base64 string
+     * @param fid {number} finger id is a number between 0 and 9
+     * @param fp_valid {number} finger flag. e.g., valid=1, duress=3
+     */
+    async uploadFingerTemplate(user_id, fingerTemplate, fid, fp_valid) {
+        return await this.functionWrapper(async () => await this.ztcp._userService.uploadFingerTemplate(user_id, fingerTemplate, fid, fp_valid), async () => { throw new Error('UDP get user template not implemented'); }, 'UPLOAD_USER_TEMPLATE');
+    }
+    /**
+     * save user and template
+     *
+     * @param {string} user_id - user id for customer
+     * @param {Finger[]} fingers - Array of finger class
+     */
+    async saveUserTemplate(user_id, fingers = []) {
+        return await this.functionWrapper(async () => await this.ztcp._userService.saveTemplates(user_id, fingers), async () => { throw new Error('UDP save user template not supported'); }, 'SAVE_USER_TEMPLATE');
     }
-    async deleteFinger(uid, fid) {
+    /**
+     * Delete a single finger template by user id and finger index
+     * @param user_id {string} user id/pin for customer
+     * @param fid {number} finger index
+     */
+    async deleteFinger(user_id, fid) {
         if (fid > 9 || 0 > fid)
             throw new Error("fid params out of index");
-        if (uid > 3000 || uid < 1)
-            throw new Error("fid params out of index");
-        return this.functionWrapper(() => this.ztcp.deleteFinger(uid, fid), async () => { throw new Error('UDP delete finger not supported'); }, 'DELETE_FINGER');
+        return this.functionWrapper(() => this.ztcp._userService.deleteFinger(user_id, fid), async () => { throw new Error('UDP delete finger not supported'); }, 'DELETE_FINGER');
     }
-    async enrollUser(uid, temp_id, user_id) {
+    /**
+     * Start to enroll a finger template
+     * @param user_id {string} user id/pin for customer
+     * @param temp_id {number} finger index
+     */
+    async enrollUser(user_id, temp_id) {
         if (temp_id < 0 || temp_id > 9)
             throw new Error("temp_id out of range 0-9");
-        if (uid < 1 || uid > 3000)
-            throw new Error("uid out of range 1-3000");
-        return this.functionWrapper(() => this.ztcp.enrollUser(uid, temp_id, user_id), async () => { throw new Error('UDP enroll user not supported'); }, 'ENROLL_USER');
+        return this.functionWrapper(() => this.ztcp._userService.enrollInfo(user_id, temp_id), async () => { throw new Error('UDP enroll user not supported'); }, 'ENROLL_USER');
     }
-    async verifyUser(uid) {
-        return this.functionWrapper(() => this.ztcp.verifyUser(uid), async () => { throw new Error('UDP verify user not supported'); }, 'VERIFY_USER');
+    async verifyUser(user_id) {
+        return this.functionWrapper(() => this.ztcp._userService.verify(user_id), async () => { throw new Error('UDP verify user not supported'); }, 'VERIFY_USER');
     }
     async restartDevice() {
         return this.functionWrapper(() => this.ztcp.restartDevice(), async () => { throw new Error('UDP restart device not supported'); }, 'RESTART_DEVICE');