atrea_control 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdf15229042c9284e6e7c385a94336e769d2c0118b7b9e723ed673faacfbac26
-  data.tar.gz: 8926e926db7cfea4b5f48473bfb9a13c57584adfea15d19afbd70b70fa3b43c0
+  metadata.gz: 01f3c707897b8cd1626855caaa5cd4758ebeae0497881dd5164c2fb67a610327
+  data.tar.gz: f567bde666512960777679842366f249b0eff130e5a3fd1c487d5d652ef11687
 SHA512:
-  metadata.gz: b774b17e3be8f214eb756839fa464f9f46bba7a2363cd1a1508c47796e6884ce16dc8172f8ceeb73b67d97bd4d9eec7d2736bcec843ce4242b73e4d457d8f3de
-  data.tar.gz: 2af518d17ad3757473bc6b0611d3b17eeeb47d6039567dd597df19979059886d8a9225915e08c4538f72eeaf7e1065efbb2714077f4b4cae7632c7fe90511919
+  metadata.gz: 6f4a7ef12bbfde071d91b350e6b100d4528c3275a2642680cf26117ace31ef9ca9ed3072aaad9cb38189f336ec563d4b764db13238248295fc84ecbfe6977f65
+  data.tar.gz: d933b73a8afe23d567aba8f56d1d58060f53699fc5fadaa2eb897e9ff1a6f2e9aa1ed314b2f805a4923d08038c8db8924b7dfc2e5e155c6219a376e2fe05f84e

data/.github/workflows/main.yml

@@ -10,7 +10,7 @@ jobs:
     - name: Set up Ruby
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 2.7.2
+        ruby-version: 2.7
         bundler-cache: true
     - uses: browser-actions/setup-firefox@latest
     - name: Run tests

data/CHANGELOG.md

@@ -1,4 +1,15 @@
 ## [Unreleased]
+### Changed
+- refactored codebase to more readable classes
+- selenium used only for login and then close => obtain SID (and user with unit)
+- login waiting mechanism
+### Added
+- found way how to change mode & power (tell unit to change)
+
+## [1.4.1] - 2021-12-18
+### Changed
+- little refactor
+
 ## [1.4.0] - 2021-12-12
 ### Changed
 - founded way to get config and data from Atrea server

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    atrea_control (1.4.0)
+    atrea_control (2.0.0)
       i18n (~> 1.8)
       nokogiri (~> 1.12)
       rest-client (~> 2.1)
@@ -18,7 +18,7 @@ GEM
     concurrent-ruby (1.1.9)
     crack (0.4.5)
       rexml
-    diff-lcs (1.4.4)
+    diff-lcs (1.5.0)
     docile (1.4.0)
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
@@ -35,6 +35,8 @@ GEM
     netrc (0.11.0)
     nokogiri (1.12.5-x86_64-darwin)
       racc (~> 1.4)
+    nokogiri (1.12.5-x86_64-linux)
+      racc (~> 1.4)
     parallel (1.21.0)
     parser (3.0.3.2)
       ast (~> 2.4.1)
@@ -65,16 +67,16 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
     rspec-support (3.10.3)
-    rubocop (1.23.0)
+    rubocop (1.24.0)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
       rexml
-      rubocop-ast (>= 1.12.0, < 2.0)
+      rubocop-ast (>= 1.15.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.14.0)
+    rubocop-ast (1.15.0)
       parser (>= 3.0.1.1)
     rubocop-rspec (2.6.0)
       rubocop (~> 1.19)

data/README.md

@@ -10,7 +10,9 @@ This gem provide simple DSL by parsing content of https://control.atrea.eu with
   * temperature
   * fan power
   * power mode
-
+* allow change
+  * power
+  * mode
 
 ## Installation
 
@@ -30,27 +32,59 @@ Or install it yourself as:
 
 ## Usage
 
-UI map of sensors is required = each box have own ID contains sensor ID. Its required for correct element lookup.
-
-Default sensor map:
+At the begin you need obtain `user_id`, `unit_id` and `sid` (auth token). For this use "Login"
 ```ruby
-def default_sensors_map
-  {
-    outdoor_temperature: "I10208",
-    current_power: "H10704",
-    current_mode: "H10705",
-  }
-end
+tokens = AtreaControl::Duplex::Login.user_tokens login: "myhome", password: "sup3r-S3CR3T-kocicka"
+tokens # => { user_id: "1234", unit_id: "85425324672", sid: 4012 }
 ```
+I recommend to store then somewhere... 
+Then you can call Unit for data...
+
 Example usage:
 ```ruby
-control = AtreaControl::Duplex.new login: "myhome", password: "sup3r-S3CR3T-kocicka", sensors_map: { current_power: "H10704" }
-control.login # => true (takes max 5.minutes)
-control.current_mode # => "Bathroom"
-control.current_power # => 37.0
+control = AtreaControl::Duplex::Unit.new user_id: "1234", unit_id: "85425324672", sid: 4012
+control.values # => { current_power: 88.0, current_mode: "CO2" }
+control.power # => 88.0 
+```
+### Dig deeper
+`AtreaControl::Duplex::Unit` expect optional argument `user_ctrl` which should be object respond to 
+
+`name` (String) = Name of unit
+`sensors` (Hash) = Map of sensors, for example: `{ outdoor_temperature: "HI10208", current_power: "H10704" }`
+`modes` (Hash) = Is a map of "changable" modes - in unit its something like "builtin?" modes. They are translated by unit lang - `{ "0" => "Vypnuto", "1" => "Automat" }` 
+`user_modes` (Hash) = Is a map user specific modes, based on home switches / devices (D1, D2, D3, IN1, IN2 ...). They are translated by user texts - `{ "D1" => "Koupelna", "D2" => "CO2", "IN1" => "ovladač" }`
+
+__Please check [lib/atrea_control/duplex/user_ctrl.rb](./lib/atrea_control/duplex/user_ctrl.rb) for more details !__
+
+## Development / TODO
+Login is currently done by selenium - fill login form. 
+I found that Atre submit form to BE, generate some "empty" HTML and JS which onLoad start doing request to queue for "login".
+
+Re-login user, add login procedure into queue:
+```bash
+curl -X POST -d "comm=config%2Flogin.cgi" "https://control.atrea.eu/apps/rd5Control/handle.php?action=unitLogin&user=XXXX&unit=NNNNNNN&table=userUnits&idPwd=YYYYYYY&NFP"
+```
+Response is time in seconds when login will ready:
+```xml
+<root><sended time="264"/></root>
+```
+Based it su shown countdown ...
+
+
+Request for current queue status
+```bash
+curl 'https://control.atrea.eu/apps/rd5Control/handle.php?Sync=1&action=unitQuery&query=loged&user=XXXX&unit=NNNNNNN'
+```
+if queue is processed:
+```xml
+<root><login uconn="16395889" sid="010101" ver="3001009"/></root>
+```
+else
+```xml
+<root><login uconn="16390480" sid="0"/></root>
 ```
 
-## Development
+Goal is to obtain "SID".
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/lib/atrea_control/duplex/login.rb

@@ -0,0 +1,107 @@
+require "selenium-webdriver"
+
+module AtreaControl
+  module Duplex
+    # Process login into RD5 with selenium to get `sid` ( auth_token ) for direct API communication
+    class Login
+
+      include AtreaControl::Logger
+
+      # @return [Hash] - user_id, unit_id, sid
+      def self.user_tokens(login:, password:)
+        i = new(login: login, password: password)
+        tokens = i.user
+
+        tokens
+      ensure
+        i.close
+      end
+
+      # @param [String] login
+      # @param [String] password
+      def initialize(login:, password:)
+        @login = login
+        @password = password
+      end
+
+      def user
+        raise AtreaControl::Error, "Must be logged in" unless login
+
+        logger.debug "refresh user data based on session"
+        @user_id = driver.execute_script("return window._user")
+        @unit_id = driver.execute_script("return window._unit")
+        @auth_token = driver.execute_script("return window.user")&.[]("auth") # sid
+
+        { user_id: @user_id, unit_id: @unit_id, sid: @auth_token }
+      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, capabilities: [options]
+      end
+
+      # Login into control
+      def login
+        return driver if @logged
+
+        @login_in_progress = true
+        logger.debug "start new login..."
+        driver.get "#{AtreaControl::Duplex::CONTROL_URI}?action=logout"
+        submit_login_form
+        finish_login
+        driver
+      ensure
+        @login_in_progress = false
+      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
+        logger.debug "Submit login form..."
+
+        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"
+        # Open "iframe" with atrea dashboard - it propagate window objects...
+        driver.get uri
+        logger.debug "login success"
+        @logged = true
+      end
+
+      # quit selenium browser
+      def close
+        driver.quit rescue nil
+        logger.debug "driver closed & destroyed"
+      ensure
+        remove_instance_variable :@driver
+      end
+
+      private
+
+      def finish_login
+        30.times do |i|
+          return true if open_dashboard
+        rescue Selenium::WebDriver::Error::NoSuchElementError => e
+          logger.debug e.message
+          logger.debug "#{i + 1}/30 attempt for login..."
+          sleep 10
+        end
+        File.write("/tmp/failed_login-#{@login}.html", driver.page_source)
+        raise AtreaControl::Error, "unable to login"
+      end
+
+    end
+  end
+end

data/lib/atrea_control/duplex/request.rb

@@ -0,0 +1,29 @@
+require "rest-client"
+
+module AtreaControl
+  module Duplex
+    # Process request with duplex unit itself. Handle response
+    class Request
+
+      # @param [String, Integer] user_id
+      # @param [String, Integer] unit_id
+      # @param [String, Integer] sid
+      # @note `ver` is done by atrea server
+      def initialize(user_id:, unit_id:, sid:)
+        @params = {
+          _user: user_id.to_i,
+          _unit: unit_id,
+          auth: sid,
+          ver: AtreaControl::Duplex::CONTROL_VERSION,
+        }
+      end
+
+      # @param [Hash] params
+      # @option params [String] :_t ("config/xml.xml") file name
+      def call(params)
+        RestClient.get "#{AtreaControl::Duplex::CONTROL_URI}/comm/sw/unit.php", params: @params.merge(params)
+      end
+
+    end
+  end
+end

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,278 +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
-
-    attr_accessor :user_id, :unit_id, :auth_token
-    attr_writer :user_texts, :user_modes, :modes
-
-    # @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, capabilities: [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 unless logged?
-      finish_login
-      refresh!
-      inspect
-    ensure
-      @login_in_progress = false
-    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
-      @name ||= user_texts["UnitName"]
-    end
-
-    # Window.user object from atrea
-    # @return [Hash, nil]
-    def user
-      driver.execute_script("return window.user")
-    end
-
-    # quit selenium browser
-    def close
-      driver.quit
-    ensure
-      remove_instance_variable :@driver
-    end
-
-    alias logout! close
-
-    def as_json(_options = nil)
-      {
-        current_mode: current_mode,
-        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 call_unit!
-      return false if @login_in_progress
-
-      logger.debug "call_unit!"
-      parse_values(response_comm_unit)
-      @valid_for = Time.now
-      as_json
-    end
-
-    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
-
-    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
-
-    # User defined texts in RD5 unit
-    # @return [Hash]
-    def user_texts
-      return @user_texts if @user_texts
-
-      response = rd5_request(params_comm_unit.merge(_t: "config/texts.xml"))
-      xml = Nokogiri::XML response.body
-      @user_texts = xml.xpath("//i").map do |node|
-        value = node.attributes["value"].value
-        id = node.attributes["id"].value
-        [id, value.gsub(/%u([\dA-Z]{4})/) { |i| +'' << i[$1].to_i(16) }]
-      end.to_h
-    end
-
-    private
-
-    # @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_values(response)
-      xml = Nokogiri::XML response.body
-      sensors_values = @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
-      refresh_data(sensors_values)
-    end
-
-    # @param [Hash] values
-    # @return [Hash]
-    def refresh_data(values)
-      @outdoor_temperature = values[:outdoor_temperature].to_f / 10.0
-      @current_power = values[:current_power].to_f
-      @current_mode = if values[:current_mode_switch].positive?
-                        user_modes[values[:current_mode_switch].to_s]
-                      else
-                        modes[values[:current_mode].to_s]
-                      end
-      # @current_mode = mode_map[values[:current_mode_name] > 0 ? values[:current_mode_name] : values[:current_mode]]
-
-      as_json
-    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
-
-    # @return [RestClient::Response]
-    def response_comm_unit
-      rd5_request(params_comm_unit.merge(_t: "config/xml.xml"))
-    end
-
-    def rd5_request(params)
-      RestClient.get "https://control.atrea.eu/comm/sw/unit.php", { Cookie: "autoLogin=#{autologin_token}", params: params }
-    end
-
-    def user_ctrl
-      response = rd5_request(params_comm_unit.merge(_t: "lang/userCtrl.xml"))
-      xml = Nokogiri::XML response.body
-    end
-
-    def autologin_token
-      @autologin_token ||= CGI.escape([@login, @password].join("\b"))
-    end
-
-    # @note `ver` is done by atrea server
-    def params_comm_unit
-      {
-        _user: user_id.to_i,
-        _unit: unit_id,
-        auth: auth_token || "null",
-        ver: "003001009",
-      }
-    end
-
-    # Update tokens based on current state
-    def refresh!
-      @user_id = driver.execute_script("return window._user")
-      @unit_id = driver.execute_script("return window._unit")
-      @auth_token = user&.[]("auth")
-    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 = rd5_request(params_comm_unit.merge(_t: "lang/texts_#{atrea_id}.xml", auth: nil))
-
-        xml = Nokogiri::XML response.body
-        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
+    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"
 
   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

@@ -2,6 +2,6 @@
 
 module AtreaControl
 
-  VERSION = "1.4.0"
+  VERSION = "2.0.0"
 
 end

data/lib/atrea_control.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atrea_control
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Lukáš Pokorný
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-12-12 00:00:00.000000000 Z
+date: 2021-12-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -92,6 +92,12 @@ files:
 - 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: []