cs 0.1.0beta3

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

@@ -0,0 +1,50 @@
+require 'digest/md5'
+
+module CommonSense
+  module EndPoint
+    class User
+      include EndPoint
+
+      resources :users
+      resource :user
+
+      attribute :email, :username, :name, :surname, :address, :zipcode,
+        :country, :mobile, :uuid, :openid, :password
+
+      def initialize(hash={})
+        if hash[:password]
+          hash[:password] = Digest::MD5.hexdigest(hash[:password])
+        end
+        super(hash)
+      end
+
+      def password=(plain_text)
+        @password = Digest::MD5.hexdigest(plain_text)
+      end
+
+      def password_hashed=(hash)
+        self.password = hash
+      end
+
+      def current_user
+        res = session.get('/users/current.json', )
+        return nil unless res && res["user"]
+
+        from_hash(res["user"])
+        self
+      end
+
+      def reload
+        current_user
+      end
+
+
+      # get groups that this users belongs to
+      def groups
+        group = Group.new
+        group.session = session
+        group.groups
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module CommonSense
+  module Error
+    class Error < ::RuntimeError
+      def initialize(message = "")
+        super(message)
+      end
+    end
+
+    class ResourceIdError < Error
+      def initialize(message = "No id found for Resrouce: #{self.class}")
+        super(message)
+      end
+    end
+
+    class ResourcesError < Error
+      def initialize(message = "'resources' is not set for class: #{self.class}")
+        super(message)
+      end
+    end
+
+    class ResourceError < Error
+      def initialize(message = "'resource' is not set for class: #{self.class}")
+        super(message)
+      end
+    end
+
+    class ResponseError < Error
+      def initialize(message = "Error Response from CommonSense")
+        super(message)
+      end
+    end
+
+    class SessionEmptyError < Error
+      def initialize(message = "There is no Session found")
+        super(message)
+      end
+    end
+
+    class RelationError < Error
+      def initialize(message = "Error when setting up relation")
+        super(message)
+      end
+    end
+
+    class NotImplementedError < Error
+      def initialize(message = "There is unimplemented method")
+        super(message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,233 @@
+module CommonSense
+  module Relation
+    module Boolean; end
+
+    def check_session!
+      raise Error::SessionEmptyError unless @session
+    end
+
+    def get_url
+      raise Error::NotImplementedError, "the class #{self.class} does not respond to 'get_url' "
+    end
+
+    def get_data!(params={})
+      check_session!
+      options = get_options(params)
+      session.get(get_url, options)
+    end
+
+    def parameter(name)
+      self.instance_variable_get("@#{name}")
+    end
+
+    def get_options(params)
+      options = {}
+
+      params.each do |k,v|
+        param_option = self.class.parameters[k]
+
+        value = v
+        value = process_param_integer(k, v, param_option) if param_option[:type] == Integer
+        value = process_param_boolean(k, v, param_option) if param_option[:type] == Boolean
+        value = process_param_string(k, v, param_option) if param_option[:type] == String
+
+        if value.kind_of?(Time)
+          value = value.to_f
+        end
+
+        options[k] = value
+      end
+
+      options
+    end
+
+    def get_data(params={})
+      get_data!(params) rescue nil
+    end
+
+    def all
+      self.to_a
+    end
+
+    def count
+      check_session!
+      resource = get_single_resource
+      resource["total"] if resource
+    end
+
+    def first
+      resource = get_single_resource
+      parse_single_resource(resource)
+    end
+
+    def last
+      total = count
+      resource = get_single_resource(page: count - 1)
+      parse_single_resource(resource)
+    end
+
+    def inspect
+      inspection = self.class.parameters.collect {|k,v| "#{k}: #{parameter(k).inspect}"}.compact.join(", ")
+      "#<#{self.class} #{inspection}>"
+    end
+
+    def where(params={})
+      process_alias!(params)
+      params.keep_if {|k| self.class.parameters[k]}
+
+      params.each do |k,v|
+        param_option = self.class.parameters[k]
+
+        value = process_param_integer(k, v, param_option) if param_option[:type] == Integer
+        value = process_param_boolean(k, v, param_option) if param_option[:type] == Boolean
+        value = process_param_string(k, v, param_option) if param_option[:type] == String
+        value = process_param_time(k, v, param_option) if param_option[:type] == Time
+
+        self.send("#{k}=", value)
+      end
+
+      self
+    end
+
+    module ClassMethod
+      def parameter(name, type, *args)
+        attr_accessor name
+        self.parameters ||= {}
+
+        param = {type: type}
+        unless args.empty?
+          param.merge!(args[0])
+        end
+
+        self.parameters[name] = param
+      end
+
+      def parameter_alias(name, name_alias)
+        attr_accessor name
+        self.parameters_alias ||= {}
+        self.parameters_alias[name] = name_alias
+      end
+
+      def parameters_alias=(parameters_alias)
+        @parameters_alias = parameters_alias
+      end
+
+      def parameters_alias
+        @parameters_alias
+      end      
+
+      def parameters=(parameters)
+        @parameters = parameters
+      end
+
+      def parameters
+        @parameters
+      end
+    end
+
+    protected
+    def self.included(base)
+      base.send(:include, Enumerable)
+      base.extend(ClassMethod)
+      base.class_eval do
+        attr_accessor :session
+      end
+    end
+
+    def parse_single_resource(resource)
+      raise Error::NotImplementedError, "parse_single_resource is not implemented for class : #{self.class}"
+    end
+
+    def get_single_resource(params={})
+      raise Error::NotImplementedError, "get_single_resource is not implemented for class : #{self.class}"
+    end
+
+    def process_alias!(params)
+      return if self.class.parameters_alias.nil?
+
+      aliases = params.select { |param| self.class.parameters_alias.include?(param) }
+      aliases.each do |alias_to, value|
+        alias_for = self.class.parameters_alias[alias_to]
+        params[alias_for] = value
+        params.delete(alias_to)
+      end
+    end
+
+
+    def process_valid_values(name, value, param_option)
+      return value unless param_option[:valid_values]
+
+      if param_option[:valid_values].include?(value)
+        value
+      elsif !value.nil?
+        raise ArgumentError, "Invalid value for parameter '#{name}'"
+      end
+
+    end
+
+    def process_default_value(name, value, param_option)
+      value.nil? ? param_option[:default] : value
+    end
+
+    def process_param_integer(name, value, param_option)
+      if value.kind_of?(Integer)
+        retval = value
+        retval = process_valid_values(name, value, param_option) if param_option[:valid_values]
+      end
+
+      retval = process_default_value(name, retval, param_option)
+
+      if !value.nil?  && !value.kind_of?(Integer)
+        raise ArgumentError, "Received non Integer value for parameter '#{name}'"
+      end
+
+      retval
+    end
+
+    def process_param_boolean(name, value, param_option)
+      retval = nil
+
+      if value.nil?
+        retval = param_option[:default] ? param_option[:default] : nil
+      elsif [0, "0", false, "false"].include?(value)
+        retval = 0
+      else
+        retval = 1
+      end
+
+      retval
+    end
+
+    def process_param_string(name, value, param_option)
+      retval = value
+      retval = process_valid_values(name, value, param_option) if param_option[:valid_values]
+      retval = process_default_value(name, retval, param_option)
+
+      retval
+    end
+
+    # This method prosess assignment for properties with datatype Time.
+    # There are 3 type that is valid for this properties:
+    #
+    # * **Time**
+    # * **Numeric**. It will convert this to ruby {Time}
+    # * **Obejct that respond to #to_time** and return ruby {Time}
+    #
+    def process_param_time(name, value, param_option)
+      retval = value
+
+      if !value.nil? && !value.kind_of?(Time)
+        if value.kind_of?(Numeric)
+          retval = Time.at(retval)
+        else
+          retval = value.to_time
+        end
+      end
+
+      retval = process_default_value(name, retval, param_option)
+      retval = process_valid_values(name, value, param_option) if param_option[:valid_values]
+
+      retval
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module CommonSense
+  module Relation
+    class SensorDataRelation
+      include Relation
+
+      parameter :page, Integer, default: 0
+      parameter :per_page, Integer, default: 1000, maximum: 1000
+      parameter :start_date, Time
+      parameter :end_date, Time
+      parameter :date, Time
+      parameter :last, Boolean
+      parameter :sort, String, valid_values: ["ASC", "DESC"]
+      parameter :interval, Integer, valid_values: [604800, 86400, 3600, 1800, 600, 300, 60]
+      parameter :sensor_id, String
+      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
+        "/sensors/#{self.sensor_id}/data.json"
+      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
+      end
+
+      def count
+        retval = 0
+        each_batch do |data|
+          retval += data.size
+        end
+
+        retval
+      end
+
+
+      def first
+        data = get_data!(page:0, per_page: 1, sort: "ASC")
+        parse_single_resource(data)
+      end
+
+      def last
+        data = get_data!(page:0, per_page: 1, sort: "DESC")
+        parse_single_resource(data)
+      end
+
+      def from(start_date)
+        param_option = self.class.parameters[:start_date]
+        self.start_date = process_param_time(:start_date, start_date, param_option)
+        self
+      end
+
+      def to(end_date)
+        param_option = self.class.parameters[:end_date]
+        self.end_date = process_param_time(:end_date, end_date, param_option)
+        self
+      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
+      end
+    end
+  end
+end