cs 0.1.0beta3

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

@@ -0,0 +1,101 @@
+require "oauth"
+
+module CommonSense
+  module Auth
+    class OAuth
+
+      attr_accessor :response_body, :response_code, :response_headers, :errors, :consumer_key,
+        :consumer_secret, :access_token, :access_token_secret
+
+      def initialize(consumer_key, consumer_secret, access_token, access_token_secret, uri=nil)
+        @consumer_key = consumer_key
+        @consumer_secret = consumer_secret
+        @access_token = access_token
+        @access_token_secret = access_token_secret
+        oauth_base = ::OAuth::Consumer.new(consumer_key, consumer_secret, :site => uri)
+        @oauth = ::OAuth::AccessToken.new(oauth_base, access_token, access_token_secret)
+        reset
+      end
+
+      def oauth
+        @oauth
+      end
+
+      def get(path, query={}, headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        response = oauth.get(path, headers)
+        parse_response(response)
+        @response_body
+      end
+
+      def post(path, body = '', headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        response = oauth.post(path, body.to_json, headers)
+        parse_response(response)
+
+        @response_body
+      end
+
+      def put(path, body = '', headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        response = oauth.put(path, body.to_json, headers)
+        parse_response(response)
+
+        @response_body
+      end
+
+      def delete(path, query={}, headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        response = oauth.delete(path, headers)
+        parse_response(response)
+
+        @response_body
+      end
+
+      def head(path, headers = {})
+        reset
+        headers = default_headers.merge(headers)
+        response = oauth.head(path, headers)
+        parse_response(response)
+
+        @response_body
+      end
+
+      def base_uri=(uri = nil)
+        self.class.base_uri uri
+      end
+
+
+      private
+      def default_headers
+        {"Content-Type" => "application/json"}
+      end
+
+      def reset
+        @errors = nil
+        @response_code = nil
+        @response_body = nil
+      end
+
+      # convert the body to hash if response is "application/json"
+      def parse_response(response)
+        @response_body = response.content_type == "application/json" ? (JSON(response.body) rescue nil) : response.body
+        @response_code = response.code.to_i
+
+        @response_headers = response.to_hash
+        @response_headers.each do |k,v|
+          @response_headers[k] = v[0] rescue nil
+        end
+
+
+        if @response_code >= 400
+          @errors = [response_body['error']]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,276 @@
+require 'commonsense-ruby-lib/serializer'
+module CommonSense
+  module EndPoint
+    include CommonSense::Serializer
+
+    attr_accessor :session
+
+    def initialize(hash={})
+      from_hash(hash)
+    end
+
+    # generate a hash representation of this end point
+    def to_parameters
+      r = self.resource rescue nil
+      r.nil? ? self.to_h(false) : { self.resource => self.to_h(false) }
+    end
+
+    def inspect
+      inspection = self.to_h.collect {|k,v| "#{k}: #{v.inspect}"}.compact.join(", ")
+      "#<#{self.class} #{inspection}>"
+    end
+
+    # get value of property name
+    def parameter(name)
+      self.instance_variable_get(name)
+    end
+
+    # Persist end point object to CS. It will create a new record on CS
+    # if it's a new object or it will update the object. It will throw an exception
+    # if it could not persist object to CS
+    #
+    # example for {Sensor} object:
+    #
+    #     sensor = client.sensors.build
+    #     sensor.name = "accelerometer"
+    #     sensor.display_name = "Accelerometer"
+    #     sensor.device_type = "BMA123"
+    #     sensor.pager_type = "email"
+    #     sensor.data_type = "json"
+    #     sensor.data_structure = {"x-axis" => "Float", "y-axis" => "Float", "z-axis" => "Float"}
+    #
+    #     sensor.save! # this will create new sensor on CS
+    #     sensor.id # should give you the id of the sensor
+    #
+    #     sensor.name = "accelerometer edit"
+    #     sensor.save! # this will update the sensor
+    def save!
+      check_session!
+
+      if @id
+        self.update!
+      else
+        self.create!
+      end
+    end
+
+    # it will persist data to CS just like {#save!} but it will return nil instead of exception
+    # if it encouter error while persiting data
+    def save
+      save! rescue nil
+    end
+
+    # Create a new end point object to CS. It will raise an exception if there is an error
+    #
+    # example for {Sensor} object:
+    #
+    #     sensor = client.sensors.build
+    #     sensor.name = "accelerometer"
+    #     sensor.display_name = "Accelerometer"
+    #     sensor.device_type = "BMA123"
+    #     sensor.pager_type = "email"
+    #     sensor.data_type = "json"
+    #     sensor.data_structure = {"x-axis" => "Float", "y-axis" => "Float", "z-axis" => "Float"}
+    #
+    #     sensor.create! # this will create new sensor on CS
+    #     sensor.id # should give you the id of the sensor
+    def create!
+      parameter = self.to_parameters
+      res = session.post(post_url, parameter)
+
+      if session.response_code != 201
+        errors = session.errors rescue nil
+        raise Error::ResponseError, errors
+      end
+
+      location_header = session.response_headers["location"]
+      id = scan_header_for_id(location_header)
+      self.id = id[0] if id
+
+      true
+    end
+
+    # Create a new endpoint object to CS, just like {#create!} but it will return nil
+    # if there is an error.
+    def create
+      result = create! rescue nil
+      not result.nil?
+    end
+
+    # Retrieve Data from CS of the current object based on the id of the object.
+    # It will return an exception if there is an error
+    #
+    # example for {Sensor} object:
+    #
+    #     sensor = client.sensors.build
+    #     sensor.id = "1"
+    #     sensor.retrieve!
+    def retrieve!
+      check_session!
+      raise Error::ResourceIdError unless @id
+
+      res = session.get(get_url)
+      if session.response_code != 200
+        errors = session.errors rescue nil
+        raise Error::ResponseError, errors
+      end
+
+      from_hash(res[resource.to_s]) if res
+      true
+    end
+
+    # alias for {#retrieve!}
+    def reload!
+      retieve!
+    end
+
+    # it will retrieve / reload current object form CS, just like {#retrieve!} but it
+    # will return nil instead of raise an exception if there is an error.
+    def retrieve
+      result = retrieve! rescue nil
+      not result.nil?
+    end
+
+    # alias for {#retrieve}
+    def reload
+      retrieve
+    end
+
+    # Update current end point object to CS. It will throw an exception if there is an error
+    #
+    # example for {Sensor} object:
+    #
+    #     sensor = client.sensors.find(1)
+    #     sensor.name = "new name"
+    #     sensor.update!
+    def update!
+      check_session!
+      raise Error::ResourceIdError unless @id
+
+      parameter = self.to_parameters
+      res = session.put(put_url, parameter)
+
+      if session.response_code != 200
+        errors = session.errors rescue nil
+        raise Error::ResponseError, errors
+      end
+
+      true
+    end
+
+    # Update current end point object to CS, just like {#update!} but it will return nil
+    # if there is an error
+    def update
+      result = update! rescue nil
+      not result.nil?
+    end
+
+
+    # Delete the current end point object from CS. It will throw an exception if there is an error
+    #
+    # example for {Sensor} object:
+    #
+    #     sensor = client.sensors.find(1)
+    #     sensor.name = "new name"
+    #     sensor.delete!
+    def delete!
+      check_session!
+      raise Error::ResourceIdError unless @id
+
+      res = session.delete(delete_url)
+
+      if session.response_code != 200
+        errors = session.errors rescue nil
+        raise Error::ResponseError, errors
+      end
+
+      self.id = nil
+
+      true
+    end
+
+    # Delete the current end point object from CS, just like {#delete!} but it will return nil
+    # if there is an error
+    def delete
+      result = delete! rescue nil
+      not result.nil?
+    end
+
+    # return the commonsense URL for method
+    # vaild value for method is `:get`, `:post`, `:put`, or `:delete`
+    def url_for(method, id=nil)
+      raise Error::ResourcesError if resources.nil?
+      url = self.class.class_variable_get("@@#{method}_url".to_sym)
+      url = url.sub(":id", "#{@id}") if id
+      url
+    end
+
+    protected
+    def scan_header_for_id(location_header)
+      location_header.scan(/.*\/#{resources}\/(.*)/)[0] if location_header
+    end
+
+    def post_url
+      url_for(:post)
+    end
+
+    def get_url
+      url_for(:get, self.id)
+    end
+
+    def put_url
+      url_for(:put, self.id)
+    end
+
+    def delete_url
+      url_for(:delete, self.id)
+    end
+
+    def self.included(base)
+      base.extend(ClassMethod)
+    end
+
+    def resource
+      self.class.class_variable_get(:@@resource)
+    rescue
+      raise Error::ResourceError, "'resource' is not set up for class : #{self.class}"
+    end
+
+    def resources
+      self.class.class_variable_get(:@@resources)
+    end
+
+    private
+    def check_session!
+      raise Error::SessionEmptyError unless @session
+    end
+
+    module ClassMethod
+      def attribute(*args)
+        attr_accessor *args
+
+        unless @attribute_set
+          @attribute_set = Set.new([:id])
+          attr_accessor :id
+        end
+        @attribute_set.merge(args)
+      end
+
+      def attribute_set
+        @attribute_set
+      end
+
+      def resources(resources)
+        class_variable_set(:@@resources, resources)
+        class_variable_set(:@@post_url, "/#{resources}.json")
+        class_variable_set(:@@get_url, "/#{resources}/:id.json")
+        class_variable_set(:@@put_url, "/#{resources}/:id.json")
+        class_variable_set(:@@delete_url, "/#{resources}/:id.json")
+      end
+
+      def resource(resource)
+        class_variable_set(:@@resource, resource)
+      end
+    end
+  end
+end

data/lib/commonsense-ruby-lib/end_point/group.rb

@@ -0,0 +1,28 @@
+module CommonSense
+  module EndPoint
+    class Group
+      include EndPoint
+
+      attr_accessor :id, :name, :description, :public
+      # get groups that user belongs to
+      def current_groups(options={})
+        res = session.get("/groups.json", options)
+        return nil unless res
+
+        group_list = res['groups']
+
+
+        groups =[]
+        if group_list
+          group_list.each do |group|
+            g = Group.new(group)
+            g.session = session
+            groups << g
+          end
+        end
+
+        groups
+      end
+    end
+  end
+end

data/lib/commonsense-ruby-lib/end_point/sensor.rb

@@ -0,0 +1,36 @@
+module CommonSense
+  module EndPoint
+    class Sensor
+      include EndPoint
+
+      attribute :name, :display_name, :device_type, :pager_type, :data_type, :data_structure
+      resources :sensors
+      resource :sensor
+
+      def initialize(hash={})
+        from_hash(hash)
+        if self.data_type == "json"
+          if self.data_structure && self.data_structure.kind_of?(String)
+            self.data_structure = JSON.parse(self.data_structure) rescue nil
+          end
+        end
+      end
+
+      # overide Endpoint#to_parameters
+      def to_parameters
+        param = self.to_h(false)
+        if param[:data_type] == "json"
+          if param[:data_structure] && !param[:data_structure].kind_of?(String)
+            param[:data_structure] = param[:data_structure].to_json
+          end
+        end
+
+        {sensor: param}
+      end
+
+      def data
+        Relation::SensorDataRelation.new(self.id, self.session)
+      end
+    end
+  end
+end

data/lib/commonsense-ruby-lib/end_point/sensor_data.rb

@@ -0,0 +1,70 @@
+module CommonSense
+  module EndPoint
+    # This object represent a sensor data point
+    # usage example:
+    #
+    #    client = CommonSense::Client.new
+    #    client.login('username', 'password')
+    #
+    #    # 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!
+    #
+    class SensorData
+      include CommonSense::EndPoint
+
+      attr_accessor :month, :week, :year
+      attribute :date, :value, :sensor_id
+      resource :data
+
+      def to_parameters
+        param = self.to_h(false)
+        param.delete(:sensor_id)
+        value = param[:value]
+        if value
+          param[:value] = value.to_json unless value.kind_of?(String) || value.kind_of?(Numeric)
+        end
+
+        {data: [param]}
+      end
+
+      # there is no currently end point for geting data by id
+      def retrieve!
+        raise Error::NotImplementedError, "There is no current end point to get sensor data by id"
+      end
+
+      # there is no currently end point for updating data
+      def update!
+        raise Error::NotImplementedError, "There is no current end point to update sensor data by id"
+      end
+
+      def scan_header_for_id(location_header)
+        location_header.scan(/.*\/sensors\/(.*)\/(.*)/)[1] if location_header
+      end
+
+      def post_url
+        "/sensors/#{sensor_id}/data.json"
+      end
+
+      def get_url
+        "/sensors/#{sensor_id}/data/#{id}.json"
+      end
+
+      def put_url
+        "/sensors/#{sensor_id}/data/#{id}.json"
+      end
+
+      def delete_url
+        "/sensors/#{sensor_id}/data/#{id}.json"
+      end
+    end
+  end
+end