quickblox 0.1.1 → 0.2

data/lib/quickblox.rb

@@ -12,16 +12,16 @@ class Quickblox
 
   def configs
     config = YAML.load_file("config.yml")
-    @application_id = config["config"]["application_id"]
-    @auth_key = config["config"]["auth_key"]
-    @auth_secret = config["config"]["auth_secret"]
-    @user_owner_id = config["config"]["user_owner_id"]
-    @server=config["config"]["server"]
+    @application_id = config["quickblox"]["application_id"]
+    @auth_key = config["quickblox"]["auth_key"]
+    @auth_secret = config["quickblox"]["auth_secret"]
+    @user_owner_id = config["quickblox"]["user_owner_id"]
+    @server=config["quickblox"]["server"]
     #to remove - for debug
-    @user_login=config["config"]["user_login"]
-    @user_password=config["config"]["user_password"]
-    @device_platform= config["config"]["device_platform"]
-    @device_udid= config["config"]["device_udid"]
+    @user_login=config["quickblox"]["user_login"]
+    @user_password=config["quickblox"]["user_password"]
+    @device_platform= config["quickblox"]["device_platform"]
+    @device_udid= config["quickblox"]["device_udid"]
 
   end
 
@@ -66,12 +66,15 @@ class Quickblox
     @device_udid
   end
 
-  #Generates token depending on a request. Application token is generated by default.
+  def get_user_id
+    @token = get_token("user") unless @token_type=='user'
+    @user_id
+  end
+
   def get_token(type = 'app')
     destroy_token if @token
     timestamp=Time.now.to_i
     nonce=rand(10000)
-
     hash = {:application_id => @application_id, :nonce => nonce, :auth_key => @auth_key, :timestamp => timestamp}
     hash.merge!({:user => {:login => @user_login, :password => @user_password, :owner_id => @user_owner_id}}) if type == 'user' || type == 'user_device'
     hash.merge!({:device => {:platform => @device_platform, :udid => @device_udid}}) if type == 'device' || type == 'user_device'
@@ -79,32 +82,31 @@ class Quickblox
     signature = HMAC::SHA1.hexdigest(@auth_secret, normalized)
     req = Net::HTTP::Post.new(@auth_uri.path)
     req.body = "#{normalized}&signature=#{signature}"
-    ask_token = Net::HTTP.start(@auth_uri.host, @auth_uri.port) do |http|
+    response = Net::HTTP.start(@auth_uri.host, @auth_uri.port) do |http|
       http.request(req)
     end
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
     @token_type=type
-    @user_id=JSON.parse(ask_token.body)["session"]["user_id"]
-    @token=JSON.parse(ask_token.body)["session"]["token"]
+    @user_id=JSON.parse(response.body)["session"]["user_id"]
+    @token=JSON.parse(response.body)["session"]["token"]
   end
 
-  #Destroys existing token
   def destroy_token
     http = Net::HTTP.new(@server)
     delete_token = Net::HTTP::Delete.new("/auth_exit?token=#{@token}")
-    http.request(delete_token)
+    @token=nil
+    response=http.request(delete_token)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
-  #Users API Requests
 
-  #Retrieve users count of the application
   def get_users_count(at_uri=nil, at_param=nil)
     @token = get_token unless @token
-    user_list = Net::HTTP.get_response(URI(@users_uri.to_s+"#{at_uri}.json")+"?token=#{@token}#{at_param}")
-    JSON.parse(user_list.body)["total_entries"]
+    response = Net::HTTP.get_response(URI(@users_uri.to_s+"#{at_uri}.json")+"?token=#{@token}#{at_param}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)["total_entries"]
   end
 
-  #Retrieve all users of the application
   def get_all_users_list
     @token = get_token unless @token
     @users_count = get_users_count unless @users_count
@@ -119,42 +121,40 @@ class Quickblox
     users
   end
 
-  #Retrive users of the application with pagination
-  def get_users_list (page=nil, per_page=nil)
+  def get_users_list (page=1, per_page=10)
     @token = get_token unless @token
-    page=1 unless page
-    per_page=10 unless per_page
-    user_list=Net::HTTP.get_response(URI(@users_uri.to_s+".json")+"?token=#{@token}&per_page=#{per_page}&page=#{page}")
-    JSON.parse(user_list.body)["items"]
+    response=Net::HTTP.get_response(URI(@users_uri.to_s+".json")+"?token=#{@token}&per_page=#{per_page}&page=#{page}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Create a new user
   def signup_user(user_params)
     @token = get_token unless @token_type=='app'
+    user_params.merge! "token" => @token, "user[owner_id]" => @user_owner_id
     normalized= normalize(user_params)
-    req = Net::HTTP::Post.new(@users_uri.path)
-    req.body = "#{normalized}&token=#{@token}"
-    Net::HTTP.start(@users_uri.host) do |http|
+    req = Net::HTTP::Post.new(URI(@users_uri.to_s+".json").path)
+    req.body = "#{normalized}"
+    response=Net::HTTP.start(@users_uri.host) do |http|
       http.request(req)
     end
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Get usser info by ID
   def get_user_by_id(id)
     @token = get_token unless @token
-    get_users_by_id = Net::HTTP.get_response(URI(@users_uri.to_s+"/#{id}.json")+"?token=#{@token}")
-    JSON.parse(get_users_by_id.body)
+    response = Net::HTTP.get_response(URI(@users_uri.to_s+"/#{id}.json")+"?token=#{@token}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Get user info by login
   def get_user_by_login(login)
     @token = get_token unless @token
-    get_user_by_login= Net::HTTP.get_response(URI(@users_uri.to_s+"/by_login.json")+"?token=#{@token}&login=#{login}")
-    JSON.parse(get_user_by_login.body)
+    response = Net::HTTP.get_response(URI(@users_uri.to_s+"/by_login.json")+"?token=#{@token}&login=#{login}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Get all users by fullname
   def get_all_users_by_fullname(fullname)
     en_fullname = URI::encode(fullname)
     @token = get_token unless @token
@@ -170,38 +170,35 @@ class Quickblox
     users
   end
 
-  #Get users by full name with pagination
-  def get_users_by_fullname(fullname, page=nil, per_page=nil)
+  def get_users_by_fullname(fullname, page=1, per_page=10)
     en_fullname = URI::encode(fullname)
-    page=1 unless page
-    per_page=10 unless per_page
     @token = get_token unless @token
-    user_list=Net::HTTP.get_response(URI(@users_uri.to_s+"/by_full_name.json")+"?token=#{@token}&per_page=#{per_page}&page=#{page}&full_name=#{en_fullname}")
-    JSON.parse(user_list.body)["items"]
+    response=Net::HTTP.get_response(URI(@users_uri.to_s+"/by_full_name.json")+"?token=#{@token}&per_page=#{per_page}&page=#{page}&full_name=#{en_fullname}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Get user by facebook ID
   def get_user_by_facebook_id(fbid)
     @token = get_token unless @token
-    get_user_by_fb= Net::HTTP.get_response(URI(@users_uri.to_s+"/by_facebook_id.json")+"?token=#{@token}&facebook_id=#{fbid}")
-    JSON.parse(get_user_by_fb.body)
+    response= Net::HTTP.get_response(URI(@users_uri.to_s+"/by_facebook_id.json")+"?token=#{@token}&facebook_id=#{fbid}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Get user by twitter ID
   def get_user_by_twitter_id(twid)
     @token = get_token unless @token
-    get_user_by_tw= Net::HTTP.get_response(URI(@users_uri.to_s+"/by_twitter_id.json")+"?token=#{@token}&twitter_id=#{twid}")
-    JSON.parse(get_user_by_tw.body)
+    response= Net::HTTP.get_response(URI(@users_uri.to_s+"/by_twitter_id.json")+"?token=#{@token}&twitter_id=#{twid}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Get user by email
   def get_user_by_email(email)
     @token = get_token unless @token
-    get_user_by_email= Net::HTTP.get_response(URI(@users_uri.to_s+"/by_email.json")+"?token=#{@token}&email=#{email}")
-    JSON.parse(get_user_by_email.body)
+    response= Net::HTTP.get_response(URI(@users_uri.to_s+"/by_email.json")+"?token=#{@token}&email=#{email}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Get all users by tags
   def get_all_users_by_tags(tags)
     en_tags = URI::encode(tags)
     @token = get_token unless @token
@@ -217,42 +214,44 @@ class Quickblox
     users
   end
 
-  #Get users by tags with pagination
   def get_users_by_tags(tags, page=nil, per_page=nil)
     en_tags = URI::encode(tags)
     @token = get_token unless @token
     page=1 unless page
     per_page=10 unless per_page
-    user_list=Net::HTTP.get_response(URI(@users_uri.to_s+"/by_tags.json")+"?token=#{@token}&per_page=#{per_page}&page=#{page}&tags=#{en_tags}")
-    JSON.parse(user_list.body)["items"]
+    response=Net::HTTP.get_response(URI(@users_uri.to_s+"/by_tags.json")+"?token=#{@token}&per_page=#{per_page}&page=#{page}&tags=#{en_tags}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Update user by ID
-  def update_user_by_id(user_params)
+  def update_user(user_params)
     @token = get_token("user") unless @token_type=='user'
     user_params.merge! "token" => @token
     normalized= normalize(user_params)
-    req = Net::HTTP::Put.new(URI(@users_uri.to_s+"/"+@user_id.to_s).path)
+    return "ERROR: No user is logged in" unless @user_id
+    req = Net::HTTP::Put.new(URI(@users_uri.to_s+"/"+@user_id.to_s+".json").path)
     req.body = "#{normalized}"
-    Net::HTTP.start(@users_uri.host) do |http|
+    response=Net::HTTP.start(@users_uri.host) do |http|
       http.request(req)
     end
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Delete user
   def delete_user
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     http = Net::HTTP.new(@server)
     delete_user = Net::HTTP::Delete.new("/users/#{@user_id}?token=#{@token}")
-    http.request(delete_user)
+    response=http.request(delete_user)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
-  #Get user info by external ID
   def get_user_by_external_id (external_id)
     @token = get_token unless @token
-    get_user_by_ext_id= Net::HTTP.get_response(URI(@users_uri.to_s+"/external/#{external_id}.json")+"?token=#{@token}")
-    JSON.parse(get_user_by_ext_id.body)
+    response= Net::HTTP.get_response(URI(@users_uri.to_s+"/external/#{external_id}.json")+"?token=#{@token}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   #Get external ID by user ID
@@ -260,91 +259,103 @@ class Quickblox
     get_user_by_id(id)["external_user_id"]
   end
 
-  #Delete User by external ID
-  def delete_user_by_external_id
-    @token = get_token("user") unless @token_type=='user'
-    external_id = get_external_id_by_user_id(@user_id)
-    http = Net::HTTP.new(@server)
-    delete_user = Net::HTTP::Delete.new("/users/external/#{external_id}?token=#{@token}")
-    http.request(delete_user)
-  end
 
-  #Location API Requests
-
-  #Create Geodatum
   def create_geodatum(geodata_params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     geodata_params.merge! "token" => @token
     normalized= normalize(geodata_params)
-    req = Net::HTTP::Post.new(@geodata_uri.path)
+    req = Net::HTTP::Post.new(URI(@geodata_uri.to_s+".json").path)
     req.body = "#{normalized}"
-    Net::HTTP.start(@geodata_uri.host) do |http|
+    response=Net::HTTP.start(@geodata_uri.host) do |http|
       http.request(req)
     end
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  #Get geodata by ID
   def get_geodata_by_id (geodata_id)
     @token = get_token unless @token
-    get_geodata_by_id= Net::HTTP.get_response(URI(@geodata_uri.to_s+"/#{geodata_id}.json")+"?token=#{@token}")
-    JSON.parse(get_geodata_by_id.body)["geo_data"]
+    response= Net::HTTP.get_response(URI(@geodata_uri.to_s+"/#{geodata_id}.json")+"?token=#{@token}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-
-  def get_geodata(geodata)
+  def get_geodata(params)
     @token = get_token unless @token
-    normalized= normalize(geodata)
-    get_geodata_by_id= Net::HTTP.get_response(URI(@geodata_uri.to_s+"/find.json")+"?#{normalized}&token=#{@token}")
-    JSON.parse(get_geodata_by_id.body)
+    normalized= normalize(params)
+    response= Net::HTTP.get_response(URI(@geodata_uri.to_s+"/find.json")+"?#{normalized}&token=#{@token}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def delete_geodata(days)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     http = Net::HTTP.new(@server)
     delete_geodata = Net::HTTP::Delete.new("/geodata?token=#{@token}&days=#{days}")
-    http.request(delete_geodata)
+    response=http.request(delete_geodata)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
+  end
+
+  def delete_geodata_by_id(id)
+    @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
+    http = Net::HTTP.new(@server)
+    delete_geodata = Net::HTTP::Delete.new("/geodata/#{id}?token=#{@token}")
+    response=http.request(delete_geodata)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
   def create_place(place_params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     place_params.merge! "token" => @token
     normalized= normalize(place_params)
-    req = Net::HTTP::Post.new(@places_uri.path)
+    req = Net::HTTP::Post.new(URI(@places_uri.to_s+".json").path)
     req.body = "#{normalized}"
-    Net::HTTP.start(@places_uri.host) do |http|
+    response=Net::HTTP.start(@places_uri.host) do |http|
       http.request(req)
     end
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
   end
 
   def get_places(page=1, per_page=10)
     @token = get_token unless @token
-    places_list=Net::HTTP.get_response(URI(@places_uri.to_s+".json")+"?token=#{@token}&per_page=#{per_page}&page=#{page}")
-    JSON.parse(places_list.body)["items"]
+    response=Net::HTTP.get_response(URI(@places_uri.to_s+".json")+"?token=#{@token}&per_page=#{per_page}&page=#{page}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_places_by_id(id)
     @token = get_token unless @token
-    places_list=Net::HTTP.get_response(URI(@places_uri.to_s+"/#{id}.json")+"?token=#{@token}")
-
-    JSON.parse(places_list.body)
+    response=Net::HTTP.get_response(URI(@places_uri.to_s+"/#{id}.json")+"?token=#{@token}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def update_place_by_id(id, place_params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     place_params.merge! "token" => @token
-    normalized= normalize(lace_params)
-    req = Net::HTTP::Put.new(URI(@places_uri.to_s+"/#{id}").path)
+    normalized= normalize(place_params)
+    req = Net::HTTP::Put.new(URI(@places_uri.to_s+"/#{id}.json").path)
     req.body = "#{normalized}"
-    Net::HTTP.start(@places_uri.host) do |http|
+    response=Net::HTTP.start(@places_uri.host) do |http|
       http.request(req)
     end
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def delete_place_by_id(id)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     http = Net::HTTP.new(@server)
     delete_place = Net::HTTP::Delete.new("/places/#{id}?token=#{@token}")
-    http.request(delete_place)
+    response=http.request(delete_place)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
 
@@ -353,79 +364,102 @@ class Quickblox
 
   def create_file(filename, file_params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     file_params.merge! "token" => @token, "blob[multipart]" => 0
     normalized = normalize(file_params)
     req = Net::HTTP::Post.new(URI(@files_uri.to_s+".json").path)
     req.body = "#{normalized}"
-    create_file = Net::HTTP.start(URI(@files_uri.to_s+".json").host) do |http|
+    response = Net::HTTP.start(URI(@files_uri.to_s+".json").host) do |http|
       http.request(req)
     end
-    link=JSON.parse(create_file.body)["blob"]["blob_object_access"]["params"]
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    link=JSON.parse(response.body)["blob"]["blob_object_access"]["params"]
     uri=URI(link)
     query = {}
-    CGI.parse(uri.query).map { |k, v| query.merge!({k => CGI.unescape(v[0])}) }
+    CGI.parse(uri.query).map { |k, v| query.merge!({k => v[0]}) }
     query.merge! "file" => File.read(filename)
     req = Net::HTTP::Post::Multipart.new uri.path, query
-    res = Net::HTTP.start(uri.host, uri.port) do |http|
+    s3=Net::HTTP.start(uri.host, uri.port) do |http|
       http.request(req)
     end
-    blobid = JSON.parse(create_file.body)["blob"]["id"]
+    return {:response_code => s3.code, :response_header => s3, :response_body => (JSON.parse(s3.body) rescue nil)} unless s3.code == "201"
+    blobid = JSON.parse(response.body)["blob"]["id"]
     filesize = File.size(filename)
     req = Net::HTTP::Put.new(URI(@files_uri.to_s+"/#{blobid}/complete.json").path)
     req.body = "blob[size]=#{filesize}&token=#{@token}"
-    p=Net::HTTP.start(@places_uri.host) do |http|
+    complete=Net::HTTP.start(@places_uri.host) do |http|
       http.request(req)
     end
-    JSON.parse(create_file.body)["blob"]
+    return {:response_code => complete.code, :response_header => complete, :response_body => (JSON.parse(complete.body) rescue nil)} unless complete.code == "200"
+    get_file_info_by_id(blobid)
   end
 
   def get_file_info_by_id(id)
     @token = get_token unless @token
-    file_info = Net::HTTP.get_response(URI(@files_uri.to_s+"/#{id}.json")+"?token=#{@token}")
-    JSON.parse(file_info.body)["blob"]
+    response = Net::HTTP.get_response(URI(@files_uri.to_s+"/#{id}.json")+"?token=#{@token}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
+  end
+
+  def get_files_list(page=1, per_page=10)
+    @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI(@files_uri.to_s+".json")+"?token=#{@token}&page=#{page}&per_page=#{per_page}")
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  def get_file_link_by_uid(id)
+  def get_file_link_by_uid(uid)
     @token = get_token unless @token
-    file_info = Net::HTTP.get_response(URI(@files_uri.to_s+"/#{id}"+"?token=#{@token}"))
-    CGI::unescapeHTML(file_info.body.gsub("<html><body>You are being <a href=\"", '').gsub("\">redirected</a>.</body></html>", ''))
+    response = Net::HTTP.get_response(URI(@files_uri.to_s+"/#{uid}.json"+"?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "302"
+    CGI::unescapeHTML(response.body.gsub("<html><body>You are being <a href=\"", '').gsub("\">redirected</a>.</body></html>", ''))
   end
 
   def get_file_link_by_id(id)
     @token = get_token unless @token
     req = Net::HTTP::Post.new(URI(@files_uri.to_s+"/#{id}/getblobobjectbyid.json").path)
     req.body = "token=#{@token}"
-    request=Net::HTTP.start(@files_uri.host) do |http|
+    response=Net::HTTP.start(@files_uri.host) do |http|
       http.request(req)
     end
-    JSON.parse(request.body)["blob_object_access"]["params"]
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)["blob_object_access"]["params"]
   end
 
   def edit_file_by_id(id, params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Put.new(URI(@files_uri.to_s+"/#{id}.json").path)
     params.merge! "token" => @token
     normalized= normalize(params)
     req.body = "#{normalized}"
-    request=Net::HTTP.start(@files_uri.host) do |http|
+    response=Net::HTTP.start(@files_uri.host) do |http|
       http.request(req)
     end
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def delete_file(id)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     http = Net::HTTP.new(@server)
-    delete_geodata = Net::HTTP::Delete.new("/blobs/#{id}/?token=#{@token}")
-    http.request(delete_geodata)
+    delete=Net::HTTP::Delete.new("/blobs/#{id}/?token=#{@token}")
+    response=http.request(delete)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
   def increase_file_links(id)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Put.new(URI(@files_uri.to_s+"/#{id}/retain.json").path)
     req.body = "token=#{@token}"
-    request=Net::HTTP.start(@files_uri.host) do |http|
+    response=Net::HTTP.start(@files_uri.host) do |http|
       http.request(req)
     end
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
+
   end
 
 
@@ -437,11 +471,11 @@ class Quickblox
     normalized= normalize(params)
     req = Net::HTTP::Post.new(URI(@pushtokens_uri.to_s+".json").path)
     req.body = "#{normalized}"
-    create_token=Net::HTTP.start(@pushtokens_uri.host) do |http|
+    response=Net::HTTP.start(@pushtokens_uri.host) do |http|
       http.request(req)
     end
-    JSON.parse(create_token.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
   end
 
   def create_subscription (channels, url=nil)
@@ -451,11 +485,11 @@ class Quickblox
     normalized= normalize(hash)
     req = Net::HTTP::Post.new(URI("http://"+@server.to_s+"/subscriptions.json").path)
     req.body = "#{normalized}"
-    subscribe=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
-    JSON.parse(subscribe.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
   end
 
   def get_subscriptions
@@ -467,18 +501,13 @@ class Quickblox
   def delete_subscription(id)
     @token = get_token("user_device") unless @token_type=='user_device'
     http = Net::HTTP.new(@server)
-    delete_subscription = Net::HTTP::Delete.new("/subscriptions/#{id}/?token=#{@token}")
-    http.request(delete_subscription)
+    delete = Net::HTTP::Delete.new("/subscriptions/#{id}/?token=#{@token}")
+    response=http.request(delete)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
   def create_event(params, message)
     @token = get_token("user_device") unless @token_type=='user_device'
-    #  message = hash
-    #  message["platform"] could be mpns, ios or android
-    #  if message[type] mpns
-    #  EXAMPLE
-    #  create_event({:event=>{:notification_type=>"push",:push_type=>"mpns",:user=>{:ids=>"616"}, :environment=>"production"}},{:type=>"toast",:body=>"message body",:head=>"message head",:return_path=>"/",:class=>2})
-
     if params[:event][:notification_type]=="push"
       if params[:event][:push_type]=="mpns"
         if message[:type]=="toast"
@@ -491,11 +520,9 @@ class Quickblox
               "</wp:Toast>"+
               "</wp:Notification>"
 
-          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]},X-WindowsPhone-Target,toast"))
+          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]},X-WindowsPhone-Target,toast")) rescue nil
         end
 
-#  create_event({:event=>{:notification_type=>"push",:push_type=>"mpns",:user=>{:ids=>"616"}, :environment=>"production"}},{:type=>"tile",:background_image=>"Red.jpg",:count=>4,:title=>"FR TITLE",:back_background_image=>"Green.jpg", :back_content=>"312312", :back_title=>"BACK TITLE",:class=>1})
-
         if message[:type]=="tile"
           mpns_body="<?xml version='1.0' encoding='utf-8'?>" +
               "<wp:Notification xmlns:wp='WPNotification'>" +
@@ -508,52 +535,45 @@ class Quickblox
               "<wp:BackContent>#{message[:back_content]}</wp:BackContent>"+
               "</wp:Tile>" +
               "</wp:Notification>"
-          puts mpns_body
-          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]},X-WindowsPhone-Target,token"))
+          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]},X-WindowsPhone-Target,token")) rescue nil
 
         end
-#     create_event({:event=>{:notification_type=>"push",:push_type=>"mpns",:user=>{:ids=>"616"}, :environment=>"production"}},{:type=>"raw",:body=>"<root><value1>fsdfsdf</value1></root>",:class=>3})
 
         if message[:type]=="raw"
-          mpns_body="<?xml version='1.0' encoding='utf-8'?>" +
-              "#{message[:body]}"
-          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]}"))
+          mpns_body=message[:body]
+          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]}")) rescue nil
 
         end
       end
 
-#  create_event({:event=>{:notification_type=>"push",:push_type=>"apns",:user=>{:ids=>"260"}, :environment=>"development"}},{:alert=>"lol",:badge_counter=>3, :sound=>"default"})
       if params[:event][:push_type]=="apns"
-        to_send="payload=" + Base64.strict_encode64({:aps => {:alert => message[:alert], :badge => message[:badge_counter].to_i || 1, :sound => message[:sound] || 'default'}}.to_json).to_s
+        to_send="payload=" + Base64.strict_encode64({:aps => {:alert => message[:alert], :badge => message[:badge_counter].to_i || 1, :sound => message[:sound] || 'default'}}.to_json).to_s rescue nil
       end
-# create_event({:event=>{:notification_type=>"push",:push_type=>"c2dm",:user=>{:ids=>"260"}, :environment=>"development"}},{:body=>'message'})
       if params[:event][:push_type]=="c2dm"
         to_send="data.message=" + Base64.strict_encode64(message[:body]).to_s
       end
-#  create_event({:event=>{:notification_type=>"push",:user=>{:ids=>"260"}, :environment=>"development"}},{:body=>'message body
       if params[:event][:push_type]==nil
         to_send=Base64.strict_encode64(message[:body]).to_s
       end
     end
 
-    #   create_event({:event=>{:notification_type=>"email",:user=>{:ids=>"260"}, :environment=>"development"}},{:body=>'Message'})
-    #   create_event({:event=>{:notification_type=>"pull",:date=>"1333974896",:end_date=>"1334060796",:user=>{:ids=>"260"}, :environment=>"development"}},{:body=>'Message'})
-
-
-    if params[:event][:notification_type]=="http_request" || params[:event][:notification_type]== "email" || params[:event][:notification_type]=="pull"
-      to_send=Base64.strict_encode64(message[:body]).to_s
+    if params[:event][:notification_type]=="email"|| params[:event][:notification_type]=="pull"
+      to_send=CGI::escape("subject="+Base64.strict_encode64(message[:subject])+"&body="+Base64.strict_encode64(message[:body]).to_s) rescue nil
     end
 
+    if params[:event][:notification_type]== "http_request"
+      to_send=CGI::escape("subject=#{message[:subject]}&body=#{message[:body]}&#{message[:params]}".to_s) rescue nil
+    end
 
     params.merge! "token" => @token
     normalized = normalize(params)
     req = Net::HTTP::Post.new(URI("http://"+@server.to_s+"/events.json").path)
     req.body = "#{normalized}&event[message]=#{to_send}"
-    subscribe=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
-
-    JSON.parse(subscribe.body)
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
   end
 
   def get_events(page=1, per_page=10)
@@ -562,87 +582,98 @@ class Quickblox
     JSON.parse(file_info.body)
   end
 
-  def edit_event(id, params, message)
+  def edit_event(id, params, message=nil)
     @token = get_token("user_device") unless @token_type=='user_device'
-    #edit_event (22,{:active=>true},{:push_type=>"mpns", :type=>"toast",:body=>"message body",:head=>"message head",:return_path=>"/",:class=>2})
-    if message[:push_type]=="mpns"
-      if message[:type]=="toast"
-        mpns_body="<?xml version='1.0' encoding='utf-8'?>"+
-            "<wp:Notification xmlns:wp='WPNotification'>"+
-            "<wp:Toast>"+
-            "<wp:Text1>#{message[:head]}</wp:Text1>"+
-            "<wp:Text2>#{message[:body]}</wp:Text2>"+
-            "<wp:Param>#{message[:return_path]}</wp:Param>"+
-            "</wp:Toast>"+
-            "</wp:Notification>"
-
-        to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]},X-WindowsPhone-Target,toast"))
-      end
+    event=get_event_by_id(id)
+    notification=event["notification_channel"]["name"]
+    params.merge! "token" => @token
+    normalized = normalize(params)
+    req = Net::HTTP::Put.new(URI("http://"+@server.to_s+"/events/#{id}.json").path)
+    if message
+      if notification=="mpns"
+        if message[:type]=="toast"
+          mpns_body="<?xml version='1.0' encoding='utf-8'?>"+
+              "<wp:Notification xmlns:wp='WPNotification'>"+
+              "<wp:Toast>"+
+              "<wp:Text1>#{message[:head]}</wp:Text1>"+
+              "<wp:Text2>#{message[:body]}</wp:Text2>"+
+              "<wp:Param>#{message[:return_path]}</wp:Param>"+
+              "</wp:Toast>"+
+              "</wp:Notification>"
+
+          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]},X-WindowsPhone-Target,toast")) rescue nil
+        end
 
-      #  edit_event(22,{:active=>true},{:push_type=>"mpns",:type=>"tile",:background_image=>"Red.jpg",:count=>4,:title=>"FR TITLE",:back_background_image=>"Green.jpg", :back_content=>"312312", :back_title=>"BACK TITLE",:class=>1})
-
-      if message[:type]=="tile"
-        mpns_body="<?xml version='1.0' encoding='utf-8'?>" +
-            "<wp:Notification xmlns:wp='WPNotification'>" +
-            "<wp:Tile>" +
-            "<wp:BackgroundImage>#{message[:background_image]}></wp:BackgroundImage>" +
-            "<wp:Count>#{message[:count]}</wp:Count>" +
-            "<wp:Title>#{message[:title]}</wp:Title>" +
-            "<wp:BackBackgroundImage>#{message[:back_background_image]}</wp:BackBackgroundImage>"+
-            "<wp:BackTitle>#{message[:back_title]}</wp:BackTitle>"+
-            "<wp:BackContent>#{message[:back_content]}</wp:BackContent>"+
-            "</wp:Tile>" +
-            "</wp:Notification>"
-        puts mpns_body
-        to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]},X-WindowsPhone-Target,token"))
 
+        if message[:type]=="tile"
+          mpns_body="<?xml version='1.0' encoding='utf-8'?>" +
+              "<wp:Notification xmlns:wp='WPNotification'>" +
+              "<wp:Tile>" +
+              "<wp:BackgroundImage>#{message[:background_image]}></wp:BackgroundImage>" +
+              "<wp:Count>#{message[:count]}</wp:Count>" +
+              "<wp:Title>#{message[:title]}</wp:Title>" +
+              "<wp:BackBackgroundImage>#{message[:back_background_image]}</wp:BackBackgroundImage>"+
+              "<wp:BackTitle>#{message[:back_title]}</wp:BackTitle>"+
+              "<wp:BackContent>#{message[:back_content]}</wp:BackContent>"+
+              "</wp:Tile>" +
+              "</wp:Notification>"
+
+          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]},X-WindowsPhone-Target,token")) rescue nil
+
+        end
+
+        if message[:type]=="raw"
+          mpns_body=message[:body]
+          to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]}")) rescue nil
+
+        end
       end
-      #     create_event(22,{:active=>true},{:push_type=>"mpns",:type=>"raw",:body=>"<root><value1>fsdfsdf</value1></root>",:class=>3})
 
-      if message[:type]=="raw"
-        mpns_body="<?xml version='1.0' encoding='utf-8'?>" +
-            "#{message[:body]}"
-        to_send=CGI::escape("mpns="+Base64.strict_encode64(mpns_body)+"&headers="+Base64.strict_encode64("Content-Type,text/xml,X-NotificationClass,#{message[:class]}"))
 
+      if notification=="apns"
+        to_send="payload=" + Base64.strict_encode64({:aps => {:alert => message[:alert], :badge => message[:badge_counter].to_i || 1, :sound => message[:sound] || 'default'}}.to_json).to_s rescue nil
       end
-    end
 
-    #   edit_event(640,{:event=>{:active=>true}},{:push_type=>"apns", :alert=>"lolishe", :badge_counter=>3, :sound=>"default"})
+      if notification=="c2dm"
+        to_send="data.message=" + Base64.strict_encode64(message[:body]).to_s
+      end
 
-    if message[:push_type]=="apns"
-      to_send="payload=" + Base64.strict_encode64({:aps => {:alert => message[:alert], :badge => message[:badge_counter].to_i || 1, :sound => message[:sound] || 'default'}}.to_json).to_s
-    end
-    # edit_event(640,{:event=>{:active=>true}},{:push_type=>"apns", :alert=>"lolishe", :badge_counter=>3, :sound=>"default"})
-    if message[:push_type]=="c2dm"
-      to_send="data.message=" + Base64.strict_encode64(message[:body]).to_s
-    end
+      if notification=="http_request" || message[:type]== "email" || message[:type]=="pull"
+        to_send=Base64.strict_encode64(message[:body]).to_s
+      end
 
+      if notification=="email"|| notification=="pull"
+        to_send=CGI::escape("subject="+Base64.strict_encode64(message[:subject])+"&body="+Base64.strict_encode64(message[:body]).to_s) rescue nil
+      end
 
-    if message[:type]=="http_request" || message[:type]== "email" || message[:type]=="pull"
-      to_send=Base64.strict_encode64(message[:body]).to_s
-    end
+      if notification=="http_request"
+        to_send=CGI::escape("subject=#{message[:subject]}&body=#{message[:body]}&#{message[:params]}".to_s) rescue nil
+      end
 
-    req = Net::HTTP::Put.new(URI("http://"+@server.to_s+"/events/#{id}.json").path)
-    params.merge! "token" => @token
-    normalized = normalize(params)
-    req.body = "#{normalized}&event[message]=#{to_send}"
-    puts req.body
-    Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+      req.body = "#{normalized}&event[message]=#{to_send}"
+    else
+      req.body = "#{normalized}"
+    end
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
   end
 
   def delete_event(id)
     @token = get_token("user_device") unless @token_type=='user_device'
     http = Net::HTTP.new(@server)
     delete_event = Net::HTTP::Delete.new("/events/#{id}?token=#{@token}")
-    http.request(delete_event)
+    response=http.request(delete_event)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
   def get_event_by_id(id)
     @token = get_token("user_device") unless @token_type=='user_device'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/events/#{id}.json?token=#{@token}"))
-    JSON.parse(event.body)["event"]
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/events/#{id}.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_pull_request_list
@@ -651,207 +682,245 @@ class Quickblox
     JSON.parse(event.body)
   end
 
-  # Ratings API requests
+# Ratings API requests
 
   def create_gamemode(title)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Post.new(URI(@gamemodes_uri.to_s+".json").path)
     req.body = "token=#{@token}&gamemode[title]=#{title}"
-    create=Net::HTTP.start(@pushtokens_uri.host) do |http|
+    response=Net::HTTP.start(@pushtokens_uri.host) do |http|
       http.request(req)
     end
-    JSON.parse(create.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
   end
 
   def update_gamemode(id, title)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Put.new(URI(@gamemodes_uri.to_s+"/#{id}.json").path)
-    req.body = "token=#{@token}&gamemode[title]=#{title}"
-    create=Net::HTTP.start(@pushtokens_uri.host) do |http|
+    req.body = "token=#{@token}&gamemode[title] =#{title}"
+    response=Net::HTTP.start(@pushtokens_uri.host) do |http|
       http.request(req)
     end
-    JSON.parse(create.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)["game_mode"]
   end
 
   def get_gamemode_by_id(id)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI(@gamemodes_uri.to_s+"/#{id}.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI(@gamemodes_uri.to_s+"/#{id}.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_gamemodes
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/application/gamemodes.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/application/gamemodes.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  def delete_gamemomde(id)
+  def delete_gamemode(id)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     http = Net::HTTP.new(@server)
     delete = Net::HTTP::Delete.new("/gamemodes/#{id}?token=#{@token}")
-    http.request(delete)
+    response = http.request(delete)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
   def create_score(params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Post.new(URI("http://"+@server.to_s+"/scores.json").path)
     params.merge! "token" => @token
     normalized = normalize(params)
     req.body = "#{normalized}"
-    create=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
-    JSON.parse(create.body)
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
 
   end
 
-  #     update_score(id,{:score=>{:game_mode_id=>"255",:value=>23})
   def update_score(id, params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Put.new(URI("http://"+@server.to_s+"/scores/#{id}.json").path)
     params.merge! "token" => @token
     normalized = normalize(params)
     req.body = "#{normalized}"
-    update=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
-    JSON.parse(update.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_score_by_id(id)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/scores/#{id}.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/scores/#{id}.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_top_scores(id, count=10, page=1, per_page=10, filters=nil, sort=1)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI(@gamemodes_uri.to_s+"/#{id}/top.#{count}.json?token=#{@token}&page=#{page}&per_page=#{per_page}&sort=#{sort}&filters=#{filters}"))
-    JSON.parse(event.body)
+    response = Net::HTTP.get_response(URI(@gamemodes_uri.to_s+"/#{id}/top.#{count}.json?token=#{@token}&page=#{page}&per_page=#{per_page}&sort=#{sort}&filters=#{filters}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_scores_for_user(id, sort_by="value", filters=nil, sort=1)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/users/#{id}/scores.json?token=#{@token}&sort=#{sort}&filters=#{filters}&sort_by=#{sort_by}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/users/#{id}/scores.json?token=#{@token}&sort=#{sort}&filters=#{filters}&sort_by=#{sort_by}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_average_scores(id)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI(@gamemodes_uri.to_s+"/#{id}/average.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI(@gamemodes_uri.to_s+"/#{id}/average.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
-  def get_average_scores_by_application
+  def get_average_scores_by_app
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/application/averages.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/application/averages.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def delete_score(id)
     @token = get_token("user") unless @token_type=='user'
     http = Net::HTTP.new(@server)
     delete = Net::HTTP::Delete.new("/scores/#{id}?token=#{@token}")
-    http.request(delete)
+    response = http.request(delete)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
   def create_gamemodeparameter(params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Post.new(URI("http://"+@server.to_s+"/gamemodeparameters.json").path)
     params.merge! "token" => @token
     normalized = normalize(params)
     req.body = "#{normalized}"
-    create=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
-    JSON.parse(create.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
   end
 
   def update_gamemodeparameter(id, params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Put.new(URI("http://"+@server.to_s+"/gamemodeparameters/#{id}.json").path)
     params.merge! "token" => @token
     normalized = normalize(params)
     req.body = "#{normalized}"
-    update=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
-    JSON.parse(update.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_gamemodeparameter_by_id(id)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/gamemodeparameters/#{id}.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/gamemodeparameters/#{id}.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_gamemodeparameter_by_gamemode_id(id)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI(@gamemodes_uri.to_s+"/#{id}/gamemodeparameters.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI(@gamemodes_uri.to_s+"/#{id}/gamemodeparameters.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def delete_gamemodeparameter(id)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     http = Net::HTTP.new(@server)
     delete = Net::HTTP::Delete.new("/gamemodeparameters/#{id}?token=#{@token}")
-    http.request(delete)
+    response = http.request(delete)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
   def create_gamemodeparametervalue(params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Post.new(URI("http://"+@server.to_s+"/gamemodeparametervalues.json").path)
     params.merge! "token" => @token
     normalized = normalize(params)
     req.body = "#{normalized}"
-    create=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
-    JSON.parse(create.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "201"
+    JSON.parse(response.body)
   end
 
-  def update_gamemodeparametervalues(id, params)
+  def update_gamemodeparametervalue(id, params)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     req = Net::HTTP::Put.new(URI("http://"+@server.to_s+"/gamemodeparametervalues/#{id}.json").path)
     params.merge! "token" => @token
     normalized = normalize(params)
     req.body = "#{normalized}"
-    update=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
+    response=Net::HTTP.start(URI("http://"+@server.to_s).host) do |http|
       http.request(req)
     end
-    JSON.parse(update.body)
-
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_gamemodeparametervalue_by_id(id)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/gamemodeparametervalues/#{id}.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/gamemodeparametervalues/#{id}.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_gamemodeparametervalue_by_score_id(id)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/scores/#{id}/gamemodeparametervalues.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/scores/#{id}/gamemodeparametervalues.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def get_api_gamemodeparametervalue_by_score_id(score_id, para_id)
     @token = get_token("user") unless @token_type=='user'
-    event = Net::HTTP.get_response(URI("http://"+@server.to_s+"/scores/#{score_id}/gamemodeparameter/#{para_id}/values.json?token=#{@token}"))
-    JSON.parse(event.body)
+    return "ERROR: No user is logged in" unless @user_id
+    response = Net::HTTP.get_response(URI("http://"+@server.to_s+"/scores/#{score_id}/gamemodeparameters/#{para_id}/value.json?token=#{@token}"))
+    return {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)} unless response.code == "200"
+    JSON.parse(response.body)
   end
 
   def delete_gamemodeparametervalue(id)
     @token = get_token("user") unless @token_type=='user'
+    return "ERROR: No user is logged in" unless @user_id
     http = Net::HTTP.new(@server)
     delete = Net::HTTP::Delete.new("/gamemodeparametervalues/#{id}?token=#{@token}")
-    http.request(delete)
+    response=http.request(delete)
+    {:response_code => response.code, :response_header => response, :response_body => (JSON.parse(response.body) rescue nil)}
   end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quickblox
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: '0.2'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-10 00:00:00.000000000 Z
+date: 2012-04-16 00:00:00.000000000 Z
 dependencies: []
 description: QuickBlox.com api
 email: andrey.kozhokaru@quickblox.com