atrea_control 1.2.1 → 2.0.0

data/lib/atrea_control/duplex/unit.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module AtreaControl
+  module Duplex
+    # Communication with RD5 unit (read/write)
+    class Unit
+      include AtreaControl::Logger
+
+      attr_reader :current_mode, :current_power, :outdoor_temperature
+      # @return [DateTime] store time of last update
+      attr_reader :valid_for
+      # @return [UserCtrl]
+      attr_reader :user_ctrl
+
+      # @param [String, Integer] user_id
+      # @param [String, Integer] unit_id
+      # @param [String, Integer] sid
+      # @param [AtreaControl::Duplex::UserCtrl] user_ctrl
+      def initialize(user_id:, unit_id:, sid:, user_ctrl: nil)
+        @user_id = user_id
+        @unit_id = unit_id
+        @sid = sid
+        @user_ctrl = user_ctrl || UserCtrl.new(user_id: user_id, unit_id: unit_id, sid: sid)
+      end
+
+      def name
+        @user_ctrl.name
+      end
+
+      def mode
+        current_mode || values[:current_mode]
+      end
+
+      def power
+        current_power || values[:current_power]
+      end
+
+      # @param [String] value 0 - power-off; 1 - automat
+      def mode=(value)
+        v = parser.input(@user_ctrl.sensors["mode_input"], value.to_s)
+        write(v)
+      end
+
+      def power=(value)
+        v = [parser.input(@user_ctrl.sensors["power_input"], value.to_s)]
+        v << parser.input(@user_ctrl.sensors["mode_switch"], "2")
+        write(v)
+      end
+
+      def values
+        parser.values(read.body).each do |name, value|
+          instance_variable_set :"@#{name}", value
+        end
+        as_json
+      end
+
+      def as_json(_options = nil)
+        {
+          current_mode: current_mode,
+          current_power: current_power,
+          outdoor_temperature: outdoor_temperature,
+          valid_for: valid_for,
+        }
+      end
+
+      def to_json(*args)
+        values.to_json(*args)
+      end
+
+      private
+
+      def parser
+        @parser ||= ::AtreaControl::SensorParser.new(@user_ctrl)
+      end
+
+      # Request to RD5
+      def request
+        @request ||= Request.new(user_id: @user_id, unit_id: @unit_id, sid: @sid)
+      end
+
+      def read
+        request.call(_t: "config/xml.xml")
+      end
+
+      # @param [Array<String>] values in format SENSOR0000VALUE
+      def write(*values)
+        inputs = values.to_h { |i| [i, nil] }
+        logger.debug("set RD5 #{inputs.keys}")
+        request.call({ _t: "config/xml.cgi", _w: 1 }.merge(inputs))
+      end
+    end
+  end
+end

data/lib/atrea_control/duplex/user_ctrl.rb

@@ -0,0 +1,138 @@
+require "nokogiri"
+
+module AtreaControl
+  module Duplex
+    # Parse `userCtrl.xml`
+    class UserCtrl
+      # @param (see #initialize)
+      def self.data(user_id:, unit_id:, sid:)
+        user_ctrl = new(user_id: user_id, unit_id: unit_id, sid: sid)
+        {
+          name: user_ctrl.name,
+          sensors: user_ctrl.sensors,
+          modes: user_ctrl.modes,
+          user_modes: user_ctrl.user_modes,
+        }
+      end
+
+      # @param [String, Integer] user_id
+      # @param [String, Integer] unit_id
+      # @param [String, Integer] sid
+      def initialize(user_id:, unit_id:, sid:)
+        @user_id = user_id
+        @unit_id = unit_id
+        @sid = sid
+      end
+
+      # Request to RD5
+      def request
+        @request ||= Request.new(user_id: @user_id, unit_id: @unit_id, sid: @sid)
+      end
+
+      # Get and parse XML with user/unit configuration source
+      def user_ctrl
+        response = request.call(_t: "lang/userCtrl.xml")
+        Nokogiri::XML response.body
+      end
+
+      # User-defined name of home (RD5 unit)
+      # @return [String]
+      def name
+        @name ||= user_texts["UnitName"]
+      end
+
+      # Gather ID of sensors based on userCtrl config file
+      def sensors
+        return @sensors if @sensors
+
+        power = user_ctrl.xpath("//body/content/i[@title='$currentPower']")
+        mode = user_ctrl.xpath("//body/content/i[@title='$currentMode']")
+        outdoor_temp = user_ctrl.xpath("//body/content/i[@title='$outdoorTemp']")
+
+        switch_mode = mode.xpath("displayval").text[/values\.(\w+)/, 1]
+
+        power_input = power.xpath("onchange").text[/getUrlPar\('(\w+)',val\)/, 1]
+        m = mode.xpath("onchange").text.match(/getUrlPar\('(\w+)',val\).*getUrlPar\(.(\w+).,2\)/)
+
+        @sensors = {
+          "outdoor_temperature" => outdoor_temp.attribute("id").value, # "I10208"
+          "current_power" => power.attribute("id").value, # "H10704"
+          "current_mode" => mode.attribute("id").value, # "H10705"
+          "current_mode_switch" => switch_mode, # "H10712"
+          "power_input" => power_input, # "H10708"
+          "mode_input" => m[1], # "H10709"
+          "mode_switch" => m[2], # "H10701"
+        }
+      end
+
+      # Generic modes
+      # @return [Hash]
+      def modes
+        return @modes if @modes
+
+        @modes = {}
+        user_ctrl.xpath("//op[@id='Mode']/i").each do |mode|
+          m = translate_mode(mode)
+          @modes[m[:id]] = m[:value]
+        end
+        @modes
+      end
+
+      # Modes by inputs - switches - named by user custom texts
+      # @return [Hash]
+      def user_modes
+        return @user_modes if @user_modes
+
+        @user_modes = {}
+        user_ctrl.xpath("//op[@id='ModeText']/i").each do |mode|
+          m = translate_mode(mode)
+          @user_modes[m[:id]] = m[:value]
+        end
+        @user_modes
+      end
+
+      private
+
+      # User defined texts in RD5 unit
+      # @return [Hash]
+      def user_texts
+        return @user_texts if @user_texts
+
+        response = request.call(_t: "config/texts.xml")
+        xml = Nokogiri::XML response.body
+        @user_texts = xml.xpath("//i").to_h do |node|
+          value = node.attributes["value"].value
+          id = node.attributes["id"].value
+          [id, value.gsub(/%u([\dA-Z]{4})/) { |i| +"" << i[Regexp.last_match(1)].to_i(16) }]
+        end
+      end
+
+      # @param [Nokogiri::XML::Element] mode
+      # @return [Hash{Symbol->String}]
+      def translate_mode(mode)
+        id = mode.attributes["id"].value
+        title = mode.attributes["title"].value
+        title = if title.start_with?("$")
+                  I18n.t(title[/\w+/])
+                else
+                  user_texts[title]
+                end
+        { id: id, value: title }
+      end
+
+      # Re-generate copy of locale files
+      # @note internal use only
+      def update_locales_files!
+        { cs: "0", de: "1", en: "2" }.each do |name, atrea_id|
+          response = request.call(_t: "lang/texts_#{atrea_id}.xml")
+
+          xml = Nokogiri::XML response.body
+          # `eval` JS object (= hash)
+          locale = eval xml.xpath("//words/text()")[0].text
+          yaml = { name.to_s => JSON.parse(locale.to_json) }.to_yaml
+          File.write(File.expand_path("../../../config/locales/#{name}.yml", __dir__), yaml)
+        end
+      end
+    end
+  end
+end

data/lib/atrea_control/duplex.rb

@@ -1,206 +1,15 @@
 # frozen_string_literal: true
 
-require "logger"
-require "nokogiri"
-require "rest-client"
-require "selenium-webdriver"
-
 module AtreaControl
   # Controller for +control.atrea.eu+
-  class Duplex
+  module Duplex
     CONTROL_URI = "https://control.atrea.eu/"
+    CONTROL_VERSION = "003001009"
 
-    attr_reader :current_mode, :current_power, :outdoor_temperature
-    # @return [DateTime] store time of last update
-    attr_reader :valid_for
-
-    # @param [String] login
-    # @param [String] password
-    # @param [Hash] sensors_map which box is related to sensor ID
-    # @option sensors_map [String] :outdoor_temperature
-    # @option sensors_map [String] :current_power
-    # @option sensors_map [String] :current_mode
-    def initialize(login:, password:, sensors_map: Config.default_sensors_map)
-      @login = login
-      @password = password
-      @sensors = sensors_map
-    end
-
-    # @return [Selenium::WebDriver::Firefox::Driver]
-    def driver
-      return @driver if defined?(@driver)
-
-      options = Selenium::WebDriver::Firefox::Options.new
-      options.headless! unless ENV["NO_HEADLESS"]
-      @driver ||= Selenium::WebDriver.for :firefox, options: options
-    end
-
-    def logged?
-      user&.[] "loged"
-    end
-
-    def login_in_progress?
-      @login_in_progress
-    end
-
-    # Login into control
-    def login
-      @login_in_progress = true
-      logger.debug "start new login"
-      driver.get CONTROL_URI
-      submit_login_form if user.nil? || !logged?
-      finish_login
-      @login_in_progress = false
-      inspect
-    end
-
-    # Submit given credentials and proceed login
-    def submit_login_form
-      form = driver.find_element(id: "loginFrm")
-      username = form.find_element(name: "username")
-      username.send_keys @login
-      password = form.find_element(name: "password")
-      password.send_keys @password
-
-      submit = form.find_element(css: "input[type=submit]")
-      submit.click
-    end
-
-    # Retrieve dashboard URI from object tag and open it again
-    def open_dashboard
-      uri = driver.find_element(tag_name: "object").attribute "data"
-      driver.get uri
-      logger.debug "#{name} login success"
-    end
-
-    # @return [String]
-    def name
-      return unless logged?
-
-      container = driver.find_element css: "div#pageTitle > h2"
-      container.text
-    end
-
-    # @return [String] ID of logged user
-    def user_id
-      @user_id ||= driver.execute_script("return window._user")
-    end
-
-    # @return [String] ID of recuperation unit
-    def unit_id
-      @unit_id ||= driver.execute_script("return window._unit")
-    end
-
-    # Window.user object from atrea
-    # @return [Hash, nil]
-    def user
-      driver.execute_script("return window.user")
-    end
-
-    # @return [String]
-    def current_mode_name
-      return current_mode unless logged?
-
-      element = sensor_element(@sensors[:current_mode])
-      element.find_element(css: "div:first-child").text
-    end
-
-    # quit selenium browser
-    def close
-      @user_auth = nil
-      driver.quit
-      remove_instance_variable :@driver
-    end
-
-    alias logout! close
-
-    def as_json(_options = nil)
-      {
-        logged: logged?,
-        current_mode: current_mode_name,
-        current_power: current_power,
-        outdoor_temperature: outdoor_temperature,
-        valid_for: valid_for,
-      }
-    end
-
-    alias values as_json
-
-    def to_json(*args)
-      as_json.to_json(*args)
-    end
-
-    def inspect
-      "<AtreaControl name: '#{name}' outdoor_temperature: '#{outdoor_temperature}°C' current_power: '#{current_power}%' current_mode: '#{current_mode_name}' valid_for: '#{valid_for}'>"
-    end
-
-    def call_unit!
-      return false if @login_in_progress
-
-      logger.debug "call_unit!"
-      parse_response(response_comm_unit)
-      @valid_for = Time.now
-      as_json
-    rescue RestClient::Forbidden
-      logger.debug "session expired..."
-      close if @logged
-      login && call_unit!
-    end
-
-    private
-
-    def parse_response(response)
-      xml = Nokogiri::XML response.body
-      sensors_values = @sensors.transform_values do |id|
-        xml.xpath("//O[@I=\"#{id}\"]/@V").last&.value
-      end
-      refresh_data(sensors_values)
-    end
-
-    # @param [Hash] values
-    # @return [Hash]
-    def refresh_data(values)
-      @outdoor_temperature = values[:outdoor_temperature].to_f / 10
-      @current_power = values[:current_power].to_f
-      @current_mode = mode_map[values[:current_mode]]
-
-      as_json
-    end
-
-    # ? I10204 ?
-    def mode_map
-      { "0" => "Vypnuto", "1" => "Automat", "2" => "Větrání", "6" => "Rozvážení" }
-    end
-
-    def logger
-      @logger ||= ::Logger.new($stdout)
-    end
-
-    def finish_login
-      13.times do |i|
-        return true if open_dashboard
-      rescue Selenium::WebDriver::Error::NoSuchElementError => _e
-        t = [3 * (1 + i), 25].min
-        logger.debug "waiting #{t}s for login..."
-        sleep t
-      end
-      raise Error, "unable to login"
-    end
-
-    def sensor_element(sensor_id)
-      driver.find_element id: "contentBox#{sensor_id}"
-    end
+    autoload :Login, "atrea_control/duplex/login"
+    autoload :Request, "atrea_control/duplex/request"
+    autoload :Unit, "atrea_control/duplex/unit"
+    autoload :UserCtrl, "atrea_control/duplex/user_ctrl"
 
-    # @return [RestClient::Response]
-    def response_comm_unit
-      params = {
-        _user: user_id,
-        _unit: unit_id,
-        auth: user&.[]("auth"),
-        _t: "config/xml.xml",
-      }
-      autologin_token = CGI.escape([@login, @password].join("\b"))
-      RestClient.get "https://control.atrea.eu/comm/sw/unit.php", { Cookie: "autoLogin=#{autologin_token}", params: params }
-    end
   end
 end

data/lib/atrea_control/logger.rb

@@ -0,0 +1,11 @@
+require "logger"
+
+module AtreaControl
+  module Logger
+
+    def logger
+      @logger ||= ::Logger.new($stdout)
+    end
+
+  end
+end

data/lib/atrea_control/sensor_parser.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module AtreaControl
+  # Call RD5 unit ang get current sensors values
+  #   parse it and return Hash
+  class SensorParser
+    # @param [AtreaControl::Duplex::UserCtrl] user_ctrl
+    def initialize(user_ctrl)
+      @user_ctrl = user_ctrl
+    end
+
+    def values(xml)
+      format_data(parse(xml))
+    end
+
+    def input(sensor, value)
+      sensor + value.to_s.rjust(5, "0")
+    end
+
+    # @see scripts.php -> loadRD5Values(node, init)
+    # @note
+    #   if(values[key]>32767) values[key]-=65536;
+    # 			if(params[key] && params[key].offset)
+    # 				values[key]=values[key]-params[key].offset;
+    # 			if(params[key] && params[key].coef)
+    # 				values[key]=values[key]/params[key].coef;
+    def parse(xml)
+      xml = Nokogiri::XML xml
+      @user_ctrl.sensors.transform_values do |id|
+        value = xml.xpath("//O[@I=\"#{id}\"]/@V").last&.value.to_i
+        value -= 65_536 if value > 32_767
+        # value -= 0 if "offset"
+        # value -= 0 if "coef"
+        value
+      end
+    end
+
+    # @param [Hash] values
+    # @return [Hash]
+    def format_data(values)
+      {
+        "current_mode" => parse_current_mode(values),
+        "current_power" => values["current_power"].to_f,
+        "outdoor_temperature" => values["outdoor_temperature"].to_f / 10.0,
+        "valid_for" => Time.now,
+      }
+    end
+
+    private
+
+    # `current_mode_switch` = mode trigger by wall switch or something similar
+    # `current_mode` = is common "builtin" mode
+    def parse_current_mode(values)
+      if values['current_mode_switch'].positive?
+        @user_ctrl.user_modes[values['current_mode_switch'].to_s]
+      else
+        @user_ctrl.modes[values['current_mode'].to_s]
+      end
+    end
+  end
+end

data/lib/atrea_control/version.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 module AtreaControl
-  VERSION = "1.2.1"
+
+  VERSION = "2.0.0"
+
 end

data/lib/atrea_control.rb

@@ -1,22 +1,17 @@
 # frozen_string_literal: true
 
 require_relative "atrea_control/version"
+require "i18n"
+require "yaml"
 
 module AtreaControl
   class Error < StandardError; end
 
   autoload :Duplex, "atrea_control/duplex"
+  autoload :Logger, "atrea_control/logger"
+  autoload :SensorParser, "atrea_control/sensor_parser"
 
-  # Provide map sensor to element ID
-  module Config
-    module_function
+  I18n.load_path.concat Dir["#{File.expand_path("../config/locales", __dir__)}/*.yml"]
+  I18n.default_locale = :cs
 
-    def default_sensors_map
-      {
-        outdoor_temperature: "I10208",
-        current_power: "H10704",
-        current_mode: "H10705",
-      }
-    end
-  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: atrea_control
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Lukáš Pokorný
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-30 00:00:00.000000000 Z
+date: 2021-12-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
@@ -44,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.142'
+        version: '4.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.142'
+        version: '4.1'
 description: Read data from web controller of RD5 duplex by Atrea.
 email:
 - pokorny@luk4s.cz
@@ -73,16 +87,22 @@ files:
 - atrea_control.gemspec
 - bin/console
 - bin/setup
+- config/locales/cs.yml
+- config/locales/de.yml
+- config/locales/en.yml
 - lib/atrea_control.rb
 - lib/atrea_control/duplex.rb
+- lib/atrea_control/duplex/login.rb
+- lib/atrea_control/duplex/request.rb
+- lib/atrea_control/duplex/unit.rb
+- lib/atrea_control/duplex/user_ctrl.rb
+- lib/atrea_control/logger.rb
+- lib/atrea_control/sensor_parser.rb
 - lib/atrea_control/version.rb
 homepage: https://github.com/luk4s/atrea_control
 licenses: []
 metadata:
-  allowed_push_host: https://rubygems.org
-  homepage_uri: https://github.com/luk4s/atrea_control
-  source_code_uri: https://github.com/luk4s/atrea_control
-  changelog_uri: https://github.com/luk4s/atrea_control/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths: