built.io 0.7 → 0.8

data/lib/built/acl.rb

@@ -0,0 +1,196 @@
+module Built
+  class ACL
+    attr_accessor :disabled
+    attr_accessor :others
+    attr_accessor :users
+    attr_accessor :roles
+
+    def initialize(data)
+      data ||= {}
+
+      @disabled = data["disable"] == true
+      @others   = data["others"] || {}
+      @users    = data["users"] || []
+      @roles    = data["roles"] || []
+      @can      = data["can"] || []
+    end
+
+    # Disable / Enable ACL ============================
+
+    # Is the ACL disabled?
+    # @return [Boolean]
+    def is_disabled?
+      @disabled
+    end
+
+    # Disable the ACL
+    def disable
+      @disabled = true
+    end
+
+    # Enable the ACL
+    def enable
+      @disabled = false
+    end
+
+    # ACL can =========================================
+
+    # Can the current user update this object?
+    def can_update?
+      !!@can.find {|x| x == "update"}
+    end
+
+    # Can the current user delete this object?
+    def can_delete?
+      !!@can.find {|x| x == "delete"}
+    end
+
+    # Can others? =====================================
+
+    # Read permission for others
+    # @return [Boolean]
+    def can_others_read?
+      @others["read"]
+    end
+
+    # Update permission for others
+    # @return [Boolean]
+    def can_others_update?
+      @others["update"]
+    end
+
+    # Update permission for others
+    # @return [Boolean]
+    def can_others_delete?
+      @others["delete"]
+    end
+
+    # Set others ======================================
+
+    # Set read permission for others
+    # @param [Boolean]
+    def others_read(bool)
+      @others["read"] = bool
+    end
+
+    # Set update permission for others
+    # @param [Boolean]
+    def others_update(bool)
+      @others["update"] = bool
+    end
+
+    # Set delete permission for others
+    # @param [Boolean]
+    def others_delete(bool)
+      @others["delete"] = bool
+    end
+
+    # Can users? ======================================
+
+    # Get read permission for user
+    def can_user_read?(user)
+      can_user_op(user, "read")
+    end
+
+    # Get update permission for user
+    def can_user_update?(user)
+      can_user_op(user, "update")
+    end
+
+    # Get delete permission for user
+    def can_user_delete?(user)
+      can_user_op(user, "delete")
+    end
+
+    # Can roles? ======================================
+
+    # Get read permission for role
+    def can_role_read?(role)
+      can_role_op(role, "read")
+    end
+
+    # Get update permission for role
+    def can_role_update?(role)
+      can_role_op(role, "update")
+    end
+
+    # Get delete permission for role
+    def can_role_delete?(role)
+      can_role_op(role, "delete")
+    end
+
+    # Set users =======================================
+
+    # Set read permission for the user
+    def user_read(user, bool)
+      user_op(user, "read", bool)
+    end
+
+    # Set update permission for the user
+    def user_update(user, bool)
+      user_op(user, "update", bool)
+    end
+
+    # Set delete permission for the user
+    def user_delete(user, bool)
+      user_op(user, "delete", bool)
+    end
+
+    # Set roles =======================================
+
+    # Set read permission for the role
+    def role_read(role, bool)
+      role_op(role, "read", bool)
+    end
+
+    # Set update permission for the role
+    def role_update(role, bool)
+      role_op(role, "update", bool)
+    end
+
+    # Set delete permission for the role
+    def role_delete(role, bool)
+      role_op(role, "delete", bool)
+    end
+
+    private
+
+    def to_s
+      "#<Built::ACL disabled=#{disabled}>"
+    end
+
+    def user_op(user, op, bool)
+      elem_op(@users, user, op, bool)
+    end
+
+    def role_op(role, op, bool)
+      elem_op(@roles, role, op, bool)
+    end
+
+    def elem_op(store, elem, op, bool)
+      uid = elem.is_a?(String) ? elem : elem.uid
+
+      if acl = store.find {|u| u == uid}
+        acl[op] = bool
+      else
+        store << {"uid" => uid, op => bool}
+      end
+    end
+
+    def can_role_op(role, op)
+      can_elem_op(@roles, role, op)
+    end
+
+    def can_user_op(user, op)
+      can_elem_op(@users, user, op)
+    end
+
+    def can_elem_op(store, elem, op)
+      uid = elem.is_a?(String) ? elem : elem.uid
+
+      acl = store.find {|u| u == uid} || {}
+
+      acl[op]
+    end
+  end
+end

data/lib/built/application.rb

@@ -36,7 +36,7 @@ module Built
       def get
         instantiate(
           Built.client.request(uri)
-            .parsed_response["application"]
+            .json["application"]
         )
       end
 

data/lib/built/class.rb

@@ -39,7 +39,7 @@ module Built
       # @return [Array] classes An array of classes
       def get_all
         Built.client.request(uri)
-          .parsed_response["classes"].map {|o| instantiate(o)}
+          .json["classes"].map {|o| instantiate(o)}
       end
 
       # Get a single class by its uid
@@ -49,7 +49,7 @@ module Built
       def get(uid)
         instantiate(
           Built.client.request(uri(uid))
-            .parsed_response["class"]
+            .json["class"]
         )
       end
 

data/lib/built/client.rb

@@ -1,6 +1,7 @@
 module Built
   class Client
-    include HTTMultiParty
+    attr_accessor :authtoken
+    attr_accessor :current_user
 
     def initialize(options={})
       @api_key    = options[:application_api_key]
@@ -10,37 +11,64 @@ module Built
       @authtoken  = options[:authtoken]
 
       # set the base uri
-      self.class.base_uri @version ? [@host, @version].join('/') : @host
-    end
-
-    # set the authtoken
-    def authtoken=(authtoken)
-      @authtoken = authtoken
+      @base_uri = @version ? [@host, @version].join('/') : @host
     end
 
     # perform a regular request
     def request(uri, method=:get, body=nil, query=nil, additionalHeaders={})
       options             = {}
-      options[:query]     = query if query
-      options[:body]      = body.to_json if body
+      options[:url]       = @base_uri + uri
+      options[:method]    = method
 
       options[:headers]   = {
         "application_api_key" => @api_key,
         "Content-Type"        => "application/json"
       }
 
+      options[:headers][:params] = query if query
+
       options[:headers][:authtoken]   = @authtoken if @authtoken
       options[:headers][:master_key]  = @master_key if @master_key
       options[:headers].merge!(additionalHeaders)
 
-      response = self.class.send(method, uri, options)
+      if body
+        is_json = options[:headers]["Content-Type"] == "application/json"
+        options[:payload] = is_json ? body.to_json : body
+        unless is_json
+          options[:headers].delete("Content-Type")
+        end
+      end
+
+      begin
+        response = Response.new(RestClient::Request.execute(options))
+      rescue => e
+        response = Response.new(e.response)
+      end
 
-      if ![200, 201, 204].include?(response.code)
+      if !(200..299).include?(response.code)
         # error, throw it
-        raise BuiltAPIError.new(response.parsed_response)
+        raise BuiltAPIError.new(response.json)
       end
 
       response
     end
   end
+
+  class Response
+    attr_reader :raw
+    attr_reader :code
+    attr_reader :body
+    attr_reader :headers
+
+    def initialize(response)
+      @raw      = response
+      @code     = response.code
+      @body     = response.body
+      @headers  = response.headers
+    end
+
+    def json
+      JSON.parse @body
+    end
+  end
 end

data/lib/built/constants.rb

@@ -1,4 +1,9 @@
 # constants
-API_URI     = "https://api.built.io"
+Built::API_URI        = "https://api.built.io"
 # we no longer need version strings
-API_VERSION = nil
+Built::API_VERSION    = nil
+# where location is stored in the object
+Built::LOCATION_PATH  = "__loc"
+Built::USER_CLASS_UID = "built_io_application_user"
+Built::ROLE_CLASS_UID = "built_io_application_user_role"
+Built::INST_CLASS_UID = "built_io_installation_data"

data/lib/built/error.rb

@@ -6,7 +6,7 @@ module Built
   # Errors thrown by the built.io API
   class BuiltAPIError < BuiltError
     attr_accessor :error_code
-    attr_accessor :error
+    attr_accessor :errors
     attr_accessor :error_message
 
     def initialize(response)
@@ -14,7 +14,7 @@ module Built
 
       if @response
         @error_code     = response["error_code"]
-        @error          = response["error"]
+        @errors         = response["errors"]
         @error_message  = response["error_message"]
       end
 

data/lib/built/installation.rb

@@ -0,0 +1,4 @@
+module Built
+  class Installation < Built::Object
+  end
+end

data/lib/built/location.rb

@@ -0,0 +1,72 @@
+module Built
+  # This is used to specify a long/lat pair in built.io
+  class Location
+    attr_accessor :long
+    attr_accessor :lat
+
+    # Create a new Location object
+    # @param [Float] long Longitude of the location
+    # @param [Float] lat Latitude of the location
+    # @return [Location] location A new location
+    def initialize(long, lat)
+      Util.type_check("long", long, Float)
+      Util.type_check("lat", lat, Float)
+
+      @long = long
+      @lat  = lat
+    end
+
+    # Distance in meters from a certain location
+    # @param [Location] location The location
+    # @return [Integer] distance in meters
+    def metersFrom(location)
+      Util.type_check("location", location, Location)
+
+      haversine(location.lat, location.long, lat, long, 1000)
+    end
+
+    # Distance in kilometers from a certain location
+    # @param [Location] location The location
+    # @return [Integer] distance in kilometers
+    def kilometersFrom(location)
+      Util.type_check("location", location, Location)
+
+      haversine(location.lat, location.long, lat, long, 1)
+    end
+
+    # Convert this into an array of [long, lat]
+    # @return [Array<Float, Float>]
+    def to_arr
+      [long, lat]
+    end
+
+    private
+
+    def to_s
+      "#<Built::Object long=#{long}, lat=#{lat}>"
+    end
+
+    def power(num, pow)
+      num ** pow
+    end
+
+    def haversine(lat1, long1, lat2, long2, factor)
+      dtor = Math::PI/180
+      r = 6378.14*factor
+     
+      rlat1 = lat1 * dtor 
+      rlong1 = long1 * dtor 
+      rlat2 = lat2 * dtor 
+      rlong2 = long2 * dtor 
+     
+      dlon = rlong1 - rlong2
+      dlat = rlat1 - rlat2
+     
+      a = power(Math::sin(dlat/2), 2) + Math::cos(rlat1) * Math::cos(rlat2) * power(Math::sin(dlon/2), 2)
+      c = 2 * Math::atan2(Math::sqrt(a), Math::sqrt(1-a))
+      d = r * c
+     
+      return d.ceil
+    end
+  end
+end