zklib 1.0.0

data/lib/zklib/data_management.rb

@@ -0,0 +1,37 @@
+class Zklib
+  module DataManagement
+    # Free data for transmission
+    def free_data
+      execute_cmd(
+        command:        CMD_FREE_DATA,
+        command_string: ''
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid free data response'
+        end
+      end
+    end
+
+    # Refresh data for transmission
+    def refresh_data
+      execute_cmd(
+        command:        CMD_REFRESHDATA,
+        command_string: ''
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid refresh data response'
+        end
+      end
+    end
+  end
+end

data/lib/zklib/device_management.rb

@@ -0,0 +1,91 @@
+class Zklib
+  module DeviceManagement
+    DEVICE_NAME_KEYWORD    = '~DeviceName'
+    DISABLE_DEVICE_KEYWORD = "\u0000\u0000"
+
+    # Disable attendance machine
+    def disable_device
+      execute_cmd(
+        command:        CMD_DISABLEDEVICE,
+        command_string: DISABLE_DEVICE_KEYWORD
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid disable device response'
+        end
+      end
+    end
+
+    # Enable attendance machine
+    def enable_device
+      execute_cmd(
+        command:        CMD_ENABLEDEVICE,
+        command_string: ''
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid enable device response'
+        end
+      end
+    end
+
+    # Get device name
+    def get_device_name
+      execute_cmd(
+        command:        CMD_DEVICE,
+        command_string: DEVICE_NAME_KEYWORD
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 8
+          data.split("\u0000").pop.tr("#{DEVICE_NAME_KEYWORD}=", '')
+        else
+          puts 'ERROR: Invalid device name response'
+        end
+      end
+    end
+
+    # Turn off attendance machine
+    def power_off_device
+      execute_cmd(
+        command:        CMD_POWEROFF,
+        command_string: ''
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid power off device response'
+        end
+      end
+    end
+
+    # Restart attendance machine
+    def restart_device
+      execute_cmd(
+        command:        CMD_RESTART,
+        command_string: ''
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid restart device response'
+        end
+      end
+    end
+  end
+end

data/lib/zklib/face_management.rb

@@ -0,0 +1,40 @@
+class Zklib
+  module FaceManagement
+    TURN_FACE_OFF_KEYWORD = 'FaceFunOff'
+    TURN_FACE_ON_KEYWORD  = 'FaceFunOn'
+
+    # Turn face off
+    def turn_face_off
+      execute_cmd(
+        command:        CMD_DEVICE,
+        command_string: TURN_FACE_OFF_KEYWORD
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid turn face off response'
+        end
+      end
+    end
+
+    # Turn face on
+    def turn_face_on
+      execute_cmd(
+        command:        CMD_DEVICE,
+        command_string: TURN_FACE_ON_KEYWORD
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid turn face on response'
+        end
+      end
+    end
+  end
+end

data/lib/zklib/helper.rb

@@ -0,0 +1,181 @@
+class Zklib
+  module Helper
+    # Check validity of response
+    #
+    # param  options
+    #        |_ data  Data to check validity
+    def check_valid(options)
+      BinData::Uint16le.read(options[:data][0..-1]).snapshot == CMD_ACK_OK
+    end
+
+    # Create checksum for execution
+    #
+    # param  options
+    #        |_ data  Data to create checksum
+    def create_checksum(options)
+      data = options[:data]
+      checksum = 0
+
+      (0...data.length).step(2) do |i|
+        checksum += (i == data.length - 1) ?
+          BinData::Uint8le.read(data[i]).snapshot :
+          BinData::Uint16le.read(data[i..-1]).snapshot
+        checksum %= USHRT_MAX
+      end
+
+      chksum = USHRT_MAX - checksum - 1
+      chksum
+    end
+
+    # Create header for execution
+    #
+    # param  options
+    #        |_ command         Command value
+    #        |_ checksum        Checksum
+    #        |_ session_id      Session ID
+    #        |_ reply_id        Reply ID
+    #        |_ command_string  Command string
+    def create_header(options)
+      header_buffer = StringIO.new
+      binary_writer = BinData::Uint16le.new
+
+      # Write command header
+      binary_writer.value = options[:command]
+      header_buffer.pos   = 0
+      binary_writer.write(header_buffer)
+
+      # Write checksum header
+      binary_writer.value = options[:checksum]
+      header_buffer.pos   = 2
+      binary_writer.write(header_buffer)
+
+      # Write session ID header
+      binary_writer.value = options[:session_id]
+      header_buffer.pos   = 4
+      binary_writer.write(header_buffer)
+
+      # Write reply ID header
+      binary_writer.value = options[:reply_id]
+      header_buffer.pos   = 6
+      binary_writer.write(header_buffer)
+
+      # Write command string header
+      header_buffer.pos = 8
+      header_buffer.write(options[:command_string])
+
+      # Rewrite checksum header
+      binary_writer.value = create_checksum(data: header_buffer.string)
+      header_buffer.pos   = 2
+      binary_writer.write(header_buffer)
+
+      # Rewrite reply ID header
+      binary_writer.value = (options[:reply_id] + 1) % USHRT_MAX
+      header_buffer.pos   = 6
+      binary_writer.write(header_buffer)
+
+      header_buffer.string
+    end
+
+    # Convert number of seconds to time
+    #
+    # param  options
+    #        |_ seconds  Time in seconds to decode
+    def decode_time(options)
+      time = options[:seconds]
+
+      # Calculate second value
+      second = time % 60
+      time = (time - second) / 60
+
+      # Calculate minute value
+      minute = time % 60
+      time = (time - minute) / 60
+
+      # Calculate hour value
+      hour = time % 24
+      time = (time - hour) / 24
+
+      # Calculate day value
+      day = time % 31 + 1
+      time = (time - day + 1) / 31
+
+      # Calculate month value
+      month = time % 12 + 1
+      time = (time - month + 1) / 12
+
+      # Calculate year value
+      year = time + 2000
+
+      Time.new(year, month, day, hour, minute, second)
+    end
+
+    def decode_user_data(options)
+      data = options[:data]
+
+      {
+        uid:      BinData::Uint16be.read(data[0..1]).snapshot,
+        role:     BinData::Uint16le.read(data[2..3]).snapshot,
+        password: nil,
+        name:     nil,
+        cardno:   nil,
+        userid:   nil
+      }
+    end
+
+    # Convert time to number of seconds
+    #
+    # param  options
+    #        |_ time  Time object to encode
+    def encode_time(options)
+      time = options[:time]
+
+      ((time.year % 100) * 12 * 31 + ((time.mon - 1) * 31) + time.day - 1) * (24 * 60 * 60) + (time.hour * 60 + time.min) * 60 + time.sec
+    end
+
+    # Execute command on attendance machine
+    #
+    # param  options
+    #        |_ command         Command to execute
+    #        |_ command_string  Command string
+    def execute_cmd(options)
+      command = options[:command]
+      self.reply_id = USHRT_MAX - 1 if command == CMD_CONNECT
+      header = create_header(
+        command:        command,
+        checksum:       0,
+        session_id:     session_id,
+        reply_id:       reply_id,
+        command_string: options[:command_string]
+      )
+
+      # Send command
+      socket = UDPSocket.new
+      socket.bind('0.0.0.0', inport)
+      socket.send(header, 0, ip, port)
+      self.data_recv = socket.recvfrom(USHRT_MAX)[0] if IO.select([socket], nil, nil, 10)
+      socket.close
+
+      # Callback
+      if data_recv && data_recv.length > 0
+        self.session_id = BinData::Uint16le.read(data_recv[4..-1]).snapshot
+        self.reply_id = BinData::Uint16le.read(data_recv[6..-1]).snapshot
+
+        yield(valid: true, data: data_recv) if block_given?
+      else
+        yield(valid: false, error: 'Empty response') if block_given?
+      end
+    end
+
+    # Receive data from non-blocking socket
+    #
+    # param  options
+    #        |_ socket  Socket to receive data from
+    def receive_nonblock(options)
+      return options[:socket].recvfrom_nonblock(USHRT_MAX)
+    rescue IO::WaitReadable
+      IO.select([options[:socket]])
+
+      retry
+    end
+  end
+end

data/lib/zklib/pin_management.rb

@@ -0,0 +1,22 @@
+class Zklib
+  module PINManagement
+    PIN_WIDTH_KEYWORD = '~PIN2Width'
+    
+    # Get PIN width
+    def get_pin_width
+      execute_cmd(
+        command:        CMD_DEVICE,
+        command_string: PIN_WIDTH_KEYWORD
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 8
+          data.split("\u0000").pop.tr("#{PIN_WIDTH_KEYWORD}=", '')
+        else
+          puts 'ERROR: Invalid PIN width response'
+        end
+      end
+    end
+  end
+end

data/lib/zklib/platform_management.rb

@@ -0,0 +1,22 @@
+class Zklib
+  module PlatformManagement
+    PLATFORM_KEYWORD = '~Platform'
+
+    # Get platform
+    def get_platform
+      execute_cmd(
+        command:        CMD_DEVICE,
+        command_string: PLATFORM_KEYWORD
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 8
+          data.split("\u0000").pop.tr("#{PLATFORM_KEYWORD}=", '')
+        else
+          puts 'ERROR: Invalid platform response'
+        end
+      end
+    end
+  end
+end

data/lib/zklib/serial_management.rb

@@ -0,0 +1,22 @@
+class Zklib
+  module SerialManagement
+    SERIAL_KEYWORD = '~SerialNumber'
+
+    # Get serial number of attendance machine
+    def get_serial_number
+      execute_cmd(
+        command:        CMD_DEVICE,
+        command_string: SERIAL_KEYWORD
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 8
+          data.split("\u0000").pop.tr("#{SERIAL_KEYWORD}=", '')
+        else
+          puts 'ERROR: Invalid serial number response'
+        end
+      end
+    end
+  end
+end

data/lib/zklib/ssr_management.rb

@@ -0,0 +1,22 @@
+class Zklib
+  module SSRManagement
+    SSR_KEYWORD = '~SSR'
+
+    # Get SSR
+    def get_ssr
+      execute_cmd(
+        command:        CMD_DEVICE,
+        command_string: SSR_KEYWORD
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 8
+          data.split("\u0000").pop.tr("#{SSR_KEYWORD}=", '')
+        else
+          puts 'ERROR: Invalid SSR response'
+        end
+      end
+    end
+  end
+end

data/lib/zklib/time_management.rb

@@ -0,0 +1,47 @@
+class Zklib
+  module TimeManagement
+    # Get current time of attendance machine
+    def get_time
+      execute_cmd(
+        command:        CMD_GET_TIME,
+        command_string: ''
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 8
+          decode_time(seconds: BinData::Uint32le.read(data[8..-1]).snapshot)
+        else
+          puts 'ERROR: Invalid time response'
+        end
+      end
+    end
+
+    # Set current time for attendance machine
+    def set_time(time = Time.now)
+      seconds        = encode_time(time: time)
+      command_buffer = StringIO.new
+      binary_writer  = BinData::Uint32le.new
+
+      # Write command string
+      binary_writer.value = seconds
+      command_buffer.pos  = 0
+      binary_writer.write(command_buffer)
+      command_string = command_buffer.string
+
+      execute_cmd(
+        command:        CMD_SET_TIME,
+        command_string: command_string
+      ) do |opts|
+        return puts "ERROR: #{options[:error]}" unless opts[:valid]
+
+        data = opts[:data]
+        if data.length > 7
+          data.split("\u0000").pop
+        else
+          puts 'ERROR: Invalid time response'
+        end
+      end
+    end
+  end
+end