cs 0.1.0beta3 → 0.1.0

data/lib/{commonsense-ruby-lib → cs}/relation/sensor_data_relation.rb

@@ -1,7 +1,8 @@
-module CommonSense
+module CS
   module Relation
     class SensorDataRelation
       include Relation
+      include Enumerable
 
       parameter :page, Integer, default: 0
       parameter :per_page, Integer, default: 1000, maximum: 1000
@@ -15,13 +16,9 @@ module CommonSense
       parameter_alias :from, :start_date
       parameter_alias :to, :end_date
 
-      include Enumerable
-
       def initialize(sensor_id, session=nil)
         self.sensor_id = sensor_id
         self.session = session
-        page = 0
-        per_page = 1000
       end
 
       def get_url
@@ -29,40 +26,9 @@ module CommonSense
       end
 
       def build(attributes={})
-        data = EndPoint::SensorData.new
-        data.sensor_id = self.sensor_id
-        data.session = self.session
-        data
-      end
-
-      def each_batch(params={}, &block)
-        check_session!
-        options = get_options(params)
-
-        page = self.page || 0;
-        begin
-          options[:page] = page
-          data = get_data(options)
-
-          data = data["data"]
-          if !data.empty?
-            yield data
-
-            page += 1
-          end
-
-        end while data.size == self.per_page
-      end
-
-      def each(&block)
-        self.each_batch do |data|
-          data.each do |data_point|
-            sensor_data = EndPoint::SensorData.new(data_point)
-            sensor_data.sensor_id = self.sensor_id
-            sensor_data.session = session
-            yield sensor_data
-          end
-        end
+        sensor_data = super(attributes)
+        sensor_data.sensor_id = self.sensor_id
+        sensor_data
       end
 
       def count
@@ -74,7 +40,6 @@ module CommonSense
         retval
       end
 
-
       def first
         data = get_data!(page:0, per_page: 1, sort: "ASC")
         parse_single_resource(data)
@@ -98,18 +63,8 @@ module CommonSense
       end
 
       private
-      def parse_single_resource(data)
-        data = data["data"]
-        data_point = data[0]
-
-        sensor_data = nil
-        if !data.empty?
-          sensor_data = EndPoint::SensorData.new(data_point)
-          sensor_data.sensor_id = self.sensor_id
-          sensor_data.session = session
-        end
-
-        sensor_data
+      def resource_class
+        EndPoint::SensorData
       end
     end
   end

data/lib/{commonsense-ruby-lib → cs}/relation/sensor_relation.rb

@@ -1,4 +1,4 @@
-module CommonSense
+module CS
   module Relation
 
     # Class that used to query List of sensor data from CS.
@@ -18,7 +18,7 @@ module CommonSense
     #
     # === Create Sensors Relation
     #
-    #    client = CommonSense::Client.new
+    #    client = CS::Client.new
     #    client.login('user', 'password')
     #    session = client.session
     #
@@ -26,7 +26,7 @@ module CommonSense
     #    sensors = client.sensors
     #
     #    # is the same as
-    #    sensors = CommonSense::Relation::Sensors.new
+    #    sensors = CS::Relation::Sensors.new
     #    sensors.session = session
     #
     # === Get all sensor
@@ -71,33 +71,20 @@ module CommonSense
       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)
+      def find!(id)
         check_session!
         sensor = EndPoint::Sensor.new(id: id)
         sensor.session = self.session
-        sensor.retrieve ? sensor : nil
+        sensor.retrieve! ? sensor : false
+      end
+
+      def find(id)
+        find!(id) rescue false
       end
 
       # Find sensor by name in regular expression.
@@ -109,53 +96,39 @@ module CommonSense
       def find_by_name(regex, parameters={})
         check_session!
         self.where(parameters)
+        regex = /\A#{regex}\z/ if regex.kind_of?(String)
         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
+      def triggers()
+        Relation::SensorTriggersRelation.new(@session)
+      end
 
-            page += 1
-          end
+      def clone_from(other_sensor)
+        sensor = Sensor.new(other_sensor.to_parameters[:sensor])
+        sensor.id = nil
+        sensor.session = self.session
 
-        end while sensors.size == self.per_page
+        sensor
       end
 
       private
+      def resource_class
+        EndPoint::Sensor
+      end
+
       def get_url
         "/sensors.json"
       end
+    end
 
-      def parse_single_resource(sensors)
-        sensors = sensors["sensors"]
-        if !sensors.empty?
-          sensor = EndPoint::Sensor.new(sensors[0])
-          sensor.session = self.session
+    class SensorTriggersRelation
+      include Relation
 
-          return sensor
-        end
-      end
+      parameter :page, Integer, default: 0, required: true
 
-      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)
+      def get_url
+        "/sensors/triggers.json"
       end
     end
   end

data/lib/cs/relation/trigger_relation.rb

@@ -0,0 +1,21 @@
+module CS
+  module Relation
+    class TriggerRelation
+      include Relation
+
+      parameter :page, Integer, default: 0, required: true
+      parameter :per_page, Integer, default: 1000, required: true, maximum: 1000
+      parameter :total, Boolean
+
+
+      private
+      def resource_class
+        EndPoint::Trigger
+      end
+
+      def get_url
+        "/triggers.json"
+      end
+    end
+  end
+end

data/lib/cs/relation/user_relation.rb

@@ -0,0 +1,20 @@
+module CS
+  module Relation
+    class UserRelation
+      include Relation
+
+      parameter :page, Integer, default: 0, required: true
+      parameter :per_page, Integer, default: 1000, required: true, maximum: 1000
+      parameter :email, Boolean
+
+      private
+      def resource_class
+        EndPoint::User
+      end
+
+      def get_url
+        "/users.json"
+      end
+    end
+  end
+end

data/lib/{commonsense-ruby-lib → cs}/serializer.rb

@@ -1,4 +1,4 @@
-module CommonSense
+module CS
   module Serializer
     def from_hash(hash)
       if hash

data/lib/cs/session.rb

@@ -0,0 +1,170 @@
+module CS
+  class Session
+    attr_accessor :logger, :base_uri
+
+    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 : CS::Auth::HTTP.new(@base_uri)
+    end
+
+    # login to commonsense
+    # @return [String] session_id
+    def login(username, password, digest=true)
+      @auth_proxy = CS::Auth::HTTP.new(@base_uri)
+      @auth_proxy.login(username, password, digest)
+    end
+
+    def oauth(consumer_key, consumer_secret, access_token, access_token_secret)
+      @auth_proxy = CS::Auth::OAuth.new(consumer_key, consumer_secret,
+                                                 access_token, access_token_secret,
+                                                 @base_uri)
+    end
+
+    def session_id
+      auth_proxy.session_id
+    end
+
+    def api_key
+      auth_proxy.api_key
+    end
+
+    def session_id=(session_id)
+      @auth_proxy = CS::Auth::HTTP.new(@base_uri)
+      @auth_proxy.session_id = session_id
+    end
+
+    def api_key=(api_key)
+      @api_key = api_key
+      @auth_proxy = CS::Auth::HTTP.new(@base_uri, api_key)
+    end
+
+    def auth_proxy
+      raise 'The session is not logged in' unless @auth_proxy
+      @auth_proxy
+    end
+
+    def retry_on_509(&block)
+      while true
+        response = yield
+        if response_code == 509
+          waitfor = Random.new.rand(30..45)
+          logger.info "limit reached. waiting for #{waitfor} before retrying" if logger
+          sleep(waitfor)
+        else
+          return response
+        end
+      end
+    end
+
+    def log_request(type, path, body, headers)
+      logger.info("")
+      logger.info("#{type} #{path}")
+      logger.debug("headers: #{headers.inspect}")
+      logger.info("parameters: #{body.inspect}")
+    end
+
+    def log_response
+      logger.info("response: #{self.response_code}")
+      logger.debug("body: #{self.response_body}")
+    end
+
+    def execute(type, path, body, headers, &block)
+      log_request(type, path, body, headers) if logger
+      response = retry_on_509 { yield }
+      log_response if logger
+
+      response
+    end
+
+    def get(path, body = '', headers = {})
+      execute("GET", path, body, headers) do
+        auth_proxy.get(path, body, headers)
+      end
+    end
+
+    def post(path, body = '', headers = {})
+      execute("POST", path, body, headers) do
+        auth_proxy.post(path, body, headers = {})
+      end
+    end
+
+    def put(path, body = '', headers = {})
+      execute("PUT", path, body, headers) do
+        auth_proxy.put(path, body, headers)
+      end
+    end
+
+    def delete(path, body='', headers = {})
+      execute("DELETE", path, body, headers) do
+        auth_proxy.delete(path, body, headers)
+      end
+    end
+
+    def head(path, headers = {})
+      execute("HEAD", path, nil, headers) do
+        auth_proxy.head(path, headers)
+      end
+    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)
+      begin
+        body = response_body.to_s
+      rescue Exception => e
+        body = e.message
+      end
+
+      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(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
+      if session_id
+        return "SESSION_ID \"#{session_id}\""
+      elsif api_key
+        return "API_KEY \"#{api_key}\""
+      end
+      return ""
+    end
+
+    def inspect
+      auth_proxy.kind_of?(CS::Auth::HTTP) ? to_s : "OAuth"
+    end
+  end
+end