Posts

gistfile1.txt

$LOAD_PATH << './lib'

require 'app'

# Private: Does the following:
#   * Gets page's posts from http://graph.facebook.com/page_id/posts.
#   * Saves/updates posts.
#   * Redirects to /posts/insights with params.
#
# Accepts:
#  'id'           - Post Facebook identifier
#  'access_token' - Post's page Facebook access token
#
# Example:
#   curl -d 'id=..&access_token=..' 'http://localhost:8000/pages/posts'
#
class PagesPosts < Goliath::API
  include Database
  include Fetchable
  include Redirectable
  include Referenceable
  include SaveOrUpdate
  include Filterable

  use Goliath::Rack::Params

  def response(env)
    fb_response = get_page_posts(params)

    run_around_filters(params, fb_response) do
      page_id         = params['id']
      access_token    = params['access_token']

      page_posts_data_raw = extract_relevant_info(fb_response['data'])
      page_posts_data = extract_type(page_posts_data_raw)
      add_page_id_to_page_posts(page_posts_data, page_id)
      save_or_update_posts(page_id, page_posts_data.clone)
      update_page_last_update(page_id)

      page_likes_data = extract_likes(fb_response['data'])
      likes = count_data(page_likes_data)

      page_comments_data = extract_comments(fb_response['data'])
      comments = count_data(page_comments_data)

      user_rank = page_users_rank(page_likes_data, page_comments_data, likes, comments)
      add_page_id_to_page_posts(user_rank, page_id)
      save_or_update_rank(page_id, user_rank.clone)

      page_loyalty_joint = page_likes_data.zip(page_comments_data).flatten.compact
      page_loyalty = page_loyalty_joint.group_by{|o| [o['date'].year,o['date'].month] }


      # local vars unavailable inside FiberIterator block
      @data         = page_posts_data
      @access_token = access_token

      unless params['insights'] == 'false'
        EM::Synchrony::FiberIterator.new(@data, 50).each do |post|
         merged_params =  {'id'          => post['id'],
                           'access_token' => @access_token}

          redirect_to_posts_insights(merged_params)
          redirect_to_posts_alchemy(merged_params)
        end
      end
      response = {'response' => 'got/saved page insights'}

      [200, [], JSON.dump(page_loyalty)]
    end
  end

  def extract_relevant_info(posts)
    posts.map do |post|
      {
        'id'           => post['id'],
        'type'         => post['type'],
        'message'      => post['message'],
        'story'        => post['story'],
        'created_time' => post['created_time'],
        'updated_time' => post['updated_time'],
      }
    end
  end

  def extract_type(posts)
    posts.select{|post| "status" != post['type']}
  end

  def extract_likes(posts)
    u = Array.new
    posts.each { |post|
      if post.has_key?("likes")        
        likes = post['likes']
        if likes.has_key?("data")
          users = likes['data']
          users.each{|like|
            like['date']=Date.parse(post['created_time'])
            u.push like
          }          
        end
      end    
    }
    return u
  end

  def extract_comments(posts)
    results = Array.new
    posts.each { |post|
      if post.has_key?("comments")        
        comments = post['comments']
        if comments.has_key?("data")
          datas = comments['data']
          datas.each{|data|
            data['from']['date']=Date.parse(post['created_time'])
            results.push data['from']
          }          
        end
      end    
    }
    return results
  end

  def count_data(data)
    h = data.inject({}) do |hash, user|
      if hash[user['id']]
        hash[user['id']] += 1
      else
        hash[user['id']] = 1
      end
      hash
    end 
  end

  def page_users_rank(a, s, likes, comments)
    userlist = a | s
    userlist.uniq! {|x| x['id']}
    userlist.map{|user|
      id = user['id']
      commtotal = comments[id] || 0
      liketotal = likes[id] || 0
      total = commtotal + liketotal
      {
        'total' => total,
        'likes' => liketotal,
        'comments' => commtotal,
        'id' => user['id']
      }
    }
  end

  def update_page_last_update(page_id)
    time = DateTime.now.new_offset(0).to_s
    update_page(page_id, {'last_update' => time})
  end
end