withings-api 0.0.3

data/features/support/method_mocker.rb

@@ -0,0 +1,36 @@
+#
+# ss
+#
+
+require_relative "../../test/helpers/method_aliaser"
+require 'net/http'
+
+def before_after_method_wrap(clazz, method_sym, &block)
+  wrap = nil
+
+  Before do
+    wrap = MethodAliaser.alias_it(clazz, method_sym, &block)
+  end
+
+  After do
+    wrap.unalias_it
+  end
+end
+
+def print_http_req_resp
+  before_after_method_wrap(Net::HTTP, :transport_request) do |aliased, *arguments|
+    puts "HTTP Request: #{arguments.first.path}"
+    res = aliased.call(*arguments)
+    puts "HTTP Response:"
+    puts "HTTP/#{res.http_version} #{res.code} #{res.message}"
+    res.to_hash.each_pair do |key, value|
+      puts "#{key}: #{value.join("; ")}"
+    end
+    puts ""
+    puts res.body
+
+    res
+  end
+end
+
+print_http_req_resp

data/features/support/world.rb

@@ -0,0 +1,34 @@
+require 'capybara/cucumber'
+
+module ApiCucumberHelpers
+  # executes the given block, storing the return value
+  # in an instance variable named "name" or the exception
+  # result in "name"_exception
+  def result_or_exception(name, &block)
+    begin
+      self.instance_variable_set("@#{name}", yield)
+    rescue => e
+      puts e
+      self.instance_variable_set("@#{name}_exception", e)
+    end
+  end
+
+  def logger
+    Cucumber.logger
+  end
+end
+
+World(ApiCucumberHelpers)
+
+# Capybara Setup
+
+Capybara.default_driver = :selenium
+Capybara.default_wait_time = 5
+World(Capybara::DSL)
+
+# overwrite puts to make it's output more
+# harmonious with the stylized Cucumber
+# output
+def puts(o)
+  Kernel.puts "      \33[36m#{o}\33[0m"
+end

data/lib/withings-api.rb

@@ -0,0 +1,19 @@
+require "withings-api/version"
+
+require "withings-api/consts"
+require "withings-api/query_string"
+require "withings-api/utils"
+require "withings-api/types"
+require "withings-api/tokens"
+require "withings-api/errors"
+require "withings-api/oauth_base"
+require "withings-api/oauth_actions"
+require "withings-api/api_response"
+require "withings-api/api_actions"
+
+module Withings
+  module Api
+    extend OAuthActions
+    extend ApiActions
+  end
+end

data/lib/withings-api/api_actions.rb

@@ -0,0 +1,27 @@
+require "withings-api/results/measure_getmeas_results"
+
+module Withings
+  module Api
+    module ApiActions
+      include OAuthBase
+
+      def measure_getmeas(parameters = {}, access_token = nil, consumer_token = nil)
+        consumer_token = consumer_token(consumer_token)
+        access_token = access_token(access_token)
+
+        http_response = oauth_http_request!(consumer_token, access_token, {:path => "http://wbsapi.withings.net/measure?action=getmeas", :parameters => parameters})
+        Withings::Api::ApiResponse.create!(http_response, Withings::Api::MeasureGetmeasResults)
+      end
+
+      private
+
+      def consumer_token(o)
+        @consumer_token || o || raise(StandardError, "No consumer token")
+      end
+
+      def access_token(o)
+        @consumer_token || o || raise(StandardError, "No access token")
+      end
+    end
+  end
+end

data/lib/withings-api/api_response.rb

@@ -0,0 +1,23 @@
+module Withings::Api
+  class ApiResponse
+    include ResultsHelpers
+
+    attr_reader :status, :body
+
+    def self.create!(http_response, body_class)
+      raise HttpNotSuccessError.new(http_response.code, http_response.body) if http_response.code != '200'
+
+      self.new(http_response.body, body_class)
+    end
+
+    def initialize(string_or_json, body_class)
+      hash = coerce_hash string_or_json
+
+      @status = hash["status"] || raise(InvalidFormat, :status_field_missing)
+
+      if hash.key?("body")
+        @body = body_class.new(hash["body"])
+      end
+    end
+  end
+end

data/lib/withings-api/consts.rb

@@ -0,0 +1,12 @@
+module Withings
+  module Api
+    module Defaults
+      API_BASE_URL = "http://wbsapi.withings.net"
+      OAUTH_BASE_URL = "https://oauth.withings.com"
+
+      OAUTH_REQUEST_TOKEN_PATH = "/account/request_token"
+      OAUTH_AUTHORIZE_PATH = "/account/authorize"
+      OAUTH_ACCESS_TOKEN_PATH = "/account/access_token"
+    end
+  end
+end

data/lib/withings-api/errors.rb

@@ -0,0 +1,23 @@
+module Withings
+  module Api
+    class Error < StandardError
+
+    end
+
+    class InvalidFormat < Error
+
+    end
+
+    class HttpNotSuccessError < Error
+      attr_accessor :code, :body
+
+      def initialize(code, body = "")
+        super(code)
+
+        @code = code
+        @body = body
+      end
+    end
+
+  end
+end

data/lib/withings-api/oauth_actions.rb

@@ -0,0 +1,94 @@
+require 'oauth'
+
+module Withings
+  module Api
+    module OAuth
+      include ::OAuth
+    end
+
+    # Simple API to ease the OAuth setup steps for Withing API client apps.
+    #
+    # Specifically, this class provides methods for OAuth access token creation.
+    #
+    # 1. Request request tokens - via {#create_request_token}
+    # 1. Redirect to authorization URL (this is handled outside of these methods, ie: by the webapp, etc.)
+    # 1. Request access tokens (for permanent access to Withings content) - via {#create_access_token}
+    module OAuthActions
+      include OAuthBase
+
+      Defaults = Withings::Api::Defaults
+
+      # Issues the "request_token" oauth HTTP request to Withings.
+      #
+      # For call details @ Withings, see http://www.withings.com/en/api/oauthguide#access
+      #
+      # For details about registering your application with Withings, see http://www.withings.com/en/api/oauthguide#registration
+      #
+      # @param [String] consumer_token the consumer key Withings assigned on app registration
+      # @param [String] consumer_secret the consumer secret Withings assigned on app registration
+      # @param [String] callback_url the URL Withings should return the user to after authorization
+      #
+      # @return [RequestTokenResponse] something encapsulating the request response
+      #
+      # @raise [Timeout::Error] on connection, or read timeout
+      # @raise [SystemCallError] on low level system call errors (connection timeout, connection refused)
+      # @raise [ProtocolError] for HTTP 5XX error response codes
+      # @raise [OAuth::Unauthorized] for HTTP 4XX error reponse codes
+      # @raise [StandardError] for everything else
+      def create_request_token(consumer_token, *arguments)
+        _consumer_token, _consumer_secret, _callback_url = nil
+
+        if arguments.length == 1 && consumer_token.instance_of?(Withings::Api::ConsumerToken)
+          _consumer_token, _consumer_secret = consumer_token.to_a
+        elsif arguments.length == 2
+          _consumer_token = consumer_token
+          _consumer_secret = arguments.shift
+        else
+          raise(ArgumentError)
+        end
+        _callback_url = arguments.shift
+
+        # TODO: warn if the callback URL isn't HTTPS
+        consumer = create_consumer(_consumer_token, _consumer_secret)
+        oauth_request_token = consumer.get_request_token({:oauth_callback => _callback_url})
+
+        RequestTokenResponse.new oauth_request_token
+      end
+
+
+      # Issues the "access_token" oauth HTTP request to Withings
+      #
+      # @param [RequestTokenResponse] request_token request token returned from {#create_request_token}
+      # @param [String] user_id user id as returned from Withings via the {RequestTokenResponse#authorization_url}
+      #
+      # @return [] the shit
+      def create_access_token(request_token, *arguments)
+        _consumer, _request_token, _user_id = nil
+
+        if request_token.instance_of?(RequestTokenResponse) && arguments.length == 1
+          _consumer = request_token.oauth_consumer
+          _request_token = request_token.oauth_request_token
+          _user_id = arguments.shift
+        elsif request_token.instance_of?(RequestToken) && arguments.length == 2
+          request_token.instance_of?(ConsumerToken)
+          _consumer = create_consumer(*arguments.shift.to_a)
+          _request_token = OAuth::RequestToken.new(_consumer, *request_token.to_a)
+          _user_id = arguments.shift
+        else
+          raise ArgumentError
+        end
+
+        oauth_access_token = _consumer.get_access_token(_request_token)
+
+        # test for unauthorized token, since oauth + withings doesn't turn this into an explicit
+        # error code / exception
+        if oauth_access_token.params.key?(:"unauthorized token")
+          raise StandardError, :"unauthorized token"
+        end
+
+        AccessTokenResponse.new oauth_access_token
+      end
+
+    end
+  end
+end

data/lib/withings-api/oauth_base.rb

@@ -0,0 +1,121 @@
+require 'net/http'
+
+module Withings::Api
+
+  module OAuthBase
+    private
+
+    def create_consumer(consumer_key, consumer_secret)
+      OAuth::Consumer.new(consumer_key, consumer_secret, {
+          # todo, this needs to be parameterized
+          :site => Defaults::OAUTH_BASE_URL,
+          :scheme => :query_string,
+          :http_method => :get,
+          :signature_method => 'HMAC-SHA1',
+          :request_token_path => Defaults::OAUTH_REQUEST_TOKEN_PATH,
+          :authorize_path => Defaults::OAUTH_AUTHORIZE_PATH,
+          :access_token_path => Defaults::OAUTH_ACCESS_TOKEN_PATH,
+      })
+
+    end
+
+    def create_signed_request(consumer_token, access_token, parameters = {})
+      default_parameters = {
+          :method => :get,
+          :parameters => {},
+          :headers => {}
+      }
+
+      parameters = default_parameters.merge parameters
+
+      method = parameters[:method].downcase
+      path = parameters[:path]
+      http_parameters = parameters[:parameters]
+      http_headers = parameters[:headers]
+
+      if method == :get && !http_parameters.empty?
+        query_string = http_parameters.to_query_string
+
+        path += "?" if ! path.include?("?")
+        path += "&" if ! path.end_with? "?"
+
+        path += query_string
+      end
+
+      consumer = create_consumer(consumer_token.key, consumer_token.secret)
+
+      _access_token = OAuth::AccessToken.new(consumer, *access_token.to_a)
+      if [:post, :put].include?(method)
+        consumer.create_signed_request(method, path, _access_token, http_parameters, http_headers)
+      else
+        consumer.create_signed_request(method, path, _access_token, http_headers)
+      end
+    end
+
+    def oauth_http_request!(consumer_token, access_token, parameters = {})
+      request = create_signed_request(consumer_token, access_token, parameters)
+      Net::HTTP.new("wbsapi.withings.net").request(request)
+    end
+  end
+
+  # Simple wrapper class that encapsulates the results of a call to {StaticHelpers#create_request_token}
+  class RequestTokenResponse
+    def initialize(oauth_request_token)
+      self.oauth_request_token = oauth_request_token
+    end
+
+    # @return [String] the OAuth request token key
+    def token
+      self.oauth_request_token.token
+    end
+
+    alias :key :token
+
+    # @return [String] the OAuth request token secret
+    def secret
+      self.oauth_request_token.secret
+    end
+
+    # @return [String] URL to redirect the user to to authorize the access to their data
+    def authorization_url
+      self.oauth_request_token.authorize_url
+    end
+
+    # @return [RequestToken]
+    def request_token
+      RequestToken.new(self.key, self.secret)
+    end
+
+    attr_accessor :oauth_request_token
+
+    # :nodoc:
+    def oauth_consumer
+      self.oauth_request_token.consumer
+    end
+  end
+
+  class AccessTokenResponse
+    def initialize(oauth_access_token)
+      @oauth_access_token = oauth_access_token
+    end
+
+    def token
+      @oauth_access_token.token
+    end
+
+    alias :key :token
+
+    def secret
+      @oauth_access_token.secret
+    end
+
+    def user_id
+      @oauth_access_token.params["userid"]
+    end
+
+    def access_token
+      AccessToken.new(self.key, self.secret)
+    end
+  end
+
+end

data/lib/withings-api/query_string.rb

@@ -0,0 +1,16 @@
+require 'uri'
+
+class Hash
+  QUERY_STRING_RESERVERED = /[\$&\+,\/:;=\?@ <>"#%\{\}\|\\\^~\[\]`]/
+
+  def to_query_string
+    hash = self
+
+    params = []
+    hash.keys.each do |key|
+      params << [key, hash[key]]
+    end
+
+    params.map { |p| p.map { |v| URI.escape(v.to_s, QUERY_STRING_RESERVERED) }.join("=") }.join("&")
+  end
+end

data/lib/withings-api/results/measure_getmeas_results.rb

@@ -0,0 +1,73 @@
+require 'json'
+
+module Withings::Api
+  # Class encapsulating a Measurement
+  #
+  # See www.withings.com/en/api/wbsapiv2
+  class Measurement
+    include ResultsHelpers
+
+    attr_accessor :measurement_type, :value_raw, :unit
+
+    def initialize(json_or_hash)
+      hash = coerce_hash json_or_hash
+
+      self.measurement_type = MeasurementType.lookup(hash["type"])
+      self.value_raw = hash["value"]
+      self.unit = hash["unit"]
+    end
+
+    def value
+      value_raw * 10**unit
+    end
+
+  end
+
+  # Class encapsulating a MeasurementGroup
+  #
+  # See www.withings.com/en/api/wbsapiv2
+  class MeasurementGroup
+    include ResultsHelpers
+
+    attr_reader :id, :attribution, :date_raw, :category, :measurements;
+
+    def initialize(json_string_or_hash)
+      hash = coerce_hash json_string_or_hash
+
+      #"grpid"=>2909, "attrib"=>0, "date"=>1222930968, "category"=>1, "measures
+      @id = hash["grpid"]
+      @date_raw = hash["date"]
+      @attribution = AttributionType.lookup(hash["attrib"])
+      @category = CategoryType.lookup(hash["category"])
+      @measurements = hash["measures"].map { |h| Measurement.new(h) }
+    end
+
+    def date
+      Time.at(date_raw)
+    end
+  end
+
+  # Class encapsulating the response to a call to
+  # measure/getmeas
+  #
+  # See www.withings.com/en/api/wbsapiv2
+  class MeasureGetmeasResults
+    include ResultsHelpers
+
+    attr_accessor :update_time_raw, :more, :measure_groups
+    alias :more? :more
+
+    def initialize(json_or_hash)
+      hash = coerce_hash json_or_hash
+
+      self.update_time_raw = hash["updatetime"] || raise(ArgumentError)
+      self.more = (hash["more"] == true)
+      self.measure_groups = hash["measuregrps"].map { |h| MeasurementGroup.new(h) }
+    end
+
+    def update_time
+      Time.at(update_time_raw)
+    end
+
+  end
+end