rubyhealthvault 0.0.1

data/lib/healthvault.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/config'
+require File.dirname(__FILE__) + '/application'

data/lib/request.rb

@@ -0,0 +1,113 @@
+# -*- ruby -*-
+#--
+# Copyright 2008 Danny Coates, Ashkan Farhadtouski
+# All rights reserved.
+# See LICENSE for permissions.
+#++
+
+require 'rexml/document'
+require 'date'
+require File.dirname(__FILE__) + '/utils/string_utils'
+require File.dirname(__FILE__) + '/wc_data/init'
+
+# HealtVault doesn't adhere to valid xml standards.
+# Attribute values must be in double quotes to be parseable
+# So we redefine REXML::Attribute.to_string to accommodate
+REXML::Attribute.class_eval {def to_string() "#@expanded_name=\"#{to_s().gsub(/"/, '"')}\"" end}
+
+module HealthVault
+  class Request < HealthVault::WCData::ComplexType
+    include WCData
+    include REXML
+    include StringUtils
+    
+    # HealthVault::WCData::Types::HMACFinalized
+    def auth=(value)
+      @children['auth'][:value] = value
+    end
+        
+    def auth
+      return @children['auth'][:value]
+    end
+
+    # HealthVault::WCData::Request::Header
+    def header=(value)
+      @children['header'][:value] = value
+    end
+        
+    def header
+      return @children['header'][:value]
+    end
+
+    # HealthVault::WCData::Request::Info
+    def info=(value)
+      @children['info'][:value] = value
+    end
+        
+    def info
+      return @children['info'][:value]
+    end
+      
+    def initialize(connection)
+      super()
+      @connection = connection  
+      @children['auth'] = {:name => 'auth', :class => HealthVault::WCData::Types::HMACFinalized, :value => nil, :min => 0, :max => 1, :order => 1, :place => :element }
+      @children['header'] = {:name => 'header', :class => HealthVault::WCData::Request::Header, :value => nil, :min => 1, :max => 1, :order => 2, :place => :element }
+      @children['header'][:value] = WCData::Request::Header.new
+      @children['info'] = {:name => 'info', :class => HealthVault::WCData::Request::Info, :value => nil, :min => 1, :max => 1, :order => 3, :place => :element }  
+    end
+    
+    def self.create(method_name, connection)
+      request = Request.new(connection) 
+      request.header.method = method_name
+      request.header.method_version = "1"
+      request.header.language = "en"
+      request.header.country = "US"
+      request.header.msg_time = DateTime.now
+      request.header.msg_ttl = 29100
+      request.header.version = "0.0.0.1"
+      request.info = request.new_request_info
+      return request
+    end
+    
+    def new_request_info
+      begin
+        class_new = "HealthVault::WCData::Methods::#{header.method}::Info.new"
+        return eval(class_new)
+      rescue
+        Configuration.instance.logger.error "No Info class for #{header.method}"
+        return HealthVault::WCData::RawInfoXml.new
+      end
+    end
+    
+    def element
+      e = Element.new('wc-request:request')
+      e.add_namespace("wc-request", "urn:com.microsoft.wc.request")
+      super(e)
+    end
+    
+    def send
+      if @connection.authenticated?
+        header.info_hash = Types::HashFinalized.new
+        header.info_hash.hash_data = Types::HashFinalizedData.new
+        header.info_hash.hash_data.alg_name = "SHA1"
+        header.info_hash.hash_data.data = CryptoUtils.encode64(CryptoUtils.digest(info.element.to_s))
+        header.auth_session = WCData::Request::AuthenticatedSessionInfo.new
+        header.auth_session.auth_token = @connection.session_token
+        header.auth_session.user_auth_token = @connection.user_auth_token #or offline_person_info
+        #INFO: call the auth= method, not create an auth variable
+        self.auth = Types::HMACFinalized.new
+        auth.hmac_data = Types::HMACFinalizedData.new
+        auth.hmac_data.alg_name = "HMACSHA1"
+        auth.hmac_data.data = CryptoUtils.encode64(CryptoUtils.hmac(@connection.shared_secret, header.element.to_s)) 
+      else
+        header.app_id = @connection.application.id
+      end
+      #if self.valid?
+      return @connection.send(self)
+      #else
+      #  raise StandardError.new("request is not valid")
+      #end      
+    end
+  end
+end

data/lib/response.rb

@@ -0,0 +1,50 @@
+# -*- ruby -*-
+#--
+# Copyright 2008 Danny Coates, Ashkan Farhadtouski
+# All rights reserved.
+# See LICENSE for permissions.
+#++
+
+require 'rexml/document'
+require File.dirname(__FILE__) + '/utils/string_utils'
+
+module HealthVault
+  class Response
+    include REXML
+    include StringUtils
+    include WCData
+    
+    attr_reader :xml, :info
+    
+    def initialize(http_response)
+      @http_response = http_response
+      @xml = Document.new(@http_response.body)
+      code = XPath.first(@xml, "//code").text
+      if code.to_i > 0
+        msg = XPath.first(@xml, "//error/message").text
+        Configuration.instance.logger.error "ERRORCODE: #{code.to_s} MESSAGE: #{msg}"
+        raise StandardError.new(msg)
+      end
+      Configuration.instance.logger.debug @xml.to_s
+      info_node = XPath.first(@xml, '//wc:info')
+      response_namespace = info_node.attribute('xmlns:wc').to_s
+      m = response_namespace.match(/urn\:com\.microsoft\.wc\.(.*)/)
+      if m.nil?
+        @info = nil
+      else
+        begin
+          mod = (m[1].split('.').collect {|s| classify(s)}).join('::') + "::Info.new"
+          # eval may as well be called evil
+          nfo = eval mod
+          @info = nfo
+          @info.parse_element(info_node)
+        rescue => e
+          puts e
+          Configuration.instance.logger.error e
+          @info = nil
+        end
+      end
+    end
+    
+  end
+end

data/lib/templates/complex_type_template.erb

@@ -0,0 +1,64 @@
+# -*- ruby -*-
+#--
+# Copyright 2008 Danny Coates, Ashkan Farhadtouski
+# All rights reserved.
+# See LICENSE for permissions.
+#++
+# AUTOGENERATED ComplexType
+
+module HealthVault
+  module WCData
+  <% modules.each do |m| %>module <%= classify(m) %>
+  <% end %>
+      class <%= class_name %> < ComplexType
+        
+  <% children.each do |child| %>   
+       <% if child[:max] == '1' %>
+        <% if child[:min].to_i > 0 %>#<b>REQUIRED</b><% end %>
+        <%= child[:doc] %><%= "#<em>value</em> is a #{child[:class]}" %>
+        def <%= underscore(child[:name]) %>=(value)
+          @children['<%= child[:name] %>'][:value] = value
+        end
+        
+        <%= "#<b>returns</b>: a #{child[:class]}" %>
+        def <%= underscore(child[:name]) %>
+          return @children['<%= child[:name] %>'][:value]
+        end
+       <% else %>
+        <%= "#<em>value</em> is a #{child[:class]}" %>
+        def add_<%= underscore(child[:name]) %>(value)
+          @children['<%= child[:name] %>'][:value] << value
+        end
+        
+        <%= "#<em>value</em> is a ##{child[:class]}" %>
+        def remove_<%= underscore(child[:name]) %>(value)
+            @children['<%= child[:name] %>'][:value].delete(value)
+        end
+        
+        <% if child[:min].to_i > 0 %>#<b>REQUIRED</b><% end %>
+        <%= child[:doc] %><%= "#<b>returns</b>: a #{child[:class]} Array" %>
+        def <%= underscore(child[:name]) %>
+          return @children['<%= child[:name] %>'][:value]
+        end
+       <% end %>
+  <% end %>
+      
+        def initialize
+          super
+          self.tag_name = '<%= tag_name %>'
+        <% children.each do |child| %>
+          <% if child[:max] == '1' %>
+          @children['<%= child[:name] %>'] = {:name => '<%= child[:name] %>', :class => <%= child[:class] %>, :value => nil, :min => <%= child[:min] %>, :max => <%= child[:max] %>, :order => <%= child[:order] %>, :place => :<%= child[:type]  %>, :choice => <%= child[:choice].to_i %> }
+            <% if child[:min] == '1' && child[:choice].nil? %>
+          @children['<%= child[:name] %>'][:value] = <%= child[:class] %>.new
+            <% end %>
+          <% else %>
+          @children['<%= child[:name] %>'] = {:name => '<%= child[:name] %>', :class => <%= child[:class] %>, :value => Array.new, :min => <%= child[:min] %>, :max => <%= child[:max] %>, :order => <%= child[:order] %>, :place => :<%= child[:type] %>, :choice => <%= child[:choice].to_i %> }
+          <% end %>
+        <% end %>
+        end
+      end
+  <%modules.length.times do %>end
+  <%  end %>
+  end
+end

data/lib/templates/simple_type_template.erb

@@ -0,0 +1,65 @@
+# -*- ruby -*-
+#--
+# Copyright 2008 Danny Coates, Ashkan Farhadtouski
+# All rights reserved.
+# See LICENSE for permissions.
+#++
+# AUTOGENERATED class
+
+module HealthVault
+  module WCData
+  <% modules.each do |m| %>module <%= classify(m) + "\n" %><% end %>
+      <%= "##{class_name} is a #{children['base'].to_s}" %>
+      class <%= class_name %> < SimpleType
+      <% children.each do |name, target| %>
+        <% if name == 'enumeration' %>
+            <% target.each do |enum| %>
+        def self.<%= enum.empty? ? 'empty' : underscore(enum.to_s.downcase.strip.gsub(' ', '_')) %>
+          return '<%= enum.to_s %>'
+        end
+            <% end %>
+        def self.enum
+          return ['<%=  target.join("','") %>']
+        end        
+        <% elsif name != 'base' %>
+        <%= "##{name} = #{target.to_s}" %>
+        def <%= name %>(value)
+        <% case name 
+           when 'minExclusive' %>
+          return value > <%= target %>
+        <% when 'minInclusive' %>
+          return value >= <%= target %>
+        <% when 'maxExclusive' %>
+          return value < <%= target %>
+        <% when 'minInclusive' %>
+          return value <= <%= target %>
+        <% when 'length' %>
+          return value.length == <%= target %>
+        <% when 'minLength' %>
+          return value.length > <%= target %>
+        <% when 'maxLength' %>
+          return value.length < <%= target %>
+        <% else %>
+          return true
+        <% end %>
+        end
+        <% end %>
+      <% end %>
+        def self.valid?(value)
+          result = true
+        <% children.each do |name, target| %>
+          <% case name 
+             when 'enumeration'%>
+          result = result && self.enum.include?(value)
+          <% when 'base' %>
+          <% else %>
+          result = result && self.<%= name %>(value)
+          <% end %>
+        <% end %>
+          return result
+        end
+      end
+  <%modules.length.times do %>end
+  <%  end %>
+  end
+end

data/lib/templates/thing_class_extension_template.erb

@@ -0,0 +1,22 @@
+# -*- ruby -*-
+#--
+# Copyright 2008 Danny Coates, Ashkan Farhadtouski
+# All rights reserved.
+# See LICENSE for permissions.
+#++
+#AUTOGENERATED Thing extension
+
+module HealthVault
+  module WCData
+    module Thing
+      class Thing        
+        @@class_hash = Hash.new  
+        <% class_hash.each do |key, val| %>
+        @@class_hash['<%= key %>'] = <%= val %><% end %>
+        def self.guid_to_class(guid)
+          return @@class_hash[guid]
+        end        
+      end
+    end
+  end
+end

data/lib/utils/crypto_utils.rb

@@ -0,0 +1,69 @@
+# -*- ruby -*-
+#--
+# Copyright 2008 Danny Coates, Ashkan Farhadtouski
+# All rights reserved.
+# See LICENSE for permissions.
+#++
+
+require 'openssl'
+require 'base64'
+
+module HealthVault
+  class CryptoUtils
+    include OpenSSL
+    def self.create_shared_secret
+      unless File.exist?("/dev/urandom")
+        Random.seed(rand(0).to_s + Time.now.usec.to_s)
+      end
+      data = BN.rand(2048, -1, false).to_s
+      return OpenSSL::Digest::SHA1.new(data).digest
+    end
+    
+    def self.encode64(text)
+      return Base64.encode64(text).gsub(/\n/, "")
+    end
+    
+    def self.hmac(key, text)
+      return HMAC.digest(OpenSSL::Digest::Digest.new("SHA1"), key, text)
+    end
+    
+    def self.digest(text)
+      return OpenSSL::Digest::SHA1.new(text).digest
+    end
+  end
+  
+  class CryptoKey
+    def initialize(pfx_or_pem_filename, password = nil)
+      begin
+        #INFO: I can't get OpenSSL::PKCS12 working on windows.
+        # This call fails with 'mac verify failed'
+        # To work around this I created a pem on the command line like:
+        # openssl pkcs12 -in xxx.pfx -out xxx.pem -nodes
+        @pfx = OpenSSL::PKCS12::PKCS12.new(File.read(pfx_or_pem_filename), password)
+        #TODO if pfx files are going to be a problem, maybe we just ought to remove
+      rescue
+        @pfx = nil
+        @pkey = OpenSSL::PKey::RSA.new(File.read(pfx_or_pem_filename),password)
+        @cert = OpenSSL::X509::Certificate.new(File.read(pfx_or_pem_filename))
+      end
+    end
+    
+    def sign(text)
+      if @pfx.nil?
+        return @pkey.sign(OpenSSL::Digest::SHA1.new, text)
+      else
+        return @pfx.key.sign(OpenSSL::Digest::SHA1.new, text)
+      end
+      
+    end
+    
+    def fingerprint
+      if @pfx.nil?
+        return OpenSSL::Digest::SHA1.hexdigest(@cert.to_der)
+      else
+        return OpenSSL::Digest::SHA1.hexdigest(@pfx.certificate.to_der)
+      end
+      
+    end
+  end
+end

data/lib/utils/string_utils.rb

@@ -0,0 +1,35 @@
+# -*- ruby -*-
+#--
+# Copyright 2008 Danny Coates, Ashkan Farhadtouski
+# All rights reserved.
+# See LICENSE for permissions.
+#++
+
+module HealthVault
+  module StringUtils
+    def camelize(string)
+      result = ""
+      parts = string.split('_')
+      result << parts.first.downcase
+      parts[1..-1].each {|s| result << s.downcase.capitalize}
+      return result
+    end
+      
+    def underscore(camel_cased_word)
+      return camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+    
+    def classify(string)
+      if string.length > 1
+        class_name =  string[/./].upcase + string[1..-1]
+      else
+        class_name = string
+      end
+      return class_name.gsub('-', '')
+    end
+  end
+end

data/lib/wc_data/complex_type.rb

@@ -0,0 +1,249 @@
+# -*- ruby -*-
+#--
+# Copyright 2008 Danny Coates, Ashkan Farhadtouski
+# All rights reserved.
+# See LICENSE for permissions.
+#++
+
+require 'rexml/document'
+
+module HealthVault
+  module WCData
+    class ComplexType
+      include REXML
+      attr_accessor :tag_name
+      
+      def initialize
+        @children = Hash.new
+      end
+      
+      def required_elements
+        return query_elements {|v| v[:min] > 0}
+      end
+      
+      def optional_elements
+        return query_elements {|v| v[:min] == 0}
+      end
+      
+      def query_elements
+        result = Array.new
+        if block_given?
+          @children.each do |key, value|
+            if yield value
+              result << key
+            end
+          end
+        else
+          result = @children.keys
+        end
+        return result        
+      end
+
+      # construct REXML::Element tree from children
+      def element(container = nil)
+        #cname = self.class.to_s
+        my_name = tag_name.to_s.strip.downcase#cname.split('::')[-1].downcase#
+        if container.nil?
+          me = Element.new(my_name)
+        elsif container.is_a?(String)
+          me = Element.new(container)
+        else
+          me = container
+        end
+        elements = @children.values.sort{|a,b| a[:order] <=> b[:order]}
+        elements.each do |el|
+          val = el[:value]
+          next if val.nil?
+          if val.is_a?(Array)
+            val.each do |v|
+              sub_element(el[:name], v, me)
+            end
+          else
+            if el[:place] == :extension
+              sub_element(el[:name], val, me, false)
+            elsif el[:place] == :attribute
+              me.add_attribute(el[:name], val.to_s)
+            else
+              sub_element(el[:name], val, me)
+            end
+          end
+        end
+        return me
+      end
+      
+      # parse WCData from the given xml element
+      def parse_element(e)
+        # parse elements
+        e.elements.each do |child|
+          node = child.name
+          if @children[node].nil?
+            begin
+              unless @children['anything'].nil?
+                #see if the parent is a 'thing'
+                types = e.parent.get_elements('type-id')
+                unless types.empty?
+                  type_guid = types[0].text.to_s
+                  type = WCData::Thing::Thing.guid_to_class(type_guid)
+                  #add_new_to_children(@children['anything'][:value], child, type)  
+                  x = type.new
+                  #TODO make SimpleTypes behave like their base types
+                  #<HACK>
+                  if x.is_a?(SimpleType) || x.is_a?(String)
+                    x = child.text
+                  end
+                  #</HACK>
+                  if x.respond_to?(:parse_element)
+                    x.parse_element(child)
+                  end
+                  @children['anything'][:class] = type
+                  if @children['anything'][:value].is_a?(Array)
+                    @children['anything'][:value] << x
+                  else
+                    @children['anything'][:value] = x
+                  end                
+                end
+              end
+            rescue => err
+              Configuration.instance.logger.error err
+            end
+            # unknown node type
+            Configuration.instance.logger.debug "unknown node of #{node} for #{self.class.to_s}"
+          else
+            #add_new_to_children(@children[node][:value],child, @children[node][:class])
+            x = @children[node][:class].new
+            #TODO make SimpleTypes behave like their base types
+            #<HACK>
+            if x.is_a?(SimpleType) || x.is_a?(String)
+              x = child.text
+            end
+            #</HACK>
+            if x.respond_to?(:parse_element)
+              x.parse_element(child)
+            end
+            if @children[node][:value].is_a?(Array)
+              @children[node][:value] << x
+            else
+              @children[node][:value] = x
+            end
+          end
+        end       
+        # parse inner text
+        if !@children['data'].nil? && !e.text.empty?
+          @children['data'][:value] = e.text
+        end
+        # parse attributes
+        e.attributes.each_attribute do |attr|
+          name = attr.name
+          if @children[name].nil?
+            # unknown attribute type
+            Configuration.instance.logger.debug "unknown attribute of #{name} for #{self.class.to_s}"
+          else
+            @children[name][:value] = attr.value.to_s
+          end
+        end
+      end
+      
+      def add_new_to_children(target, node, klass)
+        x = klass.new
+        #TODO make SimpleTypes behave like their base types
+        #<HACK>
+        if x.is_a?(SimpleType) || x.is_a?(String)
+          x = node.text
+        end
+        #</HACK>
+        if x.respond_to?(:parse_element)
+          x.parse_element(node)
+        end
+        if target.is_a?(Array)
+          target << x
+        else
+          target = x
+        end
+      end
+      
+      def valid?
+        valid = true
+        choices = Hash.new
+        @children.values.each do |child|
+          if child[:place] == :element && child[:choice].to_i > 0
+            choices[child[:choice]] ||= false
+            #TODO: validate choices
+          elsif child[:min] > 1
+            len = child[:value].length
+            valid = valid && (len > child[:min])
+            valid = valid && (len < child[:max])
+            child[:value].each do |v|
+              break if !valid
+              begin
+                if child[:class].superclass == ComplexType
+                  valid = valid && v.valid?
+                elsif child[:class].superclass == SimpleType
+                  valid = valid && child[:class].valid?(v)
+                else
+                  valid = valid && !(v.nil? || v.to_s.empty?)
+                end
+              rescue => e
+                Configuration.instance.logger.error e
+                valid = false
+                break
+              end
+            end
+          elsif child[:min] == 1
+            #TODO extract the checks to a seperate method
+            begin
+              if child[:class].superclass == ComplexType
+                valid = valid && child[:value].valid?
+              elsif child[:class].superclass == SimpleType
+                valid = valid && child[:class].valid?(child[:value])
+              else
+                valid = valid && !(child[:value].nil? || child[:value].to_s.empty?)
+              end
+            rescue => e
+              Configuration.instance.logger.error e
+              valid = false
+              break
+            end
+          end          
+        end
+        return valid
+      end
+      
+      # xml string
+      def to_s
+        return element.to_s
+      end
+      
+      def method_missing(name, *args, &blk)
+        #For more ease of use, forward method calls for
+        #complexTypes that contain 'anything' nodes
+        #to the 'anything', i.e. try to make 'anything' transparent
+        unless @children['anything'].nil?
+          #INFO: this will only work for single 'anythings'
+          if @children['anything'][:value].respond_to?(name)
+            return @children['anything'][:value].send(name, *args, &blk)            
+          end          
+        end
+        raise NoMethodError
+      end
+
+      private
+
+      def sub_element(name, obj, parent, tag = true)
+        if tag
+          n = Element.new(name, parent)
+          if obj.is_a?(ComplexType)
+            obj.element(n)
+          else
+            n.text = obj.to_s
+          end
+        else
+          if obj.is_a?(ComplexType)
+            parent << obj.element
+          else
+            parent.text = obj.to_s
+          end
+        end
+      end
+    end
+  end
+end