latch-sdk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6059a598c347a268972aec50301bac778e0a208a
+  data.tar.gz: 8f5d3b7711b4181234f56ea723d44b60ddad42d7
+SHA512:
+  metadata.gz: 4af6bdcdbd00ddfac2571c7e1aec97989e3211c820443515a7c009bf7f52fa1658c0c09a42a85da79ba3774ff2d17fa927d4d61be8c7fcc6797cfba446abe3f0
+  data.tar.gz: 2220962f2845d2b9819bfe93fde77af8bb9ac367c39c3e2055a8766cc4da79e639408519e299c9dc6ccbfcdeafd62d3f0e7a7d4864c3cbecafe8227408444edf

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/latch.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name     = 'latch-sdk'
+  s.version  = '0.0.1'
+  s.platform = Gem::Platform::RUBY
+  s.summary  = 'Latch SDK'
+  s.email = 'crresse@gmail.com'
+  # s.homepage = ''
+  s.description = s.summary
+  s.authors = ['Carlos Rodriguez']
+  s.license = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # s.add_development_dependency('rake', '>= 0.9')
+  # s.add_development_dependency('rdoc', '>= 3')
+  s.add_development_dependency('rails', '>= 4.0')
+  # s.add_development_dependency('sqlite3')
+  # s.add_development_dependency('rspec-rails')
+end

data/lib/latch.rb

@@ -0,0 +1,6 @@
+require 'latch/latch'
+require 'latch/latch_response'
+require 'latch/error'
+
+module Latch
+end

data/lib/latch/error.rb

@@ -0,0 +1,45 @@
+# Latch Ruby SDK - Set of  reusable classes to  allow developers integrate Latch on their applications.
+# Copyright (C) 2013 Eleven Paths
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Latch
+  class Error
+    attr_reader :code
+    attr_reader :message
+
+    # @param string json a Json representation of an error with "code" and "message" elements
+    def initialize(json)
+      if (json.is_a?(String))
+        json = JSON.Parse(json)
+      end
+
+      if(json.has_key?("code")  && json.has_key?("message"))
+        @code = json["code"]
+        @message = json["message"]
+      else
+        puts "Error creating error object from string " + json
+      end
+      end
+
+      # JSON representing the Error Object
+      def to_json
+      error =  {}
+      error["code"] = @code
+      error["message"] = @message
+      error.to_json
+    end
+  end
+end

data/lib/latch/latch.rb

@@ -0,0 +1,292 @@
+# Latch Ruby SDK - Set of  reusable classes to  allow developers integrate Latch on their applications.
+# Copyright (C) 2013 Eleven Paths
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Latch
+  class Latch
+    attr_accessor :api_host
+    API_HOST = 'https://latch.elevenpaths.com'
+    API_VERSION = '0.9'
+    API_CHECK_STATUS_URL = "/api/#{API_VERSION}/status"
+    API_PAIR_URL = "/api/#{API_VERSION}/pair"
+    API_PAIR_WITH_ID_URL = "/api/#{API_VERSION}/pairWithId"
+    API_UNPAIR_URL =  "/api/#{API_VERSION}/unpair"
+    API_LOCK_URL =  "/api/#{API_VERSION}/lock"
+    API_UNLOCK_URL =  "/api/#{API_VERSION}/unlock"
+    API_HISTORY_URL =  "/api/#{API_VERSION}/history"
+    API_OPERATIONS_URL =  "/api/#{API_VERSION}/operation"
+
+    AUTHORIZATION_HEADER_NAME = 'Authorization'
+    DATE_HEADER_NAME = 'X-11Paths-Date'
+    AUTHORIZATION_METHOD = '11PATHS'
+    AUTHORIZATION_HEADER_FIELD_SEPARATOR = ' '
+
+    HMAC_ALGORITHM = 'sha1'
+
+    X_11PATHS_HEADER_PREFIX = 'X-11Paths-'
+    X_11PATHS_HEADER_SEPARATOR = ':'
+
+    # The custom header consists of three parts, the method, the appId and the signature.
+    # This method returns the specified part if it exists.
+    # @param $part The zero indexed part to be returned
+    # @param $header The HTTP header value from which to extract the part
+    # @return string the specified part from the header or an empty string if not existent
+    def getPartFromHeader(part, header)
+      if (header.empty?)
+        parts = header.split(AUTHORIZATION_HEADER_FIELD_SEPARATOR)
+        if(parts.length > part)
+          return parts[part]
+        end
+      end
+      return ""
+    end
+
+    # @param $authorizationHeader Authorization HTTP Header
+    # @return string the Authorization method. Typical values are "Basic", "Digest" or "11PATHS"
+    def getAuthMethodFromHeader(authorizationHeader)
+      getPartFromHeader(0, authorizationHeader)
+      end
+
+    # @param $authorizationHeader Authorization HTTP Header
+    # @return string the requesting application Id. Identifies the application using the API
+      def getAppIdFromHeader(authorizationHeader)
+        getPartFromHeader(1, authorizationHeader)
+      end
+
+
+    # @param $authorizationHeader Authorization HTTP Header
+    # @return string the signature of the current request. Verifies the identity of the application using the API
+      def getSignatureFromHeader(authorizationHeader)
+        getPartFromHeader(2, authorizationHeader)
+      end
+
+
+    # Create an instance of the class with the Application ID and secret obtained from Eleven Paths
+    # @param $appId
+    # @param $secretKey
+      def initialize(appid, secret)
+        @appid = appid
+        @secret = secret
+        @api_host = API_HOST
+      end
+
+      def http(method, url, headers, params=nil)
+             uri = URI.parse(url)
+         http = Net::HTTP.new(uri.host, uri.port)
+
+              if (uri.default_port == 443)
+          http.use_ssl = true
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+              end
+
+              if(method == "GET")
+        request = Net::HTTP::Get.new(uri.request_uri)
+      elsif (method == 'POST')
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.set_form_data(params)
+          elsif (method == "PUT")
+            request = Net::HTTP::Put.new(uri.request_uri)
+        request.set_form_data(params)
+          elsif (method == "DELETE")
+            request = Net::HTTP::Delete.new(uri.request_uri)
+          end
+
+      headers.map do |key,value|
+        request[key] = value
+      end
+
+      response = http.request(request)
+      response.body
+      end
+
+
+    def http_get_proxy(url)
+      LatchResponse.new(http("GET", api_host + url, authenticationHeaders('GET', url, nil)))
+    end
+
+    def http_post_proxy(url, params)
+      LatchResponse.new(http("POST", api_host + url, authenticationHeaders('POST', url, nil, nil, params), params))
+    end
+
+    def http_put_proxy(url, params)
+      LatchResponse.new(http("PUT", api_host + url, authenticationHeaders('PUT', url, nil, nil, params), params))
+    end
+
+    def http_delete_proxy(url)
+      LatchResponse.new(http("DELETE", api_host + url, authenticationHeaders('DELETE', url, nil)))
+    end
+
+    def pairWithId(accountId)
+      http_get_proxy(API_PAIR_WITH_ID_URL + '/' + accountId)
+    end
+
+
+    def pair(token)
+      http_get_proxy(API_PAIR_URL + '/' + token)
+    end
+
+
+    def status(accountId)
+      http_get_proxy(API_CHECK_STATUS_URL + '/' + accountId)
+    end
+
+
+    def operationStatus(accountId, operationId)
+      http_get_proxy(API_CHECK_STATUS_URL + "/" + accountId + '/op/' + operationId)
+    end
+
+
+    def unpair(accountId)
+      http_get_proxy(API_UNPAIR_URL + '/' + accountId)
+    end
+
+    def lock(accountId, operationId=nil)
+      if (operationId  == nil)
+        http_post_proxy(API_LOCK_URL + '/' + accountId, {})
+      else
+        http_post_proxy(API_LOCK_URL + '/' + accountId + '/op/' + operationId, {})
+          end
+    end
+
+    def unlock(accountId, operationId=nil)
+      if (operationId  == nil)
+        http_post_proxy(API_UNLOCK_URL + '/' + accountId, {})
+      else
+        http_post_proxy(API_UNLOCK_URL + '/' + accountId + '/op/' + operationId, {})
+          end
+    end
+
+    def history (accountId, from='0', to=nil)
+      if (to == nil)
+        to = Time.now.to_i*1000
+      end
+      http_get_proxy(API_HISTORY_URL + '/' + accountId + '/' + from + '/' + to.to_s)
+    end
+
+    def createOperation(parentId, name, twoFactor, lockOnRequest)
+      params = { 'parentId' => parentId, 'name' => name, 'two_factor'=>twoFactor, 'lock_on_request'=>lockOnRequest}
+      http_put_proxy(API_OPERATIONS_URL, params)
+    end
+
+    def updateOperation(operationId, name, twoFactor, lockOnRequest)
+      params = { 'name' => name, 'two_factor'=>twoFactor, 'lock_on_request'=>lockOnRequest}
+      http_post_proxy(API_OPERATIONS_URL + '/' + operationId, params)
+    end
+
+    def deleteOperation(operationId)
+      http_delete_proxy(API_OPERATIONS_URL + '/' + operationId)
+    end
+
+    def getOperations(operationId=nil)
+      if (operationId == nil)
+        http_get_proxy(API_OPERATIONS_URL)
+      else
+        http_get_proxy(API_OPERATIONS_URL + '/' + operationId)
+      end
+    end
+
+    # @param $data the string to sign
+    # @return string base64 encoding of the HMAC-SHA1 hash of the data parameter using {@code secretKey} as cipher key.
+    def signData(data)
+      Base64.encode64(OpenSSL::HMAC.digest(HMAC_ALGORITHM, @secret, data))
+    end
+
+
+    # Calculate the authentication headers to be sent with a request to the API
+    # @param $HTTPMethod the HTTP Method, currently only GET is supported
+    # @param $queryString the urlencoded string including the path (from the first forward slash) and the parameters
+    # @param $xHeaders HTTP headers specific to the 11-paths API. null if not needed.
+    # @param $utc the Universal Coordinated Time for the Date HTTP header
+    # @return array a map with the Authorization and Date headers needed to sign a Latch API request
+    def authenticationHeaders(httpMethod, queryString, xHeaders=nil, utc=nil, params=nil)
+      if (utc == nil)
+        utc = getCurrentUTC
+      end
+
+      stringToSign = (httpMethod.upcase).strip + "\n" +
+              utc.to_s + "\n" +
+              getSerializedHeaders(xHeaders) + "\n" +
+              queryString.strip
+
+      if (params != nil && params.size > 0)
+        serializedParams = getSerializedParams(params)
+        if (serializedParams != nil && serializedParams.size > 0)
+          stringToSign = stringToSign.strip + "\n" + serializedParams
+        end
+      end
+
+      authorizationHeader = AUTHORIZATION_METHOD +
+                   AUTHORIZATION_HEADER_FIELD_SEPARATOR +
+                   @appid +
+                   AUTHORIZATION_HEADER_FIELD_SEPARATOR +
+                   signData(stringToSign).chop
+
+      headers = {}
+      headers[AUTHORIZATION_HEADER_NAME] = authorizationHeader
+      headers[DATE_HEADER_NAME] = utc
+      return headers
+    end
+
+
+
+    # Prepares and returns a string ready to be signed from the 11-paths specific HTTP headers received
+    # @param $xHeaders a non necessarily ordered map of the HTTP headers to be ordered without duplicates.
+    # @return a String with the serialized headers, an empty string if no headers are passed, or null if there's a problem
+    # such as non 11paths specific headers
+    def getSerializedHeaders(xHeaders)
+      if(xHeaders != nil)
+        headers = xHeaders.inject({}) do |xHeaders, keys|
+          hash[keys[0].downcase] = keys[1]
+          hash
+        end
+
+
+        serializedHeaders = ''
+
+        headers.sort.map do |key,value|
+          if(key.downcase == X_11PATHS_HEADER_PREFIX.downcase)
+            puts "Error serializing headers. Only specific " + X_11PATHS_HEADER_PREFIX + " headers need to be singed"
+            return nil
+          end
+          serializedHeaders += key + X_11PATHS_HEADER_SEPARATOR + value + ' '
+        end
+        substitute = 'utf-8'
+        return serializedHeaders.gsub(/^[#{substitute}]+|[#{substitute}]+$/, '')
+      else
+        return ""
+      end
+    end
+
+    def getSerializedParams(parameters)
+      if (parameters != nil)
+        serializedParams = ''
+
+        parameters.sort.map do |key,value|
+          serializedParams += key + "=" + value + '&'
+        end
+        substitute = '&'
+        return serializedParams.gsub(/^[#{substitute}]+|[#{substitute}]+$/, '')
+      else
+        return ""
+      end
+    end
+
+    # @return a string representation of the current time in UTC to be used in a Date HTTP Header
+    def getCurrentUTC
+      Time.now.utc
+    end
+  end
+end

data/lib/latch/latch_response.rb

@@ -0,0 +1,56 @@
+# Latch Ruby SDK - Set of  reusable classes to  allow developers integrate Latch on their applications.
+# Copyright (C) 2013 Eleven Paths
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module Latch
+  # This class models a response from any of the endpoints in the Latch API.
+  # It consists of a "data" and an "error" elements. Although normally only one of them will be
+  # present, they are not mutually exclusive, since errors can be non fatal, and therefore a response
+  # could have valid information in the data field and at the same time inform of an error.
+  class LatchResponse
+    attr_accessor :data
+    attr_accessor :error
+
+    # @param jsonString a json string received from one of the methods of the Latch API
+    def initialize(jsonString)
+      json = JSON.parse(jsonString)
+
+      if(json != nil)
+        if (json.has_key?("data"))
+          @data = json["data"]
+        end
+
+        if (json.has_key?("error"))
+          @error = Error.new(json["error"])
+        end
+      end
+      end
+
+      # Get JSON String that represents the LatchResponse object
+    def to_json
+      response = {}
+
+      if (@data != nil)
+        response["data"] = @data
+      end
+
+      if (@error != nil)
+        response["error"] = @error.to_json
+      end
+      response.to_json
+    end
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: latch-sdk
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Carlos Rodriguez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Latch SDK
+email: crresse@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- latch.gemspec
+- lib/latch.rb
+- lib/latch/error.rb
+- lib/latch/latch.rb
+- lib/latch/latch_response.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Latch SDK
+test_files: []