hik_ISAPI 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c238cc614d5f6b9b3c124405d90096f0b33f5cb00401a3f291bebd6151c293a8
+  data.tar.gz: 0c404fce16b367a021c1a1e6e732bf4899b3b6d06a4320192a3d73e2d0e72cb1
+SHA512:
+  metadata.gz: 3e97136d972327a68d62570162938d8eb66339d9357851124fff6a46662c635970809b1662cea396c923f62b29cf67b3262f0a2abd42cab9ecc5e25b6c3e2284
+  data.tar.gz: d3ed39978f2906cfbe3f96806fdb853e86feec7b3dc4b04f979c4fa2277446182fd9e6a79ec4a5f97512aaa093386cbb6a95c9456876e3e1c9f7ec6cbc8e714e

data/exe/hikvision

@@ -0,0 +1,238 @@
+#!/usr/bin/env ruby
+
+require 'hikvision'
+require 'gli'
+
+class Numeric
+  def duration
+    secs  = to_i
+    mins  = secs / 60
+    hours = mins / 60
+    days  = hours / 24
+
+    "#{days} days #{hours % 24} hours #{mins % 60} minutes #{secs % 60} seconds"
+  end
+end
+
+class App
+  extend GLI::App
+
+  def self.print_kv(key, value, opts)
+    puts "#{opts[:'with-keys'] ? key.to_s + ': ' : ''}#{value}" if opts[key]
+  end
+
+  def self.set_if_in_opts(obj, setter, val, opts)
+    return if val.nil?
+
+    if opts.include? val
+      obj.send(setter, val)
+    else
+      exit_now! "\"#{val}\" is invalid, choose from: #{opts.join(', ')}", 1
+    end
+  end
+
+  flag %i[h host], required: true
+  flag %i[u user], required: true
+  flag %i[p password], required: true
+
+  version Hikvision::VERSION
+
+  pre do |gopts, _opts, _args|
+    @dev = Hikvision::ISAPI.new(gopts[:h], gopts[:u], gopts[:p])
+    exit_now! 'could not authenticate' if @dev.put('/ISAPI/Security/sessionHeartbeat').response.code == '401'
+    1
+  end
+
+  command :uptime do |c|
+    c.action do
+      puts @dev.system.uptime.duration
+    end
+  end
+
+  command :date do |c|
+    c.flag :strftime, default_value: '%c'
+    c.action do |_gopts, opts, _args|
+      puts @dev.system.time.now.strftime opts[:strftime].to_s
+    end
+  end
+
+  desc 'Configurate time settings'
+  command :time do |c|
+    c.flag :"set-ntp", arg_name: 'host'
+    c.flag :"set-ntp-port", type: Integer, arg_name: 'port'
+    c.flag :"set-mode", must_match: %w[manual ntp], arg_name: 'ntp,manual'
+    c.switch :ntp, negatable: false
+    c.switch :"ntp-port", negatable: false
+    c.switch :mode, negatable: false
+
+    c.action do |_gopts, opts, _args|
+      ntp_edited = false
+      %i[set-ntp set-ntp-port].each do |key|
+        if opts[key]
+          ntp_edited = true
+          break
+        end
+      end
+
+      time =@dev.system.time
+      ntp = time.ntp
+
+      print_kv :ntp, ntp.host, opts
+      print_kv :"ntp-port", ntp.port, opts
+
+      ntp.host = opts[:"set-ntp"] if opts[:"set-ntp"]
+      ntp.port = opts[:"set-ntp-port"] if opts[:"set-ntp-port"]
+
+      ntp.update if ntp_edited
+
+      edited = false
+      [:"set-mode"].each do |key|
+        if opts[key]
+          edited = true
+          break
+        end
+      end
+
+      print_kv :mode, time.mode.to_s.downcase, opts
+
+      time.mode = opts[:"set-mode"] == 'ntp' ? :NTP : :manual if opts[:"set-mode"]
+
+      time.update if edited
+
+      if ntp_edited and time.mode == :manual
+        puts 'ntp settings altered but the device time mode is set to manual. please run with "--set-mode ntp" to set the time mode to ntp'
+      end
+    end
+  end
+
+  command :model do |c|
+    c.action do
+      puts @dev.system.model
+    end
+  end
+
+  command :serial do |c|
+    c.action do
+      puts @dev.system.serial
+    end
+  end
+
+  desc 'Shows the device id'
+  command :id do |c|
+    c.action do
+      puts @dev.system.id
+    end
+  end
+
+  desc 'Shows the device description'
+  command :desc do |c|
+    c.action do
+      puts @dev.system.description
+    end
+  end
+
+  command :mac do |c|
+    c.action do
+      puts @dev.system.mac_address
+    end
+  end
+
+  command :reboot do |c|
+    c.action do
+      @dev.system.reboot
+    end
+  end
+
+  desc 'List available channels'
+  command :channels do |c|
+    c.action do
+      puts @dev.streaming.channels.collect { |ch| ch.id }
+    end
+  end
+
+  desc 'Dumps device diagnosed data'
+  command :dumpdata do |c|
+    c.action do
+      puts @dev.system.diagnosed_data
+    end
+  end
+
+  command :channel do |c|
+    c.flag :'save-picture', arg_name: 'file', desc: 'saves picture to file'
+    c.flag :'set-video-codec', desc: 'sets channel video codec'
+    c.switch :'video-codec', negatable: false, desc: 'prints channel video codec'
+    c.flag :'set-audio-codec', desc: 'sets channel audio codec'
+    c.switch :'audio-codec', negatable: false, desc: 'prints channel audio codec'
+    c.switch :'disable-audio', negatable: false, desc: 'disables channel audio'
+    c.switch :'enable-audio', negatable: false, desc: 'enabled channel audio'
+    c.switch :'video-resolution', negatable: false, desc: 'prints channel video resolution'
+    c.switch :'video-framerate', negatable: false, desc: 'prints channel video framerate'
+    c.switch :'video-keyframe-interval', negatable: false, desc: 'prints channel keyframe interval'
+    c.switch :'video-cbr', negatable: false, desc: 'prints channel video constant bitrate value'
+    c.switch :'video-bitrate-type', negatable: false, desc: 'prints channel video bitrate type'
+    c.switch :'video-scan-type', negatable: false, desc: 'prints channel video scan type'
+    c.switch :'video-enabled', negatable: false, desc: 'prints if channel video is enabled'
+    c.switch :'audio-enabled', negatable: false, desc: 'prints if channel audio is enabled'
+    c.switch :enabled, negatable: false, desc: 'prints if channel is enabled'
+    c.switch :name, negatable: false, desc: 'prints channel name'
+    c.flag :'set-name', desc: 'sets channel name'
+    c.switch :all, negatable: false, desc: 'prints all possible information'
+    c.switch :'with-keys', negatable: false, desc: 'prints values with keys'
+
+    c.action do |_gopts, opts, args|
+      exit_now! "missing id\nusage: channel <id> [opts]", 1 if args.length != 1
+      id = args[0]
+      exit_now! 'channel id must be an integer', 1 if id.to_i.to_s != id
+      id = id.to_i
+      ch = @dev.streaming.channel(id)
+      exit_now! "channel id doesn't exists", 1 if ch.nil?
+
+      set_opts = %i[set-name set-video-codec set-audio-codec disable-audio enable-audio]
+
+      if opts[:all]
+        opts.each do |key|
+          next if (%w[with-keys save-picture] + set_opts.map { |o| o.to_s }).include? key[0].to_s
+
+          opts[key[0]] = true
+        end
+      end
+
+      if opts[:'save-picture']
+        file = File.open(opts[:'save-picture'], 'w+b')
+        file.write(ch.picture)
+        file.close
+      end
+
+      print_kv :name, ch.name, opts
+      print_kv :enabled, ch.enabled?, opts
+      print_kv :'video-enabled', ch.video_enabled?, opts
+      print_kv :'video-codec', ch.video_codec, opts
+      print_kv :'video-framerate', ch.video_framerate, opts
+      print_kv :'video-resolution', ch.video_resolution.collect { |r| r.to_s }.join('x'), opts
+      print_kv :'video-keyframe-interval', ch.video_keyframe_interval, opts
+      print_kv :'video-bitrate-type', ch.video_bitrate_type, opts
+      print_kv :'video-cbr', ch.video_cbitrate, opts
+      print_kv :'video-scan-type', ch.video_scan_type, opts
+      print_kv :'audio-enabled', ch.audio_enabled?, opts
+      print_kv :'audio-codec', ch.audio_codec, opts
+
+      edited = false
+      set_opts.each do |k|
+        next unless opts[k]
+
+        edited = true
+        break
+      end
+
+      ch.name = opts[:'set-name'] if opts[:'set-name']
+      set_if_in_opts(ch, :video_codec=, opts[:'set-video-codec'], ch.video_codec_opts)
+      set_if_in_opts(ch, :audio_codec=, opts[:'set-audio-codec'], ch.audio_codec_opts)
+      set_if_in_opts(ch, :audio_enabled=, false, [false]) if opts[:'disable-audio']
+      set_if_in_opts(ch, :audio_enabled=, true, [true]) if opts[:'enable-audio']
+
+      ch.update if edited
+    end
+  end
+end
+
+exit App.run(ARGV)

data/lib/hikvision/base.rb

@@ -0,0 +1,82 @@
+module Hikvision
+  class Base
+    class << self
+      private
+
+      def add_xml(method, url_path)
+        iv = :"@#{method}_xml"
+        load_method = :"load_#{method}"
+        define_method load_method do |options = {}|
+          return instance_variable_get(iv) if options.fetch(:cache, true) && instance_variable_defined?(iv)
+
+          url = url_path.respond_to?(:call) ? instance_exec(&url_path) : url_path
+          instance_variable_set(iv, @isapi.get_xml(url, options))
+        end
+
+        reload_method = method == :base ? :reload : :"reload_#{method}"
+        define_method reload_method do |options = {}|
+          send(load_method, options.merge(cache: false))
+        end
+      end
+
+      def add_getter(method, xml_method, path, opts = { cache: true }, &block)
+        define_method method do
+          v = send(:"load_#{xml_method}", opts).at_xpath(path).inner_html
+          v = block.call(v) if block
+          v
+        end
+      end
+
+      def add_list_getter(method, xml_method, path, opts = { cache: true }, &block)
+        define_method method do
+          send(:"load_#{xml_method}", opts).xpath(path).map do |v|
+            v = v.inner_html
+            v = block.call(v) if block
+            v
+          end
+        end
+      end
+
+      def add_opt_getter(method, xml_method, path, transform = nil, &block)
+        define_method method do
+          send(:"load_#{xml_method}", cache: true).at_xpath(path)[:opt].split(',').map do |v|
+            v = v.send(transform) if transform
+            v = block.call(v) if block
+            v
+          end
+        end
+      end
+
+      def add_opt_range_getter(method, xml_method, path)
+        define_method method do
+          data = send(:"load_#{xml_method}", cache: true).at_xpath(path)
+          data[:min].to_i..data[:max].to_i
+        end
+      end
+
+      def add_bool_getter(method, xml_method, path)
+        add_getter(method, xml_method, path) { |v| v == 'true' }
+      end
+
+      def add_setter(method, xml_method, path, *types, &block)
+        update_method = xml_method == :base ? :update : :"update_#{xml_method}"
+
+        if not respond_to? update_method
+          define_method update_method do |options = {}|
+            send(:"before_#{update_method}") if respond_to? :"before_#{update_method}"
+
+            options[:body] = instance_variable_get(:"@#{xml_method}_xml").to_s
+            @isapi.put_xml(respond_to?(:url) ? send(:url) : self.class.url, options)
+          end
+        end
+
+        define_method method do |value|
+          raise TypeError, "#{method}#{value} (#{value.class}) must be of type #{types}" unless types.any? { |k| value.is_a?(k) }
+
+          value = block.call(value) if block
+          send(:"load_#{xml_method}", cache: true).at_xpath(path).inner_html = value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/hikvision/isapi.rb

@@ -0,0 +1,93 @@
+require 'httparty'
+require 'nokogiri'
+
+module Hikvision
+  class ResponseError < RuntimeError
+    def initialize(xml)
+      @xml = xml
+      super(status_string)
+    end
+
+    def status_code
+      @xml.at_xpath('ResponseStatus/statusCode').inner_html.to_i
+    end
+
+    def status_string
+      @xml.at_xpath('ResponseStatus/statusString').inner_html
+    end
+
+    def sub_status_code
+      @xml.at_xpath('ResponseStatus/subStatusCode').inner_html
+    end
+  end
+
+  class ISAPI
+    include HTTParty
+
+    attr_accessor :cache
+    attr_reader :streaming, :system
+
+    def initialize(ip, username, password, args = { auth_type: 'digest_auth', https: false })
+      @cache = {}
+      @auth_type = args[:auth_type]
+      @base_uri = "http#{args[:https] ? 's' : ''}://#{ip}"
+      @auth = { username: username, password: password }
+      @streaming = Hikvision::Streaming.new(self)
+      @system = Hikvision::System.new(self)
+    end
+
+    def get(path, options = {})
+      options = default_request_options.merge(options)
+      if @cache.has_key?(path) and options.fetch(:cache, true)
+        @cache[path]
+      else
+        @cache[path] = self.class.get(@base_uri + path, options)
+      end
+    end
+
+    def get_original(path, options = {})
+      options = default_request_options.merge(options)
+      if @cache.has_key?(path) and options.fetch(:cache, true)
+        @cache[path]
+      else
+        @cache[path] = self.class.get(path, options)
+      end
+    end
+
+    def get_xml(path, options = {})
+      data = get(path, options)
+      raise "could not get xml of #{path} code:#{data.response.code}" unless ['200'].include?(data.response.code)
+
+      Nokogiri::XML(data.body).remove_namespaces!
+    end
+
+    def put(path, options = {})
+      @cache.delete(path)
+      options = default_request_options.merge(options)
+      self.class.put(@base_uri + path, options)
+    end
+
+    def post(path, options = {})
+      @cache.delete(path)
+      options = default_request_options.merge(options)
+      self.class.post(@base_uri + path, options)
+    end
+
+    def put_xml(path, options = {})
+      data = put(path, options)
+
+      return true if data.response.code == '200'
+
+      xml = Nokogiri::XML(data.body).remove_namespaces!
+      raise ResponseError, xml
+    end
+
+    private
+
+    def default_request_options
+      {
+        "#{@auth_type}": @auth
+      }
+    end
+  end
+end

data/lib/hikvision/streaming/channel.rb

@@ -0,0 +1,111 @@
+module Hikvision
+  class Streaming
+    class Channel < Hikvision::Base
+      def initialize(isapi, xml)
+        @isapi = isapi
+        @base_xml = xml
+      end
+
+      add_xml(:base, -> { url })
+      add_xml(:capabilities, -> { "#{url}/capabilities" })
+
+      add_getter(:id, :base, '//id', &:to_i)
+
+      add_getter(:name, :base, '//channelName')
+      add_setter(:name=, :base, '//channelName', String)
+      add_opt_range_getter(:name_length_opts, :capabilities, '//channelName')
+
+      add_getter(:max_packet_size, :base, '//Transport/maxPacketSize', &:to_i)
+
+      add_getter(:auth_type, :base, '//Transport/Security/certificateType')
+      add_setter(:auth_type=, :base, '//Transport/Security/certificateType', String)
+      add_opt_getter(:auth_type_opts, :capabilities, '//Transport/Security/certificateType', :to_s)
+
+      add_getter(:video_framerate, :base, '//Video/maxFrameRate') { |v| v.to_f / 100 }
+      add_setter(:video_framerate=, :base, '//Video/maxFrameRate', Numeric) { |v| (v * 100).to_i }
+      add_opt_getter(:video_framerate_opts, :capabilities, '//Video/maxFrameRate', :to_f) { |v| v / 100 }
+
+      add_getter(:video_width, :base, '//videoResolutionWidth', &:to_i)
+      add_setter(:video_width=, :base, '//videoResolutionWidth', Integer)
+      add_opt_getter(:video_width_opts, :capabilities, '//videoResolutionWidth', :to_i)
+
+      add_getter(:video_height, :base, '//videoResolutionHeight', &:to_i)
+      add_setter(:video_height=, :base, '//videoResolutionHeight', Integer)
+      add_opt_getter(:video_height_opts, :capabilities, '//videoResolutionHeight', :to_i)
+
+      add_getter(:video_cbitrate, :base, '//Video/constantBitRate', &:to_i)
+      add_setter(:video_cbitrate=, :base, '//Video/constantBitRate', Integer)
+      add_opt_range_getter(:video_cbitrate_opts, :capabilities, '//Video/constantBitRate')
+
+      add_getter(:video_vbitrate_upper_cap, :base, '//Video/vbrUpperCap', &:to_i)
+      add_setter(:video_vbitrate_upper_cap=, :base, '//Video/vbrUpperCap', Integer)
+      add_opt_range_getter(:video_vbitrate_upper_cap_opts, :capabilities, '//Video/vbrUpperCap')
+
+      add_getter(:video_keyframe_interval, :base, '//Video/keyFrameInterval') { |v| v.to_i / 1000 }
+      add_setter(:video_keyframe_interval=, :base, '//Video/keyFrameInterval', Numeric) { |v| (v * 1000).to_i }
+      add_opt_range_getter(:video_keyframe_interval_opts, :capabilities, '//Video/keyFrameInterval')
+
+      add_getter(:video_codec, :base, '//videoCodecType')
+      add_setter(:video_codec=, :base, '//videoCodecType', String)
+      add_opt_getter(:video_codec_opts, :capabilities, '//videoCodecType', :to_s)
+
+      add_getter(:video_bitrate_type, :base, '//videoQualityControlType')
+      add_setter(:video_bitrate_type=, :base, '//videoQualityControlType', String)
+      add_opt_getter(:video_bitrate_type_opts, :capabilities, '//videoQualityControlType', :to_s)
+
+      add_getter(:video_scan_type, :base, '//videoScanType')
+      add_setter(:video_scan_type=, :base, '//videoScanType', String)
+      add_opt_getter(:video_scan_type_opts, :capabilities, '//videoScanType', :to_s)
+
+      add_getter(:snapshot_image_type, :base, '//snapShotImageType')
+      add_setter(:snapshot_image_type=, :base, '//snapShotImageType', String)
+      add_opt_getter(:snapshot_image_type_opts, :capabilities, '//snapShotImageType', :to_s)
+
+      add_getter(:audio_codec, :base, '//audioCompressionType')
+      add_setter(:audio_codec=, :base, '//audioCompressionType', String)
+      add_opt_getter(:audio_codec_opts, :capabilities, '//audioCompressionType', :to_s)
+
+      add_getter(:video_smoothing, :base, '//Video/smoothing', &:to_i)
+      add_opt_range_getter(:video_smoothing_opts, :capabilities, '//Video/smoothing')
+
+      add_bool_getter(:audio_enabled?, :base, '//Audio/enabled')
+      add_setter(:audio_enabled=, :base, '//Audio/enabled', TrueClass, FalseClass)
+
+      add_bool_getter(:svc_enabled?, :base, '//Video/SVC/enabled')
+      add_setter(:svc_enabled=, :base, '//Video/SVC/enabled', TrueClass, FalseClass)
+
+      add_bool_getter(:enabled?, :base, '/StreamingChannel/enabled')
+      add_bool_getter(:video_enabled?, :base, '//Video/enabled')
+      add_bool_getter(:multicast_enabled?, :base, '//Transport/Multicast/enabled')
+      add_bool_getter(:unicast_enabled?, :base, '//Transport/Unicast/enabled')
+      add_bool_getter(:security_enabled?, :base, '//Transport/Security/enabled')
+
+      def video_resolution
+        [video_width, video_height]
+      end
+
+      def video_resolution=(value)
+        video_width = value[0]
+        video_height = value[1]
+      end
+
+      def video_resolution_opts
+        video_width_opts.zip(video_height_opts)
+      end
+
+      def picture(options = { cache: false })
+        @isapi.get("#{url}/picture", options).response.body
+      end
+
+      def url
+        "/ISAPI/Streaming/channels/#{id}"
+      end
+
+      private
+
+      def before_update
+        @isapi.cache.delete('/ISAPI/Streaming/channels')
+      end
+    end
+  end
+end

data/lib/hikvision/streaming.rb

@@ -0,0 +1,27 @@
+module Hikvision
+  class Streaming
+    def initialize(isapi)
+      @isapi = isapi
+    end
+
+    def channels
+      load_channels.values
+    end
+
+    def channel(id)
+      load_channels[id]
+    end
+
+    def load_channels(options = {})
+      return @channels if options.fetch(:cache, true) && instance_variable_defined?(:@channels)
+
+      @channels = {}
+      xml = @isapi.get_xml('/ISAPI/Streaming/channels', options)
+      xml.xpath('StreamingChannelList/StreamingChannel').each do |c|
+        channel = Channel.new(@isapi, Nokogiri::XML(c.to_s))
+        @channels[channel.id] = channel
+      end
+      @channels
+    end
+  end
+end

data/lib/hikvision/system/acs_event.rb

@@ -0,0 +1,15 @@
+module Hikvision
+  class System
+    def get_event(options = { cache: false })
+      @isapi.post('/ISAPI/AccessControl/AcsEvent?format=json', options).response.body
+    end
+
+    # 保存刷脸照片
+    def get_event_photo(url, file_path, options = { cache: false })
+      file_content = @isapi.get_original(url, options).response.body
+      File.open(file_path, 'wb') do |f|
+        f.write(file_content)
+      end
+    end
+  end
+end

data/lib/hikvision/system/device_info.rb

@@ -0,0 +1,21 @@
+module Hikvision
+  class System
+    add_xml(:device_info, '/ISAPI/System/deviceInfo')
+
+    add_getter(:name, :device_info, '//deviceName')
+    add_getter(:id, :device_info, '//deviceID')
+    add_getter(:description, :device_info, '//deviceDescription')
+    add_getter(:location, :device_info, '//deviceLocation')
+    add_getter(:model, :device_info, '//model')
+    add_getter(:serial, :device_info, '//serialNumber')
+    add_getter(:mac_address, :device_info, '//macAddress')
+    add_getter(:firmware_version, :device_info, '//firmwareVersion')
+    add_getter(:encoder_version, :device_info, '//encoderVersion')
+    add_getter(:boot_version, :device_info, '//bootVersion')
+    add_getter(:hardware_version, :device_info, '//hardwareVersion')
+    add_getter(:type, :device_info, '//deviceType')
+
+    add_bool_getter(:support_beep?, :device_info, '/DeviceInfo/supportBeep')
+    add_bool_getter(:support_video_loss?, :device_info, '/DeviceInfo/supportVideoLoss')
+  end
+end

data/lib/hikvision/system/diagnosed_data.rb

@@ -0,0 +1,7 @@
+module Hikvision
+  class System
+    def diagnosed_data(options = { cache: false })
+      @isapi.get('/ISAPI/System/diagnosedData', options).response.body
+    end
+  end
+end

data/lib/hikvision/system/face.rb

@@ -0,0 +1,7 @@
+module Hikvision
+  class System
+    def add_face(options = { cache: false })
+      @isapi.post('/ISAPI/Intelligent/FDLib/FaceDataRecord?format=json', options).response.body
+    end
+  end
+end

data/lib/hikvision/system/network/integration.rb

@@ -0,0 +1,26 @@
+module Hikvision
+  class Network
+    class Integration < Hikvision::Base
+      class << self
+        def url
+          "/ISAPI/System/Network/Integrate"
+        end
+      end
+
+      def initialize(isapi)
+        @isapi = isapi
+      end
+
+      add_xml(:base, url)
+
+      add_setter(:cgi=, :base, '//CGI/enable', TrueClass, FalseClass)
+
+      add_getter(:cgi_authentication, :base, '//CGI/certificateType') { |v| v.include?("basic") ? :basic : :digest }
+      add_setter(:cgi_authentication=, :base, '//CGI/certificateType', Symbol) { |v| v == :basic ? "digest/basic" : v.to_s }
+
+      add_bool_getter(:cgi?, :base, '//CGI/enable')
+      add_bool_getter(:onvif?, :base, '//ONVIF/enable')
+      add_bool_getter(:isapi?, :base, '//ISAPI/enable')
+    end
+  end
+end

data/lib/hikvision/system/network.rb

@@ -0,0 +1,11 @@
+module Hikvision
+  class Network < Hikvision::Base
+    attr_reader :integration
+
+    def initialize(isapi)
+      @isapi = isapi
+      @integration = Integration.new(isapi)
+    end
+  end
+end
+  

data/lib/hikvision/system/person.rb

@@ -0,0 +1,11 @@
+module Hikvision
+  class System
+    def add_person(options = { cache: false })
+      @isapi.post('/ISAPI/AccessControl/UserInfo/Record?format=json', options).response.body
+    end
+
+    def delete_person(options = { cache: false })
+      @isapi.put('/ISAPI/AccessControl/UserInfo/Delete?format=json', options).response.body
+    end
+  end
+end

data/lib/hikvision/system/reboot.rb

@@ -0,0 +1,7 @@
+module Hikvision
+  class System
+    def reboot
+      @isapi.put('/ISAPI/System/reboot')
+    end
+  end
+end

data/lib/hikvision/system/status.rb

@@ -0,0 +1,13 @@
+module Hikvision
+  class System
+    add_xml(:status, '/ISAPI/System/status')
+
+    add_getter(:uptime, :status, '//deviceUpTime', { cache: false }, &:to_i)
+
+    add_list_getter(:memory_usage, :status, '//memoryUsage', { cache: false }, &:to_i)
+    add_list_getter(:memory_available, :status, '//memoryAvailable', { cache: false }, &:to_i)
+    add_list_getter(:memory_description, :status, '//memoryDescription')
+    add_list_getter(:cpu_utilization, :status, '//cpuUtilization', { cache: false }, &:to_i)
+    add_list_getter(:cpu_description, :status, '//cpuDescription')
+  end
+end

data/lib/hikvision/system/time/ntp.rb

@@ -0,0 +1,28 @@
+module Hikvision
+  class System
+    class Time
+      class Ntp < Hikvision::Base
+        class << self
+          def url
+            '/ISAPI/System/time/ntpServers'
+          end
+        end
+
+        def initialize(isapi)
+          @isapi = isapi
+        end
+
+        add_xml(:base, url)
+
+        add_getter(:host, :base, '//hostName')
+        add_setter(:host=, :base, '//hostName', String)
+        
+        add_getter(:sync_interval, :base, '//synchronizeInterval', &:to_i)
+        add_setter(:sync_interval=, :base, '//synchronizeInterval', Integer)
+
+        add_getter(:port, :base, '//portNo', &:to_i)
+        add_setter(:port=, :base, '//portNo', Integer)
+      end
+    end
+  end
+end

data/lib/hikvision/system/time.rb

@@ -0,0 +1,31 @@
+require 'time'
+
+module Hikvision
+  class System
+    class Time < Hikvision::Base
+      attr_reader :ntp
+
+      class << self
+        def url
+          '/ISAPI/System/time'
+        end
+      end
+
+      def initialize(isapi)
+        @isapi = isapi
+        @ntp = Ntp.new(isapi)
+      end
+
+      add_xml(:base, url)
+
+      add_getter(:mode, :base, '//timeMode', &:to_sym)
+      add_setter(:mode=, :base, '//timeMode', Symbol, String)
+
+      add_getter(:now, :base, '//localTime', cache: false) { |v| Object::Time.strptime(v, '%Y-%m-%dT%H:%M:%S%Z') }
+      add_setter(:now=, :base, '//localTime', Object::Time) { |v| v.strftime('%Y-%m-%dT%H:%M:%S%Z') }
+
+      add_getter(:zone, :base, '//timeZone')
+      add_setter(:zone=, :base, '//timeZone', String)
+    end
+  end
+end

data/lib/hikvision/system.rb

@@ -0,0 +1,11 @@
+module Hikvision
+  class System < Hikvision::Base
+    attr_reader :network, :time
+
+    def initialize(isapi)
+      @isapi = isapi
+      @network = Network.new(isapi)
+      @time = Time.new(isapi)
+    end
+  end
+end

data/lib/hikvision/version.rb

@@ -0,0 +1,3 @@
+module Hikvision
+  VERSION = '0.0.1'
+end

data/lib/hikvision.rb

@@ -0,0 +1,17 @@
+require_relative 'hikvision/version'
+require_relative 'hikvision/base'
+require_relative 'hikvision/isapi'
+require_relative 'hikvision/streaming'
+require_relative 'hikvision/streaming/channel'
+require_relative 'hikvision/system'
+require_relative 'hikvision/system/time'
+require_relative 'hikvision/system/time/ntp'
+require_relative 'hikvision/system/device_info'
+require_relative 'hikvision/system/network'
+require_relative 'hikvision/system/network/integration'
+require_relative 'hikvision/system/reboot'
+require_relative 'hikvision/system/diagnosed_data'
+require_relative 'hikvision/system/status'
+require_relative 'hikvision/system/acs_event'
+require_relative 'hikvision/system/face'
+require_relative 'hikvision/system/person'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: hik_ISAPI
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- guopipi
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.21'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+description:
+email:
+executables:
+- hikvision
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/hikvision
+- lib/hikvision.rb
+- lib/hikvision/base.rb
+- lib/hikvision/isapi.rb
+- lib/hikvision/streaming.rb
+- lib/hikvision/streaming/channel.rb
+- lib/hikvision/system.rb
+- lib/hikvision/system/acs_event.rb
+- lib/hikvision/system/device_info.rb
+- lib/hikvision/system/diagnosed_data.rb
+- lib/hikvision/system/face.rb
+- lib/hikvision/system/network.rb
+- lib/hikvision/system/network/integration.rb
+- lib/hikvision/system/person.rb
+- lib/hikvision/system/reboot.rb
+- lib/hikvision/system/status.rb
+- lib/hikvision/system/time.rb
+- lib/hikvision/system/time/ntp.rb
+- lib/hikvision/version.rb
+homepage: https://github.com/guojhq/hik_ISAPI.git
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Ruby Hikvision ISAPI Interface
+test_files: []