cs 0.1.0beta3

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.rspec
+.autotest
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/vcr
+spec/support/spec_config.yml

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in commonsense-ruby-lib.gemspec
+gemspec
+gem "pry"
+gem "pry-nav"
+gem "pry-doc"
+gem "redcarpet"
+gem "time-lord"
+#gem "pry-stack_explorer"

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ahmy Yulrizka
+
+MIT License
+
+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,132 @@
+# Commonsense::Ruby::Lib
+Client library to communicate with CommonSense written in ruby
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'commonsense-ruby-lib'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install commonsense-ruby-lib
+
+## Usage
+
+### Authentication
+```ruby
+client = CommonSense::Client.new
+client.login('username','password')
+
+# get current user
+current_user = client.current_user
+```
+
+### Querying Sensor
+```ruby
+# create sensors relation
+sensors = client.sensors
+
+# is the same as
+sensors = CommonSense::Relation::Sensors.new
+sensors.session = session
+
+# Get all sensor
+sensors = client.sensors
+sensors.to_a
+
+# Get sensor by specifying parameters
+client.sensors.where(page: 0, per_page: 1000)
+client.sensors.where(owned: true)
+client.sensors.where(physical: true)
+client.sensors.where(page: 0, per_page: 1000, physical: true, owned: true, details: "full")
+
+# process each sensor
+client.sensors.where(owned: true).each {|sensor| puts sensor.name}
+
+# Chain parameters
+client.sensors.where(page:0, per_page: 10).where(physical: true)
+
+# Find sensor by name
+client.sensors.find_by_name(/position/)
+client.sensors.find_by_name(/position/, owned: true) # or
+client.sensors.where(owned: true).find_by_name(/position/)
+
+# Get first sensor or last sensor
+sensor = client.sensors.first
+sensor = client.sensors.last
+
+# Get number of sensors
+client.sensors.count
+client.sensors.where(owned: true).count
+```
+
+### Creating Sensor
+
+```ruby
+sensor = client.sensor.build
+sensor.name = "light"
+sensor.display_name = "Light"
+sensor.device_type = "Android"
+sensor.pager_type = ""
+sensor.data_type = "json"
+sensor.data_structure = {lux: "integer"}
+sensor.save!
+```
+
+### Uploading data point
+
+```ruby
+# Find the first position sensor
+sensor = client.sensors.find_by_name(/position/).first
+
+# save data point
+data = sensor.data.build
+data.date = Time.now
+data.value = {"lux" => 1}
+data.save!
+
+# more compact version
+sensor.data.build(date: Time.now, value: {"lux" => 1}).save!
+```
+
+### Debuging
+
+To get information about the API response (body, code, headers) inspect the session
+
+example
+
+```ruby
+# do some API call
+current_user = client.current_user
+
+# get the session
+session = client.session
+
+response_code = session.response_code
+response_body = session.resopnse_body
+header = session.response_headers
+
+# dump the output to text file
+session.dump_to_text("/tmp/output.txt")
+
+# open output in browser. Require 'launchy' gem
+session.open_in_browser
+```
+
+## Testing
+
+    $ cp spec/support/spec_config.yml.sample spec/support/spec_config.yml
+    $ rspec
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+require 'rubygems'
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+

data/cs.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/commonsense-ruby-lib/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ahmy Yulrizka"]
+  gem.email         = ["ahmy@sense-os.nl"]
+  gem.description   = %q{CommonSense API client library}
+  gem.summary       = %q{Client library to communicate with CommonSense written in ruby}
+  gem.homepage      = "https://github.com/senseobservationsystems/commonsense-ruby-lib"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "cs"
+  gem.require_paths = ["lib"]
+  gem.version       = CommonSense::VERSION
+  gem.add_development_dependency("rspec", "~> 2.13.0")
+  gem.add_development_dependency("launchy", "~> 2.3.0")
+  gem.add_development_dependency("fakeweb", "~> 1.3.0")
+  gem.add_dependency('httparty', '~> 0.11.0')
+  gem.add_dependency('oauth', '~> 0.4.7')
+end

data/lib/commonsense-ruby-lib.rb

@@ -0,0 +1,127 @@
+require "commonsense-ruby-lib/version"
+require "commonsense-ruby-lib/error"
+require "commonsense-ruby-lib/auth/http"
+require "commonsense-ruby-lib/auth/oauth"
+require "commonsense-ruby-lib/session"
+require "commonsense-ruby-lib/end_point"
+require "commonsense-ruby-lib/end_point/user"
+require "commonsense-ruby-lib/end_point/group"
+require "commonsense-ruby-lib/end_point/sensor"
+require "commonsense-ruby-lib/end_point/sensor_data"
+require "commonsense-ruby-lib/relation"
+require "commonsense-ruby-lib/relation/sensor_relation"
+require "commonsense-ruby-lib/relation/sensor_data_relation"
+
+module CommonSense
+
+  # Main entry class of the library.
+  #
+  # The login functionality always comes in two pair. The Bang (!) method
+  # will raise an exception when there is an error and the normal (without !)
+  # will return nil when it fails.
+  #
+  # The response can be viewed by looking at the {CommonSense::Session}
+  #
+  #     client.session # will return the session object
+  #
+  # == Authentication with User And Password
+  #
+  #     client = CommonSense::Client.new
+  #     client.login('username', 'password')
+  #
+  # == Authentication using OAuth
+  #
+  #     client = CommonSense::Client.new
+  #     client.oauth('CONSUMER_KEY', 'CONSUMER_SECRET', 'ACCESS_TOKEN', 'ACCESS_TOKEN_SECRET')
+  #
+  # == Using different API server
+  #
+  #     client = CommonSense::Client.new(base_uri: 'https://api.dev.sense-os.nl')
+  #     # or
+  #     client.base_uri = 'https://api.dev.sense-os.nl'
+  #
+  class Client
+    attr_accessor :session, :base_uri
+
+    def initialize(opts={})
+      options = {
+        base_uri: 'https://api.sense-os.nl',
+      }.merge(opts)
+      @base_uri = options[:base_uri]
+    end
+
+    # Create a new session to CommonSense using username and plain text password
+    # with `login!` it will throw exception if there is an error
+    #
+    #    client = CommonSense::Client.new
+    #    client.login!('username', 'password')
+    def login!(user, password)
+      @session = Session.new(base_uri: @base_uri)
+      @session.login(user, password)
+    end
+
+    # Create a new session to CommonSense using username and plain text password
+    # with `login` it will return nil if it not successful
+    #
+    #    client = CommonSense::Client.new
+    #    client.login('username', 'password')
+    def login(user, password)
+      login!(user, password) rescue nil
+    end
+
+    # Create a new session to CommonSense using OAuth credentials
+    #
+    #    client = CommonSense::Client.new
+    #    client.login('username', 'password')
+    def oauth(consumer_key, consumer_secret, access_token, access_token_secret)
+      @session = Session.new(base_uri: @base_uri)
+      @session.oauth(consumer_key, consumer_secret, access_token, access_token_secret)
+    end
+
+    # Create new session by manually specifiying `session_id` parameter
+    #
+    #     client = CommonSense::Client.new
+    #     client.session_id('12345')
+    def set_session_id(session_id)
+      @session = Session.new(base_uri: @base_uri)
+      @session.session_id = session_id
+    end
+
+    # Retrun logged in user
+    def current_user
+      user = EndPoint::User.new
+      user.session = @session
+      user.current_user
+    end
+
+    # Create a new user
+    #
+    #     client = CommonSense::Client.new
+    #     client.new_user(username: 'Ahmy')
+    #     client.email = 'ahmy@gmail.com'
+    #     ...
+    #     client.save!
+    def new_user(hash={})
+     user = EndPoint::User.new(hash)
+     user.session = Session.new(base_uri: @base_uri, authentication: false)
+     user
+    end
+
+    # @see CommonSense::Relation::SensorRelation
+    def sensors
+      Relation::SensorRelation.new(@session)
+    end
+
+    def current_groups
+      group = EndPoint::Group.new
+      group.session = @session
+      group.current_groups
+    end
+
+    # return errors got from session
+    def errors
+      return @session.errors if @session
+    end
+  end
+end
+

data/lib/commonsense-ruby-lib/auth/http.rb

@@ -0,0 +1,117 @@
+require "httparty"
+require "json"
+
+module CommonSense
+  module Auth
+    class HTTP
+      include HTTParty
+
+      attr_accessor :response_body, :response_code, :response_headers, :errors
+      attr_reader :session_id
+
+      def initialize(base_uri = nil)
+        self.base_uri = base_uri
+        @session_id = nil
+        reset
+      end
+
+      def get(path, query={}, headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        options = {query: query, headers: headers} 
+        @response_body = self.class.get(path, options)
+        parse_response
+        @response_body
+      end
+
+      def post(path, body = '', headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        @response_body = self.class.post(path, prepare(body, headers))
+        parse_response
+        @response_body
+      end
+
+      def put(path, body = '', headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        @response_body = self.class.put(path, prepare(body, headers))
+        parse_response
+        @response_body
+      end
+
+      def delete(path, query={}, headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        options = {query: query, headers: headers} 
+        @response_body = self.class.delete(path, options)
+        parse_response
+        @response_body
+      end
+
+      def head(path, headers = {})
+        reset
+        @response_body = self.class.head(path, prepare(nil, headers))
+        parse_response
+        @response_body
+      end
+
+      def base_uri=(uri = nil)
+        self.class.base_uri uri
+      end
+
+      def default_headers
+        header = self.class.default_options[:headers] || {}
+        header.merge({"Content-Type" => "application/json"})
+        if @session_id
+          header.merge!('X-SESSION_ID' => self.session_id)
+        end
+        header
+      end
+
+      def default_headers=(header_hash)
+        self.class.default_options[:headers] = header_hash
+      end
+
+      def session_id=(session_id)
+        @session_id = session_id
+      end
+
+
+      # login to commonsense
+      # @return [String] session_id
+      def login(username, password)
+        password = Digest::MD5.hexdigest password
+        post('/login.json', {:username => username, :password => password})
+
+        if @response_code == 200
+          self.session_id = response_body['session_id']
+        else
+          errors = [response_body['error']]
+        end
+
+        session_id
+      end
+
+      private
+      def reset
+        @errors = nil
+        @response_code = nil
+        @response_body = nil
+      end
+
+      def parse_response
+        @response_code = @response_body.response.code.to_i
+        @response_headers = @response_body.headers
+        if @response_code >= 400
+          @errors = [response_body['error']]
+        end
+      end
+
+      def prepare(body=nil, headers={})
+        headers = default_headers.merge(headers)
+        {:body => body.to_json, :headers => headers}
+      end
+    end
+  end
+end