cs 0.1.0beta3

data/lib/commonsense-ruby-lib/relation/sensor_relation.rb

@@ -0,0 +1,162 @@
+module CommonSense
+  module Relation
+
+    # Class that used to query List of sensor data from CS.
+    #
+    # == parameters
+    # The relation object has serveral parameter
+    #
+    # * page     : Integer, number of page in pagination. starts from 0
+    # * per_page : Integer, number of sensor per page, default 1000, max: 1000
+    # * shared   : Boolean, filter only sensor that is shared.
+    # * onwed    : Boolean, filter only sensor that user own.
+    # * physical : Boolean, filter only physical sensor (sensor that connected to device).
+    # * details  : String "no" or "full", gives full description of sensor
+    #
+    # == Examples
+    # This is an example how would you use the sensors relation object
+    #
+    # === Create Sensors Relation
+    #
+    #    client = CommonSense::Client.new
+    #    client.login('user', 'password')
+    #    session = client.session
+    #
+    #    # 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")
+    #
+    # === 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
+    class SensorRelation
+      include Relation
+
+      parameter :page, Integer, default: 0, required: true
+      parameter :per_page, Integer, default: 1000, required: true, maximum: 1000
+      parameter :shared, Boolean
+      parameter :owned, Boolean
+      parameter :physical, Boolean
+      parameter :details, String, valid_values: ["no", "full"]
+      parameter :group_id, String
+
+      def initialize(session=nil)
+        @session = session
+        page = 0
+        per_page = 1000
+      end
+
+      # Create a new {EndPoint::Sensor Sensor} object.
+      #
+      # example:
+      #
+      #    sensor = client.sensors.build
+      def build(attribtues={})
+        sensor = EndPoint::Sensor.new(attribtues)
+        sensor.session = self.session
+        sensor
+      end
+
+      # Find {EndPoint::Sensor Sensor} by id
+      #
+      # example:
+      #
+      #    sensor = client.sensors.find("1")
+      def find(id)
+        check_session!
+        sensor = EndPoint::Sensor.new(id: id)
+        sensor.session = self.session
+        sensor.retrieve ? sensor : nil
+      end
+
+      # Find sensor by name in regular expression.
+      # The second argument is parameter that is usualy us in {#where where}
+      #
+      # example:
+      #
+      #    client.sensors.find_by_name(/position/, owned: true)
+      def find_by_name(regex, parameters={})
+        check_session!
+        self.where(parameters)
+        self.select { |sensor| sensor.name =~ regex }
+      end
+
+      def each(&block)
+        page = self.page || 0;
+        begin
+          sensors = get_data!({
+            page: page, per_page: self.per_page, shared: self.shared,
+            owned: self.owned, physical: self.physical, details: self.details, group_id: self.group_id
+          })
+
+          sensors = sensors["sensors"]
+          if !sensors.empty?
+            sensors.each do |sensor|
+              sensor = EndPoint::Sensor.new(sensor)
+              sensor.session = session
+              yield sensor
+            end
+
+            page += 1
+          end
+
+        end while sensors.size == self.per_page
+      end
+
+      private
+      def get_url
+        "/sensors.json"
+      end
+
+      def parse_single_resource(sensors)
+        sensors = sensors["sensors"]
+        if !sensors.empty?
+          sensor = EndPoint::Sensor.new(sensors[0])
+          sensor.session = self.session
+
+          return sensor
+        end
+      end
+
+      def get_single_resource(params={})
+        options = {
+          page: 0, per_page: 1, shared: self.shared,
+          owned: self.owned, physical: self.physical, details: self.details
+        }
+        options.merge!(params)
+        get_data(options)
+      end
+    end
+  end
+end

data/lib/commonsense-ruby-lib/serializer.rb

@@ -0,0 +1,20 @@
+module CommonSense
+  module Serializer
+    def from_hash(hash)
+      if hash
+        hash.each do |k,v|
+          self.instance_variable_set("@#{k}", v) if self.respond_to?(k)
+        end
+      end
+    end
+
+    def to_h(include_nil = true)
+      symbol = self.class.attribute_set
+      hash = {}
+      symbol.each {|var| hash[var] = instance_variable_get("@#{var}")}
+
+      return include_nil ? hash : hash.reject { |k,v| v.nil? }
+    end
+
+  end
+end

data/lib/commonsense-ruby-lib/session.rb

@@ -0,0 +1,105 @@
+module CommonSense
+  class Session
+    def initialize(opts={})
+      options = {
+        base_uri: 'https://api.sense-os.nl',
+        authentication: true
+      }.merge(opts)
+      @base_uri = options[:base_uri]
+      @auth_proxy = options[:authentication] ? nil : CommonSense::Auth::HTTP.new(@base_uri)
+    end
+
+    # login to commonsense 
+    # @return [String] session_id 
+    def login(username, password)
+      @auth_proxy = CommonSense::Auth::HTTP.new(@base_uri)
+      @auth_proxy.login(username, password)
+    end
+
+    def oauth(consumer_key, consumer_secret, access_token, access_token_secret)
+      @auth_proxy = CommonSense::Auth::OAuth.new(consumer_key, consumer_secret, 
+                                                 access_token, access_token_secret,
+                                                 @base_uri)
+    end
+
+    def session_id
+      auth_proxy.session_id
+    end
+
+    def session_id=(session_id)
+      @auth_proxy = CommonSense::Auth::HTTP.new(@base_uri)
+      @auth_proxy.session_id = session_id
+    end
+
+    def auth_proxy
+      raise 'The session is not logged in' unless @auth_proxy
+      @auth_proxy
+    end
+
+    def get(path, body = '', headers = {})
+      auth_proxy.get(path, body, headers)
+    end
+
+    def post(path, body = '', headers = {})
+      auth_proxy.post(path, body, headers = {})
+    end
+
+    def put(path, body = '', headers = {})
+      auth_proxy.put(path, body, headers)
+    end
+
+    def delete(path, body='', headers = {})
+      auth_proxy.delete(path, body, headers)
+    end
+
+    def head(path, headers = {})
+      auth_proxy.head(path, headers)
+    end
+
+    def response_code 
+      auth_proxy.response_code
+    end
+
+    def response_body
+      auth_proxy.response_body
+    end
+
+    def response_headers
+      auth_proxy.response_headers
+    end
+    
+    def errors
+      auth_proxy.errors
+    end
+
+    def base_uri=(uri = nil)
+      auth_proxy.base_uri = uri
+    end
+
+    def dump_to_text(path)
+      File.open(path, 'w') do |f|
+        f.write("Response Code: #{response_code}\n")
+        f.write("Response Headers: #{response_headers}\n")
+        f.write("Errors: #{errors}\n")
+        f.write("\n")
+        f.write(response_body)
+      end
+    end
+
+    def open_in_browser(path=nil)
+      require 'launchy'
+
+      path ||= "/tmp/common-sense-ruby-#{Time.now.to_i}.html"
+      dump_to_text(path)
+      ::Launchy::Browser.run(path)
+    end
+
+    def to_s
+      "\"#{self.session_id}\""
+    end
+
+    def inspect
+      auth_proxy.kind_of?(CommonSense::Auth::HTTP) ? to_s : "OAuth"
+    end
+  end
+end

data/lib/commonsense-ruby-lib/version.rb

@@ -0,0 +1,3 @@
+module CommonSense
+  VERSION = "0.1.0beta3"
+end

data/spec/features/sensor_data_management_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe "Sensor Management" do
+end

data/spec/features/sensor_management_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe "Sensor Management" do
+
+  describe "Manage Sensor" do
+    before(:all) do
+      @client = create_client
+      @client.login($username, $password)
+    end
+
+    after(:all) do
+      @client.sensors.each {|sensors| sensors.delete}
+    end
+
+    let(:sensor_info) do
+      {
+        name: "accelerometer",
+        display_name: "Accelerometer",
+        device_type: "BMA123",
+        pager_type: "email",
+        data_type: "json",
+        data_structure: {"x-axis" => "Float", "y-axis" => "Float", "z-axis" => "Float"}
+      }
+    end
+
+    def compare_to_sensor_info(sensor)
+      sensor.name.should eq(sensor_info[:name])
+      sensor.display_name.should eq(sensor_info[:display_name])
+      sensor.display_name.should eq(sensor_info[:display_name])
+      sensor.pager_type.should eq(sensor_info[:pager_type])
+      sensor.data_type.should eq(sensor_info[:data_type])
+      sensor.data_structure.should eq(sensor_info[:data_structure])
+    end
+
+    it "create a new sensor" do
+      sensor = @client.sensors.build
+      sensor.name = sensor_info[:name]
+      sensor.display_name = sensor_info[:display_name]
+      sensor.device_type = sensor_info[:display_name]
+      sensor.pager_type = sensor_info[:pager_type]
+      sensor.data_type = sensor_info[:data_type]
+      sensor.data_structure = sensor_info[:data_structure]
+      sensor.save!
+    end
+
+    it "get list of sensor from commonSense" do
+      sensor = @client.sensors.build(sensor_info)
+      sensor.save!
+
+      @client.sensors.all.should_not be_empty
+
+      # there could be another Virtual sensor that is automatically created
+      @client.sensors.count.should be > 1
+
+      @client.sensors.each do |sensor|
+        compare_to_sensor_info(sensor)
+        break
+      end
+    end
+
+    it "get first sensor data" do
+      sensor = @client.sensors.build(sensor_info)
+      sensor.save!
+      sensor = @client.sensors.first
+
+      sensor.should_not be nil
+      compare_to_sensor_info(sensor)
+    end
+
+    it "get sensor data by id" do
+      sensor = @client.sensors.build(sensor_info)
+      sensor.save!
+
+      first = @client.sensors.first
+
+      sensor = @client.sensors.find(first.id)
+      sensor.should_not be_nil
+    end
+
+
+    it "filter sensor data" do
+      sensor = @client.sensors.build(sensor_info)
+      sensor.save!
+      sensors = @client.sensors.where(page: 0, per_page: 1, owned: true , details: "full")
+      sensors.to_a.should_not be_empty
+    end
+
+    it "should handle pagination" do
+      2.times do
+        sensor = @client.sensors.build(sensor_info)
+        sensor.save!
+      end
+
+      count = @client.sensors.count
+
+      i = 0;
+      @client.sensors.where(per_page: 1).each do
+        i += 1
+      end
+
+      i.should eq(count)
+    end
+  end
+end

data/spec/features/user_management_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe "User management" do
+
+  describe "Manage user" do
+
+    let!(:user) do
+      $user
+    end
+
+    it "create new user" do
+      current_user = user
+      current_user.id.should_not be_nil
+    end
+
+    it "get user data from commonSense" do
+      attributes = user.to_h
+
+      client = create_client
+      session_id = client.login(user.username, 'password')
+      session_id.should_not be_nil
+
+      current_user = client.current_user
+
+      attributes.each do |key, value|
+        next if key == :password
+        current_user.send(key).should eq(value)
+      end
+    end
+
+    it "update user" do
+      current_time = Time.now.to_f
+      client = create_client
+      username = "user-#{current_time}@tester.com"
+      current_user = client.new_user(username: username, email: username, password: 'password')
+      current_user.save!
+      current_user.id.should_not be_nil
+
+      expected = { username: "user-edit-#{current_time}@tester.com",
+        email: "user-edit-#{current_time}@tester.com",
+        name: "Jan Edit",
+        surname: "jagger edit",
+        address: 'Looydstraat 5 edit',
+        zipcode: '12345',
+        country: 'GERMANY',
+        mobile: '987654321'
+      }
+
+      client = create_client
+      client.session.should be_nil
+      session_id = client.login(current_user.username, 'password')
+      session_id.should_not be_nil
+      client.session.should_not be_nil
+
+      current_user = client.current_user
+
+      expected.each do |key, value|
+        current_user.send("#{key}=".to_sym, value)
+      end
+
+      current_user.save!
+      current_user.reload
+
+      expected.each do |key,value|
+        current_user.send(key).should eq(value)
+      end
+
+    end
+  end
+end