weatherlink 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d16465c0ef961c536b4a160c17993ae39978a833ff0602bb3c2975dcdb12225b
+  data.tar.gz: e33b3cd29d2430334633ca59020bca24f18cb13d1b0ff2ab5c1e650dfd1f0436
+SHA512:
+  metadata.gz: 651ba70b2b30dac3401707ba115aca784be784da3e5f7519b4d630fbe9f22e97e7f6ee2a706e0de248e1efea96e0c330e0df4f4a8642b5072a3e2dadfbd0bec2
+  data.tar.gz: b651ba906113a68977be4cda967dddcca66ca556a481b4d6bbe66723d115b157f161509d9cb0a759e02dce84a11aa45f8869aac77a6c52500a1f1d0d53ffa2be

data/.gitignore

@@ -0,0 +1,18 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/
+
+*.gem
+
+# rspec failure tracking
+.rspec_status
+
+# RubyMine files
+.idea
+.rakeTasks

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,27 @@
+AllCops:
+  TargetRubyVersion: 2.6
+  NewCops: enable
+Layout/LineLength:
+  Max: 120
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: consistent_comma
+Style/FormatString:
+  Enabled: false
+Style/FormatStringToken:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/CyclomaticComplexity:
+  Enabled: false
+Metrics/PerceivedComplexity:
+  Enabled: false
+Style/SymbolArray:
+  MinSize: 1

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.6
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in weatherlink.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    weatherlink (0.1.0)
+      ruby-units (~> 2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (12.3.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    ruby-units (2.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 12.0)
+  rspec (~> 3.0)
+  weatherlink!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Jeremy Cole
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,177 @@
+# WeatherLink
+
+This is an unofficial implementation of the Davis Instruments WeatherLink API, including both the Local API (v1) and the web API (v2).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'weatherlink'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install weatherlink
+
+## Usage
+
+### Local API
+
+To read the data from a local WeatherLink Live device via the "local API" (there is no authentication):
+
+```
+require 'weatherlink'
+
+> wl = WeatherLink::LocalClient.new(host: '<local ip address>')
+```
+
+The `current_conditions` method returns a `SensorData` object for each sensors: 
+
+```
+> cc = wl.current_conditions
+=> #<WeatherLink::SensorDataCollection (3 sensors)>
+
+> cc.to_a
+=> [#<WeatherLink::SensorData lsid=1 (Local API - ISS Record, 1 records)>,
+    #<WeatherLink::SensorData lsid=2 (Local API - LSS Temperature/Humidity Record, 1 records)>, 
+    #<WeatherLink::SensorData lsid=3 (Local API - LSS Barometric Pressure Record, 1 records)>]
+```
+
+Each `SensorData` is a wrapper for a hash containing the underlying data. Each of its keys can also be used as a method to get the data itself.
+
+```
+> pp cc[0].to_h
+{"ts"=>1609130694,
+  "temp"=>24.2 tempF,
+  "hum"=>84.9 %,
+  "dew_point"=>20.3 tempF,
+  "wet_bulb"=>22.6 tempF,
+  "heat_index"=>24.2 tempF,
+  "wind_chill"=>24.2 tempF,
+  "thw_index"=>24.2 tempF,
+  "thsw_index"=>22.2 tempF,
+  "wind_speed_last"=>0 mph,
+  "wind_dir_last"=>0 deg,
+  "wind_speed_avg_last_1_min"=>0 mph,
+  "wind_dir_scalar_avg_last_1_min"=>149 deg,
+  "wind_speed_avg_last_2_min"=>0 mph,
+  "wind_dir_scalar_avg_last_2_min"=>149 deg,
+  "wind_speed_hi_last_2_min"=>1 mph,
+  "wind_dir_at_hi_speed_last_2_min"=>149 deg,
+  "wind_speed_avg_last_10_min"=>0 mph,
+  "wind_dir_scalar_avg_last_10_min"=>149 deg,
+  "wind_speed_hi_last_10_min"=>1 mph,
+  "wind_dir_at_hi_speed_last_10_min"=>149 deg,
+  "rain_size"=>1,
+  "rain_rate_last"=>0 in/h,
+  "rain_rate_hi"=>0 in/h,
+  "rainfall_last_15_min"=>0 in,
+  "rain_rate_hi_last_15_min"=>0 in/h,
+  "rainfall_last_60_min"=>0 in,
+  "rainfall_last_24_hr"=>0 in,
+  "rain_storm"=>0 in,
+  "rain_storm_start_at"=>nil,
+  "solar_rad"=>0 W/m^2,
+  "uv_index"=>0.0,
+  "rx_state"=>0,
+  "trans_battery_flag"=>0,
+  "rainfall_daily"=>0 in,
+  "rainfall_monthly"=>18 in,
+  "rainfall_year"=>128 in,
+  "rain_storm_last"=>5 in,
+  "rain_storm_last_start_at"=>1608224100,
+  "rain_storm_last_end_at"=>1608318061}
+```
+
+Note that the unit support uses `ruby-units` which uses `Rational`, so some of the results can be... interesting:
+
+```
+> cc[0].temp
+=> -3342515348439043/791648371998720 tempC
+```
+
+Use `scalar.to_f` to get a `Float` most of the time:
+
+```
+> cc[0].temp.scalar.to_f
+=> -4.222222222222226
+```
+
+### Web API
+
+Obtain API credentials form your WeatherLink account and initialize the API:
+
+```
+require 'weatherlink'
+
+> wl = WeatherLink::Client.new(api_key: '<api key>', api_secret: '<api secret>')
+```
+
+Various aspects of the API and devices can be interrogated:
+
+```
+> wl.stations
+=> [#<WeatherLink::Station station_id=1 gateway_id_hex=a (Jackalope)>]
+
+> wl.sensors
+=> [#<WeatherLink::Sensor lsid=1 (Davis Instruments - WeatherLink LIVE Health)>,
+    #<WeatherLink::Sensor lsid=2 (Davis Instruments - Barometer)>,
+    #<WeatherLink::Sensor lsid=3 (Davis Instruments - Inside Temp/Hum)>,
+    #<WeatherLink::Sensor lsid=4 (Davis Instruments - Vantage Pro2 Plus /w 24-hr-Fan-Aspirated Radiation shield, UV & Solar Radiation Sensors)>,
+    #<WeatherLink::Sensor lsid=5 (Davis Instruments - AQS Health)>,
+    #<WeatherLink::Sensor lsid=6 (Davis Instruments - AirLink)>,
+    #<WeatherLink::Sensor lsid=7 (Davis Instruments - AQS Health)>,
+    #<WeatherLink::Sensor lsid=8 (Davis Instruments - AirLink)>,
+    #<WeatherLink::Sensor lsid=9 (Davis Instruments - AQS Health)>,
+    #<WeatherLink::Sensor lsid=10 (Davis Instruments - AirLink)>]
+
+> wl.nodes
+=> [#<WeatherLink::Node device_id_hex=a (Station - Barn)>,
+    #<WeatherLink::Node device_id_hex=b (Station - Living Room)>,
+    #<WeatherLink::Node device_id_hex=c (Station - Office)>]
+```
+
+Since most users will probably only have one station, a `station` method returns the first station for convenience:
+
+```
+wl.station
+=> #<WeatherLink::Station station_id=1 gateway_id_hex=a (Station)>
+```
+
+To collect current weather data from all sensor of the first/primary station:
+
+```
+> wl.station.current
+=> #<WeatherLink::SensorDataCollection (10 sensors)>
+```
+
+At this point accessing the underlying data is exactly the same as using the Local API above.
+
+Since the station knows the IP addresses of each sensor, if you're on the local network you can also access these sensors directly through the `local_sensors` method (which uses the same `WeatherLink::LocalClient` API above, but automatically configures it for each known sensor):
+
+```
+> wl.station.local_sensors
+=> [#<struct WeatherLink::Station::LocalSensor device=#<WeatherLink::Station station_id=1 gateway_id_hex=a (Station)>, host="1.2.3.4">,
+    #<struct WeatherLink::Station::LocalSensor device=#<WeatherLink::Node device_id_hex=b (Station - Living Room)>, host="1.2.3.5">,
+    #<struct WeatherLink::Station::LocalSensor device=#<WeatherLink::Node device_id_hex=c (Station - Office)>, host="1.2.3.6">,
+    #<struct WeatherLink::Station::LocalSensor device=#<WeatherLink::Node device_id_hex=d (Station - Barn)>, host="1.2.3.7">]
+```
+
+## Development
+
+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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jeremycole/weatherlink.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'weatherlink'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/weatherlink.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'weatherlink/version'
+require 'ruby-units'
+
+module WeatherLink
+  class Error < StandardError; end
+
+  UNIT_TYPES = %i[
+    temperature
+    humidity
+    wind_speed
+    pressure
+    wind_direction
+    rain_quantity
+    rain_rate
+    solar_radiation
+  ].freeze
+
+  Units = Struct.new(*UNIT_TYPES, keyword_init: true) do
+    def fetch(key)
+      return send(key.to_sym) if key && respond_to?(key.to_sym)
+
+      nil
+    end
+  end
+
+  METRIC_WEATHER_UNITS = Units.new(
+    temperature: 'tempC',
+    humidity: '%',
+    pressure: 'hPa',
+    wind_speed: 'm/s',
+    wind_direction: 'deg',
+    rain_quantity: 'cm',
+    rain_rate: 'cm/h',
+    solar_radiation: 'W/m^2'
+  )
+
+  IMPERIAL_WEATHER_UNITS = Units.new(
+    temperature: 'tempF',
+    humidity: '%',
+    pressure: 'inHg',
+    wind_speed: 'mph',
+    wind_direction: 'deg',
+    rain_quantity: 'in',
+    rain_rate: 'in/h',
+    solar_radiation: 'W/m^2'
+  )
+
+  SystemType = Struct.new(:name, keyword_init: true)
+
+  RecordType = Struct.new(:id, :system, :name, :type, keyword_init: true) do
+    def description
+      "#{system.name} - #{name}"
+    end
+
+    def current_conditions?
+      type == :current_conditions
+    end
+
+    def archive?
+      type == :archive
+    end
+
+    def health?
+      type == :health
+    end
+  end
+end
+
+require 'weatherlink/hash_wrapper'
+
+require 'weatherlink/api_v2'
+require 'weatherlink/client'
+
+require 'weatherlink/local_api_v1'
+require 'weatherlink/local_client'
+
+require 'weatherlink/data_record'
+require 'weatherlink/sensor_data'
+require 'weatherlink/sensor_record'
+require 'weatherlink/sensor_data_collection'
+
+require 'weatherlink/station'
+require 'weatherlink/node'
+require 'weatherlink/sensor'

data/lib/weatherlink/api_v2.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'openssl'
+require 'json'
+
+module WeatherLink
+  class APIv2
+    BASE_URI = 'https://api.weatherlink.com/v2'
+
+    SYSTEM_TYPES = {
+      Legacy: SystemType.new(name: 'Legacy'),
+      EnviroMonitor: SystemType.new(name: 'EnviroMonitor'),
+      WeatherLinkLive: SystemType.new(name: 'WeatherLink Live'),
+      AirLink: SystemType.new(name: 'AirLink'),
+    }.freeze
+
+    RECORD_TYPES = [
+      RecordType.new(
+        id: 1,
+        system: SYSTEM_TYPES[:Legacy],
+        name: 'Current Conditions Record - Revision A',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 2,
+        system: SYSTEM_TYPES[:Legacy],
+        name: 'Current Conditions Record - Revision B',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 3,
+        system: SYSTEM_TYPES[:Legacy],
+        name: 'Archive Record - Revision A',
+        type: :archive
+      ),
+      RecordType.new(
+        id: 4,
+        system: SYSTEM_TYPES[:Legacy],
+        name: 'Archive Record - Revision B',
+        type: :archive
+      ),
+      RecordType.new(
+        id: 5,
+        system: SYSTEM_TYPES[:Legacy],
+        name: 'High/Low Record (deprecated)',
+        type: :high_low
+      ),
+      RecordType.new(
+        id: 6,
+        system: SYSTEM_TYPES[:EnviroMonitor],
+        name: 'ISS Current Conditions Record',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 7,
+        system: SYSTEM_TYPES[:EnviroMonitor],
+        name: 'ISS Archive Record',
+        type: :archive
+      ),
+      RecordType.new(
+        id: 8,
+        system: SYSTEM_TYPES[:EnviroMonitor],
+        name: 'ISS High/Low Record (deprecated)',
+        type: :archive
+      ),
+      RecordType.new(
+        id: 9,
+        system: SYSTEM_TYPES[:EnviroMonitor],
+        name: 'non-ISS Record',
+        type: :unknown
+      ),
+      RecordType.new(
+        id: 10,
+        system: SYSTEM_TYPES[:WeatherLinkLive],
+        name: 'ISS Current Conditions Record',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 11,
+        system: SYSTEM_TYPES[:WeatherLinkLive],
+        name: 'ISS Archive Record',
+        type: :archive
+      ),
+      RecordType.new(
+        id: 12,
+        system: SYSTEM_TYPES[:WeatherLinkLive],
+        name: 'non-ISS Current Conditions Record',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 13,
+        system: SYSTEM_TYPES[:WeatherLinkLive],
+        name: 'non-ISS Archive Record',
+        type: :archive
+      ),
+      RecordType.new(
+        id: 14,
+        system: SYSTEM_TYPES[:EnviroMonitor],
+        name: 'Health Record',
+        type: :health
+      ),
+      RecordType.new(
+        id: 15,
+        system: SYSTEM_TYPES[:WeatherLinkLive],
+        name: 'Health Record',
+        type: :health
+      ),
+      RecordType.new(
+        id: 16,
+        system: SYSTEM_TYPES[:AirLink],
+        name: 'Current Conditions Record',
+        type: :current_conditions
+      ),
+      RecordType.new(
+        id: 17,
+        system: SYSTEM_TYPES[:AirLink],
+        name: 'Archive Record',
+        type: :archive
+      ),
+      RecordType.new(
+        id: 18,
+        system: SYSTEM_TYPES[:AirLink],
+        name: 'Health Record',
+        type: :health
+      ),
+    ].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
+
+    # TODO: Eliminate duplicate data e.g. rain_rate_last_{in,mm,clicks}
+    # TODO: Wind speeds are actually in mph not m/s?
+    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 :api_key, :api_secret, :units
+
+    def initialize(api_key:, api_secret:, units: IMPERIAL_WEATHER_UNITS)
+      @api_key = api_key
+      @api_secret = api_secret
+      @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 sensor_catalog
+      request(path: 'sensor-catalog')
+    end
+
+    def stations(ids = nil)
+      request(path: 'stations', path_params: { 'station-ids' => optional_array_param(ids) })
+    end
+
+    alias station stations
+
+    def nodes(ids = nil)
+      request(path: 'nodes', path_params: { 'node-ids' => optional_array_param(ids) })
+    end
+
+    alias node nodes
+
+    def sensors(ids = nil)
+      request(path: 'sensors', path_params: { 'sensor-ids' => optional_array_param(ids) })
+    end
+
+    alias sensor sensors
+
+    def sensor_activity(ids = nil)
+      request(path: 'sensor-activity', path_params: { 'sensor-ids' => optional_array_param(ids) })
+    end
+
+    def current(id)
+      request(path: 'current', path_params: { 'station-id' => id })
+    end
+
+    def historic(id, start_timestamp, end_timestamp)
+      request(
+        path: 'historic',
+        path_params: { 'station-id' => id },
+        query_params: { 'start-timestamp' => start_timestamp, 'end-timestamp' => end_timestamp }
+      )
+    end
+
+    def last_seconds(id, seconds)
+      historic(id, Time.now.to_i - seconds, Time.now.to_i)
+    end
+
+    def last_hour(id)
+      last_seconds(id, 3600)
+    end
+
+    def last_day(id)
+      last_seconds(id, 86_400)
+    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.parse(response.body)
+    end
+
+    def request_uri(path:, path_params: {}, query_params: {})
+      used_path_params = path_params.compact
+
+      request_params = query_params.merge({ 't' => Time.now.to_i, 'api-key' => api_key })
+      request_params.merge!(
+        {
+          'api-signature' => api_signature(path_params: used_path_params, query_params: request_params),
+        }
+      )
+
+      uri = ([BASE_URI, path] + Array(used_path_params.values)).compact.join('/')
+
+      URI("#{uri}?#{URI.encode_www_form(request_params)}")
+    end
+
+    # private
+
+    def optional_array_param(param)
+      param.is_a?(Array) ? param.join(',') : param
+    end
+
+    def stuffed_params(params)
+      params.sort_by { |k, _| k }.map { |k, v| k.to_s + v.to_s }.join
+    end
+
+    def api_signature(path_params: {}, query_params: {})
+      OpenSSL::HMAC.hexdigest('SHA256', api_secret, stuffed_params(path_params.merge(query_params)))
+    end
+  end
+end