weatherlink 0.1.0

data/lib/weatherlink/client.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module WeatherLink
+  class Client
+    attr_reader :api
+
+    def initialize(api_key:, api_secret:, station_units: IMPERIAL_WEATHER_UNITS, desired_units: METRIC_WEATHER_UNITS)
+      @api = APIv2.new(api_key: api_key, api_secret: api_secret, units: station_units)
+      @desired_units = desired_units
+    end
+
+    def attach_units(data)
+      data.map do |field, value|
+        unit = api.unit_for(field)
+        [field, unit ? Unit.new("#{value} #{unit}") : value]
+      end.to_h
+    end
+
+    def desired_unit_for(field)
+      desired_units.fetch(api.type_for(field))
+    end
+
+    def convert(field, value)
+      desired_unit = desired_unit_for(field)
+      return value unless desired_unit
+
+      value.convert_to(desired_unit)
+    end
+
+    def stations
+      @stations ||= api.station['stations'].map do |data|
+        Station.new(self, data) if data
+      end
+    end
+
+    def station
+      stations.first
+    end
+
+    def stations_by_device_id_hex(device_id_hex)
+      stations.select { |s| s.gateway_id_hex == device_id_hex }.first
+    end
+
+    def nodes
+      @nodes ||= api.nodes['nodes'].map do |data|
+        Node.new(self, data)
+      end
+    end
+
+    def node_by_device_id_hex(device_id_hex)
+      nodes.select { |n| n.device_id_hex == device_id_hex }.first
+    end
+
+    def sensors
+      @sensors ||= api.sensors['sensors'].map do |data|
+        Sensor.new(self, data)
+      end
+    end
+
+    def sensor_by_lsid(lsid)
+      sensors.select { |s| s.lsid == lsid }.first
+    end
+  end
+end

data/lib/weatherlink/data_record.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module WeatherLink
+  class DataRecord < HashWrapper
+    attr_reader :client
+
+    def initialize(client, data)
+      @client = client
+      super(data)
+    end
+  end
+end

data/lib/weatherlink/hash_wrapper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WeatherLink
+  class HashWrapper < SimpleDelegator
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+      super
+    end
+
+    private
+
+    def method_missing(symbol, *args)
+      return data.fetch(symbol.to_s) if data.include?(symbol.to_s)
+
+      super
+    end
+
+    def respond_to_missing?(symbol, include_private = false)
+      return true if data.include?(symbol.to_s)
+
+      super
+    end
+  end
+end

data/lib/weatherlink/local_api_v1.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module WeatherLink
+  class LocalAPIv1
+    class RequestError < StandardError; end
+
+    LOCAL_API = SystemType.new(name: 'Local API')
+
+    RECORD_TYPES = [
+      RecordType.new(
+        id: 1,
+        system: LOCAL_API,
+        name: 'ISS Record',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 2,
+        system: LOCAL_API,
+        name: 'Leaf/Soil Moisture Record',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 3,
+        system: LOCAL_API,
+        name: 'LSS Barometric Pressure Record',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 4,
+        system: LOCAL_API,
+        name: 'LSS Temperature/Humidity Record',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 6,
+        system: LOCAL_API,
+        name: 'AirLink Record',
+        type: :current_conditions
+      ),
+    ].freeze
+
+    RECORD_TYPES_BY_ID = RECORD_TYPES.each_with_object({}) { |r, h| h[r.id] = r }
+
+    def self.record_type(id)
+      RECORD_TYPES_BY_ID[id]
+    end
+
+    RECORD_FIELD_UNITS = {
+      temp: :temperature,
+      temp_in: :temperature,
+      dew_point: :temperature,
+      dew_point_in: :temperature,
+      wet_bulb: :temperature,
+      heat_index: :temperature,
+      heat_index_in: :temperature,
+      wind_chill: :temperature,
+      thw_index: :temperature,
+      thsw_index: :temperature,
+      hum: :humidity,
+      hum_in: :humidity,
+      bar_sea_level: :pressure,
+      bar_absolute: :pressure,
+      bar_trend: :pressure,
+      wind_speed_last: :wind_speed,
+      wind_speed_avg_last_1_min: :wind_speed,
+      wind_speed_avg_last_2_min: :wind_speed,
+      wind_speed_avg_last_10_min: :wind_speed,
+      wind_speed_hi_last_2_min: :wind_speed,
+      wind_speed_hi_last_10_min: :wind_speed,
+      wind_dir_last: :wind_direction,
+      wind_dir_scalar_avg_last_1_min: :wind_direction,
+      wind_dir_scalar_avg_last_2_min: :wind_direction,
+      wind_dir_scalar_avg_last_10_min: :wind_direction,
+      wind_dir_at_hi_speed_last_2_min: :wind_direction,
+      wind_dir_at_hi_speed_last_10_min: :wind_direction,
+      rain_rate_last: :rain_rate,
+      rain_rate_hi: :rain_rate,
+      rain_rate_hi_last_15_min: :rain_rate,
+      rainfall_last_15_min: :rain_quantity,
+      rainfall_last_60_min: :rain_quantity,
+      rainfall_last_24_hr: :rain_quantity,
+      rainfall_daily: :rain_quantity,
+      rainfall_monthly: :rain_quantity,
+      rainfall_year: :rain_quantity,
+      rain_storm: :rain_quantity,
+      rain_storm_last: :rain_quantity,
+      solar_rad: :solar_radiation,
+    }.freeze
+
+    attr_reader :host, :units
+
+    def initialize(host:, units: IMPERIAL_WEATHER_UNITS)
+      @host = host
+      @units = units
+    end
+
+    def type_for(field)
+      return nil unless [String, Symbol].include?(field.class)
+
+      RECORD_FIELD_UNITS.fetch(field.to_sym, nil)
+    end
+
+    def unit_for(field)
+      units.fetch(type_for(field))
+    end
+
+    def current_conditions
+      request(path: 'current_conditions')
+    end
+
+    def request(path:, path_params: {}, query_params: {})
+      uri = request_uri(path: path, path_params: path_params, query_params: query_params)
+      response = Net::HTTP.get_response(uri)
+      json_response = JSON.parse(response.body)
+      raise RequestError, json_response['error'] if json_response['error']
+
+      json_response['data']
+    end
+
+    def base_uri
+      "http://#{host}/v1"
+    end
+
+    def request_uri(path:, path_params: {}, query_params: {})
+      uri = ([base_uri, path] + Array(path_params.values)).compact.join('/')
+
+      if query_params.none?
+        URI(uri)
+      else
+        URI("#{uri}?#{URI.encode_www_form(query_params)}")
+      end
+    end
+
+    # private
+
+    def optional_array_param(param)
+      param.is_a?(Array) ? param.join(',') : param
+    end
+  end
+end

data/lib/weatherlink/local_client.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'ruby-units'
+
+module WeatherLink
+  class LocalClient
+    attr_reader :api, :desired_units
+
+    def initialize(host:, station_units: IMPERIAL_WEATHER_UNITS, desired_units: METRIC_WEATHER_UNITS)
+      @api = LocalAPIv1.new(host: host, units: station_units)
+      @desired_units = desired_units
+    end
+
+    META_KEYS = %w[lsid data_structure_type txid].freeze
+
+    def transform_like_api_v2(hash)
+      hash.select { |k, _| META_KEYS.include?(k) }.merge('data' => [{
+        'ts' => Time.now.to_i,
+      }.merge(hash.reject { |k, _| META_KEYS.include?(k) })])
+    end
+
+    def attach_units(data)
+      data.map do |field, value|
+        unit = api.unit_for(field)
+        [field, unit ? Unit.new("#{value} #{unit}") : value]
+      end.to_h
+    end
+
+    def desired_unit_for(field)
+      desired_units.fetch(api.type_for(field))
+    end
+
+    def convert(field, value)
+      desired_unit = desired_unit_for(field)
+      return value unless desired_unit
+
+      value.convert_to(desired_unit)
+    end
+
+    def current_conditions
+      sensors = api.current_conditions['conditions'].map do |conditions|
+        SensorData.new(self, transform_like_api_v2(conditions))
+      end
+
+      SensorDataCollection.new(self, sensors)
+    end
+
+    def stations
+      @stations ||= api.station['stations'].map do |data|
+        Station.new(self, data) if data
+      end
+    end
+
+    def sensors
+      @sensors ||= api.sensors['sensors'].map do |data|
+        Sensor.new(self, data)
+      end
+    end
+  end
+end

data/lib/weatherlink/node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module WeatherLink
+  class Node < HashWrapper
+    attr_reader :client
+
+    def initialize(client, data)
+      @client = client
+      super(data)
+    end
+
+    def to_s
+      "#<#{self.class.name} device_id_hex=#{device_id_hex} (#{description})>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def description
+      "#{station_name} - #{node_name}"
+    end
+  end
+end

data/lib/weatherlink/sensor.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module WeatherLink
+  class Sensor < HashWrapper
+    attr_reader :client
+
+    def initialize(client, data)
+      @client = client
+      super(data)
+    end
+
+    def to_s
+      "#<#{self.class.name} lsid=#{lsid} (#{description})>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def description
+      "#{manufacturer} - #{product_name}"
+    end
+  end
+end

data/lib/weatherlink/sensor_data.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module WeatherLink
+  class SensorData < SimpleDelegator
+    attr_reader :client, :records, :sensor_data
+
+    def initialize(client, sensor_data)
+      @client = client
+      @sensor_data = HashWrapper.new(sensor_data)
+      @records = @sensor_data['data'].map do |data|
+        SensorRecord.new(client, client.attach_units(data))
+      end
+      super(@records.first)
+    end
+
+    def to_s
+      "#<#{self.class.name} lsid=#{lsid} (#{record_type.description}, #{records.size} records)>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def lsid
+      sensor_data.lsid
+    end
+
+    def sensor
+      @sensor ||= @client.sensors.select { |sensor| sensor.lsid == lsid }.first
+    end
+
+    def sensor_type
+      sensor_data.sensor_type
+    end
+
+    def record_type
+      @record_type ||= client.api.class.record_type(sensor_data.data_structure_type)
+    end
+
+    def health?
+      record_type.health?
+    end
+
+    def current_conditions?
+      record_type.current_conditions?
+    end
+
+    def archive?
+      record_type.archive?
+    end
+
+    def weather?
+      record_type.current_conditions? || record_type.archive?
+    end
+
+    def description
+      record_type.description
+    end
+  end
+end

data/lib/weatherlink/sensor_data_collection.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module WeatherLink
+  class SensorDataCollection < SimpleDelegator
+    attr_reader :client
+
+    def initialize(client, sensors)
+      @client = client
+      super(sensors)
+    end
+
+    def to_s
+      "#<#{self.class.name} (#{size} sensors)>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def current_conditions
+      SensorDataCollection.new(client, select(&:current_conditions?))
+    end
+
+    def archive
+      SensorDataCollection.new(client, select(&:archive?))
+    end
+
+    def weather
+      SensorDataCollection.new(client, select(&:weather?))
+    end
+
+    def health
+      SensorDataCollection.new(client, select(&:health?))
+    end
+  end
+end