lib/social_profile/people/facebook.rb in social_profile-0.3.0 vs lib/social_profile/people/facebook.rb in social_profile-0.3.1

@@ -1,77 +1,58 @@
-require "fb_graph"
+require "fb_graph2"
 
 module SocialProfile
   module People
     class Facebook < Person
-      FRIENDS_FQL = "SELECT friend_count FROM user WHERE uid=me()"
-      FIRST_POST_FQL = "SELECT created_time FROM stream WHERE source_id = me() AND created_time < {date} limit 1"
       LAST_POSTS_FIELDS = [
-        "comments.fields(created_time).limit(1).summary(true)", 
+        "comments.fields(created_time).limit(1).summary(true)",
         "likes.limit(1).fields(id).summary(true)",
         "created_time",
         "shares"
       ]
       POST_FIELDS = [
-        "comments.fields(created_time).limit(1).summary(true)", 
+        "comments.fields(created_time).limit(1).summary(true)",
         "likes.limit(1).fields(id).summary(true)",
         "created_time",
         "shares"
       ]
-      MUTUAL_FRIENDS = "SELECT uid, mutual_friend_count FROM user WHERE uid IN(SELECT uid2 FROM friend WHERE uid1=me()) ORDER BY mutual_friend_count"
 
       # Find album by id
       def fetch_album(album_id)
-        ::FbGraph::Album.fetch(album_id, :access_token => access_token)
+        ::FbGraph2::Album.fetch(album_id, :access_token => access_token)
       end
-      
+
       # Create new album id
       def album!(options = {})
         user.album!(options)
       end
 
       # Get friends count
       #
       def friends_count
-        @friends_count ||= fetch_friends_count
+        @friends_count ||= friends(limit: 1).summary['total_count']
       end
 
       # Get followers count
       #
       def followers_count
         @followers_count ||= followers(:limit => 1).size
       end
 
-      def fetch_friends_count
-        response = FbGraph::Query.new(FRIENDS_FQL).fetch(:access_token => access_token)
-
-        response = response.first if response.is_a?(Array)
-        return nil if response.is_a?(Hash) && response["friend_count"].blank?
-
-        response["friend_count"].to_i
-      end
-
-      # Check if exists any post before current year 
+      # Check if exists any post before current year
       #
       def first_post_exists?(year)
-        timestamp = Time.new(year, 1, 1).utc.to_i
-
-        _sql = FIRST_POST_FQL.gsub('{date}', timestamp.to_s)
-        response = FbGraph::Query.new(_sql).fetch(:access_token => access_token)
-
-        response = response.first if response.is_a?(Array)
-        return nil if response.nil? || (response.is_a?(Hash) && response["created_time"].blank?)
-
-        response["created_time"].to_i
+        # TODO
+        return nil
       end
 
       # Get last limited posts from feed with comments, shares and likes counters
       #
       def last_posts(limit, options = {})
         fields = options[:fields] || LAST_POSTS_FIELDS
 
-        user.feed(:fields => fields.join(","), :limit => limit)        
+        user.feed(:fields => fields.join(","), :limit => limit)
       end
 
       # Get last post by days from feed with comments, shares and likes counters
       #
       def last_post_by_days(days, options={})
@@ -80,11 +61,11 @@
         max_iteration = options[:max_iteration] || 100
         iteration = 0
 
         posts = collection = last_posts(limit, options)
         return [] if posts.blank? || posts.last.created_time.nil?
-        
+
         last_created_time = posts.last.created_time
 
         while !last_created_time.blank? && last_created_time > date && iteration < max_iteration
           iteration += 1
           collection = collection.next
@@ -129,26 +110,22 @@
       # Get post from feed with comments, shares and likes counters
       #
       def fetch_post(post_uid, options = {})
         fields = options[:fields] || POST_FIELDS
 
-        ::FbGraph::Post.fetch(post_uid, :fields => fields.join(","), :access_token => access_token)    
+        ::FbGraph2::Post.fetch(post_uid, :fields => fields.join(","), :access_token => access_token)
       end
 
       # Get friends list with mutual friends counter
       #
       def mutual_friends(options={})
-        response = FbGraph::Query.new(MUTUAL_FRIENDS).fetch(:access_token => access_token)
-
-        return {} unless response.is_a?(Array)
-        
-        response.inject({}) {|h, a| h.merge!(a["uid"] => a["mutual_friend_count"]) }
+        return {}
       end
 
       protected
-      
+
         def user
-          @user ||= ::FbGraph::User.me(access_token)
+          @user ||= ::FbGraph2::User.me(access_token)
         end
     end
   end
 end